MySQL-Grundlagen-Tutorial 10 – Funktion Volltextsuchfunktion

Syntax:

• MATCH (col1,col2,...) AGAINST (expr [IM BOOLEAN-MODUS | MIT ABFRAGEERWEITERUNG])

MySQL unterstützt Volltextindizierung und Suchfunktionen. Der Volltextindextyp FULLTEXT-Index in MySQL. FULLTEXT-Indizes sind nur für MyISAM-Tabellen verfügbar; sie können aus CHAR-, VARCHAR- oder TEXT-Spalten als Teil einer CREATE TABLE-Anweisung erstellt oder später mit ALTER TABLE oder CREATE INDEX hinzugefügt werden. Bei größeren Datensätzen ist die Eingabe Ihrer Daten in eine Tabelle ohne FULLTEXT-Index und die anschließende Erstellung des Index schneller als die Eingabe der Daten in einen vorhandenen FULLTEXT-Index.

Die Volltextsuche wird mit der Funktion MATCH() durchgeführt.

mysql> CREATE TABLE articles (    
->   id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,    
->   title VARCHAR(200),    
->   body TEXT,    
->   FULLTEXT (title,body)    
-> );Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO articles (title,body) VALUES    
-> ('MySQL Tutorial','DBMS stands for DataBase ...'),    
-> ('How To Use MySQL Well','After you went through a ...'),    
-> ('Optimizing MySQL','In this tutorial we will show ...'),    
-> ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),    
-> ('MySQL vs. YourSQL','In the following database comparison ...'),    
-> ('MySQL Security','When configured properly, MySQL ...');Query OK, 6 rows affected (0.00 sec)
Records: 6  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM articles    
-> WHERE MATCH (title,body) AGAINST ('database');
+----+-------------------+------------------------------------------+
| id | title             | body          |
+----+-------------------+------------------------------------------+
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...            |
+----+-------------------+------------------------------------------+
2 rows in set (0.00 sec)

Die Funktion MATCH() führt eine Suche in natürlicher Sprache innerhalb der Datenbank nach einer Zeichenfolge durch. Eine Datenbank ist ein Satz von 1 oder 2 Spalten, die in FULLTEXT enthalten sind. Der Suchstring wird als Parameter an AGAINST() übergeben. Für jede Zeile in der Tabelle gibt MATCH() einen Korrelationswert zurück, d. h. ein Ähnlichkeitsmaß zwischen der Suchzeichenfolge und dem Text in dieser Zeile in der angegebenen Spalte in der MATCH()-Tabelle.

Standardmäßig werden Suchvorgänge ohne Berücksichtigung der Groß-/Kleinschreibung durchgeführt. Sie können jedoch eine Volltextsuche unter Berücksichtigung der Groß- und Kleinschreibung durchführen, indem Sie eine binäre Sortierung für die indizierten Spalten verwenden. Beispielsweise können Sie einer Spalte, die den Zeichensatz „latin1“ verwendet, die Sortiermethode „latin1_bin“ zuweisen, wodurch bei Volltextsuchen die Groß-/Kleinschreibung beachtet wird.

Wie im obigen Beispiel ist der relevante Wert eine nicht negative Gleitkommazahl, wenn MATCH() in einer WHERE-Anweisung verwendet wird. Nullkorrelation bedeutet keine Ähnlichkeit. Die Korrelation wird basierend auf der Anzahl der Wörter in der Zeile, der Anzahl der eindeutigen Wörter in der Zeile, der Gesamtzahl der Wörter in der Datenbank und der Anzahl der Dateien (Zeilen), die das eindeutige Wort enthalten, berechnet.

Für die Volltextsuche in natürlicher Sprache ist es erforderlich, dass die in der Funktion MATCH() genannten Spalten mit den Spalten übereinstimmen, die in einigen FULLTEXT-Indizes in Ihrer Tabelle enthalten sind. Bitte beachten Sie für die obige Abfrage, dass die in der Funktion MATCH() benannten Spalten (Titel und Volltext) mit den Spalten im FULLTEXT-Index der Artikeltabelle identisch sind. Wenn Sie Titel und Volltext getrennt durchsuchen möchten, sollten Sie für jede Spalte einen VOLLTEXT-Index erstellen.

