Manticore Search Manual

Manticore 的数据类型可以分为两类：全文字段和属性。

表名、字段名和属性名可以包含 ASCII 字母（a-z、A-Z）、数字（0-9）、下划线（_）以及安全的非 ASCII UTF-8 字符。未加引号的 SQL 名称必须以 ASCII 字母、下划线或非 ASCII UTF-8 字符开头。首字符之后可以使用数字。

相同的基础语法适用于各模式下支持该类型的所有表类型：RT mode 中的实时表、percolate 表和分布式表，以及 Plain mode 中的实时表、percolate 表、普通表、分布式表和模板表。它也适用于定义字段或属性的所有 schema，包括 percolate 表预期的文档 schema，以及从 SQL、CSV/TSV 或 XML 源推断出的 schema。

其他用户定义的 SQL 对象名，包括函数名、插件名和复制集群名，也遵循相同的安全 UTF-8 规则。

对于以数字开头且至少包含一个字母、下划线或非 ASCII UTF-8 字符的 SQL 名称，以及与保留 SQL 关键字完全匹配的名称，请用反引号包起来。例如，使用 `2026_архив` 或 `select`。配置文件名不加引号，并且可以以数字开头。纯数字标识符在所有模式下都会被拒绝，包括加载现有配置或元数据时；升级前请重命名任何此类对象。反引号不会让任意 ASCII 标点变成合法字符；-、$、空格以及嵌入的反引号等字符都不支持用于用户定义名称。

为了兼容常见的日志采集 schema，CREATE TABLE 和 ALTER TABLE 也不区分大小写地接受列名 @timestamp 和 @version，加不加反引号都可以。其他以 @ 开头的用户定义名称仍然无效。这个例外并不意味着 @ 会成为 SQL 或配置文件 schema 中的通用标识符字符。

为了向后兼容，Plain 模式加载配置时允许在表名、字段名和属性名的首字符之后使用早期版本曾接受的 . 和 -。请勿在新 schema 中使用这种兼容语法：SQL 无法始终如一地引用所有此类名称，SQL DDL 仍会拒绝任意标点。

标识符必须是有效的 UTF-8。控制字符、Unicode 空白字符、双向控制字符以及默认忽略的不可见字符都会被拒绝。这包括不间断空格、零宽空格和零宽连接符。

在 RT 模式和 Plain 模式下，表名编码为 UTF-8 后最多为 200 字节。每个 ASCII 字符占一个字节，而非 ASCII 字符占两个、三个或四个字节。因此，表名最多可包含 200 个 ASCII 字符；如果包含非 ASCII 字符，可用字符数会更少，具体取决于所用字符。system. 限定符之后的名称部分可以额外使用最多 48 字节，用于分片后缀和其他生成的后缀。该限定命名空间用于内部表，也可以在 SQL 中显式使用；普通的公开逻辑表名仍限制为 200 字节。这个限制在加载现有表定义时同样适用，因此升级前请先重命名任何更长的表。

在 RT 模式下，精确的逻辑表名会存储在 Manticore 的元数据中，而表文件则使用长度受限、可移植的 ASCII 基名。这样可以让字节不同的名称在大小写不敏感或归一化不敏感的文件系统上共存，并避免 Windows 保留文件名。组件映射不会预先校验完整的存储路径；操作系统的路径长度限制仍然适用，后续的文件系统错误会报告失败路径和操作系统错误。

通过 SQL 创建的表名、字段名和属性名会把 ASCII 大写字母转换为小写。非 ASCII 字符会保留原样。Plain 模式中的配置节名区分大小写，包括其中的 ASCII 字母。两种模式都不会应用 Unicode 大小写折叠或 Unicode 归一化，因此请始终使用完全一致的 Unicode 拼写。

例如：

有效的未加引号名称：title、product_id、user_name_2、товары2026、商品表、📦метка
有效的带引号名称：`2026_архив`、`select`
有效的 SQL 兼容列名：@timestamp、@version
无效名称：未加反引号的 2title、-price、user@name、user-name、@user_field，以及包含零宽空格的 badname

在 Plain 模式下，表名就是配置文件中的节名，并且在配置里不写反引号。不过在 SQL 中引用这些表时仍然可以使用反引号。例如，配置节可以命名为 таблица2026，而名为 2026_архив 的节在 SQL 中要写成 `2026_архив`。

按字段限定的全文检索操作符也支持非 ASCII UTF-8 字段名。例如，MATCH('@название клавиатура') 会将搜索范围限制在 название 字段。这同样适用于存储为 percolate 规则的按字段限定查询。

全文字段：

可以使用自然语言处理算法进行索引，因此可以搜索关键词
不能用于排序或分组
可以检索原始文档内容
原始文档内容可用于高亮显示

全文字段由数据类型 text 表示。所有其他数据类型都称为“属性”。

属性是与每个文档关联的非全文值，可用于在搜索期间执行非全文过滤、排序和分组。

通常，不仅需要根据匹配的文档 ID 及其排名来处理全文搜索结果，还需要基于许多其他每文档值进行处理。例如，可能需要按日期和相关性对新闻搜索结果进行排序，或在指定价格范围内搜索产品，或将博客搜索限制在选定用户发布的帖子中，或按月份对结果进行分组。为了实现这一点，Manticore 不仅支持全文字段，还允许为每个文档添加额外的属性。这些属性可用于过滤、排序或分组全文匹配项，或仅按属性进行搜索。

与全文字段不同，属性不进行全文索引。它们存储在表中，但无法像全文那样进行搜索。

属性的一个很好的例子是论坛帖子表。假设只有标题和内容字段需要进行全文搜索——但有时还需要将搜索限制在特定作者或子论坛（即，仅搜索那些具有特定 author_id 或 forum_id 值的行）；或按 post_date 列对匹配项进行排序；或按 post_date 的月份对匹配的帖子进行分组并计算每组的匹配计数。

‹›

SQL
JSON
PHP
Python
Python-asyncio
Javascript
Java
C#
Rust
config

📋

CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp);

POST /cli -d "CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)"

$table = new \Manticoresearch\Table($client);
$table->setName('forum');
$table->create([
    'title'=>['type'=>'text'],
    'content'=>['type'=>'text'],
    'author_id'=>['type'=>'int'],
    'forum_id'=>['type'=>'int'],
    'post_date'=>['type'=>'timestamp']
]);

utilsApi.sql('CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)')

await utilsApi.sql('CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)')

res = await utilsApi.sql('CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)');

utilsApi.sql("CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)");

utilsApi.Sql("CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)");

utils_api.sql("CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)", Some(true)).await;

table forum
{
    type = rt
    path = forum
    # when configuring fields via config, they are indexed (and not stored) by default
    rt_field = title
    rt_field = content
    # this option needs to be specified for the field to be stored
    stored_fields = title, content
    rt_attr_uint = author_id
    rt_attr_uint = forum_id
    rt_attr_timestamp = post_date
}

此示例展示了按 author_id、forum_id 过滤并按 post_date 排序的全文查询。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from forum where author_id=123 and forum_id in (1,3,7) order by post_date desc

POST /search
{
  "table": "forum",
  "query":
  {
    "match_all": {},
    "bool":
    {
      "must":
      [
        { "equals": { "author_id": 123 } },
        { "in": { "forum_id": [1,3,7] } }
      ]
    }
  },
  "sort": [ { "post_date": "desc" } ]
}

$client->search([
        'table' => 'forum',
        'query' =>
        [
            'match_all' => [],
            'bool' => [
                'must' => [
                    'equals' => ['author_id' => 123],
                    'in' => [
                        'forum_id' => [
                            1,3,7
                        ]
                    ]
                ]
            ]
        ],
        'sort' => [
        ['post_date' => 'desc']
    ]
]);

searchApi.search({"table":"forum","query":{"match_all":{},"bool":{"must":[{"equals":{"author_id":123}},{"in":{"forum_id":[1,3,7]}}]}},"sort":[{"post_date":"desc"}]})

await searchApi.search({"table":"forum","query":{"match_all":{},"bool":{"must":[{"equals":{"author_id":123}},{"in":{"forum_id":[1,3,7]}}]}},"sort":[{"post_date":"desc"}]})

res = await searchApi.search({"table":"forum","query":{"match_all":{},"bool":{"must":[{"equals":{"author_id":123}},{"in":{"forum_id":[1,3,7]}}]}},"sort":[{"post_date":"desc"}]});

HashMap<String,Object> filters = new HashMap<String,Object>(){{
    put("must", new HashMap<String,Object>(){{
        put("equals",new HashMap<String,Integer>(){{
            put("author_id",123);
        }});
        put("in",
            new HashMap<String,Object>(){{
                put("forum_id",new int[] {1,3,7});
        }});
    }});
}};
Map<String,Object> query = new HashMap<String,Object>();
query.put("match_all",null);
query.put("bool",filters);
SearchRequest searchRequest = new SearchRequest();
searchRequest.setTable("forum");
searchRequest.setQuery(query);
searchRequest.setSort(new ArrayList<Object>(){{
    add(new HashMap<String,String>(){{ put("post_date","desc");}});
}});
SearchResponse searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
var boolFilter = new BoolFilter();
boolFilter.Must = new List<Object> {
    new EqualsFilter("author_id", 123),
    new InFilter("forum_id", new List<Object> {1,3,7})
};
searchRequest.AttrFilter = boolFilter;
searchRequest.Sort = new List<Object> { new SortOrder("post_date", SortOrder.OrderEnum.Desc) };
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut sort = HashMap::new();
sort.insert("post_date".to_string(), serde_json::json!("desc"));
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(sort)
    ..Default::default()
};
let search_res = search_api.search(search_req).await;

Manticore 支持两种类型的属性存储：

行式 - Manticore Search 开箱即用的传统存储
列式 - 由 Manticore 列式库提供

从它们的名称可以理解，它们以不同的方式存储数据。传统的 行式存储：

以未压缩的方式存储属性
同一文档的所有属性存储在彼此靠近的一行中
行按顺序存储
访问属性基本上是通过将行 ID 乘以步幅（单个向量的长度）并从计算出的内存位置获取请求的属性来实现。这提供了非常低的随机访问延迟。
属性必须位于内存中才能获得可接受的性能，否则由于存储的行式特性，Manticore 可能不得不从磁盘读取太多不需要的数据，这在许多情况下是次优的。

使用 列式存储：

每个属性都独立于所有其他属性存储在其单独的“列”中
存储被分成 65536 个条目的块
块以压缩形式存储。这通常允许仅存储几个不同的值，而不是像行式存储那样存储所有值。高压缩比允许更快地从磁盘读取，并大大降低内存需求
当数据被索引时，每个块独立选择存储方案。例如，如果一个块中的所有值都相同，则采用“常量”存储，整个块只存储一个值。如果每个块的唯一值少于 256 个，则采用“表”存储，存储值表的索引而不是值本身
如果明确请求的值不在块中，可以提前拒绝在块中的搜索。

列式存储旨在处理无法放入 RAM 的大数据量，因此建议如下：

如果您有足够的内存容纳所有属性，您将从行式存储中受益
否则，列式存储仍然可以为您提供不错的性能，同时内存占用低得多，这将允许您在表中存储更多的文档

传统的行式存储是默认方式，因此如果您希望所有内容都以行式存储，创建表时无需进行任何操作。

要启用列式存储，您需要：

在 CREATE TABLE 中指定 engine='columnar'，使表的所有属性变为列式。然后，如果您希望保留特定属性为行式，需要在声明该属性时添加 engine='rowwise'。例如：
```
create table tbl(title text, type int, price float engine='rowwise') engine='columnar'
```

在 CREATE TABLE 中为特定属性指定 engine='columnar'，使其变为列式。例如：

create table tbl(title text, type int, price float engine='columnar');

或

create table tbl(title text, type int, price float engine='columnar') engine='rowwise';

在 plain 模式下，您需要在 columnar_attrs 中列出希望为列式的属性。

以下是 Manticore Search 支持的数据类型列表：

每个表都有一个文档 ID。它必须唯一且不能更新。默认情况下，文档 ID 是无符号 64 位值。显式指定的数字文档 ID 必须非零；不允许使用负数文档 ID。实时表也可以使用 UUID 文档 ID，详见 UUID document IDs。

对于数字文档 ID，你可以在 CREATE TABLE 模式中声明 id bigint，也可以省略它，让 Manticore 自动添加。在 MySQL/SQL 接口中，数字 ID 会以有符号 64 位 bigint 的形式暴露，因此较大的无符号 ID 值在这里可能显示为负数。

mysql> CREATE TABLE tbl(id bigint, content text);
DESC tbl;
+---------+--------+----------------+
| Field   | Type   | Properties     |
+---------+--------+----------------+
| id      | bigint |                |
| content | text   | indexed stored |
+---------+--------+----------------+
2 rows in set (0.00 sec)

您也可以完全省略指定 ID，它将自动启用。

mysql> CREATE TABLE tbl(content text);
DESC tbl;
+---------+--------+----------------+
| Field   | Type   | Properties     |
+---------+--------+----------------+
| id      | bigint |                |
| content | text   | indexed stored |
+---------+--------+----------------+
2 rows in set (0.00 sec)

自动 ID 生成取决于表和 ID 类型。使用数值 ID 的 RT 表和 PQ 表，在 insert 或 replace 请求中省略 ID，或者将其设为 0 时，都可以生成 ID。使用 id uuid 的 RT 表只有在省略 id 时才会生成 UUID。由外部数据源构建的普通表不支持自动 ID 生成；其源数据必须提供显式、唯一、非零的无符号 64 位文档 ID。

在处理数字文档 ID 时，需要注意无符号 64 位值会根据接口的不同而以不同方式处理：

MySQL/SQL 接口：

大于 2^63-1 的 ID 将显示为负数。
过滤此类大 ID 时，必须使用其有符号表示。
这种有符号表示只用于显示或过滤已有的大 ID；在插入或索引文档时，不接受负数 ID。
使用 UINT64() 函数查看实际的无符号值。

JSON/HTTP 接口：

ID 始终以其原始无符号值显示，无论大小。
有符号和无符号两种表示都可用于过滤已有的大 ID。
Insert 操作接受完整的无符号 64 位范围，但负数 id 值会被拒绝。

例如，让我们创建一个表并插入一些接近 2^63 的值：

mysql> create table t(id_text string);
Query OK, 0 rows affected (0.01 sec)
mysql> insert into t values(9223372036854775807, '2 ^ 63 - 1'),(9223372036854775808, '2 ^ 63');
Query OK, 2 rows affected (0.00 sec)

一些 ID 在结果中显示为负数，因为它们超过了 2^63-1。然而，使用 UINT64(id) 可以揭示它们的实际无符号值：

mysql> select *, uint64(id) from t;
+----------------------+------------+---------------------+
| id                   | id_text    | uint64(id)          |
+----------------------+------------+---------------------+
|  9223372036854775807 | 2 ^ 63 - 1 | 9223372036854775807 |
| -9223372036854775808 | 2 ^ 63     | 9223372036854775808 |
+----------------------+------------+---------------------+
2 rows in set (0.00 sec)
--- 2 out of 2 results in 0ms ---

对于查询 ID 小于 2^63 的文档，可以直接使用无符号值：

mysql> select * from t where id = 9223372036854775807;
+---------------------+------------+
| id                  | id_text    |
+---------------------+------------+
| 9223372036854775807 | 2 ^ 63 - 1 |
+---------------------+------------+
1 row in set (0.00 sec)
--- 1 out of 1 results in 0ms ---

但是，对于从 2^63 开始的 ID，需要使用有符号值：

mysql> select * from t where id = -9223372036854775808;
+----------------------+---------+
| id                   | id_text |
+----------------------+---------+
| -9223372036854775808 | 2 ^ 63  |
+----------------------+---------+
1 row in set (0.00 sec)
--- 1 out of 1 results in 0ms ---

如果使用无符号值，将会出错：

mysql> select * from t where id = 9223372036854775808;
ERROR 1064 (42000): number 9223372036854775808 is out of range [-9223372036854775808..9223372036854775807]

超出 64 位范围的值将触发类似错误：

mysql> select * from t where id = -9223372036854775809;
ERROR 1064 (42000): number -9223372036854775809 is out of range [-9223372036854775808..9223372036854775807]

MySQL/SQL 和 JSON/HTTP 接口之间的行为差异在处理非常大的文档 ID 时变得更加明显。以下是一个全面的示例：

MySQL/SQL 接口：

