CROSS JOIN vs INNER JOIN in SQL

Qual è la differenza tra CROSS JOINe INNER JOIN?

CROSS JOIN:

SELECT 
    Movies.CustomerID, Movies.Movie, Customers.Age, 
    Customers.Gender, Customers.[Education Level], 
    Customers.[Internet Connection], Customers.[Marital Status], 
FROM   
    Customers 
CROSS JOIN 
    Movies

ISCRIVITI ALL'INTERNO:

SELECT 
    Movies.CustomerID, Movies.Movie, Customers.Age, 
    Customers.Gender, Customers.[Education Level], 
    Customers.[Internet Connection], Customers.[Marital Status]
FROM   
    Customers 
INNER JOIN 
    Movies ON Customers.CustomerID = Movies.CustomerID

Qual è il migliore e perché dovrei usarne uno?

Il cross join non combina le righe, se in ogni tabella sono presenti 100 righe con corrispondenza 1 a 1, si ottengono 10.000 risultati, Innerjoin restituirà solo 100 righe nella stessa situazione.

Questi 2 esempi restituiranno lo stesso risultato:

Cross join

select * from table1 cross join table2 where table1.id = table2.fk_id

Join interno

select * from table1 join table2 on table1.id = table2.fk_id

Usa l'ultimo metodo

Ecco il miglior esempio di Cross Join e Inner Join.

Considera le seguenti tabelle

TAVOLO : Teacher

x------------------------x
| TchrId   | TeacherName | 
x----------|-------------x
|    T1    |    Mary     |
|    T2    |    Jim      |
x------------------------x

TAVOLO : Student

x--------------------------------------x
|  StudId  |    TchrId   | StudentName | 
x----------|-------------|-------------x            
|    S1    |     T1      |    Vineeth  |
|    S2    |     T1      |    Unni     |
x--------------------------------------x

1. UNIONE INTERNA

Il join interno seleziona le righe che soddisfano sia la tabella .

Considera che dobbiamo trovare gli insegnanti che sono insegnanti di classe e i loro studenti corrispondenti. In tale condizione, dobbiamo applicare JOINo INNER JOINe volontà

domanda

SELECT T.TchrId,T.TeacherName,S.StudentName 
FROM #Teacher T
INNER JOIN #Student S ON T.TchrId = S.TchrId

• SQL FIDDLE

Risultato

x--------------------------------------x
|  TchrId  | TeacherName | StudentName | 
x----------|-------------|-------------x            
|    T1    |     Mary    |    Vineeth  |
|    T1    |     Mary    |    Unni     |
x--------------------------------------x

2. CROSS JOIN

Cross join seleziona tutte le righe dalla prima tabella e tutte le righe dalla seconda tabella e mostra come prodotto cartesiano, vale a dire con tutte le possibilità.

Consideriamo che dobbiamo trovare tutti gli insegnanti nella scuola e gli studenti indipendentemente dagli insegnanti di classe, dobbiamo applicare CROSS JOIN.

domanda

SELECT T.TchrId,T.TeacherName,S.StudentName 
FROM #Teacher T
CROSS JOIN #Student S 

• SQL FIDDLE

Risultato

x--------------------------------------x
|  TchrId  | TeacherName | StudentName | 
x----------|-------------|-------------x            
|    T2    |     Jim     |    Vineeth  |
|    T2    |     Jim     |    Unni     |
|    T1    |     Mary    |    Vineeth  |
|    T1    |     Mary    |    Unni     |
x--------------------------------------x

CROSS JOIN = (INNER) JOIN = virgola (",")

TL; DR L'unica differenza tra SQL CROSS JOIN, (INNER) JOIN e virgola (",") (oltre alla virgola che ha una precedenza inferiore per l'ordine di valutazione) è che (INNER) JOIN ha un ON mentre CROSS JOIN e la virgola no.

Re prodotti intermedi

Tutti e tre producono un prodotto "cartesiano" relazionale intermedio concettuale, detto anche cross join, di tutte le possibili combinazioni di una riga di ogni tabella. È ON e / o WHERE che riduce il numero di righe. SQL Fiddle

