CONTAINS (Transact-SQL)

S’applique à :SQL ServerAzure SQL DatabaseAzure SQL Managed Instance

Recherche des concordances précises ou approximatives (moins précises) avec des mots isolés ou des expressions, des termes situés à une certaine distance les uns des autres ou des concordances pondérées dans SQL Server. CONTAINS est un prédicat utilisé dans la clause WHERE d’une instruction SELECT Transact-SQL pour effectuer une recherche en texte intégral SQL Server dans des colonnes indexées en texte intégral qui contiennent des types de données caractères.

CONTAINS peut rechercher :

• un mot ou une expression ;

• le préfixe d'un mot ou d'une expression ;

• un mot proche d'un autre mot ;

• un mot dérivant d'un autre mot par inflexion (par exemple, le radical « part » a généré par inflexion les formes dérivées partir, départ, partant ou partie) ;

• un mot synonyme d'un autre mot d'après un dictionnaire des synonymes (par exemple, le mot « métal » peut avoir des synonymes comme « aluminium » et « acier »).

Pour plus d’informations sur les sortes de recherches en texte intégral prises en charge par SQL Server, consultez Exécuter une requête avec une recherche en texte intégral.

Conventions de la syntaxe Transact-SQL

Syntaxe

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 | | }  
  

Arguments

column_name
Nom d'une colonne d'index de recherche en texte intégral de la table spécifiée dans la clause FROM. Les colonnes peuvent être de type char, varchar, nchar, nvarchar, text, ntext, image, xml, varbinary ou varbinary(max) .

column_list
Spécifie deux colonnes ou plus, séparées par des virgules. column_list doit être mis entre parenthèses. Une seule et même langue doit être utilisée dans toutes les colonnes de column_list, sauf si language_term est spécifié.

*
Spécifie que la requête doit effectuer la recherche dans toutes les colonnes indexées en texte intégral de la table spécifiée dans la clause FROM pour la condition de recherche donnée. Les colonnes de la clause CONTAINS doivent provenir d'une table unique qui possède un index de recherche en texte intégral. Une seule et même langue doit être utilisée dans toutes les colonnes de la table, sauf si language_term est spécifié.

PROPERTY ( column_name , 'property_name')
S’applique à : SQL Server 2012 (11.x) et versions ultérieures.

Spécifie une propriété du document sur laquelle rechercher la condition de recherche spécifiée.

LANGUAGE language_term
Langue à utiliser pour l’analyse lexicale, la recherche de radical, les extensions et remplacements du dictionnaire des synonymes, ainsi que le remplacement des mots parasites (ou mots vides) dans le cadre de la requête. Ce paramètre est facultatif.

Si des documents de langues différentes sont stockés ensemble en tant qu'objets blob dans une colonne unique, l'identificateur de paramètres régionaux (LCID) d'un document donné détermine la langue à utiliser pour l'indexation de son contenu. Quand une requête est effectuée sur la colonne, la spécification de LANGUAGE language_term augmente la probabilité d’une meilleure correspondance.

language_term peut être spécifié sous forme de chaîne, d’entier ou de valeur hexadécimale correspondant à l’identificateur de paramètres régionaux (LCID) de la langue. Si une langue est définie avec language_term, elle est appliquée à tous les éléments de la condition de recherche. Si aucune valeur n'est définie, la langue du texte intégral de la colonne est utilisée.

Quand il est spécifié en tant que chaîne, language_term correspond à la valeur de colonne alias dans l’affichage de compatibilité sys.syslanguages (Transact-SQL). La chaîne doit être placée entre guillemets simples, comme dans 'language_term'. Quand il est spécifié sous la forme d’un entier, language_term est le LCID qui identifie la langue. Quand il est spécifié sous la forme d’une valeur hexadécimale, language_term est 0x suivi de la valeur hexadécimale du LCID. La valeur hexadécimale ne doit pas dépasser huit caractères, y compris les zéros non significatifs.

Si la valeur est au format de jeu de caractères codés sur deux octets (DBCS), SQL Server la convertit au format Unicode.

Si le langage spécifié n’est pas valide ou si aucune ressource correspondant à ce langage n’est installée, SQL Server retourne une erreur. Pour utiliser des ressources linguistiques neutres, indiquez 0x0 pour language_term.

<contains_search_condition>
Spécifie le texte à rechercher dans column_name et les conditions de correspondance à remplir.