mysql> drop table if exists t; create table t; insert into t values(17581446260360033510);
Query OK, 0 rows affected (0.01 sec)
mysql> select * from t;
+---------------------+
| id                  |
+---------------------+
| -865297813349518106 |
+---------------------+
mysql> select *, uint64(id) from t;
+---------------------+----------------------+
| id                  | uint64(id)           |
+---------------------+----------------------+
| -865297813349518106 | 17581446260360033510 |
+---------------------+----------------------+
mysql> select * from t where id = -865297813349518106;
+---------------------+
| id                  |
+---------------------+
| -865297813349518106 |
+---------------------+
mysql> select * from t where id = 17581446260360033510;
ERROR 1064 (42000): number 17581446260360033510 is out of range [-9223372036854775808..9223372036854775807]

JSON/HTTP 接口：

# Search returns the original unsigned value
curl -s 0:9308/search -d '{"table": "t"}'
{
  "took": 0,
  "timed_out": false,
  "hits": {
    "total": 1,
    "total_relation": "eq",
    "hits": [
      {
        "_id": 17581446260360033510,
        "_score": 1,
        "_source": {}
      }
    ]
  }
}
# Both signed and unsigned values work for filtering the same stored ID
curl -s 0:9308/search -d '{"table": "t", "query": {"equals": {"id": 17581446260360033510}}}'
curl -s 0:9308/search -d '{"table": "t", "query": {"equals": {"id": -865297813349518106}}}'
# Insert with maximum unsigned 64-bit value
curl -s 0:9308/insert -d '{"table": "t", "id": 18446744073709551615, "doc": {}}'

这意味着在处理大文档 ID 时：

MySQL 接口 要求查询时使用有符号表示，但可以通过 UINT64() 显示无符号值
JSON 接口 始终使用无符号值显示，并接受两种表示进行过滤

实时表可以使用 id uuid 的 UUID 文档 ID。显式 ID 必须是 36 字符的 8-4-4-4-12 十六进制格式字符串，例如 550e8400-e29b-41d4-a716-446655440000。Manticore 接受 UUID 版本 1 到 8，以及 RFC 变体 8、9、a 和 b。支持大写字母，并会规范化为小写。

省略 id 可自动生成 UUID。这适用于 SQL INSERT 和 REPLACE、原生 JSON 插入和替换请求，以及 Elasticsearch 兼容的 _bulk index 和 create 操作。生成的 ID 采用类似 UUIDv8 的布局，并且具有与数值自动 ID 相同的唯一性保证。它们不是随机的 UUIDv4 值，不能用作加密密钥。

SQL 会将 UUID ID 作为字符串返回。对于 UUID-ID 表，原生 JSON 写入响应使用键名 id，而 JSON 搜索和 Elasticsearch 兼容响应使用 _id。

UUID ID 可用于相等和 IN 过滤器，也可用于在 REPLACE、UPDATE 和 DELETE 中标识文档。INSERT 会拒绝已存在的 ID；要覆盖该 ID 对应的文档，请使用 REPLACE。在 UUID-ID 表上执行 INSERT 或 REPLACE 后，LAST_INSERT_ID() 和 @@session.last_insert_id 会返回受影响文档的 UUID ID。

限制：

只有 id 列可以使用 uuid 类型；普通属性不能声明为 uuid。
UUID 文档 ID 仅支持实时表，包括列式实时表和复制实时表。不支持普通表（由 indexer 创建）、percolate/PQ 表或 shard 表。
ALTER TABLE 不能将现有表转换为或转换自 id uuid。
不支持对 UUID id 使用范围过滤器（<、<=、>、>=）以及数值或算术表达式。
与数值 ID 表不同，UUID-ID 表不会把 0 视为自动 ID 标记。

‹›

SQL

📋

CREATE TABLE products_uuid(id uuid, title text, price int);
INSERT INTO products_uuid(id, title, price) VALUES('550e8400-e29b-41d4-a716-446655440000', 'Crossbody Bag', 19);
INSERT INTO products_uuid(title, price) VALUES('Generated UUID Bag', 29);
SELECT id, price FROM products_uuid WHERE id='550e8400-e29b-41d4-a716-446655440000';

‹›

Response

Query OK, 0 rows affected (0.00 sec)
Query OK, 1 rows affected (0.00 sec)
Query OK, 1 rows affected (0.00 sec)
+--------------------------------------+-------+
| id                                   | price |
+--------------------------------------+-------+
| 550e8400-e29b-41d4-a716-446655440000 |    19 |
+--------------------------------------+-------+
1 row in set (0.00 sec)

通用语法：

string|text [stored|attribute] [indexed]

属性：

indexed - 全文索引（可用于全文查询）
stored - 存储在文档存储中（存储在磁盘上，而非 RAM 中，惰性读取）
attribute - 使其成为字符串属性（可以按其排序/分组）

指定至少一个属性会覆盖所有默认属性（见下文），即，如果您决定使用自定义属性组合，需要列出所有您想要的属性。

未指定任何属性：

string 和 text 是别名，但如果您不指定任何属性，它们默认表示不同的含义：

仅 string 默认表示 attribute（详见下文）。
仅 text 默认表示 stored + indexed（详见下文）。

文本（仅 text 或 text/string indexed）数据类型构成表的全文部分。文本字段被索引，可以用于搜索关键词。

文本通过分析器管道处理，将文本转换为单词，应用词形变换等。最终，从该文本构建出全文表（一种特殊的数据结构，能够快速搜索关键词）。

全文字段只能在 MATCH() 子句中使用，不能用于排序或聚合。单词存储在倒排索引中，并带有它们所属字段的引用和字段中的位置。这允许在每个字段内搜索单词，并使用邻近等高级运算符。默认情况下，字段的原始文本既被索引，也被存储在文档存储中。这意味着原始文本可以随查询结果返回，并用于搜索结果高亮。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text);

POST /cli -d "CREATE TABLE products(title text)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text']
]);

utilsApi.sql('CREATE TABLE products(title text)')

await utilsApi.sql('CREATE TABLE products(title text)')

res = await utilsApi.sql('CREATE TABLE products(title text)');

utilsApi.sql("CREATE TABLE products(title text)");

utilsApi.Sql("CREATE TABLE products(title text)");

utils_api.sql("CREATE TABLE products(title text)", Some(true)).await;

table products
{
    type = rt
    path = products
    # when configuring fields via config, they are indexed (and not stored) by default
    rt_field = title
    # this option needs to be specified for the field to be stored
    stored_fields = title
}

此行为可以通过显式指定文本仅被索引来覆盖。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text indexed);

POST /cli -d "CREATE TABLE products(title text indexed)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text','options'=>['indexed']]
]);

utilsApi.sql('CREATE TABLE products(title text indexed)')

await utilsApi.sql('CREATE TABLE products(title text indexed)')

res = await utilsApi.sql('CREATE TABLE products(title text indexed)');

utilsApi.sql("CREATE TABLE products(title text indexed)");

utilsApi.Sql("CREATE TABLE products(title text indexed)");

utils_api.sql("CREATE TABLE products(title text indexed)", Some(true)).await;

table products
{
    type = rt
    path = products
    # when configuring fields via config, they are indexed (and not stored) by default
    rt_field = title
}

字段是有名称的，您可以将搜索限制在单个字段（例如仅搜索"title"）或字段子集（例如仅"title"和"abstract"）。您最多可以拥有256个全文字段。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from products where match('@title first');

POST /search
{
    "table": "products",
    "query":
    {
        "match": { "title": "first" }
    }
}

$table->setName('products')->search('@title')->get();

searchApi.search({"table":"products","query":{"match":{"title":"first"}}})

await searchApi.search({"table":"products","query":{"match":{"title":"first"}}})

res = await searchApi.search({"table":"products","query":{"match":{"title":"first"}}});

utilsApi.sql("CREATE TABLE products(title text indexed)");

utilsApi.Sql("CREATE TABLE products(title text indexed)");

utils_api.sql("CREATE TABLE products(title text indexed)", Some(true)).await;

与全文字段不同，字符串属性（仅string或string/text attribute）按接收时的原样存储，不能用于全文搜索。相反，它们会在结果中返回，可以在WHERE子句中用于比较过滤或REGEX，并且可以用于排序和聚合。通常，不建议在字符串属性中存储大文本，而是将字符串属性用于元数据，如名称、标题、标签、键。

如果您还想索引字符串属性，可以同时指定为string attribute indexed。这将允许全文搜索并作为属性使用。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, keys string);

POST /cli -d "CREATE TABLE products(title text, keys string)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'keys'=>['type'=>'string']
]);

utilsApi.sql('CREATE TABLE products(title text, keys string)')

await utilsApi.sql('CREATE TABLE products(title text, keys string)')

res = await utilsApi.sql('CREATE TABLE products(title text, keys string)');

utilsApi.sql("CREATE TABLE products(title text, keys string)");

utilsApi.Sql("CREATE TABLE products(title text, keys string)");

utils_api.sql("CREATE TABLE products(title text, keys string)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_string = keys
}

Manticore没有专门的二进制数据类型字段，但您可以通过使用base64编码和text stored或string stored字段类型（它们是同义词）来安全地存储它。如果您不对二进制数据进行编码，部分数据可能会丢失——例如，如果遇到空字节，Manticore会修剪字符串的末尾。

这是一个示例，我们使用base64编码ls命令，将其存储在Manticore中，然后解码以验证MD5校验和保持不变：

‹›

Example

Example

📋

# md5sum /bin/ls
43d1b8a7ccda411118e2caba685f4329  /bin/ls
# encoded_data=`base64 -i /bin/ls `
# mysql -P9306 -h0 -e "drop table if exists test; create table test(data text stored); insert into test(data) values('$encoded_data')"
# mysql -P9306 -h0 -NB -e "select data from test" | base64 -d > /tmp/ls | md5sum
43d1b8a7ccda411118e2caba685f4329  -

整数类型允许存储32位无符号整数值。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, price int);

POST /cli -d "CREATE TABLE products(title text, price int)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'price'=>['type'=>'int']
]);

utilsApi.sql('CREATE TABLE products(title text, price int)')

await utilsApi.sql('CREATE TABLE products(title text, price int)')

res = await utilsApi.sql('CREATE TABLE products(title text, price int)');

utilsApi.sql("CREATE TABLE products(title text, price int)");

utilsApi.Sql("CREATE TABLE products(title text, price int)");

utils_api.sql("CREATE TABLE products(title text, price int)", Some(true)).await;

table products
{
    type = rt
    path = products

    rt_field = title
    stored_fields = title

    rt_attr_uint = type
}

整数可以通过指定位数以比32位更短的尺寸存储。例如，如果我们想存储一个我们知道不会大于8的数值，类型可以定义为bit(3)。位计数整数比全尺寸整数性能更慢，但它们需要更少的RAM。它们以32位块保存，因此为了节省空间，它们应该分组在属性定义的末尾（否则，在两个全尺寸整数之间的位计数整数也将占用32位）。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, flags bit(3), tags bit(2) );

POST /cli -d "CREATE TABLE products(title text, flags bit(3), tags bit(2))"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'flags'=>['type'=>'bit(3)'],
    'tags'=>['type'=>'bit(2)']
]);

utilsApi.sql('CREATE TABLE products(title text, flags bit(3), tags bit(2) ')

await utilsApi.sql('CREATE TABLE products(title text, flags bit(3), tags bit(2) ')

res = await utilsApi.sql('CREATE TABLE products(title text, flags bit(3), tags bit(2) ');

utilsApi.sql("CREATE TABLE products(title text, flags bit(3), tags bit(2)");

utilsApi.Sql("CREATE TABLE products(title text, flags bit(3), tags bit(2)");

utils_api.sql("CREATE TABLE products(title text, flags bit(3), tags bit(2)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_uint = flags:3
    rt_attr_uint = tags:2
}

大整数（bigint）是64位宽的有符号整数。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, price bigint );

POST /cli -d "CREATE TABLE products(title text, price bigint)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'price'=>['type'=>'bigint']
]);

utilsApi.sql('CREATE TABLE products(title text, price bigint )')

await utilsApi.sql('CREATE TABLE products(title text, price bigint )')

res = await utilsApi.sql('CREATE TABLE products(title text, price bigint )');

utilsApi.sql("CREATE TABLE products(title text, price bigint )");

utilsApi.Sql("CREATE TABLE products(title text, price bigint )");

utils_api.sql("CREATE TABLE products(title text, price bigint )", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_bigint = type
}

声明一个布尔属性。等同于位数为1的整数属性。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, sold bool );

POST /cli -d "CREATE TABLE products(title text, sold bool)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'sold'=>['type'=>'bool']
]);

utilsApi.sql('CREATE TABLE products(title text, sold bool )')

await utilsApi.sql('CREATE TABLE products(title text, sold bool )')

res = await utilsApi.sql('CREATE TABLE products(title text, sold bool )');

utilsApi.sql("CREATE TABLE products(title text, sold bool )");

utilsApi.Sql("CREATE TABLE products(title text, sold bool )");

utils_api.sql("CREATE TABLE products(title text, sold bool )", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_bool = sold
}

时间戳类型表示Unix时间戳，以32位整数存储。与基本整数不同，时间戳类型允许使用时间和日期函数。从字符串值转换遵循以下规则：

不带分隔符的数字，且长度至少为10个字符，按原样转换为时间戳。
%Y-%m-%dT%H:%M:%E*S%Z
%Y-%m-%d'T'%H:%M:%S%Z
%Y-%m-%dT%H:%M:%E*S
%Y-%m-%dT%H:%M:%s
%Y-%m-%dT%H:%M
%Y-%m-%dT%H
%Y-%m-%d
%Y-%m
%Y

这些转换格式的含义详见strptime手册，除%E*S表示毫秒外。

注意，纯表中不支持时间戳的自动转换。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, date timestamp);

POST /cli -d "CREATE TABLE products(title text, date timestamp)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'date'=>['type'=>'timestamp']
]);

utilsApi.sql('CREATE TABLE products(title text, date timestamp)')

await utilsApi.sql('CREATE TABLE products(title text, date timestamp)')

res = await utilsApi.sql('CREATE TABLE products(title text, date timestamp)');

utilsApi.sql("CREATE TABLE products(title text, date timestamp)");

utilsApi.Sql("CREATE TABLE products(title text, date timestamp)");

utils_api.sql("CREATE TABLE products(title text, date timestamp)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_timestamp = date
}

实数存储为32位IEEE 754单精度浮点数。

float 会保留约 7 位有效数字：155.83 会存储为 155.830002，51.50390089466783 会存储为 51.503902。没有双精度类型：CREATE TABLE t (x double) 会失败并返回 P03: expected 'id', got 'x'。浮点表达式也会以单精度计算，包括使用 DOUBLE() 或 bigint 操作数的表达式。需要精确小数值时，例如价格或高精度坐标，请将它们按比例放大后作为整数存入 bigint（例如，以分为单位存储价格），并在应用程序中转换。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, coeff float);

POST /cli -d "CREATE TABLE products(title text, coeff float)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'coeff'=>['type'=>'float']
]);

utilsApi.sql('CREATE TABLE products(title text, coeff float)')

await utilsApi.sql('CREATE TABLE products(title text, coeff float)')

res = await utilsApi.sql('CREATE TABLE products(title text, coeff float)');

utilsApi.sql("CREATE TABLE products(title text, coeff float)");

utilsApi.Sql("CREATE TABLE products(title text, coeff float)");

utils_api.sql("CREATE TABLE products(title text, coeff float)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_float = coeff
}

与整数类型不同，不建议直接比较两个浮点数是否相等，因为可能存在舍入误差。更可靠的做法是使用近似比较，通过检查绝对误差范围。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select abs(a-b)<=0.00001 from products

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "expressions": { "eps": "abs(a-b)" }
}

$table->setName('products')->search('')->expression('eps','abs(a-b)')->get();

searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"eps":"abs(a-b)"}})

await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"eps":"abs(a-b)"}})

res = await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"eps":"abs(a-b)"}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("ebs","abs(a-b)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Expressions = new List<Object>{
    new Dictionary<string, string> { {"ebs", "abs(a-b)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("ebs".to_string(), serde_json::json!("abs(a-b)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

另一个替代方案，也可用于执行IN(attr,val1,val2,val3)，是通过选择一个乘数因子将浮点数转换为整数进行比较操作。以下例子展示了如何将IN(attr,2.0,2.5,3.5)修改为整型值。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select in(ceil(attr*100),200,250,350) from products

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "expressions": { "inc": "in(ceil(attr*100),200,250,350)" }
}

$table->setName('products')->search('')->expression('inc','in(ceil(attr*100),200,250,350)')->get();

searchApi.search({"table":"products","query":{"match_all":{}}},"expressions":{"inc":"in(ceil(attr*100),200,250,350)"}})

await searchApi.search({"table":"products","query":{"match_all":{}}},"expressions":{"inc":"in(ceil(attr*100),200,250,350)"}})

