CONTAINS (Transact-SQL)

Si applica a: SQL Server Database SQL di Azure Istanza gestita di SQL di Azure

Cerca corrispondenze precise o fuzzy (meno precise) di singole parole e frasi, parole separate l'una dall'altra o corrispondenze ponderate in SQL Server. CONTAINS è un predicato usato nella clausola WHERE di un'istruzione SELECT Transact-SQL per eseguire una ricerca full-text SQL Server in colonne indicizzate full-text contenenti tipi di dati basati su caratteri.

Il predicato CONTAINS consente di cercare:

• Una parola o una frase.

• Il prefisso di una parola o di una frase.

• Una parola accanto a una parola specifica.

• Una parola generata da un'altra per flessione, ad esempio le parole guida, guidare, guidando e guidare derivanti dalla radice guida.

• Una parola sinonimo di un'altra parola utilizzando il thesaurus, ad esempio le parole alluminio e acciaio possono essere sinonimi della parola metallo.

Per informazioni sui formati di ricerca full-text supportati da SQL Server, vedere Eseguire query con ricerca full-text.

Convenzioni relative alla sintassi Transact-SQL

Sintassi

CONTAINS (   
     {   
        column_name | ( column_list )   
      | *   
      | PROPERTY ( { column_name }, 'property_name' )    
     }   
     , '<contains_search_condition>'  
     [ , LANGUAGE language_term ]  
   )   
  
<contains_search_condition> ::=   
  {   
      <simple_term>   
    | <prefix_term>   
    | <generation_term>   
    | <generic_proximity_term>   
    | <custom_proximity_term>   
    | <weighted_term>   
    }   
  |   
    { ( <contains_search_condition> )   
        [ { <AND> | <AND NOT> | <OR> } ]   
        <contains_search_condition> [ ...n ]   
  }   
<simple_term> ::=   
     { word | "phrase" }  
  
<prefix term> ::=   
  { "word*" | "phrase*" }  
  
<generation_term> ::=   
  FORMSOF ( { INFLECTIONAL | THESAURUS } , <simple_term> [ ,...n ] )   
  
<generic_proximity_term> ::=   
  { <simple_term> | <prefix_term> } { { { NEAR | ~ }   
     { <simple_term> | <prefix_term> } } [ ...n ] }  
  
<custom_proximity_term> ::=   
  NEAR (   
     {  
        { <simple_term> | <prefix_term> } [ ,...n ]  
     |  
        ( { <simple_term> | <prefix_term> } [ ,...n ] )   
      [, <maximum_distance> [, <match_order> ] ]  
     }  
       )   
  
      <maximum_distance> ::= { integer | MAX }  
      <match_order> ::= { TRUE | FALSE }   
  
<weighted_term> ::=   
  ISABOUT   
   ( {   
        {   
          <simple_term>   
        | <prefix_term>   
        | <generation_term>   
        | <proximity_term>   
        }   
      [ WEIGHT ( weight_value ) ]   
      } [ ,...n ]   
   )   
  
<AND> ::=   
  { AND | & }  
  
<AND NOT> ::=   
  { AND NOT | &! }  
  
<OR> ::=   
  { OR | | }  
  

Argomenti

column_name
Nome di una colonna con indicizzazione full-text della tabella specificata nella clausola FROM. La colonna o le colonne possono essere di tipo char, varchar, nchar, nvarchar, text, ntext, image, xml, varbinary r varbinary(max).

column_list
Specifica due o più colonne, separate da virgole. column_listdeve essere racchiuso tra parentesi. La lingua di tutte le colonne di column_list deve essere la stessa, a meno che non sia specificato language_term.

*
Specifica che la query esegue ricerche in tutte le colonne con indicizzazione full-text nella tabella specificata nella clausola FROM per la condizione di ricerca indicata. Le colonne nella clausola CONTAINS devono appartenere a una singola tabella che include un indice full-text. La lingua di tutte le colonne della tabella deve essere la stessa, a meno che non sia specificato language_term.