Alternativ können Sie eine boolesche Suche oder eine Suche mithilfe der Abfrageerweiterung durchführen.

Das obige Beispiel zeigt im Wesentlichen, wie die Funktion MATCH() verwendet wird, die Zeilen in absteigender Korrelationsreihenfolge zurückgibt. Das folgende Beispiel zeigt, wie der relevante Wert explizit abgerufen wird. Die Reihenfolge der zurückgegebenen Zeilen ist unsicher, da die SELECT-Anweisung keine WHERE- oder ORDER BY-Klausel enthält:

mysql> SELECT id, MATCH (title,body) AGAINST ('Tutorial')    
-> FROM articles;
+----+-----------------------------------------+
| id | MATCH (title,body) AGAINST ('Tutorial') |
+----+-----------------------------------------+
|  1 |                        0.65545833110809 |
|  2 |                                       0 |
|  3 |                        0.66266459226608 |
|  4 |                                       0 |
|  5 |                                       0 |
|  6 |                                       0 |
+----+-----------------------------------------+
6 rows in set (0.00 sec)

Das folgende Beispiel ist komplizierter. Die Abfrage gibt die relevanten Werte zurück und sortiert die Zeilen nach abnehmender Relevanz. Um dieses Ergebnis zu erzielen, sollten Sie MATCH() zweimal angeben: einmal in der SELECT-Liste und einmal in der WHERE-Klausel. Dadurch entsteht kein zusätzlicher Verwaltungsaufwand, da der MySQL-Optimierer feststellt, dass die beiden MATCH()-Aufrufe identisch sind, und den Volltextsuchcode nur einmal aktiviert.

mysql> SELECT id, body, MATCH (title,body) AGAINST    
-> ('Security implications of running MySQL as root') AS score    
-> FROM articles WHERE MATCH (title,body) AGAINST    
-> ('Security implications of running MySQL as root');
+----+-------------------------------------+-----------------+
| id | body                                | score           |
+----+-------------------------------------+-----------------+
|  4 | 1. Never run mysqld as root. 2. ... | 1.5219271183014 |
|  6 | When configured properly, MySQL ... | 1.3114095926285 |
+----+-------------------------------------+-----------------+
2 rows in set (0.00 sec)

Es gibt 2 Zeilen in der Tabelle (0,00 Sekunden)

Die Ausführung von MySQL FULLTEXT behandelt jede Folge von Einzelwort-Zeichenprototypen (Buchstaben, Zahlen und Unterstrichteile) als Wort . Diese Sequenz kann auch einfache Anführungszeichen (') enthalten, es darf jedoch nicht mehr als eins in einer Zeile stehen. Das bedeutet, dass aaa'bbb als ein Wort behandelt wird, während aaa''bbb als zwei Wörter behandelt wird. Einfache Anführungszeichen vor oder nach einem Wort werden vom FULLTEXT-Parser entfernt; aus „aaa'bbb“ wird aaa'bbb.

Der FULLTEXT-Parser bestimmt, wo ein Wort beginnt und endet, indem er nach bestimmten Trennzeichen sucht, wie zum Beispiel „ “ (Leerzeichen), , (Komma) und (Punkt). Wenn Wörter nicht durch Trennzeichen getrennt sind (z. B. im Chinesischen), kann der FULLTEXT-Parser die Anfangs- und Endpositionen eines Wortes nicht ermitteln. Um Wörter oder andere indizierte Begriffe zu einem FULLTEXT-Index in einer solchen Sprache hinzufügen zu können, müssen Sie sie vorverarbeiten, sodass sie durch ein beliebiges Trennzeichen wie „ getrennt werden.

Einige Wörter werden in ignoriert Volltextsuche:

• Jedes zu kurze Wort wird ignoriert. Die standardmäßige Mindestlänge eines bei der Volltextsuche gefundenen Wortes ist

• Wörter in Stoppwörtern werden ignoriert. Es gibt ein eingebautes Stoppwort, das durch benutzerdefinierte Listen überschrieben werden kann

Jedes richtige Wort im Vokabular und in der Abfrage wird anhand seiner Bedeutung im Vokabular und in der Abfrage gemessen. Auf diese Weise hat ein Wort, das in vielen Dokumenten vorkommt, eine geringere Bedeutung (und das haben sogar viele Wörter). Null-Wichtigkeit) aufgrund seines geringeren semantischen Werts in diesem bestimmten Vokabular. Wenn das Wort hingegen selten ist, erhält es eine höhere Bedeutung. Die Bedeutung der Wörter wird dann kombiniert und zur Berechnung der Relevanz der Zeile verwendet.

