[关闭]
@lxjwlt 2015-08-01T08:53:00.000000Z 字数 16615 阅读 4057

[译]《Sphinx权威指南》 - Sphinx入门

sphinx


最近社区搜索功能要进行优化,由于需求点比较多,功能要求比较“夸张”,我们弃用了Discuz本身那套搜索逻辑代码,自行引入Sphinx搜索引擎进行重新开发(Discuz本身带有Sphinx,但只提供基本选项,可定制度低)。Sphinx搜索引擎提供全文搜索,且性能比MySQL查询好,加之国人在Sphinx之上开发的CoreSeek,使得Sphinx支持中文搜索,所以引入Sphinx是必要的。大半个月的开发渐进尾声,我原先打算将开发过程中的要点记录下来,但没用过Sphinx的同学看到这种文章无疑云里雾里,我转而想总结一篇详尽的入门使用指南,于是google各种资料,构思目录框架,可是细想下来,才疏学浅,成文不过是Sphinx官方文档的另一个版本。一次我查如何合并数据源的时候,无意间找到了这本书《Introduction to Search with Sphinx》,书中不仅详细的介绍了sphinx的基本使用,而且也提及到Sphinx背后的搜索机制,很有参考意义。以下选取其中入门篇以便大家了解Sphinx。

本章中,我们会讨论到Sphinx基础的安装、配置和维护。不要被“基础”这形容词糊弄而跳过这个章节。对于“基础”,我不是指简单到显而易见的东西,而是指所有人都会用到的功能。

一般来说,Sphinx会使用MySQL作为它的数据源,同时,Sphinx假定你已经安装好了MySQL和MySQL开发库文件。当然你可以把Sphinx运行在其他相关的数据库或数据源上,但MySQL非常流行,所以方便起见本章内容都基于MySQL。

工作流简略

总的来说,我们要讨论的内容有安装、配置和使用。一个完整的搜索是由四个关键部分组成的:

所以,数据或多或少的从存储空间(数据源)传送到indexer程序,indexer程序生成索引并将索引传递给searchd程序,然后再传递到你的程序。每次你运行indexer程序都会触发第一部分的传递。当索引构建完毕并且indexer程序通知searchd程序索引构建完毕,这时触发第二部分的传递,而你的每次查询都会触发最后一部分的传递(即传递给客户端程序)。请看图-1。

Data flow with Sphinx

图-1. Sphinx的数据流

现在,我们不从数据出发而是从服务功能出发构建一张流程图。在图-2中,searchd程序是一个提供你对话的持续运行的服务进程,它实时地对搜索查询进行应答,就像一个相关的数据库对数据查询进行应答。indexer是一个分离的工具,它提取数据,生成索引并将索引传递给searchd。

Database, Sphinx, and application interactions

图-2 数据库、Sphinx和应用之间的交互流程

实际上,这是一个“提取”模型:indexer程序去数据库那里提取数据,生成单个或多个索引,并将它们传递给searchd程序。这其中一个重要的结论就是,Sphinx是无关存储引擎、数据库和数据源的东西。你可以使用任意内置的或外部的MySQL存储引擎(MyISAM, InnoDB, ARCHIVE, PBXT, 等等)或PostgreSQL, Oracle, MS SQL, Firebird等等引擎,或甚至不使用数据库。只要indexer程序可以直接查询你的数据库或可以从代理程序中接受到XML内容并获取到数据,那么indexer程序就可以生成索引。

图-1和图-2只是从后台的角度涵盖了基于磁盘的索引构建。对于实时索引来说,工作流程实际上是不一样的 -- indexer程序不会被用到,应用或数据库需要把用于生成索引的数据直接传递给searchd程序。

准备工作 ... 只需一分钟

Sphinx最简单的搭建方法就是安装二进制安装包。你几乎只需要一次点击,就能够搭建起一个工作环境。为了更好的使用,安装成功后,Sphinx会提供如何使用的简略说明。

  1. [root@localhost ~]# rpm -i sphinx-1.10-1.el5.i386.rpm