PROPERTY (column_name, 'property_name')
Si applica a: SQL Server 2012 (11.x) e versioni successive.

Specifica una proprietà di documento in cui cercare la condizione di ricerca specificata.

LANGUAGE language_term
Lingua da usare per word breaking, stemming, espansioni e sostituzioni del thesaurus e rimozione di parole non significative come parte della query. Il parametro è facoltativo.

Se documenti di lingue diverse vengono archiviati insieme come oggetti BLOB in una singola colonna, l'identificatore delle impostazioni locali (LCID) di un documento specifico determina la lingua da utilizzare per indicizzarne il contenuto. Se quando si esegue una query su una colonna di questo tipo si specifica LANGUAGE language_term è possibile aumentare la probabilità di una corrispondenza soddisfacente.

È possibile specificare language_term come valore stringa, intero o esadecimale corrispondente all'identificatore LCID di una lingua. Se si specifica language_term, la lingua rappresentata dall'argomento viene applicata a tutti gli elementi della condizione di ricerca. Se non si specifica alcun valore, verrà utilizzata la lingua full-text della colonna.

Quando l'argomento language_term viene specificato come stringa, corrisponde al valore della colonnaalias nella vista di compatibilità sys.syslanguages (Transact-SQL). La stringa deve essere racchiusa tra virgolette singole chiuse, come in 'language_term'. Se l'argomento language_term viene specificato come valore intero, corrisponde all'LCID effettivo che identifica la lingua. Se si specifica un valore esadecimale, language_term è 0x seguito dal valore esadecimale di LCID. Il valore esadecimale non deve superare le otto cifre, inclusi gli zeri iniziali.

Se il valore è in formato DBCS (Double-Byte Character Set), verrà convertito in Unicode da SQL Server.

Se la lingua specificata non è valida o non sono presenti risorse installate corrispondenti a tale lingua, SQL Server restituisce un errore. Per usare le risorse della lingua neutra, specificare 0x0 per language_term.

<contains_search_condition>
Specifica il testo da cercare in column_name e le condizioni della ricerca.

<contains_search_condition> è di tipo nvarchar. Viene eseguita una conversione implicita quando si utilizza come input un tipo di dati character diverso. Non è possibile usare varchar (max) e nvarchar (max) per tipi di dati di stringa di grandi dimensioni. Nell'esempio seguente la variabile @SearchWord, definita come varchar(30), causa una conversione implicita nel predicato CONTAINS.

USE AdventureWorks2022;  
GO  
DECLARE @SearchWord VARCHAR(30)  
SET @SearchWord ='performance'  
SELECT Description   
FROM Production.ProductDescription   
WHERE CONTAINS(Description, @SearchWord);  

Poiché non è possibile usare l'analisi dei parametri nella conversione, usare nvarchar per migliorare le prestazioni. Nell'esempio dichiarare @SearchWord come nvarchar(30).

USE AdventureWorks2022;  
GO  
DECLARE @SearchWord NVARCHAR(30)  
SET @SearchWord = N'performance'  
SELECT Description   
FROM Production.ProductDescription   
WHERE CONTAINS(Description, @SearchWord);  

È inoltre possibile utilizzare l'hint per la query OPTIMIZE FOR per i casi in cui viene generato un piano non ottimale.

word
Stringa di caratteri senza spazi o punteggiatura.

phrase
Una o più parole separate da uno spazio.

<simple_term>
Specifica che deve essere trovata l'esatta corrispondenza di una parola o di una frase. Esempi di termini semplici validi sono "copri capo", copricapo e "Microsoft SQL Server". Le frasi devono essere racchiuse tra virgolette doppie (""). In <contains_search_condition> le parole di una frase devono essere specificate nello stesso ordine usato nella colonna del database. La distinzione tra maiuscole e minuscole non è rilevante per la ricerca di caratteri nella parola o nella frase. Le parole non significative, quali preposizioni, congiunzioni e articoli, nelle colonne con indicizzazione full-text non vengono archiviate nell'indice full-text. Se una parola non significativa viene usata nella ricerca di una singola parola, SQL Server restituisce un messaggio di errore che indica che la query contiene solo parole non significative. In SQL Server è disponibile un elenco standard di parole non significative nella directory \Mssql\Binn\FTERef di ogni istanza di SQL Server.

