Posso fare una partita della prima lettera di grandi dimensioni su due tavoli?

select value 
from persons p join persons2 p2 
    on left(p.lastname,1) = left(p2.lastname,1)

Server SQL. C'è un modo per rendere questo SARGable / correre più veloce? Non riesco a creare colonne sul tavolo people, ma posso creare colonne su people2.

Creare una vista sulle tabelle con una colonna calcolata persistente definita come LEFT(lastname, 1) di ciascuna tabella, quindi confrontare i valori della colonna persistente calcolata.

Ecco un banco di prova che mostra come farlo:

CREATE TABLE dbo.Persons
(
    PersonID int NOT NULL
        CONSTRAINT PK_Persons
        PRIMARY KEY CLUSTERED
        IDENTITY(1,1)
    , FirstName nvarchar(500) NOT NULL
    , LastName nvarchar(500) NOT NULL
);

CREATE TABLE dbo.Persons2
(
    PersonID int NOT NULL
        CONSTRAINT PK_Persons2
        PRIMARY KEY CLUSTERED
        IDENTITY(1,1)
    , FirstName nvarchar(500) NOT NULL
    , LastName nvarchar(500) NOT NULL
);

GO
CREATE VIEW dbo.PersonsView
WITH SCHEMABINDING
AS
SELECT p1.PersonID
    , p1.FirstName
    , p1.LastName 
    , LastNameInitial = LEFT(p1.LastName, 1)
FROM dbo.Persons p1;
GO
CREATE VIEW dbo.PersonsView2
WITH SCHEMABINDING
AS
SELECT p2.PersonID
    , p2.FirstName
    , p2.LastName 
    , LastNameInitial = LEFT(p2.LastName, 1)
FROM dbo.Persons p2;
GO
CREATE UNIQUE CLUSTERED INDEX CX_PersonsView
ON dbo.PersonsView(PersonID);
CREATE NONCLUSTERED INDEX IX_PersonsView_LastNameInitial
ON dbo.PersonsView(LastNameInitial)
INCLUDE (FirstName, LastName);

CREATE UNIQUE CLUSTERED INDEX CX_PersonsView2
ON dbo.PersonsView2(PersonID);
CREATE NONCLUSTERED INDEX IX_PersonsView2_LastNameInitial
ON dbo.PersonsView2(LastNameInitial)
INCLUDE (FirstName, LastName);

CREATE STATISTICS ST_PersonsView_001
ON dbo.PersonsView(LastName);

CREATE STATISTICS ST_PersonsView2_001
ON dbo.PersonsView2(LastName);

Qui inseriremo alcuni dati di esempio:

INSERT INTO dbo.Persons(FirstName, LastName)
VALUES ('Max', 'Vernon')
    , ('Joe', 'Black');

INSERT INTO dbo.Persons2(FirstName, LastName)
VALUES ('Max', 'Vernon')
    , ('Joe', 'Black');

Ecco la SELECTdomanda:

SELECT *
FROM dbo.PersonsView pv1
    INNER JOIN dbo.PersonsView2 pv2 ON pv1.LastNameInitial = pv2.LastNameInitial;

E i risultati:

+ ---------- + ----------- + ---------- + --------------- - + ---------- + ----------- + ---------- + ------------- ---- +
| PersonID | Nome | Cognome | LastNameInitial | PersonID | Nome | Cognome | LastNameInitial |
+ ---------- + ----------- + ---------- + --------------- - + ---------- + ----------- + ---------- + ------------- ---- +
| 2 | Joe | Nero | B | 2 | Joe | Nero | B |
| 1 | Max | Vernon | V | 1 | Max | Vernon | V |
+ ---------- + ----------- + ---------- + --------------- - + ---------- + ----------- + ---------- + ------------- ---- +

Il piano di esecuzione, con solo due righe per tabella (certamente non molte righe!)

Se la lastnamecolonna è indicizzata in almeno una delle tabelle, è possibile utilizzare ancheLIKE

SELECT *
FROM   persons p
       INNER JOIN persons2 p2
               ON p2.lastname LIKE LEFT(p.lastname, 1) + '%' 

Il piano per questo può avere una ricerca sulla tabella specificata a sinistra del simile.

cioè ON p.lastname LIKE LEFT(p2.lastname, 1) + '%'non sarebbe in grado di utilizzare l'indice su persons2quello che è stato usato sopra ma potrebbe cercarne uno persons.

Il suggerimento nell'altra risposta di indicizzare una colonna calcolata su entrambi i lati è tuttavia più flessibile. Per quanto riguarda un piano di cicli nidificati, una delle tabelle può trovarsi all'interno e consentirebbe anche l'unione di molti o molti senza richiedere un ordinamento.

Mi capita di avere una tabella con 3.423 righe e 195 valori distinti in Name. Chiamerò questa tabella P(persona) e la duplicherò per creare P2(persona2). Esiste una chiave primaria univoca in cluster su una colonna ID intero. Sto utilizzando Microsoft SQL Server 2016 (KB3194716) Developer Edition (64 bit) su Windows 10 Pro 6.3 con 32 GB di RAM.

Con la query di base

select
    p.pid
from dbo.p
inner join dbo.p2 
    on LEFT(p.name, 1) = LEFT(p2.name, 1);

Ottengo 1.5M righe restituite in 3200-3300ms (dalle statistiche io).

Riscrivendo così -

select
    p.pid
from dbo.p
where exists
(
    select 1
    from dbo.p2 
    where LEFT(p.name, 1) = LEFT(p2.name, 1)
);

trascorso è ridotto a 50-60 ms e il piano è:

Vengono restituite meno righe (3.423) a causa dell'algoritmo corrispondente. Lo stesso piano e conteggio righe vengono raggiunti modificando la query di base in select distinct.

Creando una colonna indicizzata e calcolata

alter table dbo.p2
add Name1 as Left(Name, 1);

create index ix1 on dbo.p2(Name1);

Il tempo trascorso scende a 45-50ms.