res = await searchApi.search({"table":"products","query":{"match_all":{}}},"expressions":{"inc":"in(ceil(attr*100),200,250,350)"}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("inc","in(ceil(attr*100),200,250,350)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Expressions = new List<Object> {
    new Dictionary<string, string> { {"ebs", "in(ceil(attr*100),200,250,350)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("ebs".to_string(), serde_json::json!("in(ceil(attr*100),200,250,350)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

浮点值在Manticore中以精确的方式显示，以确保它们反映存储的确切值。这种方法是为了防止精度丢失，特别是在地理坐标等情况下，四舍五入到6位小数会导致不准确。

现在，Manticore首先输出一个带有6位数字的数字，然后解析并将其与原始值进行比较。如果不匹配，则会添加更多位数，直到匹配为止。

例如，如果浮点值插入为19.45，Manticore将显示为19.450001以准确表示存储的值。

‹›

Example

Example

📋

insert into t(id, f) values(1, 19.45)
--------------
Query OK, 1 row affected (0.02 sec)
--------------
select * from t
--------------
+------+-----------+
| id   | f         |
+------+-----------+
|    1 | 19.450001 |
+------+-----------+
1 row in set (0.00 sec)
--- 1 out of 1 results in 0ms ---

此数据类型允许存储JSON对象，特别适用于处理无模式数据。在定义JSON值时，请确保对象的开闭花括号{和}包含，或数组的开闭方括号[和]包含。虽然JSON不支持列存储，但它可以存储在传统的行存储中。值得注意的是，这两种存储类型可以在同一表中结合使用。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, data json);

POST /cli -d "CREATE TABLE products(title text, data json)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'data'=>['type'=>'json']
]);

utilsApi.sql('CREATE TABLE products(title text, data json)')

await utilsApi.sql('CREATE TABLE products(title text, data json)')

res = await utilsApi.sql('CREATE TABLE products(title text, data json)');

utilsApi.sql("CREATE TABLE products(title text, data json)");

utilsApi.Sql("CREATE TABLE products(title text, data json)");

utils_api.sql("CREATE TABLE products(title text, data json)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_json = data
}

JSON属性可以在大多数操作中使用。还有一些特殊函数，如ALL()、ANY()、GREATEST()、LEAST()和INDEXOF()，允许遍历属性数组。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select indexof(x>2 for x in data.intarray) from products

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "expressions": { "idx": "indexof(x>2 for x in data.intarray)" }
}

$table->setName('products')->search('')->expression('idx','indexof(x>2 for x in data.intarray)')->get();

searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"idx":"indexof(x>2 for x in data.intarray)"}})

await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"idx":"indexof(x>2 for x in data.intarray)"}})

res = await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"idx":"indexof(x>2 for x in data.intarray)"}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("idx","indexof(x>2 for x in data.intarray)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Expressions = new List<Object> {
    new Dictionary<string, string> { {"idx", "indexof(x>2 for x in data.intarray)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("idx".to_string(), serde_json::json!("indexof(x>2 for x in data.intarray)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

文本属性与字符串相同，因此无法在全文匹配表达式中使用。但是，可以使用字符串函数，如REGEX()。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select regex(data.name, 'est') as c from products where c>0

POST /search
{
  "table": "products",
  "query":
  {
    "match_all": {},
    "range": { "c": { "gt": 0 } } }
  },
  "expressions": { "c": "regex(data.name, 'est')" }
}

$table->setName('products')->search('')->expression('idx',"regex(data.name, 'est')")->filter('c','gt',0)->get();

searchApi.search({"table":"products","query":{"match_all":{},"range":{"c":{"gt":0}}}},"expressions":{"c":"regex(data.name, 'est')"}})

await searchApi.search({"table":"products","query":{"match_all":{},"range":{"c":{"gt":0}}}},"expressions":{"c":"regex(data.name, 'est')"}})

res = await searchApi.search({"table":"products","query":{"match_all":{},"range":{"c":{"gt":0}}}},"expressions":{"c":"regex(data.name, 'est')"}}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
query.put("range", new HashMap<String,Object>(){{
    put("c", new HashMap<String,Object>(){{
        put("gt",0);
    }});
}});
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("idx","indexof(x>2 for x in data.intarray)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
var rangeFilter = new RangeFilter("c");
rangeFilter.Gt = 0;
searchRequest.AttrFilter = rangeFilter;
searchRequest.Expressions = new List<Object> {
    new Dictionary<string, string> { {"idx", "indexof(x>2 for x in data.intarray)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("idx".to_string(), serde_json::json!("indexof(x>2 for x in data.intarray)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

在处理浮点值的情况下，可能需要强制执行数据类型以确保某些情况下的正确功能。例如，当处理浮点值时，必须使用DOUBLE()以确保正确的排序。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from products order by double(data.myfloat) desc

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "sort": [ { "double(data.myfloat)": { "order": "desc"} } ]
}

$table->setName('products')->search('')->sort('double(data.myfloat)','desc')->get();

searchApi.search({"table":"products","query":{"match_all":{}}},"sort":[{"double(data.myfloat)":{"order":"desc"}}]})

await searchApi.search({"table":"products","query":{"match_all":{}}},"sort":[{"double(data.myfloat)":{"order":"desc"}}]})

res = await searchApi.search({"table":"products","query":{"match_all":{}}},"sort":[{"double(data.myfloat)":{"order":"desc"}}]});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
searchRequest.setSort(new ArrayList<Object>(){{
    add(new HashMap<String,String>(){{ put("double(data.myfloat)",new HashMap<String,String>(){{ put("order","desc");}});}});
}});
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Sort = new List<Object> {
    new SortOrder("double(data.myfloat)", SortOrder.OrderEnum.Desc)
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut sort = HashMap::new();
sort.insert("double(data.myfloat)".to_string(), serde_json::json!("desc"));
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(sort)
    ..Default::default()
};
let search_res = search_api.search(search_req).await;

浮点向量属性允许存储可变长度的浮点数列表，主要用于机器学习应用和相似性搜索。此类型与多值整数（MVA）（MVAs）在几个重要方面不同：

保留值的确切顺序（与MVAs不同，MVAs可能会重新排序）
保留重复值（与MVAs不同，MVAs会去重）
插入时无需额外处理（与MVAs不同，MVAs会排序和去重）

重要： float_vector 数据类型与自动模式机制不兼容。

目前仅支持实时表（不支持普通表）
其他函数或表达式中不支持
不能在常规过滤器或排序中使用

当你配置 float_vector 属性并设置 KNN 参数时，你将启用向量相似性搜索功能。这允许你执行 k-最近邻搜索，根据向量距离查找相似文档。

你可以做到：

执行 KNN（k-最近邻）向量搜索以查找相似文档
构建语义搜索、推荐和 AI 驱动的功能
使用自动嵌入从文本中自动生成向量

你不能做到：

UPDATE float_vector 值（必须使用 REPLACE 代替）
在常规过滤器或排序中使用浮点向量
除了通过向量搜索操作，不能通过 float_vector 值进行过滤

当你创建带有 float_vector 属性的表以进行 KNN 搜索时，可以指定以下参数：

必填参数：

KNN_TYPE：目前仅支持 'hnsw'
KNN_DIMS：向量的维度数（手动插入向量时必需，使用 MODEL_NAME 时可省略）
HNSW_SIMILARITY：距离函数 - 'l2'、'ip'（内积）或 'cosine'

可选参数：

HNSW_M：图中的最大连接数（默认：16）
HNSW_EF_CONSTRUCTION：构建时间/准确性权衡（默认：200）

分块参数（使用 MODEL_NAME 时，参见分块策略）：

CHUNK_STRATEGY：文档如何转换为向量：'truncate'（默认）、'mean'、'fixed'、'recursive' 或 'sentence'。后三种会为每个文档生成多个向量，并且需要一个 float_vector_array 列。
MAX_TOKENS：每个分块的 token 数；0（默认）表示使用模型自身的上限
OVERLAP_TOKENS：相邻分块之间共享的 token；需要显式设置一个非零的 MAX_TOKENS；如果重叠过大，会自动缩减，确保分块仍能继续前进
MAX_CHUNKS：每个文档向量数的上限；0（默认）表示不限制

自动嵌入参数（当使用 MODEL_NAME 时）：

MODEL_NAME：要使用的嵌入模型（例如，快速 ONNX 路径可用 'Xenova/all-MiniLM-L6-v2'，也可以是 'sentence-transformers/all-MiniLM-L6-v2' 或 'openai/text-embedding-ada-002'）
FROM：用于生成嵌入的字段名列表（逗号分隔），或空字符串 '' 表示使用所有文本/字符串字段
API_KEY：基于 API 的模型（OpenAI、Voyage、Jina）的 API 密钥

有关设置浮点向量并在搜索中使用它们的详细信息，请参阅KNN搜索。

处理浮点向量最简便的方式是使用自动嵌入。此功能使用机器学习模型自动从您的文本数据生成嵌入，从而消除手动计算和插入向量的需要。

简化的工作流程：只需插入文本，嵌入会自动生成
无需手动计算向量：无需运行单独的嵌入模型
一致的嵌入：相同的模型确保一致的向量表示
多模型支持：可从 Hugging Face 上的 ONNX 模型中选择（推荐 - 运行在 Manticore 的快速 ONNX Runtime 后端上）、sentence-transformers、Qwen 嵌入模型，以及 OpenAI、Voyage 和 Jina 模型
灵活的字段选择：控制用于生成嵌入的字段

在创建带有自动嵌入的表时，指定以下附加参数：

MODEL_NAME：用于自动向量生成的嵌入模型
FROM：用于生成嵌入的字段（空字符串表示所有文本/字符串字段）
API_KEY：远程模型（OpenAI、Voyage、Jina）必需。在创建表时通过实际 API 请求验证 API 密钥。
API_URL：可选。自定义 API 端点 URL。如果未指定，使用默认提供者端点（例如，OpenAI 的 https://api.openai.com/v1/embeddings）。
API_TIMEOUT：可选。API 请求的 HTTP 超时时间（以秒为单位）。默认为 10 秒。设置为 '0' 以使用默认超时。适用于表创建时的验证请求和插入操作时的嵌入生成。
MAX_INPUT_TOKENS：可选。限制每段输入文本在生成嵌入前使用的 token 数；更长的文本会被截断。'0'（默认值）表示使用模型自身的上下文限制。Qwen/Qwen3-Embedding-0.6B 等长上下文模型最多可接受 32,768 个 token，并且在 CPU 上生成嵌入的时间会随着输入长度超线性增长（一个 5 KB 的文档可能需要数分钟），因此当文本字段可能包含很长或无边界的内容时，应设置上限（例如 '512'）。适用于本地模型；之后可通过 ALTER TABLE ... MODIFY COLUMN ... MAX_INPUT_TOKENS='...' 修改该设置，且无需重新为已有行生成嵌入。

对于远程模型，MODEL_NAME 可以使用传统的 provider/model 格式或显式的 provider:model 格式。当使用 API_URL 并希望将 : 后的部分原样转发到自定义提供方兼容端点时，请使用 provider:model。

支持的嵌入模型：

ONNX（推荐）：任何附带 .onnx 文件的 Hugging Face 模型，例如 Xenova/all-MiniLM-L6-v2、Xenova/all-MiniLM-L12-v2、Xenova/bge-small-en-v1.5、Xenova/multilingual-e5-small。无需 API 密钥。运行在 Manticore 快速的 ONNX Runtime 后端上（在相同硬件上比 SentenceTransformers 路径快约 14 倍，见速度提升 14 倍的嵌入）。Xenova 和 onnx-models 都发布了大量转换为 ONNX 的模型；用于嵌入时，请寻找标有 feature-extraction 任务的模型。速度对比表和实践建议见选择本地嵌入模型。
Sentence Transformers：任何合适的、基于 BERT 的 Hugging Face 模型（例如 sentence-transformers/all-MiniLM-L6-v2）- 无需 API key。仍然受支持；如果你想要的模型没有发布为 ONNX，就用这个。
Qwen 本地嵌入：Qwen 嵌入模型，如 Qwen/Qwen3-Embedding-0.6B——不需要 API 密钥。Manticore 在您创建表时下载模型。
OpenAI、Voyage、Jina：远程嵌入模型（例如，openai/text-embedding-ada-002、openai:text-embedding-ada-002、voyage/voyage-3.5-lite、jina/jina-embeddings-v2-base-en）- 需要 API_KEY='***' 参数。可选地指定 API_URL='<CUSTOM_URL>' 以使用自定义 API 端点，并使用 API_TIMEOUT='<SECONDS>' 配置 HTTP 超时（默认为 10 秒）。

‹›

SQL
JSON

📋

使用本地 ONNX 模型 - 推荐，运行在快速 ONNX 路径上（无需 API key）

CREATE TABLE products (
    title TEXT,
    description TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='Xenova/all-MiniLM-L6-v2' FROM='title'
);

使用 sentence-transformers 模型（无需 API key；运行在 Candle 路径上 - 可用时优先使用上面的 ONNX）

CREATE TABLE products_st (
    title TEXT,
    description TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='sentence-transformers/all-MiniLM-L6-v2' FROM='title'
);

使用 Qwen 本地嵌入（不需要 API 密钥）

CREATE TABLE products_qwen (
    title TEXT,
    description TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='Qwen/Qwen3-Embedding-0.6B' FROM='title'
);

使用 OpenAI 模型（需要 API_KEY 参数）

CREATE TABLE products_openai (
    title TEXT,
    content TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='cosine'
    MODEL_NAME='openai/text-embedding-ada-002' FROM='title,content' API_KEY='<OPENAI_API_KEY>'
);

使用 OpenAI 与自定义 API URL 和超时（可选）

CREATE TABLE products_openai_custom (
    title TEXT,
    content TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='cosine'
    MODEL_NAME='openai:text-embedding-ada-002' FROM='title,content'
    API_KEY='***' API_URL='https://custom-api.example.com/v1/embeddings' API_TIMEOUT='30'
);

使用 OpenRouter 与提供方限定的模型 ID

CREATE TABLE products_openrouter (
    title TEXT,
    content TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='cosine'
    MODEL_NAME='openai:openai/text-embedding-ada-002' FROM='title,content'
    API_KEY='***' API_URL='https://openrouter.ai/api/v1/embeddings' API_TIMEOUT='30'
);

使用所有文本字段进行嵌入（FROM 为空）

CREATE TABLE products_all_fields (
    title TEXT,
    description TEXT,
    tags TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='Xenova/all-MiniLM-L6-v2' FROM=''
);

FROM 参数控制用于生成嵌入的字段：

特定字段：FROM='title' - 仅使用标题字段
多个字段：FROM='title,description' - 将标题和描述字段连接并使用
所有文本字段：FROM=''（空）- 表中的所有 text（全文字段）和 string（字符串属性）字段用于嵌入生成
手动覆盖：即使配置了 MODEL_NAME，你仍然可以在 INSERT/REPLACE 中提供自己的向量
空向量：你可以插入 () 以跳过该行的嵌入生成；Manticore 会存储一个全零向量，其维度与模型相同

使用自动嵌入时，你有三种插入模式：

省略向量列，让 Manticore 从 FROM 中列出的字段生成嵌入
显式提供自己的向量以覆盖该行的自动生成
提供 () 以跳过生成并存储一个全零向量

-- Insert text data - embeddings generated automatically
INSERT INTO products (title, description) VALUES 
('smartphone', 'latest mobile device with camera'),
('laptop computer', 'portable workstation for developers');
-- Insert with a user-provided vector - no auto generation for this row
INSERT INTO products (title, embedding_vector) VALUES
('machine learning artificial intelligence', (0.653448,0.192478,0.017971,0.339821));
-- Insert with empty vector - no auto generation, stores a zero vector
INSERT INTO products (title, description, embedding_vector) VALUES
('no-vector item', 'this item has no embedding', ());

() 在你希望保留某行但不立即生成嵌入时很有用。内部存储为零填充向量，因此应将其视为“尚未生成有意义的嵌入”，而不是语义向量。如果你之后运行 ALTER TABLE ... REBUILD EMBEDDINGS，该行也会被重建；REBUILD EMBEDDINGS 不会跳过仅因为当前向量全为零的行。

或者，你可以手动插入预计算的向量数据。这需要你使用外部工具或模型自行计算向量，然后将其插入到 Manticore 中。

重要提示： 当使用 HNSW_SIMILARITY='cosine' 时，插入时向量会自动归一化为单位向量（数学长度/幅度为 1.0 的向量）。这种归一化保留了向量的方向，同时标准化了其长度，这是高效余弦相似性计算所必需的。这意味着存储的值将与你的原始输入值不同。

‹›

SQL

📋