<contains_search_condition> est nvarchar. Une conversion implicite se produit lorsqu'un autre type de données character est utilisé comme entrée. Les chaînes longues de types varchar(max) et nvarchar(max) ne peuvent pas être utilisées. Dans l'exemple suivant, la variable @SearchWord, à laquelle est attribuée la valeur varchar(30), provoque une conversion implicite dans le prédicat CONTAINS.

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

Étant donné que la détection des paramètres ne fonctionne pas lors de la conversion, utilisez nvarchar pour obtenir de meilleures performances. Dans l’exemple, déclarez @SearchWord en tant que nvarchar(30).

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

Vous pouvez également utiliser l'indicateur de requête OPTIMIZE FOR lorsqu'un plan non optimal est généré.

word
Chaîne de caractères sans espaces ni ponctuation.

phrase
Un ou plusieurs mots séparés par des espaces.

<simple_term>
Spécifie une correspondance pour un mot ou une expression exacts. Exemples de termes simples autorisés : « lieu dit », « lieudit » et « Microsoft SQL Server ». Les expressions doivent être mises entre des guillemets doubles (""). Les mots d’une expression doivent apparaître dans l’ordre spécifié dans <contains_search_condition> tels qu’ils apparaissent dans la colonne de la base de données. La recherche de caractères dans un mot ou une expression ne respecte pas la casse. Dans des colonnes d’index de recherche en texte intégral, les mots parasites ou mots vides (par exemple « un », « et » ou « le ») ne sont pas stockés dans l’index de recherche en texte intégral. Si un mot parasite est utilisé dans la recherche d'un mot unique, SQL Server retourne un message d'erreur indiquant que la requête contient uniquement des mots parasites. SQL Server contient une liste standard des mots parasites dans le répertoire \Mssql\Binn\FTERef de chaque instance de SQL Server.

La ponctuation est ignorée. Par conséquent, CONTAINS(testing, "computer failure") retourne la ligne ayant la valeur « Où est mon ordinateur (computer) ? Tout manquement de recherche est coûteux. » Pour plus d’informations sur le comportement des analyseurs lexicaux, consultez Configurer et gérer les analyseurs lexicaux et générateurs de formes dérivées pour la recherche.

<prefix_term>
Précise une correspondance de mots ou d'expressions commençant par le texte spécifié. Placez un terme préfixe entre guillemets doubles ("") et ajoutez un astérisque (*) avant les guillemets doubles fermants afin que tout le texte commençant par le terme simple spécifié avant l'astérisque soit pris en compte. La clause doit être définie de la manière suivante : CONTAINS (column, '"text*"'). L'astérisque correspond à aucun, à un ou à plusieurs caractères (du ou des mots racine dans le mot ou l'expression). Si le texte et l'astérisque ne sont pas délimités par des guillemets doubles, comme dans CONTAINS (column, 'text*'), la recherche en texte intégral considère l'astérisque comme un caractère et recherche les correspondances exactes avec text*. Le moteur d'indexation et de recherche en texte intégral ne trouve aucun mot contenant l'astérisque (*) car les analyseurs lexicaux ignorent en général ces caractères.

Quand <prefix_term> est une expression, chaque mot qui la compose est considéré comme un préfixe séparé. Ainsi, une recherche spécifiant le préfixe « contrôle des mots* » trouvera les lignes contenant le texte « contrôle des mots clés », « contrôleur des mots », etc.

<generation_term>
Précise une correspondance de mots lorsque les termes simples qui s'y trouvent contiennent des variantes du mot initial à rechercher.

INFLECTIONAL
Spécifie que le générateur de formes dérivées dépendant de la langue doit être utilisé sur le terme simple spécifié. Le comportement du générateur de formes dérivées est défini en fonction des règles de racine de chaque langue spécifique. La langue neutre ne possède pas de générateur de formes dérivées associé. La langue des colonnes interrogées est utilisée pour se reporter au générateur de formes dérivées souhaité. Si language_term est spécifié, le générateur de formes dérivées correspondant à cette langue est utilisé.

Un <simple_term> donné dans un <generation_term> ne correspondra pas aux noms et aux verbes.

THESAURUS
Spécifie l'utilisation du dictionnaire des synonymes correspondant à la langue de texte intégral de la colonne ou à la langue spécifiée dans la requête. Les modèles les plus longs de <simple_term> sont interprétés par rapport au dictionnaire des synonymes et des termes supplémentaires sont créés pour étendre ou remplacer le modèle initial. Si aucune correspondance n’est trouvée pour tout ou partie de <simple_term>, la partie sans correspondance est traitée en tant que simple_term. Pour plus d’informations sur le dictionnaire des synonymes pour la recherche en texte intégral, consultez Configurer et gérer les fichiers de dictionnaire des synonymes pour la recherche en texte intégral.

