Kapan saya harus menggunakan cross apply pada inner join?

Apa tujuan utama penggunaan CROSS APPLY ?

Saya telah membaca (samar-samar, melalui posting di Internet) yang cross applybisa lebih efisien ketika memilih lebih dari set data besar jika Anda mempartisi. (Paging datang ke pikiran)

Saya juga tahu bahwa CROSS APPLYtidak memerlukan UDF sebagai tabel kanan.

Dalam sebagian besar INNER JOINkueri (hubungan satu-ke-banyak), saya bisa menulis ulang untuk digunakan CROSS APPLY, tetapi mereka selalu memberi saya rencana eksekusi yang setara.

Adakah yang bisa memberi saya contoh yang baik ketika CROSS APPLYmembuat perbedaan dalam kasus-kasus di mana INNER JOINakan bekerja juga?

Edit:

Berikut ini contoh sepele, di mana rencana eksekusi persis sama. (Tunjukkan satu di mana mereka berbeda dan di mana cross applylebih cepat / lebih efisien)

create table Company (
    companyId int identity(1,1)
,   companyName varchar(100)
,   zipcode varchar(10) 
,   constraint PK_Company primary key (companyId)
)
GO

create table Person (
    personId int identity(1,1)
,   personName varchar(100)
,   companyId int
,   constraint FK_Person_CompanyId foreign key (companyId) references dbo.Company(companyId)
,   constraint PK_Person primary key (personId)
)
GO

insert Company
select 'ABC Company', '19808' union
select 'XYZ Company', '08534' union
select '123 Company', '10016'


insert Person
select 'Alan', 1 union
select 'Bobby', 1 union
select 'Chris', 1 union
select 'Xavier', 2 union
select 'Yoshi', 2 union
select 'Zambrano', 2 union
select 'Player 1', 3 union
select 'Player 2', 3 union
select 'Player 3', 3 


/* using CROSS APPLY */
select *
from Person p
cross apply (
    select *
    from Company c
    where p.companyid = c.companyId
) Czip

/* the equivalent query using INNER JOIN */
select *
from Person p
inner join Company c on p.companyid = c.companyId

Adakah yang bisa memberi saya contoh yang bagus ketika CROSS BERLAKU membuat perbedaan dalam kasus-kasus di mana INNER BERGABUNG juga bekerja?

Lihat artikel di blog saya untuk perbandingan kinerja terperinci:

• INNER JOIN vs. CROSS APPLY

CROSS APPLYbekerja lebih baik pada hal-hal yang tidak memiliki JOINkondisi sederhana .

Yang ini memilih 3catatan terakhir dari t2untuk setiap catatan dari t1:

SELECT  t1.*, t2o.*
FROM    t1
CROSS APPLY
        (
        SELECT  TOP 3 *
        FROM    t2
        WHERE   t2.t1_id = t1.id
        ORDER BY
                t2.rank DESC
        ) t2o

Itu tidak dapat dengan mudah dirumuskan dengan suatu INNER JOINsyarat.

Anda mungkin dapat melakukan sesuatu seperti itu menggunakan CTEfungsi dan jendela:

WITH    t2o AS
        (
        SELECT  t2.*, ROW_NUMBER() OVER (PARTITION BY t1_id ORDER BY rank) AS rn
        FROM    t2
        )
SELECT  t1.*, t2o.*
FROM    t1
INNER JOIN
        t2o
ON      t2o.t1_id = t1.id
        AND t2o.rn <= 3

, tetapi ini kurang dapat dibaca dan mungkin kurang efisien.

Memperbarui:

Baru diperiksa.

masteradalah tabel tentang 20,000,000catatan dengan PRIMARY KEYon id.

Kueri ini:

WITH    q AS
        (
        SELECT  *, ROW_NUMBER() OVER (ORDER BY id) AS rn
        FROM    master
        ),
        t AS 
        (
        SELECT  1 AS id
        UNION ALL
        SELECT  2
        )
SELECT  *
FROM    t
JOIN    q
ON      q.rn <= t.id

berjalan selama hampir 30detik, sementara yang ini:

WITH    t AS 
        (
        SELECT  1 AS id
        UNION ALL
        SELECT  2
        )
SELECT  *
FROM    t
CROSS APPLY
        (
        SELECT  TOP (t.id) m.*
        FROM    master m
        ORDER BY
                id
        ) q

instan.