CREATE TABLE products (
    title TEXT,
    image_vector FLOAT_VECTOR KNN_TYPE='hnsw' KNN_DIMS='4' HNSW_SIMILARITY='l2'
);
INSERT INTO products VALUES 
(1, 'yellow bag', (0.653448,0.192478,0.017971,0.339821)),
(2, 'white bag', (-0.148894,0.748278,0.091892,-0.095406));

如果初始摄入速度比即时向量搜索更重要，你可以首先加载没有嵌入列的表，然后稍后添加基于模型的 float_vector 列。

这种方法在希望批量插入操作尽可能快速完成，并且愿意随后运行嵌入生成作为独立的、可能耗时较长的 ALTER 操作时非常有用。

工作原理：

仅创建包含源 text 字段和 string 属性的表
插入或导入所有数据
后续使用 ALTER TABLE ... ADD COLUMN 添加嵌入列

当你使用 MODEL_NAME 和 FROM 添加 float_vector 列时，Manticore 会在 ALTER 过程中为现有行生成嵌入。如果之后需要重新生成它们，请使用 ALTER TABLE ... REBUILD EMBEDDINGS column_name。

请注意 REBUILD EMBEDDINGS：它会为每一行重新生成目标列。这包括当前向量是手动插入的行，以及使用 () 存储零向量的行。在数据提交后，Manticore 不会保留存储的向量是自动生成的、由用户提供的还是从 () 创建的，并且 REBUILD EMBEDDINGS 不会将零向量视为特殊的“跳过此行”标记。

限制：

此方法仅适用于本地 RT 表。对于属于复制集群的表不可用，因为集群表不支持 ALTER。

CREATE TABLE products (
    title TEXT,
    description TEXT
);
INSERT INTO products (id, title, description) VALUES
(1, 'smartphone', 'latest mobile device with camera'),
(2, 'laptop computer', 'portable workstation for developers');
ALTER TABLE products
ADD COLUMN embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
MODEL_NAME='Xenova/all-MiniLM-L6-v2' FROM='title,description';

有关详细信息，请参见更新表结构。

你也可以创建没有 KNN 配置的 float_vector 属性。在这种模式下，向量被存储但不能用于向量搜索操作。

你可以做到：

存储向量数据
UPDATE float_vector 值（与 KNN 不同，此时可以使用 UPDATE）

你不能做到：

执行 KNN 搜索或向量相似性搜索
使用向量进行任何搜索操作
通过 float_vector 值进行过滤

在配置KNN之前临时存储向量数据
用于后续与KNN一起使用的暂存数据
存储不需要搜索功能的向量

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, image_vector float_vector);

POST /cli -d "CREATE TABLE products(title text, image_vector float_vector)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'image_vector'=>['type'=>'float_vector']
]);

utilsApi.sql('CREATE TABLE products(title text, image_vector float_vector)')

await utilsApi.sql('CREATE TABLE products(title text, image_vector float_vector)')

res = await utilsApi.sql('CREATE TABLE products(title text, image_vector float_vector)');

utilsApi.sql("CREATE TABLE products(title text, image_vector float_vector)");

utilsApi.Sql("CREATE TABLE products(title text, image_vector float_vector)");

utils_api.sql("CREATE TABLE products(title text, image_vector float_vector)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_float_vector = image_vector
}

float_vector_array 属性为每个文档存储多个向量，而不是单个向量。其值写成向量数组，每个文档都有自己的向量数量：

[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]

这适合那些不能简单归结为单个 embedding 的文档 - 例如被拆成多个片段的长文章、从多个角度拍摄的产品、按关键帧采样的视频。与其为每个片段单独存一行再在之后去重结果，不如把文档的所有向量都保存在文档本身上。

当该属性为 KNN 配置后，所有文档的所有向量会一起建立索引；如果其中任何一个向量与查询足够接近，就算该文档匹配。搜索语义请参见每个文档多个向量。

值始终是一个向量数组：[[1,2],[3,4]]。像 (1,2,3,4) 这样的扁平列表会被拒绝，因为无法区分这是一个 4 维向量，还是两个 2 维向量。
[] 表示“没有向量”。这是一个合法的已存储值，也是省略该属性时的默认值。
同一个值中的所有向量必须具有相同的维度。
空的内层向量（[[]]）无法表示，因此会被拒绝。表示“无”请使用 []。
返回的值会保持与插入时相同的嵌套形式。

目前仅支持实时表（不支持普通表）
不支持在函数或表达式中使用
不能用于常规过滤或排序
自动嵌入可用：多向量分块策略（fixed、recursive、sentence）会为每个分块填入一个向量，而单向量策略（truncate、mean）会存储一个 1 元素数组 - 参见分块策略。目前还不支持通过 ALTER TABLE ... ADD COLUMN 添加一个由模型驱动的 float_vector_array，也不支持对其执行 ALTER TABLE ... REBUILD EMBEDDINGS；请在建表时直接声明该列。
与自动模式机制不兼容

参数与 float_vector 所使用的相同：KNN_TYPE、KNN_DIMS、HNSW_SIMILARITY，以及可选的 HNSW_M、HNSW_EF_CONSTRUCTION 和量化，但有两个区别：

KNN_DIMS 是必需的，并且 每一行 中的每个向量都必须恰好包含这么多维。插入时，如果某一行的向量宽度不同，该行会被拒绝。
MODEL_NAME 和 FROM 都可接受，并且支持自动填充数组的多向量 CHUNK_STRATEGY。参见分块策略。

你可以做的：

运行 KNN 搜索，让文档按其最近的向量进行匹配
为每个文档存储不同数量的向量，包括一个都不存

你不能做的：

对该属性执行 UPDATE：请像对带 KNN 索引的 float_vector 一样，使用 REPLACE
在常规过滤或排序中使用这些值

值为 [] 的文档，或省略了该属性的文档，不会被 KNN 搜索返回，因为它并不接近任何内容。

如果不配置 KNN，向量仍会被存储，但不可搜索，而且该列完全不需要任何选项。在这种模式下，每个值都能自我描述，因此不同的行可以保存不同宽度的向量：

CREATE TABLE products(title text, chunk_vectors float_vector_array);
INSERT INTO products VALUES (1, 'a', [[1,2]]), (2, 'b', [[1,2,3],[4,5,6]]);

在这种模式下，UPDATE 可以正常工作，就像对不带 KNN 的 float_vector 一样，[] 会清空该值。

创建一个带 KNN 索引的浮点向量数组、填充数据并进行搜索：

‹›

SQL
JSON

📋

CREATE TABLE articles(title text, chunk_vectors float_vector_array knn_type='hnsw' knn_dims='4' hnsw_similarity='l2');
INSERT INTO articles VALUES
  (1, 'first',  [[1,0,0,0],[0,1,0,0]]),
  (2, 'second', [[0,0,1,0]]),
  (3, 'no vectors yet', []);
SELECT id, knn_dist() FROM articles WHERE knn(chunk_vectors, 5, (1,0,0,0));

多值属性允许存储可变长度的32位无符号整数列表。这在存储一对多的数值时非常有用，例如标签、产品类别和属性。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, product_codes multi);

或

CREATE TABLE products(title text, product_codes mva);

POST /cli -d "CREATE TABLE products(title text, product_codes multi)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'product_codes'=>['type'=>'multi']
]);

utilsApi.sql('CREATE TABLE products(title text, product_codes multi)')

await utilsApi.sql('CREATE TABLE products(title text, product_codes multi)')

res = await utilsApi.sql('CREATE TABLE products(title text, product_codes multi)');

utilsApi.sql("CREATE TABLE products(title text, product_codes multi)");

utilsApi.Sql("CREATE TABLE products(title text, product_codes multi)");

utils_api.sql("CREATE TABLE products(title text, product_codes multi)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_multi = product_codes
}

它支持过滤和聚合，但不支持排序。过滤可以通过至少一个元素通过（使用 ANY()）或所有元素 (ALL()) 来完成。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from products where any(product_codes)=3

POST /search
{
  "table": "products",
  "query":
  {
    "match_all": {},
    "equals" : { "any(product_codes)": 3 }
  }
}

$table->setName('products')->search('')->filter('any(product_codes)','equals',3)->get();

searchApi.search({"table":"products","query":{"match_all":{},"equals":{"any(product_codes)":3}}}})

await searchApi.search({"table":"products","query":{"match_all":{},"equals":{"any(product_codes)":3}}}})

res = await searchApi.search({"table":"products","query":{"match_all":{},"equals":{"any(product_codes)":3}}}})'

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
query.put("equals",new HashMap<String,Integer>(){{
     put("any(product_codes)",3);
}});
searchRequest.setQuery(query);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.AttrFilter = new EqualsFilter("any(product_codes)", 3);
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

可以提取诸如最小或最大元素以及列表长度等信息。以下示例展示了如何按多值属性的最小元素进行排序。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select least(product_codes) l from products order by l asc

POST /search
{
  "table": "products",
  "query":
  {
    "match_all": {},
    "sort": [ { "product_codes":{ "order":"asc", "mode":"min" } } ]
  }
}

$table->setName('products')->search('')->sort('product_codes','asc','min')->get();

searchApi.search({"table":"products","query":{"match_all":{},"sort":[{"product_codes":{"order":"asc","mode":"min"}}]}})

await searchApi.search({"table":"products","query":{"match_all":{},"sort":[{"product_codes":{"order":"asc","mode":"min"}}]}})

res = await searchApi.search({"table":"products","query":{"match_all":{},"sort":[{"product_codes":{"order":"asc","mode":"min"}}]}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
searchRequest.setSort(new ArrayList<Object>(){{
    add(new HashMap<String,String>(){{ put("product_codes",new HashMap<String,String>(){{ put("order","asc");put("mode","min");}});}});
}});
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Sort = new List<Object> {
    new SortMVA("product_codes", SortOrder.OrderEnum.Asc, SortMVA.ModeEnum.Min)
};
searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut sort_opts = HashMap::new();
sort_opts.insert("order".to_string(), serde_json::json!("asc"));
sort_opts.insert("mode".to_string(), serde_json::json!("min"));
sort_expr.insert("product_codes".to_string(), serde_json::json!(sort_opts));
let sort: [HashMap; 1] = [sort_expr];
let search_req = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(sort),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

当按多值属性分组时，一个文档将贡献给与该文档关联的不同值数量相同的多个组。例如，如果一个集合恰好包含一个文档，其'product_codes'多值属性的值为5、7和11，那么按'product_codes'分组将产生3个组，COUNT(*)等于1，GROUPBY()键值分别为5、7和11。另外请注意，按多值属性分组可能导致结果集中出现重复文档，因为每个文档可以参与多个组。

‹›

SQL

📋

insert into products values ( 1, 'doc one', (5,7,11) );
select id, count(*), groupby() from products group by product_codes;

‹›

Response

Query OK, 1 row affected (0.00 sec)
+------+----------+-----------+
| id   | count(*) | groupby() |
+------+----------+-----------+
|    1 |        1 |        11 |
|    1 |        1 |         7 |
|    1 |        1 |         5 |
+------+----------+-----------+
3 rows in set (0.00 sec)

作为多值属性值插入的数字顺序不会被保留。值在内部以排序集合的形式存储。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

insert into product values (1,'first',(4,2,1,3));
select * from products;

POST /insert
{
    "table":"products",
    "id":1,
    "doc":
    {
        "title":"first",
        "product_codes":[4,2,1,3]
    }
}
POST /search
{
  "table": "products",
  "query": { "match_all": {} }
}

$table->addDocument([
    "title"=>"first",
    "product_codes"=>[4,2,1,3]
]);
$table->search('')-get();

indexApi.insert({"table":"products","id":1,"doc":{"title":"first","product_codes":[4,2,1,3]}})
searchApi.search({"table":"products","query":{"match_all":{}}})

await indexApi.insert({"table":"products","id":1,"doc":{"title":"first","product_codes":[4,2,1,3]}})
await searchApi.search({"table":"products","query":{"match_all":{}}})

await indexApi.insert({"table":"products","id":1,"doc":{"title":"first","product_codes":[4,2,1,3]}});
res = await searchApi.search({"table":"products","query":{"match_all":{}}});

InsertDocumentRequest newdoc = new InsertDocumentRequest();
HashMap<String,Object> doc = new HashMap<String,Object>(){{
    put("title","first");
    put("product_codes",new int[] {4,2,1,3});
}};
newdoc.table("products").id(1L).setDoc(doc);
sqlresult = indexApi.insert(newdoc);
Map<String,Object> query = new HashMap<String,Object>();
query.put("match_all",null);
SearchRequest searchRequest = new SearchRequest();
searchRequest.setTable("products");
searchRequest.setQuery(query);
SearchResponse searchResponse = searchApi.search(searchRequest);
System.out.println(searchResponse.toString() );

Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("title", "first");
doc.Add("product_codes", new List<Object> {4,2,1,3});
InsertDocumentRequest newdoc = new InsertDocumentRequest(table: "products", id: 1, doc: doc);
var sqlresult = indexApi.Insert(newdoc);
object query =  new { match_all=null };
var searchRequest = new SearchRequest("products", query);
var searchResponse = searchApi.Search(searchRequest);
Console.WriteLine(searchResponse.ToString())

let mut doc = HashMap::new();
doc.insert("title".to_string(), serde_json::json!("first"));
doc.insert("product_codes".to_string(), serde_json::json!([4,2,1,3]));
let insert_req = InsertDocumentRequest::new("products".to_string(), serde_json::json!(doc));
let insert_res = index_api.insert(insert_req).await;
let query = SearchQuery::new();
let search_req = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;
println!("{:?}", search_res);

‹›

Response

Query OK, 1 row affected (0.00 sec)
+------+---------------+-------+
| id   | product_codes | title |
+------+---------------+-------+
|    1 | 1,2,3,4       | first |
+------+---------------+-------+
1 row in set (0.01 sec)

{
   "table":"products",
   "id":1,
   "created":true,
   "result":"created",
   "status":201
}
{
   "took":0,
   "timed_out":false,
   "hits":{
      "total":1,
      "hits":[
         {
            "_id": 1,
            "_score":1,
            "_source":{
               "product_codes":[
                  1,
                  2,
                  3,
                  4
               ],
               "title":"first"
            }
         }
      ]
   }
}

Array
(
    [_index] => products
    [_id] => 1
    [created] => 1
    [result] => created
    [status] => 201
)
Array
(
    [took] => 0
    [timed_out] =>
    [hits] => Array
        (
            [total] => 1
            [hits] => Array
                (
                    [0] => Array
                        (
                            [_id] => 1
                            [_score] => 1
                            [_source] => Array
                                (
                                    [product_codes] => Array
                                        (
                                            [0] => 1
                                            [1] => 2
                                            [2] => 3
                                            [3] => 4
                                        )
                                    [title] => first
                                )
                        )
                )
        )
)

{'created': True,
 'found': None,
 'id': 1,
 'table': 'products',
 'result': 'created'}
{'hits': {'hits': [{u'_id': u'1',
                    u'_score': 1,
                    u'_source': {u'product_codes': [1, 2, 3, 4],
                                 u'title': u'first'}}],
          'total': 1},
 'profile': None,
 'timed_out': False,
 'took': 29}

{'created': True,
 'found': None,
 'id': 1,
 'table': 'products',
 'result': 'created'}
{'hits': {'hits': [{u'_id': u'1',
                    u'_score': 1,
                    u'_source': {u'product_codes': [1, 2, 3, 4],
                                 u'title': u'first'}}],
          'total': 1},
 'profile': None,
 'timed_out': False,
 'took': 29}

{"took":0,"timed_out":false,"hits":{"total":1,"hits":[{"_id": 1,"_score":1,"_source":{"product_codes":[1,2,3,4],"title":"first"}}]}}

class SearchResponse {
    took: 0
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=1, _score=1, _source={product_codes=[1, 2, 3, 4], title=first}}]
        aggregations: null
    }
    profile: null
}

class SearchResponse {
    took: 0
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=1, _score=1, _source={product_codes=[1, 2, 3, 4], title=first}}]
        aggregations: null
    }
    profile: null
}

class SearchResponse {
    took: 0
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=1, _score=1, _source={product_codes=[1, 2, 3, 4], title=first}}]
        aggregations: null
    }
    profile: null
}

一种允许存储可变长度64位有符号整数列表的数据类型。其功能与多值整数相同。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, values multi64);

或

CREATE TABLE products(title text, values mva64);

POST /cli -d "CREATE TABLE products(title text, values multi64)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'values'=>['type'=>'multi64']
]);

utilsApi.sql('CREATE TABLE products(title text, values multi64))')

await utilsApi.sql('CREATE TABLE products(title text, values multi64))')

res = await utilsApi.sql('CREATE TABLE products(title text, values multi64))');

utilsApi.sql("CREATE TABLE products(title text, values multi64))");

