modello T-SQL corrispondenza con le eccezioni

Question

Ecco un problema che ho più volte incontrato mentre gioca con la Stack Exchange Data Explorer, che si basa su T-SQL:

Come cercare una stringa tranne quando si verifica come sottostringa di qualche altra stringa?

Per esempio, come posso selezionare tutti i record di una tabella MyTable dove la colonna MyCol contiene la stringa foo, ma ignorando qualsiasi foo s che fanno parte della stringa foobar?

Un tentativo di rapido e sporco sarebbe qualcosa di simile:

SELECT * 
FROM MyTable 
WHERE MyCol LIKE '%foo%' 
    AND MyCol NOT LIKE '%foobar%' 

ma ovviamente questo non riuscirà a corrispondere per esempio MyCol = 'not all foos are foobars', che voglio abbinare.

Una soluzione che è venuta in mente è quello di sostituire tutte le occorrenze di foobar con alcuni marcatore fittizio (che non è una stringa di foo) e poi la verifica di eventuali rimanenti foo s, come in:

SELECT * 
FROM MyTable 
WHERE REPLACE(MyCol, 'foobar', 'X') LIKE '%foo%' 

Funziona, ma sospetto che non sia molto efficiente, dal momento che deve eseguire il REPLACE() su ogni record nella tabella. (Per SEDE, si tratta in genere della tabella Posts, che attualmente ha circa 30 milioni di righe.) I modi migliori per farlo?

(FWIW, the real use case che ha spinto a questa domanda era alla ricerca di SO messaggi con URL di immagine che utilizzano il prefisso http:// schema, ma non puntano all'host i.stack.imgur.com.)

Answer 1

Nessuno dei due le modalità fornite finora sono garantite per funzionare come pubblicizzato e eseguono solo lo REPLACE su un sottoinsieme di righe.

SQL Server does not guarantee short circuiting of predicates e can move compute scalars up into the underlying query for derived tables and CTEs.

L'unica cosa che è (mostly) garantita per funzionare è la dichiarazione CASE. Qui di seguito ho utilizzare lo zucchero varietà sintattico di IIF che si espande verso CASE

SELECT * 
FROM MyTable 
WHERE 1 = IIF(MyCol LIKE '%foo%', 
       IIF(REPLACE(MyCol, 'foobar', 'X') LIKE '%foo%', 1, 0), 
       0); 

Answer 2

Un filtro a tre stadi dovrebbe funzionare:

1. raccogliere tutte le righe corrispondenti a '% pippo%';

2. sostituire tutte le occorrenze di 'foobar' con una stringa non ricorrente (come '' forse ');

3. Controllare ancora per corrispondenza '% pippo%'

Qui si esegue solo il Sostituisci file potenzialmente corrispondenti, non tutte le righe. Se ti aspetti solo una piccola percentuale di partite, questo dovrebbe essere molto più efficiente.

SQL sarebbe simile a questa:

;with data as (
    select * 
    from MyTable 
    where MyCol like '%foo%'  
) 
select * 
from data 
where replace(MyCol, 'foobar', 'X') like '%foo%' 

Si noti che è necessario un sub-query, come non ci sono espressione scorciatoie in SQL; il motore è libero di riordinare i termini booleani come desiderato per un'elaborazione efficiente all'interno di un singolo livello di query.

Answer 3

Supponendo che siete interessati solo a trovare le istanze di foo con spazi che li circonda

SELECT * 
FROM MyTable 
WHERE MyCol LIKE 'foo %' OR MyCol LIKE '% foo %' OR MyCol LIKE '% foo' 

Answer 4

Questo sarà il più veloce di query corrente:

SELECT * 
FROM MyTable 
WHERE 
    MyCol like '%foo%' AND 
    REPLACE(MyCol, 'foobar', 'X') LIKE '%foo%' 

Sostituisci viene calcolata dopo MyCol è stata applicato, quindi è più veloce di:

REPLACE(MyCol, 'foobar', 'X') LIKE '%foo%'