cross applyterkadang memungkinkan Anda untuk melakukan hal-hal yang tidak dapat Anda lakukan inner join.

Contoh (kesalahan sintaksis):

select F.* from sys.objects O  
inner join dbo.myTableFun(O.name) F   
on F.schema_id= O.schema_id

Ini adalah kesalahan sintaksis , karena, ketika digunakan dengan inner join, fungsi tabel hanya dapat mengambil variabel atau konstanta sebagai parameter. (Yaitu, parameter fungsi tabel tidak dapat bergantung pada kolom tabel lain.)

Namun:

select F.* from sys.objects O  
cross apply ( select * from dbo.myTableFun(O.name) ) F  
where F.schema_id= O.schema_id

Ini legal.

Sunting: Atau sebagai alternatif, sintaksis lebih pendek: (oleh ErikE)

select F.* from sys.objects O  
cross apply dbo.myTableFun(O.name) F
where F.schema_id= O.schema_id

Edit:

Catatan: Informix 12.10 xC2 + memiliki Tabel Lateral Derived dan Postgresql (9.3+) memiliki Subqueries Lateral yang dapat digunakan untuk efek yang sama.

Anggap Anda memiliki dua tabel.

Tabel MASTER

x------x--------------------x
| Id   |        Name        |
x------x--------------------x
|  1   |          A         |
|  2   |          B         |
|  3   |          C         |
x------x--------------------x

TABEL DETAIL

x------x--------------------x-------x
| Id   |      PERIOD        |   QTY |
x------x--------------------x-------x
|  1   |   2014-01-13       |   10  |
|  1   |   2014-01-11       |   15  |
|  1   |   2014-01-12       |   20  |
|  2   |   2014-01-06       |   30  |
|  2   |   2014-01-08       |   40  |
x------x--------------------x-------x

Ada banyak situasi di mana kita perlu mengganti INNER JOINdengan CROSS APPLY.

1. Gabung dua tabel berdasarkan TOP nhasil

Pertimbangkan apakah kita perlu memilih Iddan Namedari Masterdan dua tanggal terakhir untuk masing-masing Iddari Details table.

SELECT M.ID,M.NAME,D.PERIOD,D.QTY
FROM MASTER M
INNER JOIN
(
    SELECT TOP 2 ID, PERIOD,QTY 
    FROM DETAILS D      
    ORDER BY CAST(PERIOD AS DATE)DESC
)D
ON M.ID=D.ID

• SQL FIDDLE

Permintaan di atas menghasilkan hasil berikut.

x------x---------x--------------x-------x
|  Id  |   Name  |   PERIOD     |  QTY  |
x------x---------x--------------x-------x
|   1  |   A     | 2014-01-13   |  10   |
|   1  |   A     | 2014-01-12   |  20   |
x------x---------x--------------x-------x

Lihat, itu menghasilkan hasil untuk dua tanggal terakhir dengan dua tanggal terakhir Iddan kemudian bergabung dengan catatan ini hanya di permintaan luar Id, yang salah. Ini harus mengembalikan Ids1 dan 2 tetapi mengembalikan hanya 1 karena 1 memiliki dua tanggal terakhir. Untuk mencapai ini, kita perlu menggunakan CROSS APPLY.

SELECT M.ID,M.NAME,D.PERIOD,D.QTY
FROM MASTER M
CROSS APPLY
(
    SELECT TOP 2 ID, PERIOD,QTY 
    FROM DETAILS D  
    WHERE M.ID=D.ID
    ORDER BY CAST(PERIOD AS DATE)DESC
)D

• SQL FIDDLE

dan membentuk hasil sebagai berikut.

x------x---------x--------------x-------x
|  Id  |   Name  |   PERIOD     |  QTY  |
x------x---------x--------------x-------x
|   1  |   A     | 2014-01-13   |  10   |
|   1  |   A     | 2014-01-12   |  20   |
|   2  |   B     | 2014-01-08   |  40   |
|   2  |   B     | 2014-01-06   |  30   |
x------x---------x--------------x-------x

Begini cara kerjanya. Kueri di dalam CROSS APPLYdapat merujuk tabel luar, di mana INNER JOINtidak bisa melakukan ini (itu melemparkan kesalahan kompilasi). Ketika menemukan dua tanggal terakhir, bergabung dilakukan di dalam CROSS APPLYyaitu WHERE M.ID=D.ID,.

2. Ketika kita membutuhkan INNER JOINfungsionalitas menggunakan fungsi.