La punteggiatura viene ignorata. CONTAINS(testing, "computer failure"), pertanto, consente di trovare una riga contenente il valore "Where is my computer? Failure to find it would be expensive”. Per altre informazioni sul comportamento dei word breaker, vedere Configurare e gestire word breaker e stemmer per la ricerca.

<prefix_term>
Specifica che devono essere trovate parole o frasi che iniziano con il testo specificato. Racchiudere un termine di prefisso tra virgolette doppie ("") e aggiungere un asterisco (*) prima delle virgolette finali, in modo che tutto il testo che inizia con il termine semplice specificato prima che l'asterisco corrisponda. La clausola deve essere specificata nel seguente modo: CONTAINS (column, '"text*"') L'asterisco corrisponde a zero, uno o più caratteri della parola o delle parole radice della parola o della frase. Se il testo e l'asterisco non sono racchiusi tra virgolette doppie, per cui vengono letti dal predicato come CONTAINS (column, 'text*'), nella ricerca full-text l'asterisco viene interpretato come carattere e viene eseguita la ricerca esatta di text*. Il motore full-text non troverà parole con il carattere asterisco (*) perché i word breaker in genere ignorano tali caratteri.

Se <prefix_term> è una frase, ogni parola della frase viene considerata un prefisso distinto. Una query che specifica il prefisso "sviluppo foto*", pertanto, consente di individuare tutte le righe che includono il testo "sviluppo fotografie", "sviluppo fotografie e ritocco" e così via.

<generation_term>
Specifica che devono essere trovate le parole i cui termini semplici includono varianti della parola originale da cercare.

INFLECTIONAL
Specifica che deve essere utilizzato lo stemmer specifico della lingua per il termine semplice specificato. Il comportamento dello stemmer dipende dalle regole di stemming di ogni lingua specifica. Alla lingua neutra non è associato alcuno stemmer. Per individuare lo stemmer corretto, viene utilizzata la lingua delle colonne in cui viene eseguita la ricerca. Se si specifica language_term, viene usato lo stemmer corrispondente a tale lingua.

Per uno specifico <simple_term> all'interno di un <generation_term>, non verranno rilevate corrispondenze né tra sostantivi né tra verbi.

THESAURUS
Specifica che verrà utilizzato il thesaurus corrispondente alla lingua full-text per le colonne oppure alla lingua specificata nella query. Il modello o i modelli più lunghi di <simple_term> vengono confrontati con il thesaurus e vengono generati termini aggiuntivi per espandere o sostituire il modello originale. Se non viene individuata alcuna corrispondenza per il valore <simple_term> o parte di esso, la parte per cui non è stata trovata alcuna corrispondenza viene considerata simple_term. Per altre informazioni sul thesaurus di ricerca full-text, vedere Configurare e gestire i file del thesaurus per la ricerca full-text.

<generic_proximity_term>
Specifica che devono essere trovate parole o frasi incluse nel documento in cui viene eseguita la ricerca.

NEAR | ~
Indica che le parole o le frasi a sinistra e a destra dell'operatore NEAR o ~ devono essere incluse in un documento in modo che venga restituita una corrispondenza. È necessario specificare due termini di ricerca. Un termine di ricerca può essere una frase o una singola parola delimitata da virgolette doppie ("phrase").

È possibile concatenare più termini vicini, come in a NEAR b NEAR c o a ~ b ~ c. I termini vicini concatenati devono essere tutti presenti nel documento affinché venga restituita una corrispondenza.