Lo standard SQL definisce <comma> tramite prodotto (7.5 1.b.ii), <cross join> via <comma> (7.7 1.a) e JOIN ON <condizione di ricerca> via <comma> più DOVE (7.7 1.b ).

Come dice Wikipedia:

Cross join

CROSS JOIN restituisce il prodotto cartesiano delle righe dalle tabelle nel join. In altre parole, produrrà righe che combinano ciascuna riga della prima tabella con ogni riga della seconda tabella.

Join interno

[...] Il risultato del join può essere definito come il risultato della prima acquisizione del prodotto cartesiano (o cross join) di tutti i record nelle tabelle (combinando tutti i record nella tabella A con tutti i record nella tabella B) e quindi restituendo tutti i record che soddisfano il predicato di join.

La "notazione di join implicita" elenca semplicemente le tabelle per l'unione, nella clausola FROM dell'istruzione SELECT, usando le virgole per separarle. Quindi specifica un cross join

Re ESTERNO raggiunge e utilizza ON vs DOVE in loro vedere le condizioni in LEFT JOIN (OUTER JOIN) vs INNER JOIN .

Perché confrontare le colonne tra le tabelle?

Quando non ci sono righe duplicate:

Ogni tabella contiene le righe che formano una vera istruzione da un determinato modello di istruzioni per riempire gli spazi vuoti. (Fa una proposta vera da-- soddisfa - un certo predicato (caratteristico) .)

• Una tabella di base contiene le righe che creano un'istruzione vera da alcuni modelli di istruzioni forniti da DBA:

  /* rows where
  customer C.CustomerID has age C.Age and ...
  */
  FROM Customers C

• Il prodotto intermedio di un join contiene le righe che rilasciano una dichiarazione vera dall'AND dei modelli dei suoi operandi:

  /* rows where
      customer C.CustomerID has age C.Age and ...
  AND movie M.Movie is rented by customer M.CustomerID and ...
  */
  FROM Customers C CROSS JOIN Movies M

• ON & DOVE vengono inserite le condizioni per fornire un ulteriore modello. Il valore è di nuovo le righe che soddisfano quel modello:

  /* rows where
      customer C.CustomerID has age C.Age and ...
  AND movie M.Movie is rented by customer M.CustomerID and ...
  AND C.CustomerID = M.CustomerID
  AND C.Age >= M.[Minimum Age]
  AND C.Age = 18
  */
  FROM Customers C INNER JOIN Movies M
  ON C.CustomerID = M.CustomerID
  AND C.Age >= M.[Minimum Age]
  WHERE C.Age = 18

In particolare, il confronto delle colonne per l'uguaglianza (SQL) tra le tabelle significa che le righe mantenute dal prodotto dalle parti del modello delle tabelle unite hanno lo stesso valore (non NULL) per quelle colonne. È solo una coincidenza che molte righe vengano in genere rimosse dai confronti di uguaglianza tra le tabelle: ciò che è necessario e sufficiente è caratterizzare le righe desiderate.

Scrivi SQL per il modello per le righe che desideri!

Per quanto riguarda il significato delle query (e le tabelle rispetto alle condizioni) vedere:
Come ottenere i dati corrispondenti da un'altra tabella SQL per due colonne diverse: Inner Join e / o Union?
Esiste una regola empirica per costruire query SQL da una descrizione leggibile dall'uomo?

Sovraccarico di "cross join"

Sfortunatamente il termine "cross join" viene utilizzato per:

• Il prodotto intermedio.
• CROSS JOIN.
• (INTERNO) UNISCITI con un ON o DOVE che non confronta le colonne di una tabella con le colonne di un'altra. (Dal momento che tende a restituire così tante righe di prodotto intermedie.)

Questi vari significati vengono confusi. (Ad esempio come in altre risposte e commenti qui.)

Utilizzo di CROSS JOIN vs (INNER) JOIN vs virgola

La convenzione comune è:

• Utilizzare CROSS JOIN quando e solo quando non si confrontano le colonne tra le tabelle. Questo per dimostrare che la mancanza di confronti era intenzionale.
• Utilizzare (INNER) UNISCITI con ON quando e solo quando si confrontano le colonne tra le tabelle. (Più probabilmente altre condizioni.)
• Non usare la virgola.

In genere anche le condizioni non su coppie di tabelle vengono mantenute per un WHERE. Tuttavia, potrebbe essere necessario inserirli in (n INNER) JOIN ON per ottenere le righe appropriate per l'argomento in un JOIN RIGHT, LEFT o FULL (OUTER).

Ri "Non usare la virgola" Il mix di virgola con JOIN esplicito può fuorviare perché la virgola ha una precedenza inferiore. Ma dato il ruolo del prodotto intermedio nel significato di CROSS JOIN, (INNER) JOIN e virgola, gli argomenti per la convenzione sopra di non usarlo affatto sono traballanti. Una CROSS JOIN o una virgola è proprio come una (INNER) JOIN che si trova su una VERA condizione. Un prodotto intermedio, ON e WHERE introducono tutti un AND nel predicato corrispondente. Comunque si può pensare ad INNER JOIN ON - diciamo, generare una riga di output solo quando si trova una coppia di righe di input che soddisfa la condizione ON - restituisce comunque le righe di cross join che soddisfano la condizione. L'unico motivo per cui ON era integrare la virgola in SQL era scrivere OUTERJoin. Naturalmente, un'espressione dovrebbe chiarirne il significato; ma ciò che è chiaro dipende dal significato delle cose.

Diagrammi di Re Venn Un diagramma di Venn con due cerchi che si intersecano può illustrare la differenza tra le righe di output per INNER, LEFT, RIGHT e FULL JOINs per lo stesso input. E quando ON è incondizionatamente VERO, il risultato INNER JOIN è lo stesso di CROSS JOIN. Inoltre può illustrare le righe di input e output per INTERSECT, UNION & EXCEPT. E quando entrambi gli input hanno le stesse colonne, il risultato INTERSECT è lo stesso di SQL NATURAL JOIN standard e il risultato EXCEPT è lo stesso di alcuni idiomi che coinvolgono LEFT & RIGHT JOIN. Ma non illustra come funziona (INNER) JOIN in generale. A prima vista sembra plausibile . Può identificare parti di di input e / o output percasi specialidi ON, PK (chiavi primarie), FK (chiavi esterne) e / o SELEZIONA. Tutto quello che devi fare per vedere questo è identificare quali sono esattamente gli elementi degli insiemi rappresentati dai cerchi . (Il che farraginoso presentazioni non fanno mai chiaro.) (Ricordate che in generale per unisce righe di output hanno intestazioni differenti da file di input . Tabelle e SQL sono sacchi non insiemi di righe con NULL .)

Inner Join

Il join che visualizza solo le righe che hanno una corrispondenza in entrambe le tabelle unite è noto come join interno. Questo è un join predefinito nella query e visualizza Designer.

Sintassi per Inner Join

SELECT t1.column_name,t2.column_name
FROM table_name1 t1
INNER JOIN table_name2 t2
ON t1.column_name=t2.column_name

Cross Join

Un join incrociato che produce il prodotto cartesiano delle tabelle coinvolte nel join. La dimensione di un prodotto cartesiano è il numero di righe nella prima tabella moltiplicato per il numero di righe nella seconda tabella.

Sintassi per Cross Join

SELECT * FROM table_name1
CROSS JOIN table_name2

Oppure possiamo scriverlo anche in un altro modo

SELECT * FROM table_name1,table_name2

Ora controlla la query qui sotto per Cross join

Esempio

SELECT * FROM UserDetails
CROSS JOIN OrderDetails

O

SELECT * FROM UserDetails, OrderDetails

Ricorda, se viene aggiunta una clausola WHERE, il cross join si comporta come un join interno. Ad esempio, le seguenti query Transact-SQL producono lo stesso set di risultati. Fare riferimento a http://technet.microsoft.com/en-us/library/ms190690(v=sql.105).aspx

CROSS JOIN

Come ho spiegato in questo articolo , CROSS JOIN ha lo scopo di generare un prodotto cartesiano.