CROSS APPLYdapat digunakan sebagai pengganti INNER JOINketika kita perlu mendapatkan hasil dari Mastertabel dan a function.

SELECT M.ID,M.NAME,C.PERIOD,C.QTY
FROM MASTER M
CROSS APPLY dbo.FnGetQty(M.ID) C

Dan inilah fungsinya

CREATE FUNCTION FnGetQty 
(   
    @Id INT 
)
RETURNS TABLE 
AS
RETURN 
(
    SELECT ID,PERIOD,QTY 
    FROM DETAILS
    WHERE ID=@Id
)

• SQL FIDDLE

yang menghasilkan hasil berikut

x------x---------x--------------x-------x
|  Id  |   Name  |   PERIOD     |  QTY  |
x------x---------x--------------x-------x
|   1  |   A     | 2014-01-13   |  10   |
|   1  |   A     | 2014-01-11   |  15   |
|   1  |   A     | 2014-01-12   |  20   |
|   2  |   B     | 2014-01-06   |  30   |
|   2  |   B     | 2014-01-08   |  40   |
x------x---------x--------------x-------x

KEUNTUNGAN TAMBAHAN LINTAS BERLAKU

APPLYdapat digunakan sebagai pengganti UNPIVOT. Entah CROSS APPLYatau OUTER APPLYdapat digunakan di sini, yang dapat dipertukarkan.

Anggap Anda memiliki tabel di bawah ini (bernama MYTABLE).

x------x-------------x--------------x
|  Id  |   FROMDATE  |   TODATE     |
x------x-------------x--------------x
|   1  |  2014-01-11 | 2014-01-13   | 
|   1  |  2014-02-23 | 2014-02-27   | 
|   2  |  2014-05-06 | 2014-05-30   | 
|   3  |     NULL    |    NULL      |
x------x-------------x--------------x

Kueri di bawah ini.

SELECT DISTINCT ID,DATES
FROM MYTABLE 
CROSS APPLY(VALUES (FROMDATE),(TODATE))
COLUMNNAMES(DATES)

• SQL FIDDLE

yang membawa Anda hasilnya

  x------x-------------x
  | Id   |    DATES    |
  x------x-------------x
  |  1   |  2014-01-11 |
  |  1   |  2014-01-13 |
  |  1   |  2014-02-23 |
  |  1   |  2014-02-27 |
  |  2   |  2014-05-06 |
  |  2   |  2014-05-30 | 
  |  3   |    NULL     | 
  x------x-------------x

Tampak bagi saya bahwa CROSS BERLAKU dapat mengisi celah tertentu ketika bekerja dengan bidang terhitung dalam kueri kompleks / bersarang, dan membuatnya lebih sederhana dan lebih mudah dibaca.

Contoh sederhana: Anda memiliki DoB dan ingin menyajikan beberapa bidang yang berkaitan dengan usia yang juga akan bergantung pada sumber data lain (seperti pekerjaan), seperti Umur, AgeGroup, AgeAtHiring, MinimumRetirementDate, dll. Untuk digunakan dalam aplikasi pengguna akhir Anda (Excel PivotTables, misalnya).

Opsi terbatas dan jarang elegan:

• BERGABUNG subqueries tidak dapat memperkenalkan nilai baru dalam dataset berdasarkan data dalam kueri induk (itu harus berdiri sendiri).

• UDF rapi, tetapi lambat karena cenderung mencegah operasi paralel. Dan menjadi entitas yang terpisah dapat menjadi hal yang baik (kode kurang) atau buruk (di mana kode).

• Tabel persimpangan. Kadang-kadang mereka dapat bekerja, tetapi segera Anda bergabung dengan subqueries dengan banyak UNION. Kekacauan besar.

• Buat lagi tampilan tujuan tunggal, dengan anggapan perhitungan Anda tidak memerlukan data yang diperoleh di tengah jalan melalui permintaan utama Anda.

• Tabel perantara. Ya ... itu biasanya bekerja, dan seringkali merupakan opsi yang baik karena dapat diindeks dan cepat, tetapi kinerja juga dapat turun karena pernyataan UPDATE tidak paralel dan tidak memungkinkan untuk mengalirkan rumus (menggunakan kembali hasil) untuk memperbarui beberapa bidang dalam pernyataan yang sama. Dan kadang-kadang Anda lebih suka melakukan hal-hal sekaligus.

