Not
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
gäller för:
SQL ServerAzure SQL DatabaseAzure SQL Managed Instance
Sökningar efter precisa eller fuzzy (mindre precisa) träffar på enskilda ord och fraser, ord inom ett visst avstånd från varandra, eller viktade träffar i SQL Server. CONTAINS är ett predikat som används i WHERE-klausulen i en Transact-SQL SELECT-sats för att utföra SQL Server-fulltextsökning på fulltextindexerade kolumner som innehåller teckenbaserade datatyper.
CONTAINS kan söka efter:
Ett ord eller en fras.
Prefixet av ett ord eller en fras.
Ett ord nära ett annat ord.
Ett ord som böjs av en annan (till exempel är ordet drive böjningsstammen för drives, drove, driving och driven).
Ett ord som är en synonym till ett annat ord som använder en synonymordbok (till exempel kan ordet "metall" ha synonymer som "aluminium" och "stål").
Information om de former av fulltextsökningar som stöds av SQL Server finns i Query with Full-Text Search.
Transact-SQL syntaxkonventioner
Syntax
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
Är namnet på en fulltextindexerad kolumn i tabellen som anges i FROM-klausulen. Kolumnerna kan vara av typen
column_list
Specificerar två eller fler kolumner, separerade av kommatecken.
column_list måste omges av parenteser. Om inte language_term anges måste språket för alla kolumner i column_list vara detsamma.
*
Specificerar att frågan söker i alla fulltextindexerade kolumner i tabellen som anges i FROM-klausulen för det givna sökvillkoret. Kolumnerna i CONTAINS-klausulen måste komma från en enda tabell som har ett fulltextindex. Om inte language_term anges måste språket för alla kolumner i tabellen vara detsamma.
EGENDOM ( column_name , 'property_name')
gäller för: SQL Server 2012 (11.x) och senare.
Specificerar en dokumentegenskap för att söka efter det angivna sökvillkoret.
Viktigt!
För att frågan ska returnera rader måste property_name anges i sökegenskapslistan för fulltextindexet och fulltextindexet måste innehålla egenskapsspecifika poster för property_name. För mer information, se Sök i dokumentfastigheter med sök i fastighetslistor.
SPRÅK language_term
Är språket att använda för ordbrytning, stemming, tesaurusutvidgningar och ersättningar samt borttagning av brusord (eller stoppord) som en del av frågan. Den här parametern är valfri.
Om dokument från olika språk lagras tillsammans som binära stora objekt (BLOBs) i en enda kolumn, avgör lokalidentifieraren (LCID) för ett givet dokument vilket språk som ska användas för att indexera innehållet. När du kör frågor mot en sådan kolumn kan det öka sannolikheten för en bra matchning om du anger LANGUAGE language_term.
language_term kan specificeras som en sträng, ett heltals- eller hexadecimalt värde som motsvarar LCID för ett språk. Om language_term anges tillämpas det språk som det representerar på alla element i sökvillkoret. Om inget värde anges används kolumnens fulltextspråk.
När den anges som en sträng motsvarar language_termaliaskolumnens värde i sys.syslanguages (Transact-SQL) kompatibilitetsvyn. Strängen måste omges av enkla citattecken, som i "language_term". När det anges som ett heltal är language_term den faktiska LCID som identifierar språket. När det anges som ett hexadecimalt värde är language_term 0x följt av hexadecimalt värde för LCID. Hexadecimalt värde får inte överstiga åtta siffror, inklusive inledande nollor.
Om värdet är i DBCS-format (double-byte character set) konverterar SQL Server det till Unicode.
Om det angivna språket inte är giltigt eller om inga resurser installeras som motsvarar det språket, ger SQL Server ett felmeddelande. Om du vill använda neutrala språkresurser anger du 0x0 som language_term.
<
contains_search_condition>
Anger den text som ska sökas efter i column_name och villkoren för en matchning.
<contains_search_condition> är nvarchar. En implicit konvertering sker när en annan teckendatatyp används som indata. Det går inte att använda stora strängdatatyper nvarchar(max) och varchar(max). I följande exempel orsakar variabeln @SearchWord, som definieras som varchar(30), en implicit konvertering i CONTAINS predikatet.
USE AdventureWorks2022;
GO
DECLARE @SearchWord VARCHAR(30)
SET @SearchWord ='performance'
SELECT Description
FROM Production.ProductDescription
WHERE CONTAINS(Description, @SearchWord);
Eftersom "parametersniffning" inte fungerar över konverteringen använder du nvarchar för bättre prestanda. I exemplet deklarerar du @SearchWord som nvarchar(30).
USE AdventureWorks2022;
GO
DECLARE @SearchWord NVARCHAR(30)
SET @SearchWord = N'performance'
SELECT Description
FROM Production.ProductDescription
WHERE CONTAINS(Description, @SearchWord);
Du kan också använda ledtråden OPTIMIZE FOR-fråga för fall där en icke-optimal plan genereras.
ord
Är en teckensträng utan mellanslag eller interpunktion.
fras
Är ett eller flera ord med mellanslag mellan varje ord.
Anmärkning
Vissa språk, såsom de som skrivs i vissa delar av Asien, kan ha fraser som består av ett eller flera ord utan mellanslag mellan dem.
<simple_term>
Specificerar en träff för ett exakt ord eller en fras. Exempel på giltiga enkla termer är "blue berry", blueberry och "Microsoft SQL Server". Fraser ska vara inneslutna med dubbla citattecken (""). Ord i en fras måste visas i samma ordning som anges i <contains_search_condition> som de förekommer i databaskolumnen. Sökningen efter tecken i ordet eller frasen är inte kasuskänslig. Brusorord (eller stoppord) (såsom a, och, eller the) i fulltextindexerade kolumner lagras inte i fulltextindexet. Om ett brusord används i en enda ordsökning returnerar SQL Server ett felmeddelande som indikerar att frågan endast innehåller brusord. SQL Server inkluderar en standardlista med brusord i katalogen \Mssql\Binn\FTERef för varje instans av SQL Server.
Interpunktion ignoreras. Därför CONTAINS(testing, "computer failure") matchar en rad med värdet, "Var är min dator? Att inte hitta den skulle bli dyrt." För mer information om ordbrytarbeteende, se Konfigurera och hantera ordbrytare och röstbrytare för sökning.
<prefix_term>
Specificerar en matchning av ord eller fraser som börjar med den angivna texten. Inkludera ett prefixord med dubbla citattecken ("") och lägg till en asterisk (*) före slutcitattecknet, så att all text som börjar med den enkla termen som anges före asterisken matchas. Klausulen ska specificeras så här: CONTAINS (column, '"text*"'). Asterisken matchar noll, ett eller flera tecken (av rotordet eller orden i ordet eller frasen). Om texten och asterisken inte är avgränsade med dubbla citattecken, så att predikatet lyder CONTAINS (column, 'text*'), betraktar fulltextsökning asterisken som ett tecken och söker efter exakta träffar med text*. Fulltextmotorn hittar inte ord med asterisk (*) eftersom ordbrytare vanligtvis ignorerar sådana tecken.
När <prefix_term> är en fras betraktas varje ord i frasen som ett separat prefix. Därför matchar en fråga som anger prefixtermen "lokal vin*" alla rader med texten "lokal vingård", "lokalt vin och middag" och så vidare.
<generation_term>
Specificerar en matchning av ord när de inkluderade enkla termerna innehåller varianter av det ursprungliga ordet att söka efter.
BÖJNING
Specificerar att den språkberoende stemmern ska användas på den angivna enkla termen. Stemmerbeteende definieras baserat på stemming-regler för varje specifikt språk. Det neutrala språket har ingen tillhörande stemmer. Kolumnspråket för de kolumner som frågas används för att referera till önskad stemmer. Om language_term anges används stemmern som motsvarar det språket.
En given <simple_term> inom en <generation_term> kommer inte att matcha både substantiv och verb.
TESAURUS
Specificerar att synonymordboken som motsvarar kolumnens fulltextspråk, eller språket som anges i frågan, används. Det längsta mönstret eller mönstren från <simple_term> matchas mot synonymordboken och ytterligare termer genereras för att utöka eller ersätta det ursprungliga mönstret. Om ingen träff hittas för hela eller delar av <simple_term> behandlas den icke-matchande delen som en simple_term. För mer information om fulltextsökartesaurusen, se Konfigurera och hantera tesaurusfiler för Full-Text sökning.
<generic_proximity_term>
Specificerar en träff av ord eller fraser som måste finnas i dokumentet som söks i.
Viktigt!
Den här funktionen tas bort i en framtida version av SQL Server. Undvik att använda den här funktionen i nytt utvecklingsarbete och planera att ändra program som för närvarande använder den här funktionen. Vi rekommenderar att du använder <custom_proximity_term>.
NÄRA | ~
Indikerar att ordet eller frasen på varje sida av operatorn NEAR eller ~ måste förekomma i ett dokument för att en träff ska kunna returneras. Du måste ange två söktermer. En given sökterm kan vara antingen ett enda ord eller en fras som avgränsas med dubbla citattecken ("fras").
Flera närhetstermer kan kedjas samman, som i a NEAR b NEAR c eller a ~ b ~ c. Kedjade närhetstermer måste alla finnas i dokumentet för att en matchning ska kunna returneras.
Till exempel CONTAINS(*column_name*, 'fox NEAR chicken') skulle och CONTAINSTABLE(*table_name*, *column_name*, 'fox ~ chicken') båda returnera alla dokument i den angivna kolumnen som innehåller både "räv" och "kyckling". Dessutom returnerar CONTAINSTABLE en rang för varje dokument baserat på närheten mellan "räv" och "kyckling". Till exempel, om ett dokument innehåller meningen "Räven åt kycklingen," skulle dess rangordning vara hög eftersom termerna ligger närmare varandra än i andra dokument.
För mer information om generiska närhetstermer, se Sök efter ord nära ett annat ord med NEAR.
<custom_proximity_term>
gäller för: SQL Server 2012 (11.x) och senare.
Specificerar en matchning av ord eller fraser, och valfritt det maximala tillåtna avståndet mellan söktermer. Du kan också ange att söktermer måste hittas i exakt den ordning du anger dem i (<match_order>).
En given sökterm kan vara antingen ett enda ord eller en fras som avgränsas med dubbla citattecken ("fras"). Varje angiven term måste finnas i dokumentet för att en matchning ska kunna returneras. Du måste ange minst två söktermer. Det maximala antalet söktermer är 64.
Som standard returnerar den anpassade närhetstermen alla rader som innehåller de angivna termerna oavsett mellanliggande avstånd och oavsett deras ordning. Till exempel, för att matcha följande fråga behöver ett dokument helt enkelt innehålla term1 och "term3 term4" var som helst, i valfri ordning:
CONTAINS(column_name, 'NEAR(term1,"term3 term4")')
De valfria parametrarna är följande:
<maximum_distance>
Specificerar det maximala tillåtna avståndet mellan söktermerna i början och slutet av en sträng för att den strängen ska kvalificera som en matchning.
heltal
Specificerar ett positivt heltal från 0 till 4294967295. Detta värde styr hur många icke-söktermer som kan förekomma mellan den första och sista söktermen, och exkluderar eventuella ytterligare specificerade söktermer.
Till exempel söker följande fråga efter AA och BB, i vilken ordning som helst, inom ett maximalt avstånd på fem.
CONTAINS(column_name, 'NEAR((AA,BB),5)')
Strängen AA one two three four five BB skulle vara en match. I följande exempel specificerar frågan för tre söktermer, AA, , BBoch CC inom ett maximalt avstånd på fem:
CONTAINS(column_name, 'NEAR((AA,BB,CC),5)')
Denna fråga skulle matcha följande sträng, där det totala avståndet är fem:
BB one two CC three four five A A
Observera att den inre söktermen, CC, inte räknas.
MAX
Returnerar alla rader som innehåller de angivna termerna oavsett avståndet mellan dem. Det här är standardinställningen.
<match_order>
Specificerar om termerna måste förekomma i den angivna ordningen för att returneras av en sökfråga. För att specificera <match_order> måste du också ange <maximum_distance>.
<match_order> tar ett av följande värden:
TRUE
Upprätthåller den angivna ordern inom villkoren. Till exempel NEAR(A,B) skulle endast matcha A ... B.
FALSE
Ignorerar den angivna ordningen. Till exempel NEAR(A,B) skulle matcha både A ... B och B ... A.
Det här är standardinställningen.
Till exempel söker följande närhetsterm orden "Monday", "Tuesday" och "Wednesday" i angiven ordning med oavsett avståndet mellan dem:
CONTAINS(column_name, 'NEAR ((Monday, Tuesday, Wednesday), MAX, TRUE)')
För mer information om användning av anpassade närhetstermer, se Sök efter ord nära ett annat ord med NEAR.
<weighted_term>
Specificerar att de matchande raderna (som returneras av frågan) matchar en lista med ord och fraser, där varje rad valfritt ges ett viktningsvärde.
OMKRING
Specificerar det< weighted_term> nyckelordet.
VIKT(weight_value)
Specificerar ett viktvärde, vilket är ett tal från 0,0 till 1,0. Varje komponent i <weighted_term> kan innehålla en weight_value.
weight_value är ett sätt att ändra hur olika delar av en fråga påverkar rankningsvärdet som tilldelas varje rad som matchar frågan. WEIGHT påverkar inte resultaten av CONTAINS-frågor, men WEIGHT påverkar rang i CONTAINSTABLE-frågor .
Anmärkning
Den decimala separatorn är alltid ett punktum, oavsett operativsystemets plats.
{ OCH | & } | { OCH INTE | &! } | { ELLER | | }
Specificerar en logisk operation mellan två innehåller sökvillkor.
{ OCH | & }
Indikerar att de två contains sökvillkoren måste uppfyllas för en träff. Ampersand-symbolen (&) kan användas istället för nyckelordet AND för att representera OCH-operatorn.
{ OCH INTE | &! }
Indikerar att det andra sökvillkoret inte får finnas för en träff. Tecknet följd av utropstecknets symbol (&!) kan användas istället för nyckelordet AND NOT för att representera operatorn AND NOT.
{ ELLER | | }
Indikerar att någon av de två innehåller sökvillkor måste uppfyllas för en träff. Strecksymbolen (|) kan användas istället för nyckelordet OR för att representera ELLER-operatorn.
När <contains_search_condition> innehåller parentesgrupper utvärderas dessa parentesgrupper först. Efter att ha utvärderat parenteserade grupper gäller dessa regler när dessa logiska operatorer med innehåller sökvillkor:
NOT appliceras före OCH.
NOT kan bara förekomma efter OCH, alltså i AND NOT. OR NOT-operatören är inte tillåten. NOT kan inte specificeras före första terminen. Till exempel
CONTAINS (mycolumn, 'NOT "phrase_to_search_for" ' )är inte giltigt.AND tillämpas före operationssalen.
Booleska operatorer av samma typ (OCH, ELLER) är associativa och kan därför tillämpas i valfri ordning.
n
Är en platshållare som indikerar att flera sökvillkor och termer i CONTAINS kan specificeras.
Allmänna kommentarer
Fulltextpredikat och funktioner fungerar på en enda tabell, vilket är underförstått i FROM-predikatet. Om du vill söka i flera tabeller använder du en ansluten tabell i FROM-satsen för att söka efter en resultatuppsättning som är produkten av två eller flera tabeller.
Fulltextpredikat tillåts inte i OUTPUT-satsen när databaskompatibilitetsnivån är inställd på 100.
Köra frågor mot fjärrservrar
Du kan använda ett fyrdelat namn i predikatet CONTAINS eller FREETEXT för att söka fulltextindexerade kolumner i måltabellerna på en länkad server. Om du vill förbereda en fjärrserver för att ta emot fulltextfrågor skapar du ett fulltextindex för måltabellerna och kolumnerna på fjärrservern och lägger sedan till fjärrservern som en länkad server.
Jämförelse av LIKE till Full-Text Search
Till skillnad från fulltextsökning fungerar LIKETransact-SQL predikat endast på teckenmönster. Du kan inte heller använda LIKE-predikatet för att fråga efter formaterade binära data. Dessutom är en LIKE-fråga mot en stor mängd ostrukturerade textdata mycket långsammare än en motsvarande fulltextfråga mot samma data. En LIKE-fråga mot miljontals rader av textdata kan ta minuter att returnera; medan en fulltextfråga kan ta bara sekunder eller mindre mot samma data, beroende på antalet rader som returneras och deras storlek. En annan aspekt är att LIKE endast utför en enkel mönsterskanning av en hel tabell. En fulltextfråga, däremot, är språkmedveten och tillämpar specifika transformationer vid index- och frågetidpunkt, såsom filtrering av stoppord och att skapa tesaurus- och böjningsutvidgningar. Dessa transformationer hjälper heltextfrågor att förbättra deras återkallelse och den slutliga rankingen av deras resultat.
Sökning av flera kolumner (Full-Text sökning)
Du kan söka flera kolumner genom att ange en lista med kolumner att söka i. Kolumnerna måste komma från samma tabell.
Till exempel söker följande CONTAINS-fråga efter termen Red i Name och Color kolumnerna i Production.Product tabellen i AdventureWorks2025:s exempeldatabas.
Use AdventureWorks2022;
GO
SELECT Name, Color
FROM Production.Product
WHERE CONTAINS((Name, Color), 'Red');
Examples
A. Att använda CONTAINS med <simple_term>
Följande exempel visar alla produkter med priset på $80.99 som innehåller ordet Mountain.
USE AdventureWorks2022;
GO
SELECT Name, ListPrice
FROM Production.Product
WHERE ListPrice = 80.99
AND CONTAINS(Name, 'Mountain');
GO
B. Att använda CONTAINS och frasen med <simple_term>
Följande exempel returnerar alla produkter som innehåller antingen frasen Mountain eller Road.
USE AdventureWorks2022;
GO
SELECT Name
FROM Production.Product
WHERE CONTAINS(Name, ' Mountain OR Road ')
GO
C. Att använda CONTAINS med <prefix_term>
Följande exempel returnerar alla produktnamn med minst ett ord som börjar med prefixkedjan i kolumnen Name .
USE AdventureWorks2022;
GO
SELECT Name
FROM Production.Product
WHERE CONTAINS(Name, ' "Chain*" ');
GO
D. Att använda CONTAINS och OR med <prefix_term>
Följande exempel returnerar alla kategoribeskrivningar som innehåller strängar med prefix av antingen chain eller full.
USE AdventureWorks2022;
GO
SELECT Name
FROM Production.Product
WHERE CONTAINS(Name, '"chain*" OR "full*"');
GO
E. Att använda CONTAINS med <proximity_term>
gäller för: SQL Server 2012 (11.x) och senare.
Följande exempel söker i Production.ProductReview tabellen efter alla kommentarer som innehåller ordet bike inom 10 termer från ordet "control" och i angiven ordning (det vill säga där "bike" föregår "control").
USE AdventureWorks2022;
GO
SELECT Comments
FROM Production.ProductReview
WHERE CONTAINS(Comments , 'NEAR((bike,control), 10, TRUE)');
GO
F. Att använda CONTAINS med <generation_term>
Följande exempel söker efter alla produkter med ord av formen ride: riding, ridden, och så vidare.
USE AdventureWorks2022;
GO
SELECT Description
FROM Production.ProductDescription
WHERE CONTAINS(Description, ' FORMSOF (INFLECTIONAL, ride) ');
GO
G. Att använda CONTAINS med <weighted_term>
Följande exempel söker efter alla produktnamn som innehåller orden performance, comfortable, eller smooth, och olika vikter ges till varje ord.
USE AdventureWorks2022;
GO
SELECT Description
FROM Production.ProductDescription
WHERE CONTAINS(Description, 'ISABOUT (performance weight (.8),
comfortable weight (.4), smooth weight (.2) )' );
GO
H. Att använda CONTAINS med variabler
I följande exempel används en variabel i stället för en specifik söktermen.
USE AdventureWorks2022;
GO
DECLARE @SearchWord NVARCHAR(30)
SET @SearchWord = N'Performance'
SELECT Description
FROM Production.ProductDescription
WHERE CONTAINS(Description, @SearchWord);
GO
I. Att använda CONTAINS med en logisk operator (OCH)
Följande exempel använder databasens ProductDescription-tabell AdventureWorks2025 . Frågan använder predikatet CONTAINS för att söka efter beskrivningar där beskrivnings-ID inte är lika med 5 och beskrivningen innehåller både ordet Aluminum och ordet spindle. Sökvillkoret använder AND-booleanoperatorn.
USE AdventureWorks2022;
GO
SELECT Description
FROM Production.ProductDescription
WHERE ProductDescriptionID <> 5 AND
CONTAINS(Description, 'Aluminum AND spindle');
GO
J. Att använda CONTAINS för att verifiera en radinsättning
Följande exempel använder CONTAINS inom en SELECT-delfråga. Med hjälp av databasen AdventureWorks2025 hämtar frågan kommentarsvärdet för alla kommentarer i ProductReview-tabellen för en viss cykel. Sökvillkoret använder AND-booleanoperatorn.
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. Förfrågan på en dokumentegenskap
gäller för: SQL Server 2012 (11.x) och senare.
Följande fråga söker på en indexerad egenskap, Title, i kolumnen Document i tabellen Production.Document . Frågan returnerar endast dokument vars Title egenskap innehåller strängen Maintenance eller Repair.
Anmärkning
För att en egenskapssökning ska returnera rader måste filtret eller filtren som tolkar kolumnen under indexeringen extrahera den angivna egenskapen. Dessutom måste fulltextindexet för den angivna tabellen ha konfigurerats för att inkludera egenskapen. För mer information, se Sök i dokumentfastigheter med sök i fastighetslistor.
Use AdventureWorks2022;
GO
SELECT Document
FROM Production.Document
WHERE CONTAINS(PROPERTY(Document,'Title'), 'Maintenance OR Repair');
GO
Se även
Kom igång med Full-Text Search
Skapa och hantera Full-Text kataloger
SKAPA FULLTEXTKATALOG (Transact-SQL)
SKAPA FULLTEXTINDEX (Transact-SQL)
Skapa och hantera Full-Text index
fråga med Full-Text Sök
CONTAINSTABLE (Transact-SQL)
FRITEXT (Transact-SQL)
FRITEXTTABELL (Transact-SQL)
fråga med Full-Text Sök
Fulltextsökning
Skapa Full-Text sökfrågor (Visual Database Tools)
DÄR (Transact-SQL)
Söka dokumentegenskaper med listor över sökegenskaper