这项技术最适合同大型词库一起使用 (事实上, 此时它经过仔细的调整 )。对于很小的表，单词分布并不能充分反映它们的语义价值， 而这个模式有时可能会产生奇特的结果。例如, 虽然单词 “MySQL” 出现在文章表中的每一行，但对这个词的搜索可能得不到任何结果：

mysql> SELECT * FROM articles

-> WHERE MATCH (title,body) AGAINST ('MySQL');

找不到搜索的词(0.00 秒)

这个搜索的结果为空，原因是单词 “MySQL” 出现在至少全文的50%的行中。 因此, 它被列入停止字。对于大型数据集，使用这个操作最合适不过了----一个自然语言问询不会从一个1GB 的表每隔一行返回一次。对于小型数据集，它的用处可能比较小。

一个符合表中所有行的内容的一半的单词查找相关文档的可能性较小。事实上, 它更容易找到很多不相关的内容。我们都知道，当我们在因特网上试图使用搜索引擎寻找资料的时候，这种情况发生的频率颇高。可以推论，包含该单词的行因其所在特别数据集 而被赋予较低的语义价值。 一个给定的词有可能在一个数据集中拥有超过其50%的域值，而在另一个数据集却不然。

当你第一次尝试使用全文搜索以了解其工作过程时，这个50% 的域值提供重要的蕴涵操作：若你创建了一个表，并且只将文章的1、2行插入其中， 而文中的每个单词在所有行中出现的机率至少为 50% 。那么结果是你什么也不会搜索到。一定要插入至少3行，并且多多益善。需要绕过该50% 限制的用户可使用布尔搜索代码。

1. 布尔全文搜索

利用IN BOOLEAN MODE修改程序， MySQL 也可以执行布尔全文搜索：

mysql> SELECT * FROM articles WHERE MATCH (title,body)    
-> AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);
+----+-----------------------+-------------------------------------+
| id | title                 | body                                |
+----+-----------------------+-------------------------------------+
|  1 | MySQL Tutorial        | DBMS stands for DataBase ...        |
|  2 | How To Use MySQL Well | After you went through a ...        |
|  3 | Optimizing MySQL      | In this tutorial we will show ...   |
|  4 | 1001 MySQL Tricks     | 1. Never run mysqld as root. 2. ... |
|  6 | MySQL Security        | When configured properly, MySQL ... |
+----+-----------------------+-------------------------------------+

Nach dem Login kopieren

这个问询检索所有包含单词“MySQL”的行，但不检索包含单词“YourSQL”的行。

布尔全文搜索具有以下特点：

• 它们不使用 50% 域值。.

• 它们不会按照相关性渐弱的顺序将行进行分类。你可以从上述问询结果中看到这一点：相关性最高的行是一个包含两个“MySQL” 的行，但它被列在最后的位置，而不是开头位置。

• 即使没有FULLTEXT，它们仍然可以工作，尽管这种方式的搜索执行的速度非常之慢。

• 最小单词长度全文参数和最大单词长度全文参数均适用。

• 停止字适用。

布尔全文搜索的性能支持以下操作符：

• +

一个前导的加号表示该单词必须 出现在返回的每一行的开头位置。

• -

一个前导的减号表示该单词一定不能出现在任何返回的行中。

• (无操作符)

在默认状态下(当没有指定 + 或–的情况下)，该单词可有可无，但含有该单词的行等级较高。这和MATCH() ... AGAINST()不使用IN BOOLEAN MODE修改程序时的运作很类似。

• > <

这两个操作符用来改变一个单词对赋予某一行的相关值的影响。 > 操作符增强其影响，而 <操作符则减弱其影响。请参见下面的例子。

• ( )

括号用来将单词分成子表达式。括入括号的部分可以被嵌套。

• ~