Un prodotto cartesiano prende due serie A e B e genera tutte le possibili permutazioni dei record di coppia da due serie di dati dati.

Per esempio, a patto di avere i seguenti rankse suitsdel database tabelle:

E il ranksha le seguenti righe:

| name  | symbol | rank_value |
|-------|--------|------------|
| Ace   | A      | 14         |
| King  | K      | 13         |
| Queen | Q      | 12         |
| Jack  | J      | 11         |
| Ten   | 10     | 10         |
| Nine  | 9      |  9         |

Mentre la suitstabella contiene i seguenti record:

| name    | symbol |
|---------|--------|
| Club    | ♣      |
| Diamond | ♦      |
| Heart   | ♥      |
| Spade   | ♠      |

Come query CROSS JOIN come la seguente:

SELECT
   r.symbol AS card_rank,
   s.symbol AS card_suit
FROM
   ranks r
CROSS JOIN
   suits s

genererà tutte le possibili permutazioni di rankse suitescoppie:

| card_rank | card_suit |
|-----------|-----------|
| A         | ♣         |
| A         | ♦         |
| A         | ♥         |
| A         | ♠         |
| K         | ♣         |
| K         | ♦         |
| K         | ♥         |
| K         | ♠         |
| Q         | ♣         |
| Q         | ♦         |
| Q         | ♥         |
| Q         | ♠         |
| J         | ♣         |
| J         | ♦         |
| J         | ♥         |
| J         | ♠         |
| 10        | ♣         |
| 10        | ♦         |
| 10        | ♥         |
| 10        | ♠         |
| 9         | ♣         |
| 9         | ♦         |
| 9         | ♥         |
| 9         | ♠         |

UNIONE INTERNA

D'altra parte, INNER JOIN non restituisce il prodotto cartesiano dei due set di dati di unione.

Invece, INNER JOIN prende tutti gli elementi dalla tabella di sinistra e li confronta con i record della tabella di destra in modo che:

• se nessun record corrisponde alla tabella di destra, la riga di sinistra viene filtrata dal set di risultati
• per qualsiasi record corrispondente sulla tabella di destra, la riga di sinistra viene ripetuta come se ci fosse un Prodotto cartesiano tra quella registrazione e tutti i relativi record figlio associati nella tabella di destra.

Ad esempio, supponendo che abbiamo una relazione da una a molte tabelle tra una tabella padre poste una post_commenttabella figlio che abbia il seguente aspetto:

Ora, se la posttabella ha i seguenti record:

| id | title     |
|----|-----------|
| 1  | Java      |
| 2  | Hibernate |
| 3  | JPA       |

e la post_commentstabella ha queste righe:

| id | review    | post_id |
|----|-----------|---------|
| 1  | Good      | 1       |
| 2  | Excellent | 1       |
| 3  | Awesome   | 2       |

Una query INNER JOIN come la seguente:

SELECT
   p.id AS post_id,
   p.title AS post_title,
   pc.review  AS review
FROM post p
INNER JOIN post_comment pc ON pc.post_id = p.id

includerà tutti i postrecord insieme a tutti i loro associati post_comments:

| post_id | post_title | review    |
|---------|------------|-----------|
| 1       | Java       | Good      |
| 1       | Java       | Excellent |
| 2       | Hibernate  | Awesome   |

Fondamentalmente, puoi pensare a INNER JOIN come a CROSS JOIN filtrato in cui solo i record corrispondenti vengono conservati nel set di risultati finale.

Per maggiori dettagli sul funzionamento di INNER JOIN, consulta anche questo articolo .

SQL Server accetta anche la notazione più semplice di:

SELECT A.F, 
       B.G, 
       C.H 
  FROM TABLE_A A, 
       TABLE_B B, 
       TABLE_C C
 WHERE A.X = B.X 
   AND B.Y = C.Y

Utilizzando questa semplice notazione, non è necessario preoccuparsi della differenza tra i join interni e incrociati. Invece di due clausole "ON", esiste una sola clausola "WHERE" che fa il lavoro. Se hai qualche difficoltà a capire quali clausole "JOIN" "ON" vanno dove, abbandona la notazione "JOIN" e usa quella più semplice sopra.

