Puis-je faire une correspondance de première lettre discutable sur deux tables?

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

Serveur SQL. Existe-t-il un moyen de rendre ce SARGable / plus rapide? Je ne peux pas créer de colonnes sur la table des personnes, mais je peux créer des colonnes sur les personnes2.

Créez une vue sur les tables avec une colonne calculée persistante définie comme la LEFT(lastname, 1)de chaque table, puis comparez les valeurs des colonnes persistantes calculées.

Voici un banc d'essai montrant comment procéder:

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);

Ici, nous allons insérer quelques exemples de données:

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

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

Voici la SELECTrequête:

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

Et les résultats:

+ ---------- + ----------- + ---------- + --------------- - + ---------- + ----------- + ---------- + ------------- ---- +
| PersonID | Prénom | Nom | LastNameInitial | PersonID | Prénom | Nom | LastNameInitial |
+ ---------- + ----------- + ---------- + --------------- - + ---------- + ----------- + ---------- + ------------- ---- +
| 2 | Joe | Noir | B | 2 | Joe | Noir | B |
| 1 | Max | Vernon | V | 1 | Max | Vernon | V |
+ ---------- + ----------- + ---------- + --------------- - + ---------- + ----------- + ---------- + ------------- ---- +

Le plan d'exécution, avec seulement deux lignes par table (certes pas beaucoup de lignes!)

Si la lastnamecolonne est indexée dans au moins une des tables, vous pouvez également utiliserLIKE

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

Le plan pour cela peut avoir une recherche sur la table spécifiée à gauche de similaire.

c.-à ON p.lastname LIKE LEFT(p2.lastname, 1) + '%'-d. ne serait pas en mesure de faire usage de l'index persons2utilisé ci-dessus mais pourrait en rechercher un persons.

La suggestion dans l'autre réponse d'indexer une colonne calculée des deux côtés est cependant plus flexible. En ce qui concerne un plan de boucles imbriquées, chaque table peut être à l'intérieur et cela permettrait également une fusion de plusieurs à plusieurs sans nécessiter de tri.

Il se trouve que j'ai une table avec 3 423 lignes et 195 valeurs distinctes Name. Je vais appeler cette table P(personne) et la dupliquer pour créer P2(personne2). Il existe une clé primaire unique en cluster sur une colonne d'ID entier. J'utilise Microsoft SQL Server 2016 (KB3194716) Developer Edition (64 bits) sur Windows 10 Pro 6.3 avec 32 Go de RAM.

Avec la requête de base

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

J'obtiens 1,5M de lignes retournées en 3200-3300ms (à partir des statistiques io).

En réécrivant ainsi -

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

écoulé se réduit à 50-60 ms et le plan est le suivant:

Moins de lignes sont renvoyées (3 423) en raison de l'algorithme de correspondance. Le même nombre de plans et de lignes est obtenu en remplaçant la requête de base par select distinct.

En créant une colonne indexée et calculée

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

create index ix1 on dbo.p2(Name1);

Le temps écoulé tombe à 45-50 ms.