CONTAINS(*column_name*, 'fox NEAR chicken') e CONTAINSTABLE(*table_name*, *column_name*, 'fox ~ chicken'), ad esempio restituiscono entrambi tutti i documenti nella colonna specificata che contengono sia "fox" che "chicken". CONTAINSTABLE, inoltre, restituisce una pertinenza per ogni documento in base alla prossimità delle parole "volpe" e "pollo". Ad esempio, se un documento contiene la frase "La volpe mangia il pollo", il relativo rango è elevato perché i termini sono più vicini uno all'altro che negli altri documenti.

Per altre informazioni sui termini di prossimità generici, vedere Ricerca di parole vicine a un'altra parola con NEAR.

<custom_proximity_term>
Si applica a: SQL Server 2012 (11.x) e versioni successive.

Specifica una corrispondenza di parole o frasi e facoltativamente la distanza massima consentita tra termini di ricerca. È anche possibile indicare che i termini di ricerca devono essere trovati nell'ordine esatto in cui vengono specificati (<match_order>).

Un termine di ricerca può essere una frase o una singola parola delimitata da virgolette doppie ("phrase"). Ogni termine specificato deve trovarsi nel documento affinché venga restituita una corrispondenza. È necessario specificare almeno due termini di ricerca. Il numero massimo di termini di ricerca è 64.

Per impostazione predefinita, il termine vicino personalizzato restituisce qualsiasi riga contenente i termini specificati indipendentemente dalla distanza e dall'ordine. Ad esempio, per trovare una corrispondenza con la query seguente, un documento dovrebbe semplicemente contenere term1 e "term3 term4" in qualsiasi punto e in qualsiasi ordine:

CONTAINS(column_name, 'NEAR(term1,"term3 term4")')  

I parametri facoltativi sono i seguenti:

<maximum_distance>
Specifica la distanza massima consentita tra i termini di ricerca all'inizio e alla fine di una stringa affinché tale stringa possa essere ritenuta una corrispondenza.

integer
Specifica un intero positivo compreso tra 0 e 4294967295. Questo valore determina il numero di termini non di ricerca che possono esistere tra il primo e l'ultimo termine di ricerca, esclusi eventuali termini di ricerca specificati aggiuntivi.

La query seguente, ad esempio, cerca "AA" e "BB", in qualsiasi ordine, entro una distanza massima di cinque.

CONTAINS(column_name, 'NEAR((AA,BB),5)')  

La stringa AA one two three four five BB consente di trovare corrispondenze. Nell'esempio seguente, la query specifica tre termini di ricerca, AA, BB e CC entro una distanza massima di cinque:

CONTAINS(column_name, 'NEAR((AA,BB,CC),5)')  

La query troverebbe una corrispondenza per la stringa seguente in cui la distanza totale è cinque:

BB one two CC three four five A A

Si noti che il termine di ricerca interno, CC, non viene preso in considerazione.

MAX
Restituisce le righe che contengono i termini specificati indipendentemente dalla distanza esistente tra di essi. Si tratta dell'impostazione predefinita.

<match_order>
Specifica se i termini devono trovarsi nell'ordine specificato che deve essere restituito da una query di ricerca. Per specificare <match_order>, è anche necessario specificare <maximum_distance>.

<match_order> accetta uno dei valori seguenti:

TRUE
Applica l'ordine specificato all'interno dei termini. Ad esempio, NEAR(A,B) corrisponderebbe solo a A ... B.

FALSE
Ignora l'ordine specificato. Ad esempio, NEAR(A,B) corrisponderebbe sia a A ... B sia a B ... A.

Si tratta dell'impostazione predefinita.

Ad esempio, il termine vicino seguente cerca le parole "Monday", "Tuesday" e "Wednesday" nell'ordine specificato indipendentemente dalla distanza esistente tra di essi:

CONTAINS(column_name, 'NEAR ((Monday, Tuesday, Wednesday), MAX, TRUE)')  