<generic_proximity_term>
Spécifie une correspondance de mots ou d'expressions qui doit figurer dans le document faisant l'objet d'une recherche.

NEAR | ~
Indique que le mot ou l'expression qui se trouve de chaque côté de l'opérateur NEAR ou ~ doit figurer dans un document pour qu'une correspondance soit retournée. Vous devez spécifier deux termes de recherche. Un terme de recherche donné peut être un mot unique ou une expression délimitée par des guillemets doubles ("expression").

Plusieurs termes de proximité peuvent être enchaînés, par exemple a NEAR b NEAR c ou a ~ b ~ c. Les termes de proximité enchaînés doivent tous figurer dans le document pour qu'une correspondance soit retournée.

Par exemple, CONTAINS(*column_name*, 'fox NEAR chicken') et CONTAINSTABLE(*table_name*, *column_name*, 'fox ~ chicken') retournent tous les deux les documents de la colonne spécifiée qui contiennent à la fois « fox » et « chicken ». De plus, CONTAINSTABLE retourne un classement pour chaque document en fonction de la proximité de « renard » et de « poulet ». Par exemple, si un document contient la phrase, « Le renard a mangé le poulet », son classement serait élevé car les termes sont plus proches l'un de l'autre que dans d'autres documents.

Pour plus d’informations sur les termes de proximité génériques, consultez Recherche de mots dans le voisinage d’autres mots avec NEAR.

<custom_proximity_term>
S’applique à : SQL Server 2012 (11.x) et versions ultérieures.

Spécifie une correspondance de mots ou d'expressions, et la distance maximale éventuellement autorisée entre des termes de recherche. Vous pouvez également spécifier que les termes de recherche doivent être recherchés dans l’ordre exact dans lequel vous les spécifiez (<match_order>).

Un terme de recherche donné peut être un mot unique ou une expression délimitée par des guillemets doubles ("expression"). Chaque terme spécifié doit figurer dans le document pour qu'une correspondance soit retournée. Vous devez spécifier au moins deux termes de recherche. Le nombre maximal de termes de recherche est de 64.

Par défaut, le terme de proximité personnalisée retourne toutes les lignes qui contiennent les termes spécifiés indépendamment de la distance qui les sépare et indépendamment de leur ordre. Par exemple, pour correspondre à la requête suivante, un document devrait simplement contenir term1 et « term3 term4 », peu importe leur place et leur ordre dans le document :

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

Les paramètres facultatifs sont les suivants :

<maximum_distance>
Spécifie la distance maximale autorisée entre les termes de recherche au début et à la fin d'une chaîne afin que cette chaîne soit considérée comme une correspondance.

entier
Spécifie un entier positif compris 0 et 4 294 967 295. Cette valeur contrôle le nombre de termes n'appartenant pas à la recherche pouvant se situer entre les premier et dernier termes de la recherche, à l'exclusion de tout autre terme de recherche spécifié supplémentaire.

Par exemple, la requête suivante recherche les termes AA et BB qui peuvent être dans n’importe l'ordre, mais dans une distance maximale de cinq.

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

La chaîne AA one two three four five BB serait une correspondance. Dans l’exemple suivant, la requête spécifie trois termes de recherche (AA, BB et CC) dans une distance maximale de cinq :

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

Cette requête correspondrait à la chaîne suivante, dans laquelle la distance totale est de cinq :

BB one two CC three four five A A

Notez que le terme de recherche interne, CC, n'est pas compté.

MAX
Retourne toutes les lignes qui contiennent les termes spécifiés indépendamment de la distance qui les sépare. Il s’agit de la valeur par défaut.

<match_order>
Spécifie si les termes doivent apparaître dans l'ordre spécifié pour être retournés par une requête de recherche. Pour spécifier <match_order>, vous devez également spécifier <maximum_distance>.

<match_order> prend l’une des valeurs suivantes :

TRUE
Impose l'ordre spécifié parmi les termes. Par exemple, NEAR(A,B) correspondrait uniquement à A ... B.

FALSE
Ignore l'ordre spécifié. Par exemple, NEAR(A,B) correspondrait à la fois à A ... B et à B ... A.

