Comparez la différence de performance de T-SQL Between et '<' '>' operator?

Vous pouvez vérifier cela assez facilement en vérifiant les plans de requête dans les deux situations. Il n'y a pas de différence dont je suis conscient. Il y a une différence logique entre BETWEEN et "<" et ">" … BETWEEN est inclusif. C'est équivalent à "<=" et "=>".

Le moteur de search convertit entre >= et <= (jetez un oeil au plan de requête) donc en pratique ils sont identiques et en théorie >= <= est plus rapide car le moteur n'aura pas à traduire. Bonne chance quand même remarquer une différence.

Je l'utilise entre toute façon, je trouve qu'il se lit plus facilement

Des requêtes / vues nestedes très complexes avec de nombreuses comparaisons entre les deux pourraient être modifiées en >= <= car cela pourrait potentiellement empêcher les timeouts d'optimization en réduisant le time passé à refactoriser la requête (juste une théorie, non testée par moi et je ne l'ai jamais remarquée )

Les deux opérateurs qui sont comparés ici sont fondamentalement différents et donc pourquoi les plans d'exécution qui sont générés sont également susceptibles d'être différents (bien que non garantis).

Le facteur déterminant est la dissortingbution des données (sélectivité) de la colonne à laquelle les opérateurs de comparaison sont appliqués. Ceci avec les statistics dictera si un index est ou n'est pas utilisé etc.

J'espère que cela a du sens.

Aimez quand les gens donnent le code pour faire vos propres tests, vous devez faire un plus grand sous-set / test répété pour tenir count des index chargés en memory, etc … avant de sauter aux conclusions cependant. Voici le même code avec une table plus grande et 10 itérations

 DECLARE @Startdatetime datetime , @Diff int = 0 , @Addrowcount int = 1000 , @ptr int = 1; SET NOCOUNT ON; --Create a tempory table to perform our tests on DROP TABLE dbo.perftest CREATE TABLE dbo.perftest( id int NOT NULL IDENTITY(1 , 1) PRIMARY KEY , mytext nvarchar( 50 )NOT NULL ); --Now add some sample rows SET @Addrowcount = 20000; WHILE(@Addrowcount > 0) BEGIN INSERT INTO dbo.perftest( mytext ) VALUES( 'thetext' ); SET @Addrowcount = @Addrowcount - 1; END; WHILE @ptr < 10 -- do this a few times to account for indexes being loaded into memory BEGIN SELECT @Startdatetime = GETDATE(); -- do method 1 here SELECT mytext FROM dbo.perftest WHERE(id >= (100 + (@ptr * 1000))) AND (id <= (500 + (@ptr * 1000))); --end method1 SELECT @Diff = DATEDIFF( millisecond , @Startdatetime , GETDATE()); PRINT ':Method 1: ' + CAST(@Diff AS nvarchar( 20 )) + ' ms'; --reset start time SELECT @Startdatetime = GETDATE(); --do method2 here SELECT mytext FROM dbo.perftest WHERE id BETWEEN (300 + (@ptr * 1000)) AND (800 + (@ptr * 1000)); --end method2 SELECT @Diff = DATEDIFF( millisecond , @Startdatetime , GETDATE()); PRINT ':Method 2: ' + CAST(@Diff AS nvarchar( 20 )) + ' ms'; SET @ptr = @ptr + 1 END 

Vous donne un set de résultats très différent:

 --Method 1 -- 10 ms --Method 2 -- 33 ms --Method 1 -- 40 ms --Method 2 -- 26 ms --Method 1 -- 23 ms --Method 2 -- 23 ms --Method 1 -- 13 ms --Method 2 -- 16 ms --Method 1 -- 13 ms --Method 2 -- 20 ms --Method 1 -- 6 ms --Method 2 -- 16 ms --Method 1 -- 26 ms --Method 2 -- 16 ms --Method 1 -- 13 ms --Method 2 -- 13 ms --Method 1 -- 16 ms --Method 2 -- 13 ms 

Je dirais de ce test (encore assez peu scientifique), pas beaucoup de différence de toute façon.

réellement. J'essaie juste de vérifier avec certaines de mes données. BETWEEN est équivalent à "> =" et "<". Par exemple: Entre '05 / 01/2010 'et '05 / 30/2010': Vous n'aurez que des données entre le 5/1/2010 00:00:00 et le 29/5/2010 23:59:59. Essayez d'interroger votre table avec "Ordre par [TimeField] desc" et vous verrez le résultat.

Je me suis également intéressé à savoir s'il existe une différence de performance lorsque j'ai utilisé (> = et <=) par rapport à l'utilisation du mot-key between. (Je viens d'un fond dotnet et j'aime les opérateurs de style> =).
Voici le script que j'ai utilisé:

 DECLARE @Startdatetime datetime , @Diff int = 0 , @Addrowcount int = 1000; SET NOCOUNT ON; --Create a tempory table to perform our tests on CREATE TABLE dbo.perftest( id smallint NOT NULL IDENTITY(1 , 1) PRIMARY KEY , mytext nvarchar( 50 )NOT NULL ); --Now add some sample rows SET @Addrowcount = 1000; WHILE(@Addrowcount > 0) BEGIN INSERT INTO dbo.perftest( mytext ) VALUES( 'thetext' ); SET @Addrowcount = @Addrowcount - 1; END; SELECT @Startdatetime = GETDATE(); -- do method 1 here SELECT mytext FROM dbo.perftest WHERE(id >= 100) AND (id <= 900); --end method1 SELECT @Diff = DATEDIFF( millisecond , @Startdatetime , GETDATE()); PRINT ':Method 1: ' + CAST(@Diff AS nvarchar( 20 )) + ' ms'; --reset start time SELECT @Startdatetime = GETDATE(); --do method2 here SELECT mytext FROM dbo.perftest WHERE id BETWEEN 100 AND 900; --end method2 SELECT @Diff = DATEDIFF( millisecond , @Startdatetime , GETDATE()); PRINT ':Method 2: ' + CAST(@Diff AS nvarchar( 20 )) + ' ms'; 

Les résultats étaient:

Méthode 1: 140 ms

Méthode 2: 70 ms

Il semble donc que la performance est améliorée en utilisant entre.