• Permintaan bersarang. Ya pada titik mana pun Anda dapat menempatkan tanda kurung di seluruh kueri Anda dan menggunakannya sebagai subquery tempat Anda dapat memanipulasi data sumber dan bidang yang dihitung sama. Tetapi Anda hanya bisa melakukan ini begitu banyak sebelum menjadi jelek. Sangat jelek.

• Kode berulang. Apa nilai terbesar dari 3 pernyataan panjang (KASUS ... LAIN ... AKHIR)? Itu akan bisa dibaca!

  • Beri tahu klien Anda untuk menghitung sendiri.

Apakah saya melewatkan sesuatu? Mungkin, jadi jangan ragu untuk berkomentar. Tapi hei, LINTAS BERLAKU adalah seperti anugerah dalam situasi seperti: Anda hanya menambahkan sederhanaCROSS APPLY (select tbl.value + 1 as someFormula) as crossTbl dan voila! Bidang baru Anda sekarang siap digunakan secara praktis seperti selalu ada di sumber data Anda.

Nilai-nilai yang diperkenalkan melalui CROSS APPLY dapat ...

• digunakan untuk membuat satu atau beberapa bidang terhitung tanpa menambahkan masalah kinerja, kompleksitas atau keterbacaan ke dalam campuran
• seperti dengan BERGABUNG, beberapa pernyataan BERLAKU LINTAS berikutnya dapat merujuk pada diri mereka sendiri: CROSS APPLY (select crossTbl.someFormula + 1 as someMoreFormula) as crossTbl2
• Anda dapat menggunakan nilai yang diperkenalkan oleh CROSS BERLAKU dalam kondisi BERGABUNG berikutnya
• Sebagai bonus, ada aspek fungsi yang dihargai Tabel

Sial, tidak ada yang tidak bisa mereka lakukan!

Lintas berlaku berfungsi dengan baik dengan bidang XML juga. Jika Anda ingin memilih nilai simpul dalam kombinasi dengan bidang lain.

Misalnya, jika Anda memiliki tabel yang berisi beberapa xml

<root>
    <subnode1>
       <some_node value="1" />
       <some_node value="2" />
       <some_node value="3" />
       <some_node value="4" />
    </subnode1>
</root>

Menggunakan kueri

SELECT
       id as [xt_id]
      ,xmlfield.value('(/root/@attribute)[1]', 'varchar(50)') root_attribute_value
  ,node_attribute_value = [some_node].value('@value', 'int')
  ,lt.lt_name   
FROM dbo.table_with_xml xt
CROSS APPLY xmlfield.nodes('/root/subnode1/some_node') as g ([some_node])
LEFT OUTER JOIN dbo.lookup_table lt
ON [some_node].value('@value', 'int') = lt.lt_id

Akan mengembalikan hasilnya

xt_id root_attribute_value node_attribute_value lt_name
----------------------------------------------------------------------
1     test1            1                    Benefits
1     test1            4                    FINRPTCOMPANY

Ini sudah dijawab dengan sangat baik secara teknis, tetapi izinkan saya memberikan contoh nyata bagaimana ini sangat berguna:

Katakanlah Anda memiliki dua tabel, Pelanggan dan Pesanan. Pelanggan memiliki banyak Pesanan.

Saya ingin membuat tampilan yang memberi saya detail tentang pelanggan, dan pesanan terbaru yang mereka buat. Hanya dengan BERGABUNG, ini akan membutuhkan beberapa penggabungan dan agregasi diri yang tidak cantik. Tetapi dengan Cross Apply, ini sangat mudah:

SELECT *
FROM Customer
CROSS APPLY (
  SELECT TOP 1 *
  FROM Order
  WHERE Order.CustomerId = Customer.CustomerId
  ORDER BY OrderDate DESC
) T

Cross apply dapat digunakan untuk menggantikan subquery di mana Anda memerlukan kolom subquery

subquery

select * from person p where
p.companyId in(select c.companyId from company c where c.companyname like '%yyy%')

di sini saya tidak akan dapat memilih kolom dari tabel perusahaan jadi, menggunakan lintas berlaku

select P.*,T.CompanyName
from Person p
cross apply (
    select *
    from Company C
    where p.companyid = c.companyId and c.CompanyName like '%yyy%'
) T

Saya kira itu harus dibaca;)