Per altre informazioni sull'uso di termini di prossimità personalizzati, vedere Ricerca di parole vicine a un'altra parola con NEAR.

<weighted_term>
Specifica che le righe restituite dalla query corrispondono a un elenco di parole e di frasi, a ognuna delle quali può essere associato un valore di ponderazione facoltativo.

ISABOUT
Specifica la parola chiave <weighted_term>.

WEIGHT(weight_value)
Specifica un valore di ponderazione compreso tra 0.0 e 1.0. Ogni componente di <weighted_term> può includere un valore weight_value. weight_value consente di modificare l'effetto delle varie parti di una query sul valore di pertinenza assegnato a ogni riga che soddisfa la query. WEIGHT non ha alcun effetto sui risultati delle query CONTAINS, ma ha effetto sul valore di pertinenza nelle query CONTAINSTABLE.

{ AND | & } | { AND NOT | &! } | { OR | | }
Specifica un'operazione logica tra due condizioni di ricerca del predicato CONTAINS.

{ AND | & }
Indica che devono essere soddisfatte entrambe le condizioni di ricerca del predicato CONTAINS. Per rappresentare l'operatore AND, è possibile usare il carattere e commerciale (&) anziché la parola chiave AND.

{ AND NOT | &! }
Indica che la seconda condizione di ricerca non deve essere soddisfatta. Per rappresentare l'operatore AND NOT, è possibile usare il carattere e commerciale seguito dal punto esclamativo (&!) anziché la parola chiave AND NOT.

{ OR | | }
Indica che deve essere soddisfatta una delle due condizioni di ricerca del predicato CONTAINS. Per rappresentare l'operatore OR, è possibile utilizzare il carattere barra (|) anziché la parola chiave OR.

Quando <contains_search_condition> include gruppi tra parentesi, tali gruppi vengono valutati per primi. In seguito alla valutazione dei gruppi tra parentesi, gli operatori logici che includono condizioni di ricerca vengono valutati in base alle regole seguenti:

• L'operatore NOT viene applicato prima dell'operatore AND.

• L'operatore NOT può essere utilizzato solo dopo l'operatore AND, ad esempio in AND NOT. L'operatore OR NOT non è consentito. Non è possibile specificare l'operatore NOT prima del primo termine. CONTAINS (mycolumn, 'NOT "phrase_to_search_for" ' ), ad esempio, non è valido:

• L'operatore AND viene applicato prima dell'operatore OR.

• Gli operatori booleani dello stesso tipo (AND, OR) sono associativi e pertanto possono essere applicati in qualsiasi ordine.

n
Segnaposto che indica la possibilità di specificare più termini e più condizioni di ricerca del predicato CONTAINS.

Osservazioni generali

I predicati e le funzioni full-text possono essere utilizzati in una singola tabella, specificata in modo implicito nel predicato FROM. Per cercare in più tabelle, utilizzare una tabella unita in join nella clausola FROM, che consente di eseguire una ricerca in un set di risultati prodotto da due o più tabelle.

I predicati full-text non sono consentiti nella clausola OUTPUT quando il livello di compatibilità del database è impostato su 100.

Esecuzione di query in server remoti

È possibile usare un nome in quattro parti nel predicato CONTAINS o FREETEXT per eseguire query di colonne con indicizzazione full-text delle tabelle di destinazione in un server collegato. Per preparare un server remoto alla ricezione di query full-text, creare un indice full-text delle tabelle di destinazione e delle colonne nel server remoto, quindi aggiungere il server remoto come server collegato.

Confronto tra LIKE e la ricerca full-text