utilsApi.Sql("CREATE TABLE products(title text, values multi64))");

utils_api.sql("CREATE TABLE products(title text, values multi64))", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_multi_64 = values
}

当使用列式存储时，可以为属性指定以下特性。

默认情况下，Manticore 列式存储以列式方式存储所有属性，同时也在特殊的文档存储中按行存储。这使得像 SELECT * FROM ... 这样的查询能够快速执行，尤其是在一次获取大量记录时。但是，如果您确定不需要此功能或希望节省磁盘空间，可以在创建表时通过指定 fast_fetch='0' 来禁用它，或者（如果您在配置中定义表）使用 columnar_no_fast_fetch，如下例所示。

‹›

RT mode
Plain mode

📋

create table t(a int, b int fast_fetch='0') engine='columnar'; desc t;

‹›

Response

+-------+--------+---------------------+
| Field | Type   | Properties          |
+-------+--------+---------------------+
| id    | bigint | columnar fast_fetch |
| a     | uint   | columnar fast_fetch |
| b     | uint   | columnar            |
+-------+--------+---------------------+
3 rows in set (0.00 sec)

Last modified: September 23, 2026

Manticore 的数据类型可以分为两类：全文字段和属性。

其他用户定义的 SQL 对象名，包括函数名、插件名和复制集群名，也遵循相同的安全 UTF-8 规则。

例如：

有效的未加引号名称：title、product_id、user_name_2、товары2026、商品表、📦метка
有效的带引号名称：`2026_архив`、`select`
有效的 SQL 兼容列名：@timestamp、@version
无效名称：未加反引号的 2title、-price、user@name、user-name、@user_field，以及包含零宽空格的 badname

全文字段：

可以使用自然语言处理算法进行索引，因此可以搜索关键词
不能用于排序或分组
可以检索原始文档内容
原始文档内容可用于高亮显示

全文字段由数据类型 text 表示。所有其他数据类型都称为“属性”。

属性是与每个文档关联的非全文值，可用于在搜索期间执行非全文过滤、排序和分组。

与全文字段不同，属性不进行全文索引。它们存储在表中，但无法像全文那样进行搜索。

‹›

SQL
JSON
PHP
Python
Python-asyncio
Javascript
Java
C#
Rust
config

📋

CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp);

POST /cli -d "CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)"

$table = new \Manticoresearch\Table($client);
$table->setName('forum');
$table->create([
    'title'=>['type'=>'text'],
    'content'=>['type'=>'text'],
    'author_id'=>['type'=>'int'],
    'forum_id'=>['type'=>'int'],
    'post_date'=>['type'=>'timestamp']
]);

utilsApi.sql('CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)')

await utilsApi.sql('CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)')

res = await utilsApi.sql('CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)');

utilsApi.sql("CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)");

utilsApi.Sql("CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)");

utils_api.sql("CREATE TABLE forum(title text, content text, author_id int, forum_id int, post_date timestamp)", Some(true)).await;

table forum
{
    type = rt
    path = forum
    # when configuring fields via config, they are indexed (and not stored) by default
    rt_field = title
    rt_field = content
    # this option needs to be specified for the field to be stored
    stored_fields = title, content
    rt_attr_uint = author_id
    rt_attr_uint = forum_id
    rt_attr_timestamp = post_date
}

此示例展示了按 author_id、forum_id 过滤并按 post_date 排序的全文查询。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from forum where author_id=123 and forum_id in (1,3,7) order by post_date desc

POST /search
{
  "table": "forum",
  "query":
  {
    "match_all": {},
    "bool":
    {
      "must":
      [
        { "equals": { "author_id": 123 } },
        { "in": { "forum_id": [1,3,7] } }
      ]
    }
  },
  "sort": [ { "post_date": "desc" } ]
}

$client->search([
        'table' => 'forum',
        'query' =>
        [
            'match_all' => [],
            'bool' => [
                'must' => [
                    'equals' => ['author_id' => 123],
                    'in' => [
                        'forum_id' => [
                            1,3,7
                        ]
                    ]
                ]
            ]
        ],
        'sort' => [
        ['post_date' => 'desc']
    ]
]);

searchApi.search({"table":"forum","query":{"match_all":{},"bool":{"must":[{"equals":{"author_id":123}},{"in":{"forum_id":[1,3,7]}}]}},"sort":[{"post_date":"desc"}]})

await searchApi.search({"table":"forum","query":{"match_all":{},"bool":{"must":[{"equals":{"author_id":123}},{"in":{"forum_id":[1,3,7]}}]}},"sort":[{"post_date":"desc"}]})

res = await searchApi.search({"table":"forum","query":{"match_all":{},"bool":{"must":[{"equals":{"author_id":123}},{"in":{"forum_id":[1,3,7]}}]}},"sort":[{"post_date":"desc"}]});

HashMap<String,Object> filters = new HashMap<String,Object>(){{
    put("must", new HashMap<String,Object>(){{
        put("equals",new HashMap<String,Integer>(){{
            put("author_id",123);
        }});
        put("in",
            new HashMap<String,Object>(){{
                put("forum_id",new int[] {1,3,7});
        }});
    }});
}};
Map<String,Object> query = new HashMap<String,Object>();
query.put("match_all",null);
query.put("bool",filters);
SearchRequest searchRequest = new SearchRequest();
searchRequest.setTable("forum");
searchRequest.setQuery(query);
searchRequest.setSort(new ArrayList<Object>(){{
    add(new HashMap<String,String>(){{ put("post_date","desc");}});
}});
SearchResponse searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
var boolFilter = new BoolFilter();
boolFilter.Must = new List<Object> {
    new EqualsFilter("author_id", 123),
    new InFilter("forum_id", new List<Object> {1,3,7})
};
searchRequest.AttrFilter = boolFilter;
searchRequest.Sort = new List<Object> { new SortOrder("post_date", SortOrder.OrderEnum.Desc) };
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut sort = HashMap::new();
sort.insert("post_date".to_string(), serde_json::json!("desc"));
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(sort)
    ..Default::default()
};
let search_res = search_api.search(search_req).await;

Manticore 支持两种类型的属性存储：

行式 - Manticore Search 开箱即用的传统存储
列式 - 由 Manticore 列式库提供

从它们的名称可以理解，它们以不同的方式存储数据。传统的 行式存储：

以未压缩的方式存储属性
同一文档的所有属性存储在彼此靠近的一行中
行按顺序存储
访问属性基本上是通过将行 ID 乘以步幅（单个向量的长度）并从计算出的内存位置获取请求的属性来实现。这提供了非常低的随机访问延迟。
属性必须位于内存中才能获得可接受的性能，否则由于存储的行式特性，Manticore 可能不得不从磁盘读取太多不需要的数据，这在许多情况下是次优的。

使用 列式存储：

每个属性都独立于所有其他属性存储在其单独的“列”中
存储被分成 65536 个条目的块
块以压缩形式存储。这通常允许仅存储几个不同的值，而不是像行式存储那样存储所有值。高压缩比允许更快地从磁盘读取，并大大降低内存需求
当数据被索引时，每个块独立选择存储方案。例如，如果一个块中的所有值都相同，则采用“常量”存储，整个块只存储一个值。如果每个块的唯一值少于 256 个，则采用“表”存储，存储值表的索引而不是值本身
如果明确请求的值不在块中，可以提前拒绝在块中的搜索。

列式存储旨在处理无法放入 RAM 的大数据量，因此建议如下：

如果您有足够的内存容纳所有属性，您将从行式存储中受益
否则，列式存储仍然可以为您提供不错的性能，同时内存占用低得多，这将允许您在表中存储更多的文档

传统的行式存储是默认方式，因此如果您希望所有内容都以行式存储，创建表时无需进行任何操作。

要启用列式存储，您需要：

在 CREATE TABLE 中指定 engine='columnar'，使表的所有属性变为列式。然后，如果您希望保留特定属性为行式，需要在声明该属性时添加 engine='rowwise'。例如：
```
create table tbl(title text, type int, price float engine='rowwise') engine='columnar'
```

在 CREATE TABLE 中为特定属性指定 engine='columnar'，使其变为列式。例如：

create table tbl(title text, type int, price float engine='columnar');

或

create table tbl(title text, type int, price float engine='columnar') engine='rowwise';

在 plain 模式下，您需要在 columnar_attrs 中列出希望为列式的属性。

以下是 Manticore Search 支持的数据类型列表：

mysql> CREATE TABLE tbl(id bigint, content text);
DESC tbl;
+---------+--------+----------------+
| Field   | Type   | Properties     |
+---------+--------+----------------+
| id      | bigint |                |
| content | text   | indexed stored |
+---------+--------+----------------+
2 rows in set (0.00 sec)

您也可以完全省略指定 ID，它将自动启用。

mysql> CREATE TABLE tbl(content text);
DESC tbl;
+---------+--------+----------------+
| Field   | Type   | Properties     |
+---------+--------+----------------+
| id      | bigint |                |
| content | text   | indexed stored |
+---------+--------+----------------+
2 rows in set (0.00 sec)

在处理数字文档 ID 时，需要注意无符号 64 位值会根据接口的不同而以不同方式处理：

MySQL/SQL 接口：

大于 2^63-1 的 ID 将显示为负数。
过滤此类大 ID 时，必须使用其有符号表示。
这种有符号表示只用于显示或过滤已有的大 ID；在插入或索引文档时，不接受负数 ID。
使用 UINT64() 函数查看实际的无符号值。

JSON/HTTP 接口：

ID 始终以其原始无符号值显示，无论大小。
有符号和无符号两种表示都可用于过滤已有的大 ID。
Insert 操作接受完整的无符号 64 位范围，但负数 id 值会被拒绝。

例如，让我们创建一个表并插入一些接近 2^63 的值：

mysql> create table t(id_text string);
Query OK, 0 rows affected (0.01 sec)
mysql> insert into t values(9223372036854775807, '2 ^ 63 - 1'),(9223372036854775808, '2 ^ 63');
Query OK, 2 rows affected (0.00 sec)

一些 ID 在结果中显示为负数，因为它们超过了 2^63-1。然而，使用 UINT64(id) 可以揭示它们的实际无符号值：

mysql> select *, uint64(id) from t;
+----------------------+------------+---------------------+
| id                   | id_text    | uint64(id)          |
+----------------------+------------+---------------------+
|  9223372036854775807 | 2 ^ 63 - 1 | 9223372036854775807 |
| -9223372036854775808 | 2 ^ 63     | 9223372036854775808 |
+----------------------+------------+---------------------+
2 rows in set (0.00 sec)
--- 2 out of 2 results in 0ms ---

对于查询 ID 小于 2^63 的文档，可以直接使用无符号值：

mysql> select * from t where id = 9223372036854775807;
+---------------------+------------+
| id                  | id_text    |
+---------------------+------------+
| 9223372036854775807 | 2 ^ 63 - 1 |
+---------------------+------------+
1 row in set (0.00 sec)
--- 1 out of 1 results in 0ms ---

但是，对于从 2^63 开始的 ID，需要使用有符号值：

mysql> select * from t where id = -9223372036854775808;
+----------------------+---------+
| id                   | id_text |
+----------------------+---------+
| -9223372036854775808 | 2 ^ 63  |
+----------------------+---------+
1 row in set (0.00 sec)
--- 1 out of 1 results in 0ms ---

如果使用无符号值，将会出错：

mysql> select * from t where id = 9223372036854775808;
ERROR 1064 (42000): number 9223372036854775808 is out of range [-9223372036854775808..9223372036854775807]

超出 64 位范围的值将触发类似错误：

mysql> select * from t where id = -9223372036854775809;
ERROR 1064 (42000): number -9223372036854775809 is out of range [-9223372036854775808..9223372036854775807]

MySQL/SQL 和 JSON/HTTP 接口之间的行为差异在处理非常大的文档 ID 时变得更加明显。以下是一个全面的示例：

MySQL/SQL 接口：

mysql> drop table if exists t; create table t; insert into t values(17581446260360033510);
Query OK, 0 rows affected (0.01 sec)
mysql> select * from t;
+---------------------+
| id                  |
+---------------------+
| -865297813349518106 |
+---------------------+
mysql> select *, uint64(id) from t;
+---------------------+----------------------+
| id                  | uint64(id)           |
+---------------------+----------------------+
| -865297813349518106 | 17581446260360033510 |
+---------------------+----------------------+
mysql> select * from t where id = -865297813349518106;
+---------------------+
| id                  |
+---------------------+
| -865297813349518106 |
+---------------------+
mysql> select * from t where id = 17581446260360033510;
ERROR 1064 (42000): number 17581446260360033510 is out of range [-9223372036854775808..9223372036854775807]

JSON/HTTP 接口：

# Search returns the original unsigned value
curl -s 0:9308/search -d '{"table": "t"}'
{
  "took": 0,
  "timed_out": false,
  "hits": {
    "total": 1,
    "total_relation": "eq",
    "hits": [
      {
        "_id": 17581446260360033510,
        "_score": 1,
        "_source": {}
      }
    ]
  }
}
# Both signed and unsigned values work for filtering the same stored ID
curl -s 0:9308/search -d '{"table": "t", "query": {"equals": {"id": 17581446260360033510}}}'
curl -s 0:9308/search -d '{"table": "t", "query": {"equals": {"id": -865297813349518106}}}'
# Insert with maximum unsigned 64-bit value
curl -s 0:9308/insert -d '{"table": "t", "id": 18446744073709551615, "doc": {}}'

这意味着在处理大文档 ID 时：

MySQL 接口 要求查询时使用有符号表示，但可以通过 UINT64() 显示无符号值
JSON 接口 始终使用无符号值显示，并接受两种表示进行过滤

SQL 会将 UUID ID 作为字符串返回。对于 UUID-ID 表，原生 JSON 写入响应使用键名 id，而 JSON 搜索和 Elasticsearch 兼容响应使用 _id。

限制：

只有 id 列可以使用 uuid 类型；普通属性不能声明为 uuid。
UUID 文档 ID 仅支持实时表，包括列式实时表和复制实时表。不支持普通表（由 indexer 创建）、percolate/PQ 表或 shard 表。
ALTER TABLE 不能将现有表转换为或转换自 id uuid。
不支持对 UUID id 使用范围过滤器（<、<=、>、>=）以及数值或算术表达式。
与数值 ID 表不同，UUID-ID 表不会把 0 视为自动 ID 标记。

‹›

SQL

📋

CREATE TABLE products_uuid(id uuid, title text, price int);
INSERT INTO products_uuid(id, title, price) VALUES('550e8400-e29b-41d4-a716-446655440000', 'Crossbody Bag', 19);
INSERT INTO products_uuid(title, price) VALUES('Generated UUID Bag', 29);
SELECT id, price FROM products_uuid WHERE id='550e8400-e29b-41d4-a716-446655440000';

‹›

Response

Query OK, 0 rows affected (0.00 sec)
Query OK, 1 rows affected (0.00 sec)
Query OK, 1 rows affected (0.00 sec)
+--------------------------------------+-------+
| id                                   | price |
+--------------------------------------+-------+
| 550e8400-e29b-41d4-a716-446655440000 |    19 |
+--------------------------------------+-------+
1 row in set (0.00 sec)

通用语法：

string|text [stored|attribute] [indexed]

属性：

indexed - 全文索引（可用于全文查询）
stored - 存储在文档存储中（存储在磁盘上，而非 RAM 中，惰性读取）
attribute - 使其成为字符串属性（可以按其排序/分组）

指定至少一个属性会覆盖所有默认属性（见下文），即，如果您决定使用自定义属性组合，需要列出所有您想要的属性。

未指定任何属性：

string 和 text 是别名，但如果您不指定任何属性，它们默认表示不同的含义：

仅 string 默认表示 attribute（详见下文）。
仅 text 默认表示 stored + indexed（详见下文）。

文本（仅 text 或 text/string indexed）数据类型构成表的全文部分。文本字段被索引，可以用于搜索关键词。

文本通过分析器管道处理，将文本转换为单词，应用词形变换等。最终，从该文本构建出全文表（一种特殊的数据结构，能够快速搜索关键词）。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text);

POST /cli -d "CREATE TABLE products(title text)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text']
]);

utilsApi.sql('CREATE TABLE products(title text)')

await utilsApi.sql('CREATE TABLE products(title text)')

res = await utilsApi.sql('CREATE TABLE products(title text)');

utilsApi.sql("CREATE TABLE products(title text)");

utilsApi.Sql("CREATE TABLE products(title text)");

utils_api.sql("CREATE TABLE products(title text)", Some(true)).await;

table products
{
    type = rt
    path = products
    # when configuring fields via config, they are indexed (and not stored) by default
    rt_field = title
    # this option needs to be specified for the field to be stored
    stored_fields = title
}