Sphinx 安装成功!

现在我们创建一个全文索引,并启动一个search后台进程,你已经准备好了。

编写索引规则:

  1. editor /etc/sphinx/sphinx.conf

重新生成全部索引:

  1. sudo -u sphinx indexer --all --rotate

启动/关闭searchd进程:

  1. service searchd start/stop

使用MySQL客户端对searchd进程进行查询:

  1. mysql -h 0 -P 9306
  2. mysql> SELECT * FROM test1 WHERE MATCH('test');

查阅/usr/share/doc/sphinx-1.10 手册,了解更多细节。

上述rpm命令的安装成功后,会提供/etc/sphinx/sphinx.conf配置文件和一个示例文件,并预加载了两个测试用的全文索引:基于硬盘的索引test1,和一个实时索引testrt。

Windows系统下,你可以通过拷贝示例文件模版(都以.conf为后缀名)来创建一个sphinx.conf配置文件,只需进行小部分的修改,下面的测试例子就可以正常运行:

  1. sql_host = localhost
  2. sql_user = root
  3. sql_pass =
  4. sql_db = test

test1索引是从示例MySQL数据表(test.documents)中获取数据,所以为了使用这个索引,你需要事先进入对应的数据表中,然后运行indexer程序生成索引数据。根据你MySQL的版本,你可能需要手动创建test数据库。你也可以使用不同的数据库名,将其代替test数据库完成以下的示例。你可以注入/usr/share/doc/下的example.sql文件,通过里面的SQL示例语句来创建数据表。

  1. [root@localhost ~]# mysql -u root test < /usr/share/doc/sphinx-1.10/example.sql
  2. [root@localhost ~]# indexer test1
  3. Sphinx 1.10-id64-beta (r2420)
  4. Copyright (c) 2001-2010, Andrew Aksyonoff
  5. Copyright (c) 2008-2010, Sphinx Technologies Inc (http://sphinxsearch.com)
  6. using config file '/etc/sphinx/sphinx.conf'...
  7. indexing index 'test1'...
  8. collected 4 docs, 0.0 MB
  9. sorted 0.0 Mhits, 100.0% done
  10. total 4 docs, 193 bytes
  11. total 0.007 sec, 24683 bytes/sec, 511.57 docs/sec
  12. total 3 reads, 0.000 sec, 0.1 kb/call avg, 0.0 msec/call avg
  13. total 9 writes, 0.000 sec, 0.1 kb/call avg, 0.0 msec/call avg

然后,你可以启动searchd程序,并使用示例PHP test程序或MySQL客户端来查询索引:

  1. [root@localhost ~]# service searchd start
  2. Starting searchd: Sphinx 1.10-id64-beta (r2420)
  3. Copyright (c) 2001-2010, Andrew Aksyonoff
  4. Copyright (c) 2008-2010, Sphinx Technologies Inc (http://sphinxsearch.com)
  5. using config file '/etc/sphinx/sphinx.conf'...
  6. listening on all interfaces, port=9312
  7. listening on all interfaces, port=9306
  8. precaching index 'test1'
  9. [root@localhost ~]# mysql -u root test < /usr/share/doc/sphinx-1.10/example.sql
  10. precached 2 indexes in 0.005 sec
  11. [ OK ]
  12. [root@localhost ~]# mysql -h0 -P9306
  13. Welcome to the MySQL monitor. Commands end with ; or \g.
  14. Your MySQL connection id is 1
  15. Server version: 1.10-id64-beta (r2420)
  16. Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
  17. mysql> select * from test1 where match('test');
  18. +------+--------+----------+------------+
  19. | id | weight | group_id | date_added |
  20. +------+--------+----------+------------+
  21. | 1 | 2421 | 1 | 1283729225 |
  22. | 2 | 2421 | 1 | 1283729225 |
  23. | 4 | 1442 | 2 | 1283729225 |
  24. +------+--------+----------+------------+
  25. 3 rows in set (0.00 sec)
  26. mysql> exit
  27. Bye
  28. [root@localhost ~]# php /usr/share/sphinx/api/test.php test
  29. Query 'test ' retrieved 3 of 3 matches in 0.000 sec.
  30. Query stats:
  31. 'test' found 5 times in 3 documents
  32. Matches:
  33. 1. doc_id=1, weight=101, group_id=1, date_added=2010-09-06 03:27:05
  34. 2. doc_id=2, weight=101, group_id=1, date_added=2010-09-06 03:27:05
  35. 3. doc_id=4, weight=1, group_id=2, date_added=2010-09-06 03:27:05
  36. [root@localhost ~]#

实时索引更加简单。它们在运行时被生成,所以你不需要具备数据库或者运行indexer程序。只需要启动searchd程序就可以开始工作:

  1. [root@localhost ~]# mysql -h0 -P9306
  2. Welcome to the MySQL monitor. Commands end with ; or \g.
  3. Your MySQL connection id is 1
  4. Server version: 1.10-id64-beta (r2420)
  5. Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
  6. mysql> select * from testrt;
  7. Empty set (0.00 sec)

让我们在这里暂停一下,然后把你的注意力集中在一些容易忽略但非常重要的东西上。

这不是MySQL语句!

这仅仅是MySQL客户端和我们的Sphinx服务器进行的对话。注意看Server的版本字段的版本号:注意,这是Sphinx的版本标签(和修订版本ID)。而且我们选取数据的testrt也不是一个MySQL数据表。它是一个Sphinx的实时索引名叫作testrt,定义在默认的配置文件中。

现在我们已经可以筛选出结果,下面让我们更进一步,给我们的索引注入一些数据:

  1. mysql> insert into testrt (id, title, content, gid)
  2. -> values (1, 'hello', 'world', 123);
  3. Query OK, 1 row affected (0.01 sec)
  4. mysql> insert into testrt (id, title, content, gid)
  5. -> values (2, 'hello', 'another hello', 234);
  6. Query OK, 1 row affected (0.00 sec)
  7. mysql> select * from testrt;
  8. +------+--------+------+
  9. | id | weight | gid |
  10. +------+--------+------+
  11. | 1 | 1 | 123 |
  12. | 2 | 1 | 234 |
  13. +------+--------+------+
  14. 2 rows in set (0.00 sec)
  15. mysql> select * from testrt where match('world');
  16. +------+--------+------+
  17. | id | weight | gid |
  18. +------+--------+------+
  19. | 1 | 1643 | 123 |
  20. +------+--------+------+
  21. 1 row in set (0.00 sec)

实时索引的数据注入方式和一般的索引是不同的。为了让test1索引起作用,我们向MySQL注入了示例文件example.sql,然后告诉indexer去获取这部分的数据并生成索引。而对于实时索引testrt,我们只需要连接searchd并直接向testrt索引导入数据,略过了MySQL和indexer程序。我们使用INSERT语句,就像我们插入数据到MySQL一样。此外,我们使用MySQL客户端发送这些语句到Sphinx,因为Sphinx作为MySQL的网络协议能够识别同样的语言。只是Sphinx不像MySQL,Sphinx的SELECT语句不会返回数据本身;Sphinx只会返回文档的ID集合和经过计算得到的权值。这是因为title和content字段被识别为全文搜索字段,而Sphinx只会存储全文索引(就像第一章的描述)而不是原始文本。

非常简单,不是么?当然,在实际开发中,你需要一个配置文件和你的数据相绑定。让我们看看示例配置文件的内容,然后创建自己的配置文件。

基本配置

sphinx.conf配置文件包含的部分有三种主要类型:

下面一小节会覆盖配置文件中每个部分的命令,这对于你开始使用Sphinx来说是非常重要的。

定义数据源

就像我在第一章所说的,那些事先存在并要批量转换成索引的数据通常存在你的SQL数据库或XML文件中,但Sphinx允许其他方式的引入。sphinx.conf中的数据源定义告诉indexer程序数据存储位置和如何获取这些数据。典型的数据源定义看起来就像:

  1. source src1
  2. {
  3. type = mysql
  4. sql_host = localhost
  5. sql_user = test
  6. sql_pass =
  7. sql_db = test
  8. sql_port = 9306 # optional, default is 9306
  9. sql_query = \
  10. SELECT id, group_id, UNIX_TIMESTAMP(date_added) date_added, \
  11. title, content \
  12. FROM documents
  13. sql_attr_uint = group_id
  14. sql_attr_timestamp = date_added
  15. }

这里做了什么?首先,我们定义了一个数据源的名字(src1)还有数据源的类型(mysql)。其次,我们为indexer程序提供了MySQL访问的认证信息,当获取数据时要用到。再者,通过使用sql_query命令,我们定义了查询(也叫作主查询),事实上indexer会用这个查询去获取数据。我们还定义了用于索引属性而不用于全文搜索的列字段还有它们各自的类型。那么接下来,我们要将group_id(正整数)和date_added(时间戳)设为属性:

  1. sql_attr_uint = group_id
  2. sql_attr_timestamp = date_added

以上为Sphinx提供了足够的信息去获取数据并生成索引。

另外,数据源的类型也是可选的。大部分类型都类似于MySQL,但你也可以实用其他SQL数据库,比如PostgreSQL, MS SQL, Oracle等等。虽然有一种类型不是SQL数据库。这个类型叫做xmlpipe,你可以将特殊格式的XML文档提供给indexer程序,而不需要进入数据库中获取数据。

为了了解属性的使用,让我们回到第一章使用书籍摘要的例子。书籍的标题和摘要用作全文搜索,而价格和出版年份作为属性。Sphinx要求SELECT语句中的第一个字段必须是独一无二的ID。为了满足以上要求,配置选项可以这么写:

  1. sql_query = SELECT id, title, abstract, price, year FROM books
  2. sql_attr_float = price
  3. sql_attr_uint = year

我们显式地定义了两个属性,而其余的都会自动被当作是全文字段。细心的读者可能会问,为什么我们不把ID标记为属性。答案是,indexer把第一个字段返回的值当做ID,在内部会对它进行特殊处理。

基于磁盘的索引

当你定义好你的数据源,是时候告诉Sphinx该如何对这些数据生成索引了。下面介绍全文索引配置,以下给出简单的示例:

  1. index test1
  2. {
  3. source = src1
  4. charset_type = sbcs
  5. path = /usr/local/sphinx/data/test1
  6. }

这配置会创建一个叫test1的索引,它会从数据源src1中获取数据,期望文本数据是single-byte编码格式,而且使用/usr/local/sphinx/data/test1.*作为索引文件的基本名。

你可以定义多个数据源并将他们的数据合并到单独一个全文索引中。当数据库是分布式(亦称共享式),这会非常有用,但这既不要求全文索引是分布式的,也不要求全文索引转换成分布式的。所有的数据源结构,也就是说,字段和属性的集合,都必须相同,这样才能进行合并;否则,indexer程序会执行失败并抛出错误。为了定义多个数据源,我们只需要枚举它们:

  1. index test2
  2. {
  3. source = src1
  4. source = src2
  5. source = src3
  6. charset_type = sbcs
  7. path = /usr/local/sphinx/data/test2
  8. }

当生成索引test2时,所有来自上述例子中三个数据源的数据都会合并到一个单独的索引中。只要这些数据源结构相同,那么它们可以来自不同的位置和不同的存储方式。举个例子,你可以从机器A中MySQL服务器中获取一半的数据,而另一半的数据则从机器B的PostgreSQL服务器中得到。

字符编码设置支持sbcs(指Single Byte Character Set)和utf-8。然而,通过使用charset_table指令,任何单字节字符编码都可以被支持。这提供了大量的选项去操作字符集:你可以选取字符集用于生成索引,选择用于替换空白字符的字符,控制如何将一种字符集映射另一种字符集。在第三章会详细介绍。

path指令设置存储文件的路径为/usr/local/sphinx/data/test1,而indexer程序会将这个路径作为前缀生成出索引文件名。例如,属性集会存在/usr/local/sphinx/data/test1.spa中,等等。

上述例子非常简单,但事实上,索引定义比我们预期更强大,它允许其余许多选项不进行设置,保留默认值。大部分这些选项都控制索引生成期间和搜索期间的文本处理,你可以:

这些选项中一部分会在后面详细介绍,而另一部分在对应的文档中能找到详细解释。

实时索引

实时索引不使用数据源,但Sphinx依然需要知道你在索引中要用到哪个字段和哪个属性,所以你需要在配置文件中将这些都指定处理。以下是例子:

  1. index rt
  2. {
  3. type = rt
  4. path = /usr/local/sphinx/data/rt
  5. rt_field = title
  6. rt_field = content
  7. rt_attr_uint = group_id
  8. rt_attr_timestamp = published
  9. rt_mem_limit = 256M
  10. }

这个例子创建了一个实时索引叫作rt,这个索引有两个全文字段,一个整数属性和一个时间戳属性。这里有几点是和常规索引不一样的,也就是在实时索引中:

配置文件中最后一个命令rt_mem_limit非常重要。这个命令控制实时的内存中的索引块(内存块)的最大尺寸,Sphinx会为该索引使用该内存块。你每次对实时索引作的改变都会造成部分内存的使用,而当searchd程序使用的内存达到了上限,它就必须将数据存储在硬盘上,并重新申请一块内存空间。

因此,这个命令能够高效的控制实时索引每一块的大小。rt_mem_limit默认为32MB,所以默认值适用于更小的存储。但如果你计划要向你的实时索引中导入G字节的数据,你肯定不希望它会划分为上百个32MB的小块。因此,你需要根据你心中期望的数据大小,小心调整rt_mem_limit选项。

Sphinx不会占用超出实际使用的内存,所以如果实时索引只使用了1MB,即使limit设置到2GB,Sphinx无论如何也只会占用1MB的内存。另一方面,处理太多小的磁盘块会带来很大的影响。所以合理的超出这个限制不会带来太多的不利影响,当你为设置多大的值犹豫不决的时候,指定更大的空间比更小的空间要更好。

分布式索引

最后注意,Sphinx支持所谓的分布式索引。有时候,你会想要搜索的其他任意的索引 -- 任意指的是任意一种 -- 它可以是普通索引或者实时索引,不论是在本地机器上还是在远程机器上,或者甚至是指向其他分布式索引或远程机器的指针。下面给出例子:

  1. index dist1
  2. {
  3. type = distributed
  4. local = archive
  5. local = rtdelta
  6. agent = server2.vpn.mycompany.net:9312:archive2
  7. agent = server3.vpn.mycompany.net:9312:archive3
  8. }

每一次我们使用dist1索引进行搜索,searchd程序都会向两个本地索引archive和rtdelta进行搜索,并连接网络到远程服务器,对archive2索引和archive3索引进行查询,最后将结果合并到一起,发送给应用。所有远程服务端(代理)都会被并行的查询,所以如果每个服务器都花费了一秒,那么整个查询过程也仅仅只花费了一秒的时间。在dist_thread指令的帮助下,本地索引查询也是可以并行处理的,这条指令我们晚点会讨论到。

为SQL数据定义字段和属性

我们要进行索引的SQL列都是不一样的。部分列会作为生成索引和搜索的字段;部分列作为属性,存储在索引中以备后用,而部分列可能甚至不是真正的列,而是可计算的表达式。

Sphinx支持大量的常用属性类型和多个实用的功能,以便更好的将存储在数据库上的各类型文本字段进行索引。

大部分情况下,所有sql_query生成的列都是常规的文本字段。主要的例外是第一列,第一列作为文档的ID,而其余的列都可以显式定义为其他类型。这种规范能让Sphinx识别出:引入的列是文本字段,还是给定类型的属性,或者是一类除了进行全文索引还需要额外处理的特殊字段。

受制于技术限制,Sphinx只允许限定数量的字段。当前的索引格式可接受高达255个字段,但匹配引擎的技术限制限定了字段数量只能有32个。

下面是支持的属性类型:

SQL数据源也支持特殊的字段类型:

Sphinx配置

配置文件中indexer和searchd的配置填充了大量的指令用于程序的维护和性能调试。这些指令通常包括一列接口,用来设置绑定、日志打印和查询日志文件的位置、多个完整性检查限制、缓存大小等等。只有一个配置是必要的:你需要使用pid_file指令定义searchd程序的PID文件的存储位置。为了生成索引达到更好性能,大部分的安装过程会用到mem_limit指令来减少indexer程序占用的内存。

通过继承管理配置

配置文件可能会变得非常大。幸运的是,两个实用的工具可以帮助你将它们保持简洁明了。首先,数据源和索引配置可以被继承,通过拷贝父级的所有配置,你可以对不一样的选项进行重写。例如,把SQL访问权限信息写在一个独立的数据源配置中,其余配置继承于它,这是非常好的实践:

  1. source base
  2. {
  3. sql_host = localhost
  4. sql_user = root
  5. sql_pass = supersecret
  6. sql_db = myprojectdatabase
  7. }

为了继承前面的配置,像下面那样,在每一个数据源中引入它:

  1. source books : base
  2. {
  3. sql_query = SELECT * FROM books
  4. }
  5. source freshbooks : books
  6. {
  7. sql_query = SELECT * FROM books WHERE DATE_ADD(added,INTERVAL 1 DAY)<NOW()
  8. }
  9. source authors : base
  10. {
  11. sql_query = SELECT * FROM authors
  12. }

如果新的配置项有了新的值,那么该选项的继承值都会被废弃。即使这个指令是多值指令 -- 意思是该指令可以在同一配置块中定义多次。(比如,数据源配置中的sql_attr_uint) -- 如果你定义了新的值,那么整列数值都会被废弃。例如,下面例子中的test2数据源只具有其中定义的新的sql_attr_uint属性(books_written),而没有上一级test1数据源中的三个数值:

  1. source test1
  2. {
  3. sql_query = SELECT * FROM books
  4. sql_attr_uint = year_published
  5. sql_attr_uint = num_pages
  6. sql_attr_uint = isbn
  7. }
  8. source test2 : test1
  9. {
  10. sql_query = SELECT * FROM authors
  11. sql_attr_uint = books_written
  12. }

其次,你可以编译配置文件。也就是说,如果配置文件以 #!/usr/bin/program 开头,那么Sphinx程序不会直接读取它,而是通过那指定的程序运行配置文件,并将其返回结果用作配置文件。

当配置文件准备就绪,便执行初始indexer程序,生成索引数据,然后启动search进程,之后你便可以开始搜索了:

  1. $ indexer --all
  2. $ searchd

search进程可以使用多种不同的API来访问(虽然都提供相同功能的访问权限),下面逐一介绍。

访问searchd程序

配置端口

首先,让我们先回到配置文件,看看选择使用哪个API。一个叫作listen的指令可以让你将searchd程序绑定和指定的TCP端口或Unix 套接字相绑定,你可以选择一个用于通信通道的网络协议。下面的配置,设置了让searchd与原生Sphinx API协议在9312端口进行通信,并与MySQL网络协议在9306端口进行通信:

  1. searchd
  2. {
  3. listen = localhost:9312 # protocol defaults to "sphinx"
  4. listen = localhost:9306:mysql41 # but we can override it
  5. }

默认情况下,searchd监听所有的接口,使用TCP 9312端口对SphinxAPI进行监听,并使用9360端口连接MySQL。上述的配置和默认情况是几乎一样的,但它只监听localhost接口,而不是所有的接口(万一你只需要在Sphinx所在的同一个服务器上接收Sphinx的数据,这样的配置对于提高安全性来说是很有用的)。

使用Sphinx API

从调用程序的角度看,原生的API只提供了SphinxClient类,这个类提供了大量的实用方法。当然,重要的是,Query()方法承担了所有搜索的工作:

  1. $cl = new SphinxClient();
  2. $result = $cl->Query("this is my query", "myindex");
  3. var_dump($result);

非常简单。第一个参数是要搜索的字符串,而第二个参数则是指定配置文件中的一个Sphinx索引。然而,就如同配置文件中有多个index配置选项,在查询进行时也有多种配置选项。你可以在客户端对象(上述例子中的$cl)上调用方法来控制这些配置选项。客户端对象可以分为这些主要的功能组块:

通用的客户端方法是任何你能想到的关于网络客户端API:你可以指定进行对话的searchd实例、指定超时时间、对错误和警告信息的检测等等。

查询配置和全文匹配配置会影响searchd进程处理的查询过程。它们提供方法去控制查询过程中有多少匹配结果缓存在RAM内存中和多少匹配结果会返回到你的程序中;如果达到了查询匹配或查询时间的上限,那么searchd会强制中止查询(并返回已经查询到的结果);控制如何对匹配结果进行权值计算和控制每个字段的权值;指定结果集合中应当返回的属性和表达式。而且没错,Sphinx支持算术表达式的计算。

查询设置是独立的一组配置,因为Sphinx可以处理的查询条件对全文搜索来说并不是必须的。如果你传入一个空字符串作为你的查询文本,Sphinx默认情况下会匹配所有的已生成索引的文档,计算你写的表达式,并进行属性、排序和分组。这种查询通常被称作全扫描,因为在内部它们的确是通过对属性数据进行全扫描来实现的。因为普遍需求,全扫描功能得到支持:在一些情况下,Sphinx查询比相同的SQL查询要更快,尽管全扫描也是如此的。

原生API提供的匹配筛选、排序和分组配置和SQL语法提供的WHERE、ORDER BY和GROUP BY语句的效果是一样的,你可以对匹配结果进行你需要的筛选、排序和分组匹配。例如,如果你要搜索MySQL中1990年代的书籍,并按照价格排序,可以这么写:

  1. $cl = new SphinxClient();
  2. $cl->SetFilterRange("year_published", 1990, 1999);
  3. $cl->SetSortMode(SPH_SORT_EXTENDED, "price DESC");
  4. $result = $cl->Query("mysql", "booksindex");

上述代码不仅一目了然而且也展示了通用API的使用模式:首先创建一个客户端对象,配置所有查询设置,然后启动搜索并获取结果。当然,产品级的代码应当添加错误处理:

  1. $cl = new SphinxClient();
  2. $cl->SetFilterRange("year_published", 1990, 1999);
  3. $cl->SetSortMode(SPH_SORT_EXTENDED, "price DESC");
  4. $result = $cl->Query("mysql", "booksindex");
  5. if (!$result)
  6. {
  7. // oops, there was an error
  8. DisplayErrorPage($cl->GetLastError());
  9. } else
  10. {
  11. // everything was good
  12. DisplaySearchResult($result);
  13. }

为了进一步完善,让我们也看看如何使用原生API来对年份来分组和计算数据:

  1. $cl = new SphinxClient();
  2. $cl->SetFilterRange("year_published", 1990, 1999);
  3. $cl->SetSortMode(SPH_SORT_EXTENDED, "price DESC");
  4. $cl->SetGroupBy("year_published", SPH_GROUPBY_ATTR);
  5. $cl->SetSelect("*, MIN(price) AS minprice,
  6. MAX(price) AS maxprice, AVG(price) AS avgprice");
  7. $result = $cl->Query("mysql", "booksindex");

你会发现,当我们进一步地为查询添加更多的处理时,代码也开始越来越像SQL了。但我们用的是零散的接口而不是单一的表达式来构建查询的。

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注