一个前导的代字号用作否定符， 用来否定单词对该行相关性的影响。 这对于标记“noise（无用信息）”的单词很有用。包含这类单词的行较其它行等级低，但因其可能会和-号同时使用，因而不会在任何时候都派出所有无用信息行。

• *

星号用作截断符。于其它符号不同的是，它应当被追加到要截断的词上。

• "

一个被括入双引号的短语 (‘"’) 只和字面上包含该短语输入格式的行进行匹配。全文引擎将短语拆分成单词，在FULLTEXT索引中搜索该单词。 非单词字符不需要严密的匹配：短语搜索只要求符合搜索短语包含的单词且单词的排列顺序相同的内容。例如， "test phrase" 符合 "test, phrase"。

若索引中不存在该短语包含的单词，则结果为空。例如，若所有单词都是禁用词，或是长度都小于编入索引单词的最小长度，则结果为空。

以下例子展示了一些使用布尔全文符号的搜索字符串：

• 'apple banana'

寻找包含至少两个单词中的一个的行。

• '+apple +juice'

寻找两个单词都包含的行。

• '+apple macintosh'

寻找包含单词“apple”的行，若这些行也包含单词“macintosh”， 则列为更高等级。

• '+apple -macintosh'

寻找包含单词“apple” 但不包含单词 “macintosh”的行。

• '+apple +(>turnover

寻找包含单词“apple”和“turnover” 的行，或包含“apple” 和“strudel”的行 (无先后顺序),然而包含 “apple turnover”的行较包含“apple strudel”的行排列等级更为高。

• 'apple*'

寻找包含“apple”、“apples”、“applesauce”或“applet”的行。

• '"some words"'

寻找包含原短语“some words”的行 (例如,包含“some words of wisdom” 的行，而非包含 “some noise words”的行)。注意包围词组的‘"’ 符号是界定短语的操作符字符。它们不是包围搜索字符串本身的引号。

2. 全文搜索带查询扩展

全文搜索支持查询扩展功能 (特别是其多变的“盲查询扩展功能” )。若搜索短语的长度过短, 那么用户则需要依靠全文搜索引擎通常缺乏的内隐知识进行查询。这时，查询扩展功能通常很有用。例如, 某位搜索 “database” 一词的用户，可能认为“MySQL”、“Oracle”、“DB2” and “RDBMS”均为符合 “databases”的项，因此都应被返回。这既为内隐知识。

在下列搜索短语后添加WITH QUERY EXPANSION，激活盲查询扩展功能(即通常所说的自动相关性反馈)。它将执行两次搜索，其中第二次搜索的搜索短语是同第一次搜索时找到的少数顶层文件连接的原始搜索短语。这样,假如这些文件中的一个 含有单词 “databases” 以及单词 “MySQL”, 则第二次搜索会寻找含有单词“MySQL” 的文件，即使这些文件不包含单词 “database”。下面的例子显示了这个不同之处：

mysql> SELECT * FROM articles   
 -> WHERE MATCH (title,body) AGAINST ('database');
+----+-------------------+------------------------------------------+
| id | title             | body                                     |
+----+-------------------+------------------------------------------+
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
+----+-------------------+------------------------------------------+
2 rows in set (0.00 sec)

mysql> SELECT * FROM articles    
-> WHERE MATCH (title,body)    
-> AGAINST ('database' WITH QUERY EXPANSION);
+----+-------------------+------------------------------------------+
| id | title             | body                                     |
+----+-------------------+------------------------------------------+
|  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
|  5 | MySQL vs. YourSQL | In the following database comparison ... |
|  3 | Optimizing MySQL  | In this tutorial we will show ...        |
+----+-------------------+------------------------------------------+
3 rows in set (0.00 sec)

Nach dem Login kopieren

另一个例子是Georges Simenon 搜索关于Maigret的书籍, 这个用户不确定“Maigret”一词的拼法。若不使用查询扩展而搜索“Megre and the reluctant witnesses” 得到的结果只能是的“Maigret and the Reluctant Witnesses” 。 而带有查询扩展的搜索会在第二遍得到带有“Maigret”一词的所有书名。

注释： 盲查询扩展功能很容易返回非相关文件而增加无用信息，因此只有在查询一个长度很短的短语时才有必要使用这项功能。

3. 全文停止字

以下表列出了默认的全文停止字：

<🎜 nicht >auf jeden Fallbeschriebenobwohlnichtnichtanders wartuttuttut nichttutnichterledigt nach untennach untenwährendjedemeduzBachtentwedersonstanderswogenugganzbesondersundusw.auchimmerallejederjederallesüberallexgenauBeispielaußerweitwenigefünfteerstefünfgefolgtfolgendfolgtfürehemalige frühervonviervonweiterweiterhinbekommenwirdwirdgegebengibtgehtgehtgehtwegbekommenbekommenGrüße hattenichtpassiertkaumhathat nichthabenichthabeerer istHallohelfendaherihrhierhierim Folgenden hiermithierinhieraufsiesie selbstHalloihnsich selbstseinhierherhoffentlichwieWie auch immeraberich würdeich werdeich binich 'vedhwennignoriertsofortininsofern incin der Tatzeigenangezeigtzeigt aninneresinsofernsonderninnach innenistist nichteses würdees wirdes istes istsich selbsteinfachbehaltenbehältbehaltenwissenweißbekanntzuletztin letzter Zeitspäterletzteresin letzter Zeitmindestenswenigerdamitnichtunsmögen gefälltwahrscheinlichwenigAussehenSieht ausAussehenltdhauptsächlichvielevielleichtvielleichtichmeineinzwischennurkönntemehrmehr das meistemeistensvielmussmeinich selbstNamenämlichundnahefastnotwendigbrauchenbrauchenwedernietrotzdemneunächsteneunneinniemandnichtkeineniemandnochnormalerweisenicht

a's	fähig	ungefähr	oben	entsprechend
entsprechend	quer	eigentlich	nach	danach
wieder	gegen	ist nicht	alle	erlauben
erlaubt	fast	allein	davon	schon
auch	obwohl	immer	bin	unter
unter	einem	und	ein anderer	jeder
jeder	sowieso	jeder	alles	sowieso
sowieso	überall	abseits	erscheinen	schätzen
angemessen	sind	nicht	in der Nähe	so
beiseite	fragen	fragen	zugehörige	bei
verfügbar	weg	schrecklich	sein	geworden
weil	geworden	wird	werden	gewesen
vorher	vorher	danach	sein	glauben
unten	neben	außerdem	das Beste	besser
zwischen	darüber	beides	kurz	aber
durch	komm schon	c's	kam	kann
kann nicht	kann nicht	kann nicht	Ursache	Ursachen
gewiss	sicherlich	Änderungen	eindeutig	co
com	kommen	kommt	betreffend	folgerichtig
erwägen	erwägen	enthalten	enthaltend	enthalten
entsprechend	konnte	konnte	natürlich	derzeit
nichts	Neuartiges	jetzt	nirgendwo	offensichtlich
von	aus	oft	oh	ok
okay	alt	auf	einmal	eins
eins	nur	auf	oder	andere
andere	sonst	sollten	unsere	unsere
uns selbst	draußen	draußen	über	insgesamt
eigene	besondere	besondere	pro	vielleicht
platzierte	bitte	plus	möglich	vermutlich
wahrscheinlich	liefert	que	ziemlich	qv
eher	rd	re	wirklich	vernünftig
bezüglich	unabhängig	mit Grüßen	relativ	bzw.
richtig	sagte	gleiches	sah	sagte
sagte	sagt	zweitens	zweitens	sehen
sehen	scheinen	schien	scheint	scheint
gesehen	selbst	selbst	vernünftig	gesendet
ernsthaft	ernsthaft	sieben	mehrere	soll
sie	sollte	sollte nicht	seit	sechs
also	irgendwas	jemand	irgendwie	jemand
etwas	irgendwann	manchmal	etwas	irgendwo
bald	tut mir leid	spezifiziert	spezifizieren	spezifizieren
noch	sub	so	sup	sicher
t's	nehmen	genommen	erzählen	neigen
D	Dann	Danke	Danke	Danke
das	das ist	dass	die	ihre
ihre	sie	sich selbst	dann	danach
dort	es gibt	danach	damit	daher
darin	dort	darauf	diese	Sie
Sie würden	Sie werden	Sie sind	Sie haben	denken
Drittes	dies	gründlich	gründlich	diese
obwohl	drei	durch	durchgehend	bis
so	zu	gemeinsam	auch	nahm
in Richtung	in Richtung	versucht	versucht	wirklich
versucht	versucht	zweimal	zwei	un
unter	leider	es sei denn	unwahrscheinlich	bis
zu	bis	auf	uns	Verwendung
gebraucht	nützlich	verwendet	verwendet	normalerweise
Wert	verschieden	sehr	über	nämlich
vs	wollen	wollen	war	war nicht
so	wir	wir würden	wir Wir sind	wir sind
wir sind	willkommen	gut	sind	waren
waren nicht	was	was ist	was auch immer	wann
woher	wann auch immer	wo	wo ist	wonach
wohingegen	wobei	wobei	worauf	wohin
ob	was	während	wohin	wer
wer ist	wer auch immer	ganz	Wer	Wessen
Warum	wird	willig	wünschen	mit
innerhalb	ohne	wird nicht	wundern	würde
würde	würde nicht	ja	noch	du
du würdest	du wirst	du bist	du hast	dein
dein	sich selbst	sich selbst	Null




4. Volltextqualifizierung

• Die Volltextsuche gilt nur für MyISAM-Tabellen.

• Die Volltextsuche funktioniert mit den meisten Multibyte-Zeichensätzen. Eine Ausnahme bildet Unicode; anstelle des ucs2-Zeichensatzes kann der utf8-Zeichensatz verwendet werden.

• Ideografische Sprachen wie Chinesisch und Japanisch haben keine benutzerdefinierten Trennzeichen. Daher kann der FULLTEXT-Parser nicht bestimmen, wo Wörter in diesen oder anderen Sprachen beginnen und enden.

• Wenn mehrere Zeichensätze in einer einzelnen Tabelle unterstützt werden, müssen alle Spalten im FULLTEXT-Index denselben Zeichensatz und dieselbe Bibliothek verwenden.

• Die Spaltenliste von MATCH() muss genau mit der Spaltenliste in einigen FULLTEXT-Indexdefinitionen in der Tabelle übereinstimmen, es sei denn, MATCH() befindet sich im BOOLEAN-MODUS.

• Das Argument für AGAINST() muss eine konstante Zeichenfolge sein.

5. Feinabstimmung der MySQL-Volltextsuche




Die Volltextsuchkapazität von MySQL weist fast keine vom Benutzer einstellbaren Parameter auf . Wenn Sie über eine MySQL-Quelldistribution verfügen, können Sie die Leistung der Volltextsuche besser steuern, da einige Änderungen Änderungen am Quellcode erfordern.

Beachten Sie, dass die Volltextsuche sorgfältig abgestimmt werden muss, um effektiver zu sein. Tatsächlich führt eine Änderung der Standardleistung in den meisten Fällen nur zu einer Leistungsminderung. Ändern Sie keine MySQL-Quellen, es sei denn, Sie wissen, was Sie tun.

Die meisten der unten beschriebenen Volltextvariablen müssen beim Start des Servers festgelegt werden. Um sie zu ändern, muss der Server neu gestartet werden; sie werden nicht geändert, während der Server läuft.

Bei einigen Variablenänderungen müssen Sie den FULLTEXT-Index in der Tabelle neu erstellen. Die entsprechende Bedienungsanleitung finden Sie am Ende dieses Kapitels.

• Die Systemargumente ft_min_word_len und ft_max_word_len geben die minimale und maximale Länge der indizierten Wörter an. Der standardmäßige Mindestwert beträgt vier Zeichen; der standardmäßige Maximalwert hängt von der verwendeten MySQL-Version ab. Wenn Sie einen Wert ändern, müssen Sie Ihren FULLTEXT-Index neu erstellen. Wenn Sie beispielsweise möchten, dass ein Wort mit drei Zeichen durchsuchbar ist, können Sie die Variable ft_min_word_len festlegen, indem Sie die folgende Zeile in eine Auswahldatei verschieben:

· [mysqld ]

· ft_min_word_len=3

Dann starten Sie den Server neu und erstellen Sie Ihren VOLLTEXT-Index neu. Achten Sie auch besonders auf die Kommentare zu myisamchk in der Beschreibung hinter der Tabelle.

• Um das Standardstoppwort zu überschreiben, können Sie die Systemvariable ft_stopword_file festlegen. Der Variablenwert sollte ein Dateipfadname sein, der Stoppwörter enthält, oder eine leere Zeichenfolge, die zum Stoppen der Stoppwortfilterung verwendet wird. Erstellen Sie Ihren FULLTEXT-Index neu, nachdem Sie den Wert dieser Variablen oder den Inhalt der Stoppwortdatei geändert haben.

Stoppwörter haben eine freie Form, d. h. Sie können jedes nicht alphanumerische Zeichen wie Zeilenumbruch, Leerzeichen oder Komma verwenden, um Stoppwörter zu trennen. Ausnahmen sind der Unterstrich (_) und das einfache Anführungszeichen ('), die als Teil eines Wortes betrachtet werden. Der Stoppwort-Zeichensatz ist der Standardzeichensatz des Servers.

• Der Schwellenwert von 50 % für Abfragen in natürlicher Sprache wird durch den jeweils gewählten Kompromiss bestimmt. Um dies zu verhindern, suchen Sie in myisam/ftdefs.h nach der folgenden Zeile:

· #define GWS_IN_USE GWS_PROB

Ändern Sie die Zeile in:

#define GWS_IN_USE GWS_FREQ

und dann MySQL neu kompilieren. Zu diesem Zeitpunkt besteht keine Notwendigkeit, den Index neu zu erstellen. Hinweis: Dadurch verringern Sie erheblich die Fähigkeit von MySQL, geeignete Korrelationswerte für die MATCH()-Funktion bereitzustellen. Wenn Sie nach solchen gebräuchlichen Wörtern suchen müssen, ist es besser, stattdessen den IN BOOLEAN MODE zu verwenden, da dieser den Schwellenwert von 50 % nicht einhält.

• Um den für die boolesche Volltextsuche verwendeten Operator zu ändern, legen Sie die Systemvariable ft_boolean_syntax fest. Diese Variable kann auch bei laufendem Server geändert werden, allerdings müssen Sie dazu über SUPER-Berechtigungen verfügen. In diesem Fall ist es nicht erforderlich, den Index neu zu erstellen.

Wenn Sie die Volltextvariablen ändern, die sich auf die Indizierung auswirken (ft_min_word_len, ft_max_word_len oder ft_stopword_file), oder wenn Sie die Stoppwortdatei selbst ändern, müssen Sie nach der Änderung und dem Neustart des Servers Ihre Datei neu erstellen VOLLTEXT-Index. Um den Index zu diesem Zeitpunkt neu zu erstellen, führen Sie einfach einen SCHNELLEN Reparaturvorgang durch:

mysql> REPAIR TABLE tbl_name QUICK;

Beachten Sie, dass if Sie verwenden myisamchk, um eine Operation auszuführen, die einen Tabellenindex ändert (z. B. Reparatur oder Analyse), und erstellt den FULLTEXT-Index unter Verwendung der Standard-Volltextparameterwerte für minimale und maximale Wortlänge und Stoppwörter neu. sofern Sie nichts anderes angeben. Dies führt dazu, dass die Abfrage fehlschlägt.

发生这个问题的原因是只有服务器认识这些参数。它们的存储位置不在 MyISAM 索引文件中。若你已经修改了最小单词长度或最大单词长度或服务器中的停止字，为避免这个问题，为你对mysqld所使用的myisamchk 指定同样的ft_min_word_len、 ft_max_word_len和ft_stopword_file值。例如，假如你已经将最小单词长度设置为 3, 则你可以这样修改一个带有myisamchk的表：

shell> myisamchk --recover --ft_min_word_len=3 tbl_name.MYI

为保证 myisamchk 及服务器对全文参数使用相同的值， 可将每一项都放在供选文件中的 [mysqld]和 [myisamchk] 部分：

[mysqld]
ft_min_word_len=3
[myisamchk]
ft_min_word_len=3

Nach dem Login kopieren

使用 REPAIR TABLE、 ANALYZE TABLE、OPTIMIZE TABLE或ALTER TABLE来代替使用 myisamchk 。这些语句通过服务器来执行，服务器知道使用哪个全文参数值更加合适。

 以上就是MySQL基础教程10 —— 函数之全文搜索功能的内容，更多相关内容请关注PHP中文网（m.sbmmt.com）！