此行为可以通过显式指定文本仅被索引来覆盖。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text indexed);

POST /cli -d "CREATE TABLE products(title text indexed)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text','options'=>['indexed']]
]);

utilsApi.sql('CREATE TABLE products(title text indexed)')

await utilsApi.sql('CREATE TABLE products(title text indexed)')

res = await utilsApi.sql('CREATE TABLE products(title text indexed)');

utilsApi.sql("CREATE TABLE products(title text indexed)");

utilsApi.Sql("CREATE TABLE products(title text indexed)");

utils_api.sql("CREATE TABLE products(title text indexed)", Some(true)).await;

table products
{
    type = rt
    path = products
    # when configuring fields via config, they are indexed (and not stored) by default
    rt_field = title
}

字段是有名称的，您可以将搜索限制在单个字段（例如仅搜索"title"）或字段子集（例如仅"title"和"abstract"）。您最多可以拥有256个全文字段。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from products where match('@title first');

POST /search
{
    "table": "products",
    "query":
    {
        "match": { "title": "first" }
    }
}

$table->setName('products')->search('@title')->get();

searchApi.search({"table":"products","query":{"match":{"title":"first"}}})

await searchApi.search({"table":"products","query":{"match":{"title":"first"}}})

res = await searchApi.search({"table":"products","query":{"match":{"title":"first"}}});

utilsApi.sql("CREATE TABLE products(title text indexed)");

utilsApi.Sql("CREATE TABLE products(title text indexed)");

utils_api.sql("CREATE TABLE products(title text indexed)", Some(true)).await;

如果您还想索引字符串属性，可以同时指定为string attribute indexed。这将允许全文搜索并作为属性使用。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, keys string);

POST /cli -d "CREATE TABLE products(title text, keys string)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'keys'=>['type'=>'string']
]);

utilsApi.sql('CREATE TABLE products(title text, keys string)')

await utilsApi.sql('CREATE TABLE products(title text, keys string)')

res = await utilsApi.sql('CREATE TABLE products(title text, keys string)');

utilsApi.sql("CREATE TABLE products(title text, keys string)");

utilsApi.Sql("CREATE TABLE products(title text, keys string)");

utils_api.sql("CREATE TABLE products(title text, keys string)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_string = keys
}

这是一个示例，我们使用base64编码ls命令，将其存储在Manticore中，然后解码以验证MD5校验和保持不变：

‹›

Example

Example

📋

# md5sum /bin/ls
43d1b8a7ccda411118e2caba685f4329  /bin/ls
# encoded_data=`base64 -i /bin/ls `
# mysql -P9306 -h0 -e "drop table if exists test; create table test(data text stored); insert into test(data) values('$encoded_data')"
# mysql -P9306 -h0 -NB -e "select data from test" | base64 -d > /tmp/ls | md5sum
43d1b8a7ccda411118e2caba685f4329  -

整数类型允许存储32位无符号整数值。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, price int);

POST /cli -d "CREATE TABLE products(title text, price int)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'price'=>['type'=>'int']
]);

utilsApi.sql('CREATE TABLE products(title text, price int)')

await utilsApi.sql('CREATE TABLE products(title text, price int)')

res = await utilsApi.sql('CREATE TABLE products(title text, price int)');

utilsApi.sql("CREATE TABLE products(title text, price int)");

utilsApi.Sql("CREATE TABLE products(title text, price int)");

utils_api.sql("CREATE TABLE products(title text, price int)", Some(true)).await;

table products
{
    type = rt
    path = products

    rt_field = title
    stored_fields = title

    rt_attr_uint = type
}

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, flags bit(3), tags bit(2) );

POST /cli -d "CREATE TABLE products(title text, flags bit(3), tags bit(2))"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'flags'=>['type'=>'bit(3)'],
    'tags'=>['type'=>'bit(2)']
]);

utilsApi.sql('CREATE TABLE products(title text, flags bit(3), tags bit(2) ')

await utilsApi.sql('CREATE TABLE products(title text, flags bit(3), tags bit(2) ')

res = await utilsApi.sql('CREATE TABLE products(title text, flags bit(3), tags bit(2) ');

utilsApi.sql("CREATE TABLE products(title text, flags bit(3), tags bit(2)");

utilsApi.Sql("CREATE TABLE products(title text, flags bit(3), tags bit(2)");

utils_api.sql("CREATE TABLE products(title text, flags bit(3), tags bit(2)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_uint = flags:3
    rt_attr_uint = tags:2
}

大整数（bigint）是64位宽的有符号整数。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, price bigint );

POST /cli -d "CREATE TABLE products(title text, price bigint)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'price'=>['type'=>'bigint']
]);

utilsApi.sql('CREATE TABLE products(title text, price bigint )')

await utilsApi.sql('CREATE TABLE products(title text, price bigint )')

res = await utilsApi.sql('CREATE TABLE products(title text, price bigint )');

utilsApi.sql("CREATE TABLE products(title text, price bigint )");

utilsApi.Sql("CREATE TABLE products(title text, price bigint )");

utils_api.sql("CREATE TABLE products(title text, price bigint )", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_bigint = type
}

声明一个布尔属性。等同于位数为1的整数属性。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, sold bool );

POST /cli -d "CREATE TABLE products(title text, sold bool)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'sold'=>['type'=>'bool']
]);

utilsApi.sql('CREATE TABLE products(title text, sold bool )')

await utilsApi.sql('CREATE TABLE products(title text, sold bool )')

res = await utilsApi.sql('CREATE TABLE products(title text, sold bool )');

utilsApi.sql("CREATE TABLE products(title text, sold bool )");

utilsApi.Sql("CREATE TABLE products(title text, sold bool )");

utils_api.sql("CREATE TABLE products(title text, sold bool )", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_bool = sold
}

时间戳类型表示Unix时间戳，以32位整数存储。与基本整数不同，时间戳类型允许使用时间和日期函数。从字符串值转换遵循以下规则：

不带分隔符的数字，且长度至少为10个字符，按原样转换为时间戳。
%Y-%m-%dT%H:%M:%E*S%Z
%Y-%m-%d'T'%H:%M:%S%Z
%Y-%m-%dT%H:%M:%E*S
%Y-%m-%dT%H:%M:%s
%Y-%m-%dT%H:%M
%Y-%m-%dT%H
%Y-%m-%d
%Y-%m
%Y

这些转换格式的含义详见strptime手册，除%E*S表示毫秒外。

注意，纯表中不支持时间戳的自动转换。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, date timestamp);

POST /cli -d "CREATE TABLE products(title text, date timestamp)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'date'=>['type'=>'timestamp']
]);

utilsApi.sql('CREATE TABLE products(title text, date timestamp)')

await utilsApi.sql('CREATE TABLE products(title text, date timestamp)')

res = await utilsApi.sql('CREATE TABLE products(title text, date timestamp)');

utilsApi.sql("CREATE TABLE products(title text, date timestamp)");

utilsApi.Sql("CREATE TABLE products(title text, date timestamp)");

utils_api.sql("CREATE TABLE products(title text, date timestamp)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_timestamp = date
}

实数存储为32位IEEE 754单精度浮点数。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, coeff float);

POST /cli -d "CREATE TABLE products(title text, coeff float)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'coeff'=>['type'=>'float']
]);

utilsApi.sql('CREATE TABLE products(title text, coeff float)')

await utilsApi.sql('CREATE TABLE products(title text, coeff float)')

res = await utilsApi.sql('CREATE TABLE products(title text, coeff float)');

utilsApi.sql("CREATE TABLE products(title text, coeff float)");

utilsApi.Sql("CREATE TABLE products(title text, coeff float)");

utils_api.sql("CREATE TABLE products(title text, coeff float)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_float = coeff
}

与整数类型不同，不建议直接比较两个浮点数是否相等，因为可能存在舍入误差。更可靠的做法是使用近似比较，通过检查绝对误差范围。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select abs(a-b)<=0.00001 from products

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "expressions": { "eps": "abs(a-b)" }
}

$table->setName('products')->search('')->expression('eps','abs(a-b)')->get();

searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"eps":"abs(a-b)"}})

await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"eps":"abs(a-b)"}})

res = await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"eps":"abs(a-b)"}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("ebs","abs(a-b)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Expressions = new List<Object>{
    new Dictionary<string, string> { {"ebs", "abs(a-b)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("ebs".to_string(), serde_json::json!("abs(a-b)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select in(ceil(attr*100),200,250,350) from products

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "expressions": { "inc": "in(ceil(attr*100),200,250,350)" }
}

$table->setName('products')->search('')->expression('inc','in(ceil(attr*100),200,250,350)')->get();

searchApi.search({"table":"products","query":{"match_all":{}}},"expressions":{"inc":"in(ceil(attr*100),200,250,350)"}})

await searchApi.search({"table":"products","query":{"match_all":{}}},"expressions":{"inc":"in(ceil(attr*100),200,250,350)"}})

res = await searchApi.search({"table":"products","query":{"match_all":{}}},"expressions":{"inc":"in(ceil(attr*100),200,250,350)"}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("inc","in(ceil(attr*100),200,250,350)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Expressions = new List<Object> {
    new Dictionary<string, string> { {"ebs", "in(ceil(attr*100),200,250,350)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("ebs".to_string(), serde_json::json!("in(ceil(attr*100),200,250,350)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

现在，Manticore首先输出一个带有6位数字的数字，然后解析并将其与原始值进行比较。如果不匹配，则会添加更多位数，直到匹配为止。

例如，如果浮点值插入为19.45，Manticore将显示为19.450001以准确表示存储的值。

‹›

Example

Example

📋

insert into t(id, f) values(1, 19.45)
--------------
Query OK, 1 row affected (0.02 sec)
--------------
select * from t
--------------
+------+-----------+
| id   | f         |
+------+-----------+
|    1 | 19.450001 |
+------+-----------+
1 row in set (0.00 sec)
--- 1 out of 1 results in 0ms ---

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, data json);

POST /cli -d "CREATE TABLE products(title text, data json)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'data'=>['type'=>'json']
]);

utilsApi.sql('CREATE TABLE products(title text, data json)')

await utilsApi.sql('CREATE TABLE products(title text, data json)')

res = await utilsApi.sql('CREATE TABLE products(title text, data json)');

utilsApi.sql("CREATE TABLE products(title text, data json)");

utilsApi.Sql("CREATE TABLE products(title text, data json)");

utils_api.sql("CREATE TABLE products(title text, data json)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_json = data
}

JSON属性可以在大多数操作中使用。还有一些特殊函数，如ALL()、ANY()、GREATEST()、LEAST()和INDEXOF()，允许遍历属性数组。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select indexof(x>2 for x in data.intarray) from products

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "expressions": { "idx": "indexof(x>2 for x in data.intarray)" }
}

$table->setName('products')->search('')->expression('idx','indexof(x>2 for x in data.intarray)')->get();

searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"idx":"indexof(x>2 for x in data.intarray)"}})

await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"idx":"indexof(x>2 for x in data.intarray)"}})

res = await searchApi.search({"table":"products","query":{"match_all":{}},"expressions":{"idx":"indexof(x>2 for x in data.intarray)"}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("idx","indexof(x>2 for x in data.intarray)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Expressions = new List<Object> {
    new Dictionary<string, string> { {"idx", "indexof(x>2 for x in data.intarray)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("idx".to_string(), serde_json::json!("indexof(x>2 for x in data.intarray)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

文本属性与字符串相同，因此无法在全文匹配表达式中使用。但是，可以使用字符串函数，如REGEX()。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select regex(data.name, 'est') as c from products where c>0

POST /search
{
  "table": "products",
  "query":
  {
    "match_all": {},
    "range": { "c": { "gt": 0 } } }
  },
  "expressions": { "c": "regex(data.name, 'est')" }
}

$table->setName('products')->search('')->expression('idx',"regex(data.name, 'est')")->filter('c','gt',0)->get();

searchApi.search({"table":"products","query":{"match_all":{},"range":{"c":{"gt":0}}}},"expressions":{"c":"regex(data.name, 'est')"}})

await searchApi.search({"table":"products","query":{"match_all":{},"range":{"c":{"gt":0}}}},"expressions":{"c":"regex(data.name, 'est')"}})

res = await searchApi.search({"table":"products","query":{"match_all":{},"range":{"c":{"gt":0}}}},"expressions":{"c":"regex(data.name, 'est')"}}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
query.put("range", new HashMap<String,Object>(){{
    put("c", new HashMap<String,Object>(){{
        put("gt",0);
    }});
}});
searchRequest.setQuery(query);
Object expressions = new HashMap<String,Object>(){{
    put("idx","indexof(x>2 for x in data.intarray)");
}};
searchRequest.setExpressions(expressions);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
var rangeFilter = new RangeFilter("c");
rangeFilter.Gt = 0;
searchRequest.AttrFilter = rangeFilter;
searchRequest.Expressions = new List<Object> {
    new Dictionary<string, string> { {"idx", "indexof(x>2 for x in data.intarray)"} }
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut expr = HashMap::new();
expr.insert("idx".to_string(), serde_json::json!("indexof(x>2 for x in data.intarray)"));
let expressions: [HashMap; 1] = [expr];
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    expressions: serde_json::json!(expressions),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

在处理浮点值的情况下，可能需要强制执行数据类型以确保某些情况下的正确功能。例如，当处理浮点值时，必须使用DOUBLE()以确保正确的排序。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from products order by double(data.myfloat) desc

POST /search
{
  "table": "products",
  "query": { "match_all": {} } },
  "sort": [ { "double(data.myfloat)": { "order": "desc"} } ]
}

$table->setName('products')->search('')->sort('double(data.myfloat)','desc')->get();

searchApi.search({"table":"products","query":{"match_all":{}}},"sort":[{"double(data.myfloat)":{"order":"desc"}}]})

await searchApi.search({"table":"products","query":{"match_all":{}}},"sort":[{"double(data.myfloat)":{"order":"desc"}}]})

res = await searchApi.search({"table":"products","query":{"match_all":{}}},"sort":[{"double(data.myfloat)":{"order":"desc"}}]});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
searchRequest.setSort(new ArrayList<Object>(){{
    add(new HashMap<String,String>(){{ put("double(data.myfloat)",new HashMap<String,String>(){{ put("order","desc");}});}});
}});
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Sort = new List<Object> {
    new SortOrder("double(data.myfloat)", SortOrder.OrderEnum.Desc)
};
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut sort = HashMap::new();
sort.insert("double(data.myfloat)".to_string(), serde_json::json!("desc"));
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(sort)
    ..Default::default()
};
let search_res = search_api.search(search_req).await;

浮点向量属性允许存储可变长度的浮点数列表，主要用于机器学习应用和相似性搜索。此类型与多值整数（MVA）（MVAs）在几个重要方面不同：

保留值的确切顺序（与MVAs不同，MVAs可能会重新排序）
保留重复值（与MVAs不同，MVAs会去重）
插入时无需额外处理（与MVAs不同，MVAs会排序和去重）

重要： float_vector 数据类型与自动模式机制不兼容。

目前仅支持实时表（不支持普通表）
其他函数或表达式中不支持
不能在常规过滤器或排序中使用

当你配置 float_vector 属性并设置 KNN 参数时，你将启用向量相似性搜索功能。这允许你执行 k-最近邻搜索，根据向量距离查找相似文档。

你可以做到：

执行 KNN（k-最近邻）向量搜索以查找相似文档
构建语义搜索、推荐和 AI 驱动的功能
使用自动嵌入从文本中自动生成向量

你不能做到：

UPDATE float_vector 值（必须使用 REPLACE 代替）
在常规过滤器或排序中使用浮点向量
除了通过向量搜索操作，不能通过 float_vector 值进行过滤

当你创建带有 float_vector 属性的表以进行 KNN 搜索时，可以指定以下参数：

必填参数：

KNN_TYPE：目前仅支持 'hnsw'
KNN_DIMS：向量的维度数（手动插入向量时必需，使用 MODEL_NAME 时可省略）
HNSW_SIMILARITY：距离函数 - 'l2'、'ip'（内积）或 'cosine'

可选参数：

HNSW_M：图中的最大连接数（默认：16）
HNSW_EF_CONSTRUCTION：构建时间/准确性权衡（默认：200）

分块参数（使用 MODEL_NAME 时，参见分块策略）：

CHUNK_STRATEGY：文档如何转换为向量：'truncate'（默认）、'mean'、'fixed'、'recursive' 或 'sentence'。后三种会为每个文档生成多个向量，并且需要一个 float_vector_array 列。
MAX_TOKENS：每个分块的 token 数；0（默认）表示使用模型自身的上限
OVERLAP_TOKENS：相邻分块之间共享的 token；需要显式设置一个非零的 MAX_TOKENS；如果重叠过大，会自动缩减，确保分块仍能继续前进
MAX_CHUNKS：每个文档向量数的上限；0（默认）表示不限制