LINTAS BERLAKU akan agak unik bagi orang yang membaca untuk memberi tahu mereka bahwa UDF sedang digunakan yang akan diterapkan ke setiap baris dari tabel di sebelah kiri.

Tentu, ada batasan lain di mana CROSS BERLAKU lebih baik digunakan daripada BERGABUNG dengan teman yang telah diposting di atas.

Berikut adalah artikel yang menjelaskan semuanya, dengan perbedaan kinerja dan penggunaannya di GABUNG.

SQL Server LINTAS BERLAKU dan OUTER BERLAKU LAGI

Seperti yang disarankan dalam artikel ini, tidak ada perbedaan kinerja di antara mereka untuk operasi join normal (INNER DAN CROSS).

Perbedaan penggunaan tiba ketika Anda harus melakukan kueri seperti ini:

CREATE FUNCTION dbo.fn_GetAllEmployeeOfADepartment(@DeptID AS INT)  
RETURNS TABLE 
AS 
RETURN 
   ( 
   SELECT * FROM Employee E 
   WHERE E.DepartmentID = @DeptID 
   ) 
GO 
SELECT * FROM Department D 
CROSS APPLY dbo.fn_GetAllEmployeeOfADepartment(D.DepartmentID)

Artinya, ketika Anda harus berhubungan dengan fungsi. Ini tidak dapat dilakukan menggunakan INNER JOIN, yang akan memberi Anda kesalahan "Pengidentifikasi multi-bagian" D.DepartmentID "tidak dapat diikat." Di sini nilainya diteruskan ke fungsi karena setiap baris dibaca. Kedengarannya keren bagiku. :)

Ya saya tidak yakin apakah ini memenuhi syarat sebagai alasan untuk menggunakan Cross Apply versus Inner Join, tetapi pertanyaan ini dijawab untuk saya di Post Forum menggunakan Cross Apply, jadi saya tidak yakin apakah ada metode equalivent menggunakan Inner Join:

Create PROCEDURE [dbo].[Message_FindHighestMatches]

-- Declare the Topical Neighborhood
@TopicalNeighborhood nchar(255)

SEBAGAI MULAI

-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with SELECT statements.
SET NOCOUNT ON

Create table  #temp
(
    MessageID         int,
    Subjects          nchar(255),
    SubjectsCount    int
)

Insert into #temp Select MessageID, Subjects, SubjectsCount From Message

Select Top 20 MessageID, Subjects, SubjectsCount,
    (t.cnt * 100)/t3.inputvalues as MatchPercentage

From #temp 

cross apply (select count(*) as cnt from dbo.Split(Subjects,',') as t1
             join dbo.Split(@TopicalNeighborhood,',') as t2
             on t1.value = t2.value) as t
cross apply (select count(*) as inputValues from dbo.Split(@TopicalNeighborhood,',')) as t3

Order By MatchPercentage desc

drop table #temp

AKHIR

Inti dari operator BERLAKU adalah untuk memungkinkan korelasi antara sisi kiri dan kanan operator dalam klausa FROM.

Berbeda dengan BERGABUNG, korelasi antara input tidak diperbolehkan.

Berbicara tentang korelasi di operator BERLAKU, maksud saya di sisi kanan kita dapat menempatkan:

• tabel turunan - sebagai subquery berkorelasi dengan alias
• fungsi bernilai tabel - tampilan konseptual dengan parameter, di mana parameter dapat merujuk ke sisi kiri

Keduanya dapat mengembalikan beberapa kolom dan baris.

Ini mungkin pertanyaan lama, tapi saya masih suka kekuatan CROSS BERLAKU untuk menyederhanakan penggunaan kembali logika dan menyediakan mekanisme "rantai" untuk hasil.

Saya telah menyediakan SQL Fiddle di bawah ini yang menunjukkan contoh sederhana tentang bagaimana Anda dapat menggunakan CROSS APPLY untuk melakukan operasi logis kompleks pada set data Anda tanpa hal-hal yang berantakan sama sekali. Tidak sulit untuk memperkirakan dari sini perhitungan yang lebih kompleks.

http://sqlfiddle.com/#!3/23862/2

Sementara sebagian besar kueri yang menggunakan CROSS APPLY dapat ditulis ulang menggunakan INNER JOIN, CROSS APPLY dapat menghasilkan rencana eksekusi yang lebih baik dan kinerja yang lebih baik, karena dapat membatasi set yang bergabung belum sebelum bergabung terjadi.

Dicuri dari Sini