Contrariamente alla ricerca full-text, il predicato LIKE di Transact-SQL funziona unicamente con modelli di caratteri. Non è inoltre possibile utilizzare il predicato LIKE per eseguire query su dati binari formattati. Inoltre, l'esecuzione di una query LIKE su una grande quantità di dati di testo non strutturati è molto più lenta dell'esecuzione di una query full-text equivalente sugli stessi dati. Una query LIKE eseguita su milioni di righe di dati di testo può richiedere diversi minuti, mentre per una query full-text sugli stessi dati possono essere necessari al massimo pochi secondi, a seconda del numero di righe restituite e delle relative dimensioni. Si tenga inoltre presente che LIKE esegue unicamente un'analisi modello semplice di un'intera tabella. Una query full-text tiene invece conto della lingua, applicando trasformazioni specifiche durante l'esecuzione della query e dell'indice, ad esempio il filtro delle parole non significative ed espansioni flessive e del thesaurus. Tali trasformazioni consentono alle query full-text di migliorare la chiamata e il rango finale dei risultati.

Esecuzione di query su più colonne (ricerca full-text)

È possibile eseguire una query su più colonne specificando un elenco di colonne in cui eseguire ricerche. Le colonne devono appartenere alla stessa tabella.

Ad esempio, la query CONTAINS seguente cerca il termine Red nelle Name colonne e Color della Production.Product tabella del database di esempio AdventureWorks2022.

Use AdventureWorks2022;  
GO  
SELECT Name, Color   
FROM Production.Product  
WHERE CONTAINS((Name, Color), 'Red');  

Esempi

R. Utilizzo di CONTAINS con <simple_term>

Nell'esempio seguente vengono trovati tutti i prodotti il cui prezzo è $80.99 e contenenti la parola Mountain.

USE AdventureWorks2022;  
GO  
SELECT Name, ListPrice  
FROM Production.Product  
WHERE ListPrice = 80.99  
   AND CONTAINS(Name, 'Mountain');  
GO  

B. Utilizzo di CONTAINS e di una frase con <simple_term>

Nell'esempio seguente vengono restituiti tutti i prodotti che contengono la frase Mountain o Road.

USE AdventureWorks2022;  
GO  
SELECT Name  
FROM Production.Product  
WHERE CONTAINS(Name, ' Mountain OR Road ')  
GO  

C. Utilizzo di CONTAINS con <prefix_term>

Nell'esempio seguente vengono restituiti tutti i nomi di prodotto della colonna Name contenenti almeno una parola che inizia con il prefisso chain.

USE AdventureWorks2022;  
GO  
SELECT Name  
FROM Production.Product  
WHERE CONTAINS(Name, ' "Chain*" ');  
GO  

D. Utilizzo di CONTAINS e OR con <prefix_term>

Nell'esempio seguente vengono restituite tutte le descrizioni di categoria contenenti stringhe con il prefisso chain o full.

USE AdventureWorks2022;  
GO  
SELECT Name  
FROM Production.Product  
WHERE CONTAINS(Name, '"chain*" OR "full*"');  
GO  

E. Utilizzo di CONTAINS con <proximity_term>

Si applica a: SQL Server 2012 (11.x) e versioni successive.

L'esempio seguente cerca nella tabella Production.ProductReview tutti i commenti che contengono la parola bike all'interno di 10 termini della parola control e nell'ordine specificato (ovvero dove "bike" precede "control").

USE AdventureWorks2022;  
GO  
SELECT Comments  
FROM Production.ProductReview  
WHERE CONTAINS(Comments , 'NEAR((bike,control), 10, TRUE)');  
GO  

F. Utilizzo di CONTAINS con <generation_term>

Nell'esempio seguente viene eseguita la ricerca di tutti i prodotti con parole derivate da ride, ad esempio riding, ridden e così via.

USE AdventureWorks2022;  
GO  
SELECT Description  
FROM Production.ProductDescription  
WHERE CONTAINS(Description, ' FORMSOF (INFLECTIONAL, ride) ');  
GO  

G. Utilizzo di CONTAINS con <weighted_term>

Nell'esempio seguente viene eseguita la ricerca di tutti i nomi di prodotto contenenti la parola performance, comfortable o smooth. Ogni parola viene ponderata in modo diverso.