自动嵌入参数（当使用 MODEL_NAME 时）：

MODEL_NAME：要使用的嵌入模型（例如，快速 ONNX 路径可用 'Xenova/all-MiniLM-L6-v2'，也可以是 'sentence-transformers/all-MiniLM-L6-v2' 或 'openai/text-embedding-ada-002'）
FROM：用于生成嵌入的字段名列表（逗号分隔），或空字符串 '' 表示使用所有文本/字符串字段
API_KEY：基于 API 的模型（OpenAI、Voyage、Jina）的 API 密钥

有关设置浮点向量并在搜索中使用它们的详细信息，请参阅KNN搜索。

处理浮点向量最简便的方式是使用自动嵌入。此功能使用机器学习模型自动从您的文本数据生成嵌入，从而消除手动计算和插入向量的需要。

简化的工作流程：只需插入文本，嵌入会自动生成
无需手动计算向量：无需运行单独的嵌入模型
一致的嵌入：相同的模型确保一致的向量表示
多模型支持：可从 Hugging Face 上的 ONNX 模型中选择（推荐 - 运行在 Manticore 的快速 ONNX Runtime 后端上）、sentence-transformers、Qwen 嵌入模型，以及 OpenAI、Voyage 和 Jina 模型
灵活的字段选择：控制用于生成嵌入的字段

在创建带有自动嵌入的表时，指定以下附加参数：

MODEL_NAME：用于自动向量生成的嵌入模型
FROM：用于生成嵌入的字段（空字符串表示所有文本/字符串字段）
API_KEY：远程模型（OpenAI、Voyage、Jina）必需。在创建表时通过实际 API 请求验证 API 密钥。
API_URL：可选。自定义 API 端点 URL。如果未指定，使用默认提供者端点（例如，OpenAI 的 https://api.openai.com/v1/embeddings）。
API_TIMEOUT：可选。API 请求的 HTTP 超时时间（以秒为单位）。默认为 10 秒。设置为 '0' 以使用默认超时。适用于表创建时的验证请求和插入操作时的嵌入生成。
MAX_INPUT_TOKENS：可选。限制每段输入文本在生成嵌入前使用的 token 数；更长的文本会被截断。'0'（默认值）表示使用模型自身的上下文限制。Qwen/Qwen3-Embedding-0.6B 等长上下文模型最多可接受 32,768 个 token，并且在 CPU 上生成嵌入的时间会随着输入长度超线性增长（一个 5 KB 的文档可能需要数分钟），因此当文本字段可能包含很长或无边界的内容时，应设置上限（例如 '512'）。适用于本地模型；之后可通过 ALTER TABLE ... MODIFY COLUMN ... MAX_INPUT_TOKENS='...' 修改该设置，且无需重新为已有行生成嵌入。

支持的嵌入模型：

ONNX（推荐）：任何附带 .onnx 文件的 Hugging Face 模型，例如 Xenova/all-MiniLM-L6-v2、Xenova/all-MiniLM-L12-v2、Xenova/bge-small-en-v1.5、Xenova/multilingual-e5-small。无需 API 密钥。运行在 Manticore 快速的 ONNX Runtime 后端上（在相同硬件上比 SentenceTransformers 路径快约 14 倍，见速度提升 14 倍的嵌入）。Xenova 和 onnx-models 都发布了大量转换为 ONNX 的模型；用于嵌入时，请寻找标有 feature-extraction 任务的模型。速度对比表和实践建议见选择本地嵌入模型。
Sentence Transformers：任何合适的、基于 BERT 的 Hugging Face 模型（例如 sentence-transformers/all-MiniLM-L6-v2）- 无需 API key。仍然受支持；如果你想要的模型没有发布为 ONNX，就用这个。
Qwen 本地嵌入：Qwen 嵌入模型，如 Qwen/Qwen3-Embedding-0.6B——不需要 API 密钥。Manticore 在您创建表时下载模型。
OpenAI、Voyage、Jina：远程嵌入模型（例如，openai/text-embedding-ada-002、openai:text-embedding-ada-002、voyage/voyage-3.5-lite、jina/jina-embeddings-v2-base-en）- 需要 API_KEY='***' 参数。可选地指定 API_URL='<CUSTOM_URL>' 以使用自定义 API 端点，并使用 API_TIMEOUT='<SECONDS>' 配置 HTTP 超时（默认为 10 秒）。

‹›

SQL
JSON

📋

使用本地 ONNX 模型 - 推荐，运行在快速 ONNX 路径上（无需 API key）

CREATE TABLE products (
    title TEXT,
    description TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='Xenova/all-MiniLM-L6-v2' FROM='title'
);

使用 sentence-transformers 模型（无需 API key；运行在 Candle 路径上 - 可用时优先使用上面的 ONNX）

CREATE TABLE products_st (
    title TEXT,
    description TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='sentence-transformers/all-MiniLM-L6-v2' FROM='title'
);

使用 Qwen 本地嵌入（不需要 API 密钥）

CREATE TABLE products_qwen (
    title TEXT,
    description TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='Qwen/Qwen3-Embedding-0.6B' FROM='title'
);

使用 OpenAI 模型（需要 API_KEY 参数）

CREATE TABLE products_openai (
    title TEXT,
    content TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='cosine'
    MODEL_NAME='openai/text-embedding-ada-002' FROM='title,content' API_KEY='<OPENAI_API_KEY>'
);

使用 OpenAI 与自定义 API URL 和超时（可选）

CREATE TABLE products_openai_custom (
    title TEXT,
    content TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='cosine'
    MODEL_NAME='openai:text-embedding-ada-002' FROM='title,content'
    API_KEY='***' API_URL='https://custom-api.example.com/v1/embeddings' API_TIMEOUT='30'
);

使用 OpenRouter 与提供方限定的模型 ID

CREATE TABLE products_openrouter (
    title TEXT,
    content TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='cosine'
    MODEL_NAME='openai:openai/text-embedding-ada-002' FROM='title,content'
    API_KEY='***' API_URL='https://openrouter.ai/api/v1/embeddings' API_TIMEOUT='30'
);

使用所有文本字段进行嵌入（FROM 为空）

CREATE TABLE products_all_fields (
    title TEXT,
    description TEXT,
    tags TEXT,
    embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
    MODEL_NAME='Xenova/all-MiniLM-L6-v2' FROM=''
);

FROM 参数控制用于生成嵌入的字段：

特定字段：FROM='title' - 仅使用标题字段
多个字段：FROM='title,description' - 将标题和描述字段连接并使用
所有文本字段：FROM=''（空）- 表中的所有 text（全文字段）和 string（字符串属性）字段用于嵌入生成
手动覆盖：即使配置了 MODEL_NAME，你仍然可以在 INSERT/REPLACE 中提供自己的向量
空向量：你可以插入 () 以跳过该行的嵌入生成；Manticore 会存储一个全零向量，其维度与模型相同

使用自动嵌入时，你有三种插入模式：

省略向量列，让 Manticore 从 FROM 中列出的字段生成嵌入
显式提供自己的向量以覆盖该行的自动生成
提供 () 以跳过生成并存储一个全零向量

-- Insert text data - embeddings generated automatically
INSERT INTO products (title, description) VALUES 
('smartphone', 'latest mobile device with camera'),
('laptop computer', 'portable workstation for developers');
-- Insert with a user-provided vector - no auto generation for this row
INSERT INTO products (title, embedding_vector) VALUES
('machine learning artificial intelligence', (0.653448,0.192478,0.017971,0.339821));
-- Insert with empty vector - no auto generation, stores a zero vector
INSERT INTO products (title, description, embedding_vector) VALUES
('no-vector item', 'this item has no embedding', ());

或者，你可以手动插入预计算的向量数据。这需要你使用外部工具或模型自行计算向量，然后将其插入到 Manticore 中。

‹›

SQL

📋

CREATE TABLE products (
    title TEXT,
    image_vector FLOAT_VECTOR KNN_TYPE='hnsw' KNN_DIMS='4' HNSW_SIMILARITY='l2'
);
INSERT INTO products VALUES 
(1, 'yellow bag', (0.653448,0.192478,0.017971,0.339821)),
(2, 'white bag', (-0.148894,0.748278,0.091892,-0.095406));

如果初始摄入速度比即时向量搜索更重要，你可以首先加载没有嵌入列的表，然后稍后添加基于模型的 float_vector 列。

这种方法在希望批量插入操作尽可能快速完成，并且愿意随后运行嵌入生成作为独立的、可能耗时较长的 ALTER 操作时非常有用。

工作原理：

仅创建包含源 text 字段和 string 属性的表
插入或导入所有数据
后续使用 ALTER TABLE ... ADD COLUMN 添加嵌入列

限制：

此方法仅适用于本地 RT 表。对于属于复制集群的表不可用，因为集群表不支持 ALTER。

CREATE TABLE products (
    title TEXT,
    description TEXT
);
INSERT INTO products (id, title, description) VALUES
(1, 'smartphone', 'latest mobile device with camera'),
(2, 'laptop computer', 'portable workstation for developers');
ALTER TABLE products
ADD COLUMN embedding_vector FLOAT_VECTOR KNN_TYPE='hnsw' HNSW_SIMILARITY='l2'
MODEL_NAME='Xenova/all-MiniLM-L6-v2' FROM='title,description';

有关详细信息，请参见更新表结构。

你也可以创建没有 KNN 配置的 float_vector 属性。在这种模式下，向量被存储但不能用于向量搜索操作。

你可以做到：

存储向量数据
UPDATE float_vector 值（与 KNN 不同，此时可以使用 UPDATE）

你不能做到：

执行 KNN 搜索或向量相似性搜索
使用向量进行任何搜索操作
通过 float_vector 值进行过滤

在配置KNN之前临时存储向量数据
用于后续与KNN一起使用的暂存数据
存储不需要搜索功能的向量

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, image_vector float_vector);

POST /cli -d "CREATE TABLE products(title text, image_vector float_vector)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'image_vector'=>['type'=>'float_vector']
]);

utilsApi.sql('CREATE TABLE products(title text, image_vector float_vector)')

await utilsApi.sql('CREATE TABLE products(title text, image_vector float_vector)')

res = await utilsApi.sql('CREATE TABLE products(title text, image_vector float_vector)');

utilsApi.sql("CREATE TABLE products(title text, image_vector float_vector)");

utilsApi.Sql("CREATE TABLE products(title text, image_vector float_vector)");

utils_api.sql("CREATE TABLE products(title text, image_vector float_vector)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_float_vector = image_vector
}

float_vector_array 属性为每个文档存储多个向量，而不是单个向量。其值写成向量数组，每个文档都有自己的向量数量：

[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]

值始终是一个向量数组：[[1,2],[3,4]]。像 (1,2,3,4) 这样的扁平列表会被拒绝，因为无法区分这是一个 4 维向量，还是两个 2 维向量。
[] 表示“没有向量”。这是一个合法的已存储值，也是省略该属性时的默认值。
同一个值中的所有向量必须具有相同的维度。
空的内层向量（[[]]）无法表示，因此会被拒绝。表示“无”请使用 []。
返回的值会保持与插入时相同的嵌套形式。

目前仅支持实时表（不支持普通表）
不支持在函数或表达式中使用
不能用于常规过滤或排序
自动嵌入可用：多向量分块策略（fixed、recursive、sentence）会为每个分块填入一个向量，而单向量策略（truncate、mean）会存储一个 1 元素数组 - 参见分块策略。目前还不支持通过 ALTER TABLE ... ADD COLUMN 添加一个由模型驱动的 float_vector_array，也不支持对其执行 ALTER TABLE ... REBUILD EMBEDDINGS；请在建表时直接声明该列。
与自动模式机制不兼容

参数与 float_vector 所使用的相同：KNN_TYPE、KNN_DIMS、HNSW_SIMILARITY，以及可选的 HNSW_M、HNSW_EF_CONSTRUCTION 和量化，但有两个区别：

KNN_DIMS 是必需的，并且 每一行 中的每个向量都必须恰好包含这么多维。插入时，如果某一行的向量宽度不同，该行会被拒绝。
MODEL_NAME 和 FROM 都可接受，并且支持自动填充数组的多向量 CHUNK_STRATEGY。参见分块策略。

你可以做的：

运行 KNN 搜索，让文档按其最近的向量进行匹配
为每个文档存储不同数量的向量，包括一个都不存

你不能做的：

对该属性执行 UPDATE：请像对带 KNN 索引的 float_vector 一样，使用 REPLACE
在常规过滤或排序中使用这些值

值为 [] 的文档，或省略了该属性的文档，不会被 KNN 搜索返回，因为它并不接近任何内容。

CREATE TABLE products(title text, chunk_vectors float_vector_array);
INSERT INTO products VALUES (1, 'a', [[1,2]]), (2, 'b', [[1,2,3],[4,5,6]]);

在这种模式下，UPDATE 可以正常工作，就像对不带 KNN 的 float_vector 一样，[] 会清空该值。

创建一个带 KNN 索引的浮点向量数组、填充数据并进行搜索：

‹›

SQL
JSON

📋

CREATE TABLE articles(title text, chunk_vectors float_vector_array knn_type='hnsw' knn_dims='4' hnsw_similarity='l2');
INSERT INTO articles VALUES
  (1, 'first',  [[1,0,0,0],[0,1,0,0]]),
  (2, 'second', [[0,0,1,0]]),
  (3, 'no vectors yet', []);
SELECT id, knn_dist() FROM articles WHERE knn(chunk_vectors, 5, (1,0,0,0));

多值属性允许存储可变长度的32位无符号整数列表。这在存储一对多的数值时非常有用，例如标签、产品类别和属性。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, product_codes multi);

或

CREATE TABLE products(title text, product_codes mva);

POST /cli -d "CREATE TABLE products(title text, product_codes multi)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'product_codes'=>['type'=>'multi']
]);

utilsApi.sql('CREATE TABLE products(title text, product_codes multi)')

await utilsApi.sql('CREATE TABLE products(title text, product_codes multi)')

res = await utilsApi.sql('CREATE TABLE products(title text, product_codes multi)');

utilsApi.sql("CREATE TABLE products(title text, product_codes multi)");

utilsApi.Sql("CREATE TABLE products(title text, product_codes multi)");

utils_api.sql("CREATE TABLE products(title text, product_codes multi)", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_multi = product_codes
}

它支持过滤和聚合，但不支持排序。过滤可以通过至少一个元素通过（使用 ANY()）或所有元素 (ALL()) 来完成。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select * from products where any(product_codes)=3

POST /search
{
  "table": "products",
  "query":
  {
    "match_all": {},
    "equals" : { "any(product_codes)": 3 }
  }
}

$table->setName('products')->search('')->filter('any(product_codes)','equals',3)->get();

searchApi.search({"table":"products","query":{"match_all":{},"equals":{"any(product_codes)":3}}}})

await searchApi.search({"table":"products","query":{"match_all":{},"equals":{"any(product_codes)":3}}}})

res = await searchApi.search({"table":"products","query":{"match_all":{},"equals":{"any(product_codes)":3}}}})'

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
query.put("equals",new HashMap<String,Integer>(){{
     put("any(product_codes)",3);
}});
searchRequest.setQuery(query);
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.AttrFilter = new EqualsFilter("any(product_codes)", 3);
var searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let search_request = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

可以提取诸如最小或最大元素以及列表长度等信息。以下示例展示了如何按多值属性的最小元素进行排序。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

select least(product_codes) l from products order by l asc

POST /search
{
  "table": "products",
  "query":
  {
    "match_all": {},
    "sort": [ { "product_codes":{ "order":"asc", "mode":"min" } } ]
  }
}

$table->setName('products')->search('')->sort('product_codes','asc','min')->get();

searchApi.search({"table":"products","query":{"match_all":{},"sort":[{"product_codes":{"order":"asc","mode":"min"}}]}})

await searchApi.search({"table":"products","query":{"match_all":{},"sort":[{"product_codes":{"order":"asc","mode":"min"}}]}})

res = await searchApi.search({"table":"products","query":{"match_all":{},"sort":[{"product_codes":{"order":"asc","mode":"min"}}]}});

searchRequest = new SearchRequest();
searchRequest.setTable("forum");
query = new HashMap<String,Object>();
query.put("match_all",null);
searchRequest.setQuery(query);
searchRequest.setSort(new ArrayList<Object>(){{
    add(new HashMap<String,String>(){{ put("product_codes",new HashMap<String,String>(){{ put("order","asc");put("mode","min");}});}});
}});
searchResponse = searchApi.search(searchRequest);