Il s’agit de la valeur par défaut.

Par exemple, le terme de proximité suivant recherche les mots « Monday », « Tuesday » et « Wednesday » dans l'ordre spécifié, indépendamment de la distance qui les sépare :

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

Pour plus d’informations sur l’utilisation des termes de proximité personnalisés, consultez Recherche de mots dans le voisinage d’autres mots avec NEAR.

<weighted_term>
Précise que les lignes retournées par la requête correspondent à une liste de mots ou d'expressions auxquels une valeur de pondération peut être affectée.

ISABOUT
Spécifie le mot clé <weighted_term>.

WEIGHT(weight_value)
Définit une valeur de pondération qui est un nombre compris entre 0,0 et 1,0. Chaque élément de <weighted_term> peut inclure une valeur weight_value. weight_value permet de changer l’influence de diverses parties d’une requête sur la valeur de classement assignée à chaque ligne correspondant à la requête. WEIGHT n’a pas d’incidence sur les résultats des requêtes CONTAINS, mais impacte le classement dans les requêtes CONTAINSTABLE.

{ AND | & } | { AND NOT | &! } | { OR | | }
Spécifie une opération logique entre deux conditions de recherche de contenu.

{ AND | & }
Indique que les deux conditions de recherche de contenu doivent être satisfaites pour obtenir une correspondance. Vous pouvez utiliser une esperluette (&) à la place du mot clé AND pour représenter l’opérateur AND.

{ AND NOT | &! }
Indique que la deuxième condition de recherche ne doit pas être satisfaite pour obtenir une correspondance. Vous pouvez utiliser une esperluette suivie d’un point d’exclamation (&!) à la place du mot clé AND NOT pour représenter l’opérateur AND NOT.

{ OR | | }
Indique que l'une des deux conditions de recherche de contenu doit être satisfaite pour obtenir une correspondance. Le symbole de barre verticale (|) peut être utilisé à la place du mot clé OR pour représenter l'opérateur OR.

Quand <contains_search_condition> comporte des groupes placés entre parenthèses, ces groupes sont évalués en premier. Une fois ces groupes évalués, les règles suivantes sont appliquées lorsque ces opérateurs logiques sont utilisés dans les conditions de recherche de contenu :

• NOT est appliqué avant AND.

• NOT peut uniquement être utilisé après AND, comme dans AND NOT. L'opérateur OR NOT n'est pas autorisé. NOT ne peut pas être spécifié avant le premier terme. Par exemple, CONTAINS (mycolumn, 'NOT "phrase_to_search_for" ' ) est incorrect.

• AND est appliqué avant OR.

• Les opérateurs booléens de même type (AND, OR) sont associatifs et peuvent donc être utilisés dans un ordre quelconque.

n
Espace réservé indiquant que plusieurs conditions de recherche CONTAINS peuvent être spécifiées, de même que plusieurs termes dans celles-ci.

Remarques d'ordre général

Les prédicats et les fonctions de texte intégral s'appliquent à une table unique, ce qui est implicite dans le prédicat FROM. Pour effectuer des recherches sur plusieurs tables, utilisez une table jointe dans votre clause FROM afin de baser votre recherche sur un jeu de résultats qui est le produit de deux tables ou plus.

Les prédicats de texte intégral ne sont pas autorisés dans la clause OUTPUT quand le niveau de compatibilité de la base de données a la valeur 100.

Interrogation de serveurs distants

Vous pouvez utiliser un nom en quatre parties dans le prédicat CONTAINS ou FREETEXT pour faire des requêtes sur les colonnes indexées en texte intégral dans les tables cibles d’un serveur lié. Pour préparer un serveur distant à recevoir des requêtes de texte intégral, créez un index de recherche en texte intégral sur les tables et colonnes cibles du serveur distant, puis ajoutez le serveur distant comme serveur lié.

Comparaison entre LIKE et la recherche en texte intégral