USE AdventureWorks2022;  
GO  
SELECT Description  
FROM Production.ProductDescription  
WHERE CONTAINS(Description, 'ISABOUT (performance weight (.8),   
comfortable weight (.4), smooth weight (.2) )' );  
GO  

H. Utilizzo di CONTAINS con variabili

Nell'esempio seguente viene utilizzata una variabile anziché un termine di ricerca specifico.

USE AdventureWorks2022;  
GO  
DECLARE @SearchWord NVARCHAR(30)  
SET @SearchWord = N'Performance'  
SELECT Description   
FROM Production.ProductDescription   
WHERE CONTAINS(Description, @SearchWord);  
GO  

I. Utilizzo di CONTAINS con un operatore logico (AND)

Nell'esempio seguente viene utilizzata la tabella ProductDescription del database AdventureWorks2022 . La query usato il predicato CONTAINS per cercare le descrizioni il cui ID sia diverso da 5 e che contengano le parole Aluminum e spindle. Nella condizione di ricerca viene utilizzato l'operatore booleano AND.

USE AdventureWorks2022;  
GO  
SELECT Description  
FROM Production.ProductDescription  
WHERE ProductDescriptionID <> 5 AND  
   CONTAINS(Description, 'Aluminum AND spindle');  
GO  

J. Utilizzo di CONTAINS per verificare l'inserimento di una riga

Nell'esempio seguente viene utilizzato il predicato CONTAINS in una sottoquery SELECT. Se si utilizza il database AdventureWorks2022, la query consente di ottenere il valore di commento per tutti i commenti della tabella ProductReview per un ciclo specifico. Nella condizione di ricerca viene utilizzato l'operatore booleano AND.

USE AdventureWorks2022;  
GO  
INSERT INTO Production.ProductReview   
  (ProductID, ReviewerName, EmailAddress, Rating, Comments)   
VALUES  
  (780, 'John Smith', 'john@fourthcoffee.com', 5,   
'The Mountain-200 Silver from AdventureWorks2008 Cycles meets and exceeds expectations. I enjoyed the smooth ride down the roads of Redmond');  
  
-- Given the full-text catalog for these tables is Adv_ft_ctlg,   
-- with change_tracking on so that the full-text indexes are updated automatically.  
WAITFOR DELAY '00:00:30';     
-- Wait 30 seconds to make sure that the full-text index gets updated.  
  
SELECT r.Comments, p.Name  
FROM Production.ProductReview AS r  
JOIN Production.Product AS p   
    ON r.ProductID = p.ProductID  
    AND r.ProductID = (SELECT ProductID  
FROM Production.ProductReview  
WHERE CONTAINS (Comments,   
    ' AdventureWorks2008 AND   
    Redmond AND   
    "Mountain-200 Silver" '));  
GO  

K. Query su una proprietà di documento

Si applica a: SQL Server 2012 (11.x) e versioni successive.

Tramite la query seguente viene eseguita una ricerca su una proprietà indicizzata, Title, nella colonna Document della tabella Production.Document. La query restituisce solo documenti la cui proprietà Title contiene la stringa Maintenance o Repair.

Use AdventureWorks2022;  
GO  
SELECT Document 
FROM Production.Document  
WHERE CONTAINS(PROPERTY(Document,'Title'), 'Maintenance OR Repair');  
GO  

Vedi anche

Introduzione alla ricerca full-text
Creare e gestire cataloghi full-text
CREATE FULLTEXT CATALOG (Transact-SQL)
CREATE FULLTEXT INDEX (Transact-SQL)
Creazione e gestione di indici full-text
Eseguire query con ricerca full-text
CONTAINSTABLE (Transact-SQL)
FREETEXT (Transact-SQL)
FREETEXTTABLE (Transact-SQL)
Eseguire query con ricerca full-text
Ricerca full-text
Creare query di ricerca full-text (Visual Database Tools)
WHERE (Transact-SQL)
Eseguire ricerche nelle proprietà dei documenti con elenchi delle proprietà di ricerca