object query =  new { match_all=null };
var searchRequest = new SearchRequest("forum", query);
searchRequest.Sort = new List<Object> {
    new SortMVA("product_codes", SortOrder.OrderEnum.Asc, SortMVA.ModeEnum.Min)
};
searchResponse = searchApi.Search(searchRequest);

let query = SearchQuery::new();
let mut sort_opts = HashMap::new();
sort_opts.insert("order".to_string(), serde_json::json!("asc"));
sort_opts.insert("mode".to_string(), serde_json::json!("min"));
sort_expr.insert("product_codes".to_string(), serde_json::json!(sort_opts));
let sort: [HashMap; 1] = [sort_expr];
let search_req = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    sort: serde_json::json!(sort),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;

‹›

SQL

📋

insert into products values ( 1, 'doc one', (5,7,11) );
select id, count(*), groupby() from products group by product_codes;

‹›

Response

Query OK, 1 row affected (0.00 sec)
+------+----------+-----------+
| id   | count(*) | groupby() |
+------+----------+-----------+
|    1 |        1 |        11 |
|    1 |        1 |         7 |
|    1 |        1 |         5 |
+------+----------+-----------+
3 rows in set (0.00 sec)

作为多值属性值插入的数字顺序不会被保留。值在内部以排序集合的形式存储。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust

📋

insert into product values (1,'first',(4,2,1,3));
select * from products;

POST /insert
{
    "table":"products",
    "id":1,
    "doc":
    {
        "title":"first",
        "product_codes":[4,2,1,3]
    }
}
POST /search
{
  "table": "products",
  "query": { "match_all": {} }
}

$table->addDocument([
    "title"=>"first",
    "product_codes"=>[4,2,1,3]
]);
$table->search('')-get();

indexApi.insert({"table":"products","id":1,"doc":{"title":"first","product_codes":[4,2,1,3]}})
searchApi.search({"table":"products","query":{"match_all":{}}})

await indexApi.insert({"table":"products","id":1,"doc":{"title":"first","product_codes":[4,2,1,3]}})
await searchApi.search({"table":"products","query":{"match_all":{}}})

await indexApi.insert({"table":"products","id":1,"doc":{"title":"first","product_codes":[4,2,1,3]}});
res = await searchApi.search({"table":"products","query":{"match_all":{}}});

InsertDocumentRequest newdoc = new InsertDocumentRequest();
HashMap<String,Object> doc = new HashMap<String,Object>(){{
    put("title","first");
    put("product_codes",new int[] {4,2,1,3});
}};
newdoc.table("products").id(1L).setDoc(doc);
sqlresult = indexApi.insert(newdoc);
Map<String,Object> query = new HashMap<String,Object>();
query.put("match_all",null);
SearchRequest searchRequest = new SearchRequest();
searchRequest.setTable("products");
searchRequest.setQuery(query);
SearchResponse searchResponse = searchApi.search(searchRequest);
System.out.println(searchResponse.toString() );

Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("title", "first");
doc.Add("product_codes", new List<Object> {4,2,1,3});
InsertDocumentRequest newdoc = new InsertDocumentRequest(table: "products", id: 1, doc: doc);
var sqlresult = indexApi.Insert(newdoc);
object query =  new { match_all=null };
var searchRequest = new SearchRequest("products", query);
var searchResponse = searchApi.Search(searchRequest);
Console.WriteLine(searchResponse.ToString())

let mut doc = HashMap::new();
doc.insert("title".to_string(), serde_json::json!("first"));
doc.insert("product_codes".to_string(), serde_json::json!([4,2,1,3]));
let insert_req = InsertDocumentRequest::new("products".to_string(), serde_json::json!(doc));
let insert_res = index_api.insert(insert_req).await;
let query = SearchQuery::new();
let search_req = SearchRequest {
    table: "forum".to_string(),
    query: Some(Box::new(query)),
    ..Default::default(),
};
let search_res = search_api.search(search_req).await;
println!("{:?}", search_res);

‹›

Response

Query OK, 1 row affected (0.00 sec)
+------+---------------+-------+
| id   | product_codes | title |
+------+---------------+-------+
|    1 | 1,2,3,4       | first |
+------+---------------+-------+
1 row in set (0.01 sec)

{
   "table":"products",
   "id":1,
   "created":true,
   "result":"created",
   "status":201
}
{
   "took":0,
   "timed_out":false,
   "hits":{
      "total":1,
      "hits":[
         {
            "_id": 1,
            "_score":1,
            "_source":{
               "product_codes":[
                  1,
                  2,
                  3,
                  4
               ],
               "title":"first"
            }
         }
      ]
   }
}

Array
(
    [_index] => products
    [_id] => 1
    [created] => 1
    [result] => created
    [status] => 201
)
Array
(
    [took] => 0
    [timed_out] =>
    [hits] => Array
        (
            [total] => 1
            [hits] => Array
                (
                    [0] => Array
                        (
                            [_id] => 1
                            [_score] => 1
                            [_source] => Array
                                (
                                    [product_codes] => Array
                                        (
                                            [0] => 1
                                            [1] => 2
                                            [2] => 3
                                            [3] => 4
                                        )
                                    [title] => first
                                )
                        )
                )
        )
)

{'created': True,
 'found': None,
 'id': 1,
 'table': 'products',
 'result': 'created'}
{'hits': {'hits': [{u'_id': u'1',
                    u'_score': 1,
                    u'_source': {u'product_codes': [1, 2, 3, 4],
                                 u'title': u'first'}}],
          'total': 1},
 'profile': None,
 'timed_out': False,
 'took': 29}

{'created': True,
 'found': None,
 'id': 1,
 'table': 'products',
 'result': 'created'}
{'hits': {'hits': [{u'_id': u'1',
                    u'_score': 1,
                    u'_source': {u'product_codes': [1, 2, 3, 4],
                                 u'title': u'first'}}],
          'total': 1},
 'profile': None,
 'timed_out': False,
 'took': 29}

{"took":0,"timed_out":false,"hits":{"total":1,"hits":[{"_id": 1,"_score":1,"_source":{"product_codes":[1,2,3,4],"title":"first"}}]}}

class SearchResponse {
    took: 0
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=1, _score=1, _source={product_codes=[1, 2, 3, 4], title=first}}]
        aggregations: null
    }
    profile: null
}

class SearchResponse {
    took: 0
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=1, _score=1, _source={product_codes=[1, 2, 3, 4], title=first}}]
        aggregations: null
    }
    profile: null
}

class SearchResponse {
    took: 0
    timedOut: false
    hits: class SearchResponseHits {
        total: 1
        hits: [{_id=1, _score=1, _source={product_codes=[1, 2, 3, 4], title=first}}]
        aggregations: null
    }
    profile: null
}

一种允许存储可变长度64位有符号整数列表的数据类型。其功能与多值整数相同。

‹›

SQL
JSON
PHP
Python
Python-asyncio
javascript
java
C#
Rust
config

📋

CREATE TABLE products(title text, values multi64);

或

CREATE TABLE products(title text, values mva64);

POST /cli -d "CREATE TABLE products(title text, values multi64)"

$table = new \Manticoresearch\Table($client);
$table->setName('products');
$table->create([
    'title'=>['type'=>'text'],
    'values'=>['type'=>'multi64']
]);

utilsApi.sql('CREATE TABLE products(title text, values multi64))')

await utilsApi.sql('CREATE TABLE products(title text, values multi64))')

res = await utilsApi.sql('CREATE TABLE products(title text, values multi64))');

utilsApi.sql("CREATE TABLE products(title text, values multi64))");

utilsApi.Sql("CREATE TABLE products(title text, values multi64))");

utils_api.sql("CREATE TABLE products(title text, values multi64))", Some(true)).await;

table products
{
    type = rt
    path = products
    rt_field = title
    stored_fields = title
    rt_attr_multi_64 = values
}

当使用列式存储时，可以为属性指定以下特性。

‹›

RT mode
Plain mode

📋

create table t(a int, b int fast_fetch='0') engine='columnar'; desc t;

‹›

Response

+-------+--------+---------------------+
| Field | Type   | Properties          |
+-------+--------+---------------------+
| id    | bigint | columnar fast_fetch |
| a     | uint   | columnar fast_fetch |
| b     | uint   | columnar            |
+-------+--------+---------------------+
3 rows in set (0.00 sec)

数据类型创建本地表

Last modified: September 23, 2026

在 Manticore Search 中，有以下两种方式来管理表：

实时模式不需要在配置文件中定义表。但是，searchd 部分中的 data_dir 指令是必需的。表文件存储在 data_dir 内。

仅在此模式下可用复制功能。

您可以使用 SQL 命令如 CREATE TABLE、ALTER TABLE 和 DROP TABLE 来创建和修改表结构，并删除它。此模式特别适用于实时和 过滤查询 表。

创建时，表名中的 ASCII 字母会转换为小写。非 ASCII 的 UTF-8 字符会保留原始拼写，不会进行 Unicode 大小写折叠。参见表、字段和属性名称语法。

在这种模式下，您可以在配置文件中指定表结构。Manticore 在启动时读取此结构并在表不存在时创建它。此模式特别适用于 纯文本 表，这些表使用外部存储的数据。

要删除一个表，请从配置文件中移除它或移除路径设置并发送 SIGHUP 信号给服务器或重启它。

在此模式下，配置节名称区分大小写。表、字段和属性名称，以及命名的 source 节，都可以包含非 ASCII 的 UTF-8 字符。不会应用 Unicode 大小写折叠和 Unicode 规范化，因此请始终使用完全一致的 Unicode 拼写。参见表、字段和属性名称语法。

此模式支持所有类型的表。

表类型	实时模式	纯文本模式
实时	支持	支持
纯文本	不支持	支持
过滤查询	支持	支持
分布式	支持	支持
模板	不支持	支持

行级和列式属性存储实时表

Last modified: September 02, 2026

一个 实时表 是 Manticore 中的主要表类型。它允许您添加、更新和删除文档，并且您可以立即看到这些更改。您可以在配置文件中设置实时表，或者使用 CREATE、UPDATE、DELETE 或 ALTER 命令。

内部，一个实时表由一个或多个称为碎片的普通表组成。有两类碎片：

多个 磁盘碎片 - 这些保存在磁盘上，并且结构类似于普通表。
单个 内存碎片 - 这些保存在内存中并收集所有更改。

内存碎片的大小由 rt_mem_limit 设置控制。一旦达到此限制，内存碎片将作为磁盘碎片转移到磁盘上。如果磁盘碎片过多，Manticore 将组合一些碎片以提高性能。

您可以使用两种方式创建新的实时表：通过 CREATE TABLE 命令或通过 HTTP JSON API 的 _mapping 端点。

您可以使用此命令通过 SQL 和 HTTP 协议进行：

‹›

SQL
JSON
PHP
Python
Python-asyncio
Javascript
Java
C#
Rust
Typescript
Go
CONFIG

📋

CREATE TABLE products(title text, price float) morphology='stem_en';

POST /sql?mode=raw -d "CREATE TABLE products(title text, price float)  morphology='stem_en'"

$index = new \Manticoresearch\Index($client);
$index->setName('products');
$index->create([
    'title'=>['type'=>'text'],
    'price'=>['type'=>'float'],
]);

utilsApi.sql('CREATE TABLE forum(title text, price float)')

await utilsApi.sql('CREATE TABLE forum(title text, price float)')

res = await utilsApi.sql('CREATE TABLE forum(title text, price float)');

utilsApi.sql("CREATE TABLE forum(title text, price float)");

utilsApi.Sql("CREATE TABLE forum(title text, price float)");

utils_api.sql("CREATE TABLE forum(title text, price float)", Some(true)).await;

res = await utilsApi.sql('CREATE TABLE forum(title text, price float)');

utilsAPI.Sql(context.Background()).Body("CREATE TABLE forum(title text, price float)").Execute()

table products {
  type = rt
  path = tbl
  rt_field = title
  rt_attr_uint = price
  stored_fields = title
}

‹›

Response

Query OK, 0 rows affected (0.00 sec)

注意：_mapping API 需要 Manticore Buddy。如果不起作用，请确保已安装 Buddy。

另外，您还可以通过 _mapping 端点创建新表。此端点允许您定义类似 Elasticsearch 的表结构并将其转换为 Manticore 表。

请求体必须具有以下结构：

"properties"
{
  "FIELD_NAME_1":
  {
    "type": "FIELD_TYPE_1"
  },
  "FIELD_NAME_2":
  {
    "type": "FIELD_TYPE_2"
  },
  ...
  "FIELD_NAME_N":
  {
    "type": "FIELD_TYPE_M"
  }
}

在创建表时，Elasticsearch 数据类型将根据以下规则映射到 Manticore 类型：

aggregate_metric => json
binary => string
boolean => bool
byte => int
completion => string
date => timestamp
date_nanos => bigint
date_range => json
dense_vector => json
flattened => json
flat_object => json
float => float
float_range => json
geo_point => json
geo_shape => json
half_float => float
histogram => json
integer => int
integer_range => json
ip => string
ip_range => json
keyword => string
knn_vector => float_vector
long => bigint
long_range => json
match_only_text => text
object => json
point => json
scaled_float => float
search_as_you_type => text
shape => json
short => int
text => text
unsigned_long => int
version => string

‹›

JSON

JSON

📋

⚙

POST /your_table_name/_mapping -d '
{
  "properties": {
    "price": {
        "type": "float"
    },
    "title": {
        "type": "text"
    }
  }
}
'

‹›

Response

{
"total":0,
"error":"",
"warning":""
}

您可以创建实时表的一个副本，可以包含或不包含其数据。请注意，如果表很大，复制带数据的表可能需要一些时间。复制工作在同步模式下进行，但如果连接中断，它将在后台继续。

CREATE TABLE [IF NOT EXISTS] table_name LIKE old_table_name [WITH DATA]

注意：复制表需要 Manticore Buddy。如果不起作用，请确保已安装 Buddy。

‹›

SQL
Example (WITH DATA)
JSON
JSON example (WITH DATA)

📋

create table products LIKE old_products;

create table products LIKE old_products WITH DATA;

POST /sql?mode=raw -d "create table products LIKE old_products"

POST /sql?mode=raw -d "create table products LIKE old_products WITH DATA"

添加文档。
使用更新过程更新属性和全文字段。
删除文档。
清空表。
使用 ALTER 命令在线更改架构，如在线更改架构所述。
在配置文件中定义表，如定义表所述。
使用自动 ID 生成。

不能使用 indexer 功能进行数据摄取。
不能连接到 sources 以便轻松从外部存储索引数据。
不能更新 killlist_target，因为它由实时表自动管理。

下表列出了实时表中不同文件扩展名及其对应说明：

Extension	Description
`.lock`	一个锁文件，确保一次只有一个进程可以访问该表。
`.ram`	表的RAM部分，存储在内存中，用作变更的累积器。
`.meta`	定义实时表结构和设置的表头文件。
`..sp`	存储在磁盘上的磁盘块，格式与普通表相同。当RAM块大小超过 rt_mem_limit 时创建。

详情请参阅有关磁盘块结构的普通表文件结构。

创建本地表普通表

Last modified: July 20, 2026

数据类型

全文字段与属性

表和字段名语法

全文字段

属性

行式与列式属性存储

如何在存储类型之间切换

文档 ID

大 ID 的接口差异

UUID 文档 ID

字符数据类型

文本

字符串

在Manticore中存储二进制数据

整数

大整数

布尔类型

时间戳

浮点数

JSON

Float vector

一般限制

使用浮点向量与 KNN（向量搜索）

功能

参数

方法 1：自动嵌入（推荐）

自动嵌入的优势

创建带有自动嵌入的表

FROM 参数使用

使用自动嵌入插入数据

方法 2：手动向量插入

方法 3：在批量加载后添加嵌入列

不使用 KNN 的浮点向量（仅存储）

使用场景

浮点向量数组

值语法

一般限制

将浮点向量数组用于 KNN

不使用 KNN 的浮点向量数组

多值整数（MVA）

多值大整数

列式属性特性

fast_fetch

数据类型

全文字段与属性

表和字段名语法

全文字段

属性

行式与列式属性存储

如何在存储类型之间切换

文档 ID

大 ID 的接口差异

UUID 文档 ID

字符数据类型

文本

字符串

在Manticore中存储二进制数据

整数

大整数

布尔类型

时间戳

浮点数

JSON

Float vector

一般限制

使用浮点向量与 KNN（向量搜索）

功能

参数

方法 1：自动嵌入（推荐）

自动嵌入的优势

创建带有自动嵌入的表

FROM 参数使用

使用自动嵌入插入数据

方法 2：手动向量插入

方法 3：在批量加载后添加嵌入列

不使用 KNN 的浮点向量（仅存储）

使用场景

浮点向量数组

值语法

一般限制