Contrairement à la recherche en texte intégral, le prédicat LIKETransact-SQL fonctionne uniquement sur les modèles de caractères. En outre, vous ne pouvez pas utiliser le prédicat LIKE pour interroger des données binaires mises en forme. De plus, une requête LIKE portant sur un important volume de données de texte non structurées est beaucoup plus lente qu'une requête de texte intégral équivalente exécutée sur les mêmes données. Une requête LIKE portant sur des millions de lignes de données de texte peut prendre plusieurs minutes pour retourner un résultat alors qu'une requête de texte intégral retourne en quelques secondes à peine le même résultat, en fonction du nombre de lignes retournées et de leur taille. Une autre considération à prendre en compte est que LIKE effectue uniquement une analyse de modèle simple d'une table entière. Par opposition, une requête de texte intégral est consciente de la langue et applique des transformations spécifiques au niveau de l'index et de l'heure de requête, telles que le filtrage de mots vides et l'ajout au dictionnaire des synonymes et aux formes fléchies. Ces transformations permettent aux requêtes de texte intégral d'améliorer le rappel et le dernier classement de leurs résultats.

Interrogation de plusieurs colonnes (recherche en texte intégral)

Vous pouvez interroger plusieurs colonnes en spécifiant une liste de colonnes à rechercher. Les colonnes doivent être issues de la même table.

Par exemple, la requête CONTAINS suivante recherche le terme Red dans les colonnes Name et Color de la table Production.Product utilisée dans l’exemple de base de données AdventureWorks2022.

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

Exemples

R. Utilisation de CONTAINS avec <simple_term>

L'exemple ci-dessous recherche tous les produits qui contiennent le mot $80.99 et qui coûtent Mountain.

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

B. Utilisation de CONTAINS et d’une expression avec <simple_term>

L'exemple ci-dessous retourne tous les produits qui contiennent l'expression Mountain ou Road.

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

C. Utilisation de CONTAINS avec <prefix_term>

L'exemple ci-dessous retourne tous les noms de produits comportant au moins un mot commençant par la chaîne de préfixe dans la colonne Name.

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

D. Utilisation de CONTAINS et OR avec <prefix_term>

L'exemple ci-dessous retourne toutes les descriptions de catégorie contenant les chaînes chain ou full.

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

E. Utilisation de CONTAINS avec <proximity_term>

S’applique à : SQL Server 2012 (11.x) et versions ultérieures.

L’exemple suivant recherche, dans la table Production.ProductReview, tous les commentaires qui contiennent le mot bike dans une distance de 10 termes du mot control et dans l’ordre spécifié (autrement dit, où bike précède control).

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

F. Utilisation de CONTAINS avec <generation_term>

L'exemple ci-dessous recherche tous les produits comportant des formes dérivées du mot ride : riding, ridden, etc.

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

G. Utilisation de CONTAINS avec <weighted_term>

L'exemple ci-dessous recherche tous les noms de produits contenant les termes « performance », « comfortable » ou « smooth ». Une pondération différente est affectée à chacun des mots.

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

H. Utilisation de CONTAINS avec des variables

L'exemple ci-dessous utilise une variable à la place d'un terme de recherche spécifique.

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

I. Utilisation de CONTAINS avec un opérateur logique (AND)

L'exemple suivant utilise la table ProductDescription de la base de données AdventureWorks2022 . La requête utilise le prédicat CONTAINS pour rechercher les descriptions dont l’ID de description n’est pas égal à 5 et qui contiennent les mots Aluminum et spindle. La condition de recherche utilise l'opérateur booléen AND.

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

J. Utilisation de CONTAINS pour vérifier une insertion de ligne

L'exemple suivant utilise CONTAINS dans le cadre d'une sous-requête SELECT. À partir de la base de données AdventureWorks2022, la requête obtient la valeur de tous les commentaires de la table ProductReview pour un cycle particulier. La condition de recherche utilise l'opérateur booléen 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. Interrogation sur une propriété de document

S’applique à : SQL Server 2012 (11.x) et versions ultérieures.

La requête suivante effectue une recherche sur une propriété indexée, Title, dans la colonne Document de la table Production.Document. La requête retourne uniquement les documents dont la propriété Title contient la chaîne Maintenance ou Repair.

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

Voir aussi

Commencer à utiliser la recherche en texte intégral
Créer et gérer des catalogues de texte intégral
CREATE FULLTEXT CATALOG (Transact-SQL)
CREATE FULLTEXT INDEX (Transact-SQL)
Créer et gérer des index de recherche en texte intégral
Exécuter une requête avec une recherche en texte intégral
CONTAINSTABLE (Transact-SQL)
FREETEXT (Transact-SQL)
FREETEXTTABLE (Transact-SQL)
Exécuter une requête avec une recherche en texte intégral
Recherche en texte intégral
Créer des requêtes de recherche en texte intégral (Visual Database Tools)
WHERE (Transact-SQL)
Rechercher les propriétés du document à l’aide des listes des propriétés de recherche