MySQL sporadic MATCH AGAINST具有唯一索引的行为

Question

向多表全文布尔搜索添加唯一键时，结果循环遍历3个任意状态中的1个，只有1个状态正确。

当检查下面的sqlfiddle时，请牢记这一点，因为查询可能最初正常工作 - 在这种情况下，将空白添加到左侧面板然后重新生成并重新运行 - 然后它应该被打破（但它非常灵活 - 小姐）。

http://sqlfiddle.com/#!9/8d95ba/18

这里是有问题的查询：

SELECT `i`.`item_id`, `g_a`.`alias` AS `group`, `i`.`name` AS `name` 
    FROM `item` `i` 
    JOIN `group_alias` `g_a` USING (group_id) 
    WHERE 
     MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE) 
    OR 
     MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE); 

够简单。但有以下唯一索引另外：

ALTER TABLE `item_with_unique` ADD UNIQUE INDEX `unique_item_group` (`group_id`, `name`) 

结果周期任意这三种状态之间：

1. 因为如果没有WHERE子句
2. 别名匹配的回报，因为所有行返回如果WHERE子句中没有OR部分
3. 返回正确的结果（从我的经验来看，这已经非常罕见）

行为似乎与它所处的3个状态中的任何一个一致，直到查询以某种小的方式改变（例如添加方括号）或者模式被重建 - 在这一点上它有可能改变。

在描述这种行为的MySQL文档中，我错过了这些限制吗？这是一个错误吗？或者我刚刚做了一件明显错误的事情？

Mysql版本5.6.35（撰写本文时，请参阅sqlfiddle）。

Sqlfiddle留给后人的情况下，链接死：

CREATE TABLE `group` (
    `group_id` INT UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
    `name` VARCHAR(256), 
    FULLTEXT INDEX `search` (`name`) 
) ENGINE = InnoDB; 

CREATE TABLE `group_alias` (
    `group_id` INT UNSIGNED NOT NULL, 
    `alias` VARCHAR(256), 
    CONSTRAINT `alias_group_id` 
    FOREIGN KEY (`group_id`) 
    REFERENCES `group` (`group_id`), 
    FULLTEXT INDEX `search` (`alias`) 
) ENGINE = InnoDB; 

CREATE TABLE `item` (
    `item_id` INT UNSIGNED AUTO_INCREMENT PRIMARY KEY, 
    `group_id` INT UNSIGNED, 
    `name` VARCHAR(255) NOT NULL, 
    CONSTRAINT `item_group_id` 
    FOREIGN KEY (`group_id`) 
    REFERENCES `group` (`group_id`), 
    FULLTEXT INDEX `search` (`name`) 
) ENGINE = InnoDB; 

CREATE TABLE `item_with_unique` LIKE `item`; 
ALTER TABLE `item_with_unique` ADD UNIQUE INDEX `unique_item_group` (`group_id`, `name`); 

INSERT INTO `group` (`group_id`, `name`) VALUES (1, 'Thompson'); 
INSERT INTO `group` (`group_id`, `name`) VALUES (2, 'MacDonald'); 
INSERT INTO `group` (`group_id`, `name`) VALUES (3, 'Stewart'); 

INSERT INTO `group_alias` (`group_id`, `alias`) VALUES (1, 'Tomson'); 
INSERT INTO `group_alias` (`group_id`, `alias`) VALUES (2, 'Something'); 
INSERT INTO `group_alias` (`group_id`, `alias`) VALUES (3, 'MacStewart'); 

INSERT INTO `item` (`item_id`, `group_id`, `name`) VALUES (1, 1, 'MacTavish'); 
INSERT INTO `item` (`item_id`, `group_id`, `name`) VALUES (2, 1, 'MacTavish; Red'); 
INSERT INTO `item` (`item_id`, `group_id`, `name`) VALUES (3, 2, 'MacAgnew'); 
INSERT INTO `item` (`item_id`, `group_id`, `name`) VALUES (4, 3, 'Spider'); 
INSERT INTO `item` (`item_id`, `group_id`, `name`) VALUES (5, 2, 'blahblah'); 

INSERT INTO `item_with_unique` SELECT * FROM `item`; 


SELECT `i`.`item_id`, `g_a`.`alias` AS `group`, `i`.`name` AS `name`, 
IF(MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `group_match`, 
IF(MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `item_match` 
    FROM `item` `i` 
    JOIN `group_alias` `g_a` USING (group_id) 
    WHERE 
     MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE) 
    OR 
     MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE); 

SELECT "Same query, using table with unique index (NOTE: sporadically this is actually correct, in such case, skip to bottom notes)"; 
SELECT `i`.`item_id`, `g_a`.`alias` AS `group`, `i`.`name` AS `name`, 
IF(MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `group_match`, 
IF(MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `item_match` 
    FROM `item_with_unique` `i` 
    JOIN `group_alias` `g_a` USING (group_id) 
    WHERE 
     MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE) 
    OR 
     MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE); 

SELECT "Union of the two OR match conditions seperately (expected result from second query)"; 
SELECT `i`.`item_id`, `g_a`.`alias` AS `group`, `i`.`name` AS `name`, 
IF(MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `group_match`, 
IF(MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `item_match` 
    FROM `item_with_unique` `i` 
    JOIN `group_alias` `g_a` USING (group_id) 
    WHERE 
     MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE) 
UNION 
SELECT `i`.`item_id`, `g_a`.`alias` AS `group`, `i`.`name` AS `name`, 
IF(MATCH (`g_a`.`alias`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `group_match`, 
IF(MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE), 1, 0) AS `item_match` 
    FROM `item_with_unique` `i` 
    JOIN `group_alias` `g_a` USING (group_id) 
    WHERE 
     MATCH (`i`.`name`) AGAINST ('Mac*' IN BOOLEAN MODE); 

SELECT "Now rebuild the schema (add a newline somewhere so sqlfiddle thinks it has changed) and observe that the results of the second query. It may take multiple attempts but it usually cycles between 3 states:"; 
SELECT "1: Returns ALL results as if there were no conditions (5 rows)"; 
SELECT "2: Returns results as if there were no second part to the OR condition (1 row)"; 
SELECT "3: Returns the correct results (rarely)"; 

Answer 1

如果你有一个字的名称和别名。你正在检查整个值或主要值。那么FULLTEXT并不是你需要的索引类型。

一个简单的INDEX(name)，连同name LIKE 'Mac%'将是非常有效的。

如果你有很长的词组有很多的话，和“麦当劳”可能是在它的中间，然后FULLTEXT和MATCH ... AGAINST是正确的道路要走。

无论使用哪种类型的索引，

WHERE table1 ... 
    OR table2 ... 

将是低效的。粗略地说，优化器将不得不做一个“交叉连接”来获得两个表之间的所有行组合，然后然后查看哪些匹配一个或其他匹配/类似。

也许你有“过度标准化”的数据？ name和alias不能同时在同一个表中吗？该查询将更快，和将有优化技术，使其更快。只有1K行，你拥有的速度会明显变慢;我所建议的可以优化超过数百万甚至数十亿行。