Non è barare.

Durante la scrittura di query utilizzando i join interni, i record recuperano da entrambe le tabelle se la condizione è soddisfatta su entrambe le tabelle, ovvero la corrispondenza esatta della colonna comune in entrambe le tabelle.

Mentre si scrive query usando cross join il risultato è come un prodotto cartesiano del no di record in entrambe le tabelle. esempio se table1 contiene 2 record e table2 contiene 3 record, il risultato della query è 2 * 3 = 6 record.

Quindi non andare per cross join fino a quando non ne hai bisogno.

Il cross join e il join interno sono gli stessi con l'unica differenza che nel join interno filtriamo in modo booleano alcuni dei risultati del prodotto cartesiano

table1
x--------------------------------------x
|  fieldA  |    fieldB   |    fieldC   | 
x----------|-------------|-------------x            
|    A     |      B      |    option1  |
|    A     |      B1     |    option2  |
x--------------------------------------x

table2
x--------------------------------------x
|  fieldA  |    fieldB   |    fieldC   | 
x----------|-------------|-------------x            
|    A     |      B      |    optionB1 |
|    A1    |      B1     |    optionB2 |
x--------------------------------------x

 cross join
  A,B,option1,A,B,optionB1
  A,B,option1,A1,B1,optionB2
  A,B1,option2,A,B,optionB1
  A,B1,option2,A1,B1,optionB2

 inner join on field1 (only with the value is the same in both tables)
  A,B,option1,A,B,optionB1
  A,B1,option2,A,B,optionB1

 inner join on field1
  A,B,option1,A,B,optionB1

È sulla progettazione dei nostri dati che decidiamo che esiste un solo caso del campo che stiamo usando per il join. Unisci solo incrocia unisci entrambe le tabelle e ottieni solo le linee che realizzano un'espressione booleana speciale.

Nota che se i campi su cui stiamo eseguendo i nostri join sarebbero nulli in entrambe le tabelle, passeremmo il filtro. Spetta a noi o al produttore del database aggiungere ulteriori regole per evitare o consentire null. Aderendo alle basi è solo un cross join seguito da un filtro.

Il join interno fornirà il risultato di record corrispondenti tra due tabelle, mentre il join incrociato fornisce le possibili combinazioni tra due tabelle.

A = {1,5,3,4,6,7,9,8} B = {2,8,5,4,3,6,9}

cross join agire come prodotto cartesiano A ✖ B = {1,2}, {1,8} ..., {5,2}, {5,8}, {5,5} ..... {3,3} ..., {6,6} .... {8,9} e ha restituito questo set di risultati lungo ..

quando inner joinlo si fa attraverso il prodotto cartesiano e si scelgono le coppie corrispondenti .. se si pensa che questa coppia ordinata sia la chiave primaria di due tabelle e la ricerca della clausola A = B, inner joinscegliere {5,5}, {4,4}, {6,6} , {9,9} e ha restituito la colonna richiesta nella clausola select relativa a questi ID.

se cross joinsu a = b il risultato è lo stesso set di risultati di inner join. in quel caso anche usare inner join.

Dipende dall'output che ti aspetti.

Un cross join abbina tutte le righe di una tabella a tutte le righe di un'altra tabella. Un join interno corrisponde su uno o più campi. Se hai una tabella con 10 righe e un'altra con 10 righe, i due join si comporteranno diversamente.

Il cross join avrà restituito 100 righe e non saranno correlate, proprio quello che viene chiamato un prodotto cartesiano. Il join interno abbinerà i record tra loro. Supponendo che uno abbia una chiave primaria e che sia una chiave esterna nell'altra, si otterrebbero 10 righe restituite.

Un cross join ha un'utilità generale limitata, ma esiste per completezza e descrive il risultato dell'unione di tabelle senza relazioni aggiunte alla query. È possibile utilizzare un join incrociato per creare elenchi di combinazioni di parole o qualcosa di simile. Un join interno invece è il join più comune.