Oracle中的慢查询（在SQL Server中快速运行）（相关子查询）

Question

We are annoyed by the symptom below. We would appreciate any advice from you about the cause of it and the way to resolve it.

I run the simple query below and it took 3,800 seconds for Oracle DB to return the result, while the same query completes in a few seconds in a SQL Server database that has the same tables. (It's used as a datamart).

Query:

select
T_X.Col1
,(select count(1) from T_X where T_X.colX = T_Y.colY) as cnt1
from T_Y

Records count:

T_X: 96,536

T_Y: 129,359

Other info:

-ColY is the primary key of T_Y and there is no index on ColXin in both of the two enrironment.

-Oracle 11.1 (ran the query using SQL Developer)

-SQL Server 2008 (ran the query using SSMS)

-No big differences of hardware specs between the two environment.

-The query above is a part of the bigger one. We simplified it and find the part was the bottleneck.

We would appreciate your advice!

Additional Info (the purpose of the query)

The query above is a part of the query below. Our purpose is to find out (the count of) records in T_Y that doesn't have correspondent records in other tables (T_A, T_B, T_C, T_D, T_E, T_X).

select          
  count(1)          
from            
  (select
     T_Y.ColA
    ,T_Y.ColG
    ,T_Y.ColH
    ,(select count(1) from T_A A where A.ColA = T_Y.ColY) as cnt1
    ,(select count(1) from T_B B where B.ColB = T_Y.ColY) as cnt2
    ,(select count(1) from T_X where T_X.ColX = T_Y.ColY) as cnt3
    ,(select count(1) from T_C C where C.ColC = T_Y.ColY) as cnt4
    ,(select count(1) from T_D D where D.ColD = T_Y.ColY) as cnt5
    ,(select count(1) from T_E E where E.ColE = T_Y.ColY) as cnt6
  from T_Y
  )XXX
where 1=1
  and XXX.ColH in ('X')
  and XXX.cnt1 = 0
  and XXX.cnt2 = 0
  and XXX.cnt3 = 0
  and XXX.cnt4 = 0
  and XXX.cnt5 = 0
  and XXX.cnt6 = 0
;           

Execution Plan - Oracle (for the original query)(Execute Explain Plan)

"Optimizer" "Cost"  "Cardinality"   "Bytes" "Partition Start"   "Partition Stop"    "Partition Id"  "ACCESS PREDICATES" "FILTER PREDICATES"
"SELECT STATEMENT"  "ALL_ROWS"  "121"   "129359"    "776154"    ""  ""  ""  ""  ""
"SORT(AGGREGATE)"   ""  ""  "1" "6" ""  ""  ""  ""  ""
"TABLE ACCESS(FULL) XXXXX.T_X"  "ANALYZED"  "6616"  "2" "12"    ""  ""  ""  ""  ""T_X"."ColX"=:B1"
"INDEX(FAST FULL SCAN) XXXXX.T_Y_0" "ANALYZED"  "121"   "129359"    "776154"    ""  ""  ""  ""  ""

Execution Plan - SQL Server (for the original query)

Line 7 indicates that SQL server uses Clustered Index Scan instead of Table Scan though the clustered index doesn't include ColumnY. Could anyone explain what does this mean? Can I force Oracle to use the similar Execution Plan using hint clause or anything?

  |--Compute Scalar(DEFINE:([Expr1008]=CASE WHEN [Expr1006] IS NULL THEN (0) ELSE [Expr1006] END))
       |--Parallelism(Gather Streams)
            |--Hash Match(Right Outer Join, HASH:([DB_X].[dbo].[T_X].[ColX])=([DB_X].[dbo].[T_Y].[ColY]), RESIDUAL:([DB_X].[dbo].[T_X].[ColX]=[DB_X].[dbo].[T_Y].[ColY]))
                 |--Compute Scalar(DEFINE:([Expr1006]=CONVERT_IMPLICIT(int,[Expr1013],0)))
                 |    |--Hash Match(Aggregate, HASH:([DB_X].[dbo].[T_X].[ColX]), RESIDUAL:([DB_X].[dbo].[T_X].[ColX] = [DB_X].[dbo].[T_X].[ColX]) DEFINE:([Expr1013]=COUNT(*)))
                 |         |--Parallelism(Repartition Streams, Hash Partitioning, PARTITION COLUMNS:([DB_X].[dbo].[T_X].[ColX]))
                 |              |--Clustered Index Scan(OBJECT:([DB_X].[dbo].[T_X].[PK_T_X]))
                 |--Parallelism(Repartition Streams, Hash Partitioning, PARTITION COLUMNS:([DB_X].[dbo].[T_Y].[ColY]))
                      |--Clustered Index Scan(OBJECT:([DB_X].[dbo].[T_Y].[PK_T_Y]))

Answer 1

You need an index on t_x(colX) . I am guessing this index exists on SQL Server.

This version might be faster on either machine:

select t_x.colX, count(1)
from T_X 
group by t_x.colX;

It is not exactly the same, but it might be what you really want.

Answer 2

Our purpose is to find out (the count of) records in T_Y that doesn't have correspondent records in other tables (T_A, T_B, T_C, T_D, T_E, T_X).

That would better be expressed as:

select          
  count(*)          
from            
  T_Y
where ColH in ('X') and
      not exists (select null from T_A A where A.ColA = T_Y.ColY) and
      not exists (select null from T_B B where B.ColB = T_Y.ColY) and
      not exists (select null from T_X where T_X.ColX = T_Y.ColY) and
      not exists (select null from T_C C where C.ColC = T_Y.ColY) and
      not exists (select null from T_D D where D.ColD = T_Y.ColY) and
      not exists (select null from T_E E where E.ColE = T_Y.ColY);