UPDATE 命令用于更改指定表中现有文档的行式存储属性值。请注意,您无法更新全文字段或列式存储属性的内容。如果有此需求,请使用 REPLACE。
RT、PQ 和普通表均支持属性更新。只要属性存储在行式存储中,所有属性类型都可以更新。
请注意,文档 ID 无法更新。
需要特别注意的是,更新属性会禁用其二级索引。如果保持二级索引的连续性至关重要,请考虑完全或部分替换文档。
有关 UPDATE 与部分 REPLACE 的更多信息,请阅读此处。
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
UPDATE products SET enabled=0 WHERE id=10;POST /update
{
"table":"products",
"id":10,
"doc":
{
"enabled":0
}
}$index->updateDocument([
'enabled'=>0
],10);indexApi = api = manticoresearch.IndexApi(client)
indexApi.update({"table" : "products", "id" : 1, "doc" : {"price":10}})indexApi = api = manticoresearch.IndexApi(client)
await indexApi.update({"table" : "products", "id" : 1, "doc" : {"price":10}})res = await indexApi.update({"table" : "products", "id" : 1, "doc" : {"price":10}});UpdateDocumentRequest updateRequest = new UpdateDocumentRequest();
doc = new HashMap<String,Object >(){{
put("price",10);
}};
updateRequest.index("products").id(1L).setDoc(doc);
indexApi.update(updateRequest);Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("price", 10);
UpdateDocumentRequest updateRequest = new UpdateDocumentRequest(index: "products", id: 1, doc: doc);
indexApi.Update(updateRequest);let mut doc = HashMap::new();
doc.insert("price".to_string(), serde_json::json!(10));
let update_req = UpdateDocumentRequest {
table: serde_json::json!("products"),
doc: serde_json::json!(doc),
id: serde_json::json!(1),
..Default::default(),
};
let update_res = index_api.update(update_req).await;res = await indexApi.update({ index: "test", id: 1, doc: { cat: 10 } });updateDoc = map[string]interface{} {"cat":10}
updateRequest = openapiclient.NewUpdateDocumentRequest("test", updateDoc)
updateRequest.SetId(1)
res, _, _ = apiClient.IndexAPI.Update(context.Background()).UpdateDocumentRequest(*updateRequest).Execute()Query OK, 1 row affected (0.00 sec){
"table":"products",
"updated":1
}Array(
[_index] => products
[_id] => 10
[result] => updated
){'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{"table":"products","_id":1,"result":"updated"}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}{
"table":"test",
"_id":1,
"result":"updated"
}{
"table":"test",
"_id":1,
"result":"updated"
}可以在单个语句中更新多个属性。例如:
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
UPDATE products
SET price=100000000000,
coeff=3465.23,
tags1=(3,6,4),
tags2=()
WHERE MATCH('phone') AND enabled=1;POST /update
{
"table":"products",
"doc":
{
"price":100000000000,
"coeff":3465.23,
"tags1":[3,6,4],
"tags2":[]
},
"query":
{
"match": { "*": "phone" },
"equals": { "enabled": 1 }
}
}$query= new BoolQuery();
$query->must(new Match('phone','*'));
$query->must(new Equals('enabled',1));
$index->updateDocuments([
'price' => 100000000000,
'coeff' => 3465.23,
'tags1' => [3,6,4],
'tags2' => []
],
$query
);indexApi = api = manticoresearch.IndexApi(client)
indexApi.update({"table" : "products", "id" : 1, "doc" : {
"price": 100000000000,
"coeff": 3465.23,
"tags1": [3,6,4],
"tags2": []}})indexApi = api = manticoresearch.IndexApi(client)
await indexApi.update({"table" : "products", "id" : 1, "doc" : {
"price": 100000000000,
"coeff": 3465.23,
"tags1": [3,6,4],
"tags2": []}})res = await indexApi.update({"table" : "products", "id" : 1, "doc" : {
"price": 100000000000,
"coeff": 3465.23,
"tags1": [3,6,4],
"tags2": []}});UpdateDocumentRequest updateRequest = new UpdateDocumentRequest();
doc = new HashMap<String,Object >(){{
put("price",10);
put("coeff",3465.23);
put("tags1",new int[]{3,6,4});
put("tags2",new int[]{});
}};
updateRequest.index("products").id(1L).setDoc(doc);
indexApi.update(updateRequest);Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("price", 10);
doc.Add("coeff", 3465.23);
doc.Add("tags1", new List<int> {3,6,4});
doc.Add("tags2", new List<int> {});
UpdateDocumentRequest updateRequest = new UpdateDocumentRequest(index: "products", id: 1, doc: doc);
indexApi.Update(updateRequest);let mut doc = HashMap::new();
doc.insert("price".to_string(), serde_json::json!(10));
doc.insert("coeff".to_string(), serde_json::json!(3465.23));
doc.insert("tags1".to_string(), serde_json::json!([3,6,4]));
doc.insert("tags2".to_string(), serde_json::json!([]));
let update_req = UpdateDocumentRequest {
table: serde_json::json!("products"),
doc: serde_json::json!(doc),
id: serde_json::json!(1),
..Default::default(),
};
let update_res = index_api.update(update_req).await;res = await indexApi.update({ index: "test", id: 1, doc: { name: "Doc 21", cat: "10" } });updateDoc = map[string]interface{} {"name":"Doc 21", "cat":10}
updateRequest = manticoreclient.NewUpdateDocumentRequest("test", updateDoc)
updateRequest.SetId(1)
res, _, _ = apiClient.IndexAPI.Update(context.Background()).UpdateDocumentRequest(*updateRequest).Execute()Query OK, 148 rows affected (0.0 sec){
"table":"products",
"updated":148
}Array(
[_index] => products
[updated] => 148
){'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{"table":"products","_id":1,"result":"updated"}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}{
"table":"test",
"_id":1,
"result":"updated"
}{
"table":"test",
"_id":1,
"result":"updated"
}当为 32 位属性分配超出范围的值时,这些值将被静默截断为其低 32 位。例如,如果您尝试用值 4294967297 更新 32 位无符号整数,实际存储的值将是 1,因为 4294967297(十六进制为 0x100000001)的低 32 位等于 1(十六进制为 0x00000001)。
UPDATE 可用于对数值数据类型或数值数据类型的数组执行部分 JSON 更新。只需确保不要用浮点值更新整数值,因为它会被四舍五入。
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
insert into products (id, title, meta) values (1,'title','{"tags":[1,2,3]}');
update products set meta.tags[0]=100 where id=1;POST /insert
{
"table":"products",
"id":100,
"doc":
{
"title":"title",
"meta": {
"tags":[1,2,3]
}
}
}
POST /update
{
"table":"products",
"id":100,
"doc":
{
"meta.tags[0]":100
}
}$index->insertDocument([
'title' => 'title',
'meta' => ['tags' => [1,2,3]]
],1);
$index->updateDocument([
'meta.tags[0]' => 100
],1);indexApi = api = manticoresearch.IndexApi(client)
indexApi.update({"table" : "products", "id" : 1, "doc" : {
"meta.tags[0]": 100}})indexApi = api = manticoresearch.IndexApi(client)
await indexApi.update({"table" : "products", "id" : 1, "doc" : {
"meta.tags[0]": 100}})res = await indexApi.update({"table" : "products", "id" : 1, "doc" : {
"meta.tags[0]": 100}});UpdateDocumentRequest updateRequest = new UpdateDocumentRequest();
doc = new HashMap<String,Object >(){{
put("meta.tags[0]",100);
}};
updateRequest.index("products").id(1L).setDoc(doc);
indexApi.update(updateRequest);Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("meta.tags[0]", 100);
UpdateDocumentRequest updateRequest = new UpdateDocumentRequest(index: "products", id: 1, doc: doc);
indexApi.Update(updateRequest);let mut doc = HashMap::new();
doc.insert("meta.tags[0]".to_string(), serde_json::json!(100));
let update_req = UpdateDocumentRequest {
table: serde_json::json!("products"),
doc: serde_json::json!(doc),
id: serde_json::json!(1),
..Default::default(),
};
let update_res = index_api.update(update_req).await;res = await indexApi.update({"table" : "test", "id" : 1, "doc" : { "meta.tags[0]": 100} });updateDoc = map[string]interface{} {"meta.tags[0]":100}
updateRequest = manticoreclient.NewUpdateDocumentRequest("test", updateDoc)
updateRequest.SetId(1)
res, _, _ = apiClient.IndexAPI.Update(context.Background()).UpdateDocumentRequest(*updateRequest).Execute()Query OK, 1 row affected (0.00 sec)
Query OK, 1 row affected (0.00 sec){
"table":"products",
"_id":100,
"created":true,
"result":"created",
"status":201
}
{
"table":"products",
"updated":1
}Array(
[_index] => products
[_id] => 1
[created] => true
[result] => created
)
Array(
[_index] => products
[updated] => 1
){'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{"table":"products","_id":1,"result":"updated"}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}{"table":"test","_id":1,"result":"updated"}{
"table":"test",
"_id":1,
"result":"updated"
}更新其他数据类型或更改 JSON 属性中的属性类型需要进行完整的 JSON 更新。
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
insert into products values (1,'title','{"tags":[1,2,3]}');
update products set data='{"tags":["one","two","three"]}' where id=1;POST /insert
{
"table":"products",
"id":1,
"doc":
{
"title":"title",
"data":"{\"tags\":[1,2,3]}"
}
}
POST /update
{
"table":"products",
"id":1,
"doc":
{
"data":"{\"tags\":[\"one\",\"two\",\"three\"]}"
}
}$index->insertDocument([
'title'=> 'title',
'data' => [
'tags' => [1,2,3]
]
],1);
$index->updateDocument([
'data' => [
'one', 'two', 'three'
]
],1);indexApi.insert({"table" : "products", "id" : 100, "doc" : {"title" : "title", "meta" : {"tags":[1,2,3]}}})
indexApi.update({"table" : "products", "id" : 100, "doc" : {"meta" : {"tags":['one','two','three']}}})await indexApi.insert({"table" : "products", "id" : 100, "doc" : {"title" : "title", "meta" : {"tags":[1,2,3]}}})
await indexApi.update({"table" : "products", "id" : 100, "doc" : {"meta" : {"tags":['one','two','three']}}})res = await indexApi.insert({"table" : "products", "id" : 100, "doc" : {"title" : "title", "meta" : {"tags":[1,2,3]}}});
res = await indexApi.update({"table" : "products", "id" : 100, "doc" : {"meta" : {"tags":['one','two','three']}}});InsertDocumentRequest newdoc = new InsertDocumentRequest();
doc = new HashMap<String,Object>(){{
put("title","title");
put("meta",
new HashMap<String,Object>(){{
put("tags",new int[]{1,2,3});
}});
}};
newdoc.index("products").id(100L).setDoc(doc);
indexApi.insert(newdoc);
updatedoc = new UpdateDocumentRequest();
doc = new HashMap<String,Object >(){{
put("meta",
new HashMap<String,Object>(){{
put("tags",new String[]{"one","two","three"});
}});
}};
updatedoc.index("products").id(100L).setDoc(doc);
indexApi.update(updatedoc);Dictionary<string, Object> meta = new Dictionary<string, Object>();
meta.Add("tags", new List<int> {1,2,3});
Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("title", "title");
doc.Add("meta", meta);
InsertDocumentRequest newdoc = new InsertDocumentRequest(index: "products", id: 100, doc: doc);
indexApi.Insert(newdoc);
meta = new Dictionary<string, Object>();
meta.Add("tags", new List<string> {"one","two","three"});
doc = new Dictionary<string, Object>();
doc.Add("meta", meta);
UpdateDocumentRequest updatedoc = new UpdateDocumentRequest(index: "products", id: 100, doc: doc);
indexApi.Update(updatedoc);let mut meta = HashMap::new();
meta.insert("tags".to_string(), serde_json::json!([1,2,3]));
let mut doc = HashMap::new();
doc.insert("title".to_string(), serde_json::json!("title"));
doc.insert("meta".to_string(), serde_json::json!(meta));
let insert_req = InsertDocumentRequest {
table: serde_json::json!("products"),
doc: serde_json::json!(doc),
id: serde_json::json!(100),
..Default::default(),
};
let insert_res = index_api.insert(insert_req).await;
meta = HashMap::new();
meta.insert("tags".to_string(), serde_json::json!(["one","two","three"]));
doc = HashMap::new();
doc.insert("meta".to_string(), serde_json::json!(meta));
let update_req = UpdateDocumentRequest {
table: serde_json::json!("products"),
doc: serde_json::json!(doc),
id: serde_json::json!(100),
..Default::default(),
};
let update_res = index_api.update(update_req).await;res = await indexApi.insert({
index: 'test',
id: 1,
doc: { content: 'Text 1', name: 'Doc 1', meta: { tags:[1,2,3] } }
})
res = await indexApi.update({ index: 'test', id: 1, doc: { meta: { tags:['one','two','three'] } } });metaField := map[string]interface{} {"tags": []int{1, 2, 3}}
insertDoc := map[string]interface{} {"name": "Doc 1", "meta": metaField}}
insertRequest := manticoreclient.NewInsertDocumentRequest("test", insertDoc)
insertRequest.SetId(1)
res, _, _ := apiClient.IndexAPI.Insert(context.Background()).InsertDocumentRequest(*insertRequest).Execute();
metaField = map[string]interface{} {"tags": []string{"one", "two", "three"}}
updateDoc := map[string]interface{} {"meta": metaField}
updateRequest := manticoreclient.NewUpdateDocumentRequest("test", updateDoc)
res, _, _ = apiClient.IndexAPI.Update(context.Background()).UpdateDocumentRequest(*updateRequest).Execute()Query OK, 1 row affected (0.00 sec)
Query OK, 1 row affected (0.00 sec){
"table":"products",
"updated":1
}Array(
[_index] => products
[_id] => 1
[created] => true
[result] => created
)
Array(
[_index] => products
[updated] => 1
){'created': True,
'found': None,
'id': 100,
'table': 'products',
'result': 'created'}
{'id': 100, 'table': 'products', 'result': 'updated', 'updated': None}{'created': True,
'found': None,
'id': 100,
'table': 'products',
'result': 'created'}
{'id': 100, 'table': 'products', 'result': 'updated', 'updated': None}{"table":"products","_id":100,"created":true,"result":"created"}
{"table":"products","_id":100,"result":"updated"}class SuccessResponse {
index: products
id: 100
created: true
result: created
found: null
}
class UpdateResponse {
index: products
updated: null
id: 100
result: updated
}class SuccessResponse {
index: products
id: 100
created: true
result: created
found: null
}
class UpdateResponse {
index: products
updated: null
id: 100
result: updated
}class SuccessResponse {
index: products
id: 100
created: true
result: created
found: null
}
class UpdateResponse {
index: products
updated: null
id: 100
result: updated
}{
"table":"test",
"_id":1,
"created":true,
"result":"created"
}
{
"table":"test",
"_id":1,
"result":"updated"
}{
"table":"test",
"_id":1,
"created":true,
"result":"created"
}
{
"table":"test",
"_id":1,
"result":"updated"
}当使用复制时,表名应在 SQL 中以 cluster_name: 前缀,以便更新将传播到集群中的所有节点。对于通过 HTTP 的查询,应设置一个 cluster 属性。有关更多详细信息,请参阅 设置复制。
{
"cluster":"nodes4",
"table":"test",
"id":1,
"doc":
{
"gid" : 100,
"price" : 1000
}
}
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
update weekly:posts set enabled=0 where id=1;POST /update
{
"cluster":"weekly",
"table":"products",
"id":1,
"doc":
{
"enabled":0
}
}$index->setName('products')->setCluster('weekly');
$index->updateDocument(['enabled'=>0],1);indexApi.update({"cluster":"weekly", "table" : "products", "id" : 1, "doc" : {"enabled" : 0}})await indexApi.update({"cluster":"weekly", "table" : "products", "id" : 1, "doc" : {"enabled" : 0}})res = wait indexApi.update({"cluster":"weekly", "table" : "products", "id" : 1, "doc" : {"enabled" : 0}});updatedoc = new UpdateDocumentRequest();
doc = new HashMap<String,Object >(){{
put("enabled",0);
}};
updatedoc.index("products").cluster("weekly").id(1L).setDoc(doc);
indexApi.update(updatedoc);Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("enabled", 0);
UpdateDocumentRequest updatedoc = new UpdateDocumentRequest(index: "products", cluster: "weekly", id: 1, doc: doc);
indexApi.Update(updatedoc);let mut doc = HashMap::new();
doc.insert("enabled".to_string(), serde_json::json!(0));
let update_req = UpdateDocumentRequest {
table: serde_json::json!("products"),
cluster: serde_json::json!("weekly"),
doc: serde_json::json!(doc),
id: serde_json::json!(1),
};
let update_res = index_api.update(update_req).await;res = wait indexApi.update( {cluster: 'test_cluster', index : 'test', id : 1, doc : {name : 'Doc 11'}} );updateDoc = map[string]interface{} {"name":"Doc 11"}
updateRequest = manticoreclient.NewUpdateDocumentRequest("test", updateDoc)
updateRequest.SetCluster("test_cluster")
updateRequest.SetId(1)
res, _, _ = apiClient.IndexAPI.Update(context.Background()).UpdateDocumentRequest(*updateRequest).Execute()以下是 SQL UPDATE 语句的语法:
UPDATE table SET col1 = newval1 [, ...] WHERE where_condition [OPTION opt_name = opt_value [, ...]] [FORCE|IGNORE INDEX(id)]
where_condition 的语法与 SELECT 语句相同。
多值属性值集必须作为逗号分隔的列表在括号中指定。要从多值属性中删除所有值,只需将其设置为 ()。
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
UPDATE products SET tags1=(3,6,4) WHERE id=1;
UPDATE products SET tags1=() WHERE id=1;POST /update
{
"table":"products",
"_id":1,
"doc":
{
"tags1": []
}
}$index->updateDocument(['tags1'=>[]],1);indexApi.update({"table" : "products", "id" : 1, "doc" : {"tags1": []}})await indexApi.update({"table" : "products", "id" : 1, "doc" : {"tags1": []}})indexApi.update({"table" : "products", "id" : 1, "doc" : {"tags1": []}})updatedoc = new UpdateDocumentRequest();
doc = new HashMap<String,Object >(){{
put("tags1",new int[]{});
}};
updatedoc.index("products").id(1L).setDoc(doc);
indexApi.update(updatedoc);Dictionary<string, Object> doc = new Dictionary<string, Object>();
doc.Add("tags1", new List<int> {});
UpdateDocumentRequest updatedoc = new UpdateDocumentRequest(index: "products", id: 1, doc: doc);
indexApi.Update(updatedoc);let mut doc = HashMap::new();
doc.insert("tags1".to_string(), serde_json::json!([]));
let update_req = UpdateDocumentRequest {
table: serde_json::json!("products"),
doc: serde_json::json!(doc),
id: serde_json::json!(1),
..Default::default(),
};
let update_res = index_api.update(update_req).await;res = await indexApi.update({ index: 'test', id: 1, doc: { cat: 10 } });updateDoc = map[string]interface{} {"cat":10}
updateRequest = manticoreclient.NewUpdateDocumentRequest("test", updateDoc)
updateRequest.SetId(1)
res, _, _ = apiClient.IndexAPI.Update(context.Background()).UpdateDocumentRequest(*updateRequest).Execute()Query OK, 1 row affected (0.00 sec)
Query OK, 1 row affected (0.00 sec){
"table":"products",
"updated":1
}Array(
[_index] => products
[updated] => 1
){'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{'id': 1, 'table': 'products', 'result': 'updated', 'updated': None}{"table":"products","_id":1,"result":"updated"}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}class UpdateResponse {
index: products
updated: null
id: 1
result: updated
}{
"table":"test",
"_id":1,
"result":"updated"
}{
"table":"test",
"_id":1,
"result":"updated"
}OPTION 子句是 Manticore 特定的扩展,允许您控制每次更新的选项。语法如下:
OPTION <optionname>=<value> [ , ... ]
选项与 SELECT 语句相同。特别是对于 UPDATE 语句,您可以使用这些选项:
- 'ignore_nonexistent_columns' - 如果设置为 1,则表示更新将静默忽略任何关于尝试更新当前表模式中不存在的列的警告。默认值为 0。
- 'strict' - 此选项用于部分 JSON 属性更新。默认情况下(strict=1),
UPDATE将在UPDATE查询尝试对非数值属性进行更新时导致错误。strict=0 时,如果多个属性被更新且某些属性不允许更新,则UPDATE将不会导致错误,而是仅对允许的属性进行更改(其余属性将被忽略)。如果UPDATE的SET变化中没有任何允许的更改,则即使 strict=0,命令也会导致错误。
在极少数情况下,Manticore 的内置查询分析器可能无法正确理解查询并确定是否应使用 ID 表。这可能导致类似 UPDATE ... WHERE id = 123 的查询性能不佳。
有关如何强制优化器使用 docid 索引的信息,请参阅 查询优化器提示。
使用 HTTP JSON 协议的更新是通过 /update 端点执行的。语法类似于 /insert 端点,但这次 doc 属性是必需的。
服务器将返回一个 JSON 对象,说明操作是否成功。
- JSON
POST /update
{
"table":"test",
"id":1,
"doc":
{
"gid" : 100,
"price" : 1000
}
}{
"table": "test",
"_id": 1,
"result": "updated"
}需要更新的文档的 ID 可以直接使用 id 属性设置,如上一个示例所示,或者可以通过查询更新文档,并将更新应用于匹配查询的所有文档:
- JSON
POST /update
{
"table":"test",
"doc":
{
"price" : 1000
},
"query":
{
"match": { "*": "apple" }
}
}{
"table":"products",
"updated":1
}查询语法与 /search 端点 相同。请注意,您不能同时指定 id 和 query。
FLUSH ATTRIBUTES
The FLUSH ATTRIBUTES 命令确保所有活动表中的内存属性更新都被刷新到磁盘。它返回一个标识结果磁盘状态的标签,该状态代表自服务器启动以来实际执行的磁盘属性保存次数。
mysql> UPDATE testindex SET channel_id=1107025 WHERE id=1;
Query OK, 1 row affected (0.04 sec)
mysql> FLUSH ATTRIBUTES;
+------+
| tag |
+------+
| 1 |
+------+
1 row in set (0.19 sec)
参见 attr_flush_period 设置。
您可以使用 /bulk 端点在一个调用中执行多个更新操作。此端点仅适用于 Content-Type 设置为 application/x-ndjson 的数据。数据应格式化为新行分隔的 JSON(NDJSON)。这意味着每行应包含恰好一个 JSON 语句,并以新行 \n 结尾,可能还有 \r。
- JSON
POST /bulk
{ "update" : { "table" : "products", "id" : 1, "doc": { "price" : 10 } } }
{ "update" : { "table" : "products", "id" : 2, "doc": { "price" : 20 } } }{
"items":
[
{
"update":
{
"table":"products",
"_id":1,
"result":"updated"
}
},
{
"update":
{
"table":"products",
"_id":2,
"result":"updated"
}
}
],
"errors":false
}/bulk 端点支持插入、替换和删除。每个语句以动作类型开始(在这种情况下,update)。以下是受支持的动作列表:
insert:插入文档。语法与 /insert 端点 相同。create:insert的同义词replace:替换文档。语法与 /replace 相同。index:replace的同义词update:更新文档。语法与 /update 相同。delete:删除文档。语法与 /delete 端点 相同。
还支持通过查询进行更新和通过查询进行删除。
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
POST /bulk
{ "update" : { "table" : "products", "doc": { "coeff" : 1000 }, "query": { "range": { "price": { "gte": 1000 } } } } }
{ "update" : { "table" : "products", "doc": { "coeff" : 0 }, "query": { "range": { "price": { "lt": 1000 } } } } }$client->bulk([
['update'=>[
'table' => 'products',
'doc' => [
'coeff' => 100
],
'query' => [
'range' => ['price'=>['gte'=>1000]]
]
]
],
['update'=>[
'table' => 'products',
'doc' => [
'coeff' => 0
],
'query' => [
'range' => ['price'=>['lt'=>1000]]
]
]
]
]);docs = [ \
{ "update" : { "table" : "products", "doc": { "coeff" : 1000 }, "query": { "range": { "price": { "gte": 1000 } } } } }, \
{ "update" : { "table" : "products", "doc": { "coeff" : 0 }, "query": { "range": { "price": { "lt": 1000 } } } } } ]
indexApi.bulk('\n'.join(map(json.dumps,docs)))docs = [ \
{ "update" : { "table" : "products", "doc": { "coeff" : 1000 }, "query": { "range": { "price": { "gte": 1000 } } } } }, \
{ "update" : { "table" : "products", "doc": { "coeff" : 0 }, "query": { "range": { "price": { "lt": 1000 } } } } } ]
await indexApi.bulk('\n'.join(map(json.dumps,docs)))docs = [
{ "update" : { "table" : "products", "doc": { "coeff" : 1000 }, "query": { "range": { "price": { "gte": 1000 } } } } },
{ "update" : { "table" : "products", "doc": { "coeff" : 0 }, "query": { "range": { "price": { "lt": 1000 } } } } } ];
res = await indexApi.bulk(docs.map(e=>JSON.stringify(e)).join('\n'));String body = "{ \"update\" : { \"index\" : \"products\", \"doc\": { \"coeff\" : 1000 }, \"query\": { \"range\": { \"price\": { \"gte\": 1000 } } } }} "+"\n"+
"{ \"update\" : { \"index\" : \"products\", \"doc\": { \"coeff\" : 0 }, \"query\": { \"range\": { \"price\": { \"lt\": 1000 } } } } }"+"\n";
indexApi.bulk(body);string body = "{ \"update\" : { \"index\" : \"products\", \"doc\": { \"coeff\" : 1000 }, \"query\": { \"range\": { \"price\": { \"gte\": 1000 } } } }} "+"\n"+
"{ \"update\" : { \"index\" : \"products\", \"doc\": { \"coeff\" : 0 }, \"query\": { \"range\": { \"price\": { \"lt\": 1000 } } } } }"+"\n";
indexApi.Bulk(body);string body = r#"{ "update" : { "index" : "products", "doc": { "coeff" : 1000 }, "query": { "range": { "price": { "gte": 1000 } } } }}
{ "update" : { "index" : "products", "doc": { "coeff" : 0 }, "query": { "range": { "price": { "lt": 1000 } } } } }
"#;
index_api.bulk(body).await;updateDocs = [
{
update: {
index: 'test',
id: 1,
doc: { content: 'Text 11', cat: 1, name: 'Doc 11' },
},
},
{
update: {
index: 'test',
id: 2,
doc: { content: 'Text 22', cat: 9, name: 'Doc 22' },
},
},
];
res = await indexApi.bulk(
updateDocs.map((e) => JSON.stringify(e)).join("\n")
);body := "{\"update\": {\"index\": \"test\", \"id\": 1, \"doc\": {\"content\": \"Text 11\", \"name\": \"Doc 11\", \"cat\": 1 }}}" + "\n" +
"{\"update\": {\"index\": \"test\", \"id\": 2, \"doc\": {\"content\": \"Text 22\", \"name\": \"Doc 22\", \"cat\": 9 }}}" +"\n";
res, _, _ := apiClient.IndexAPI.Bulk(context.Background()).Body(body).Execute(){
"items":
[
{
"update":
{
"table":"products",
"updated":1
}
},
{
"update":
{
"table":"products",
"updated":3
}
}
],
"errors":false
}Array(
[items] => Array (
Array(
[update] => Array(
[_index] => products
[updated] => 1
)
)
Array(
[update] => Array(
[_index] => products
[updated] => 3
)
)
){'error': None,
'items': [{u'update': {u'table': u'products', u'updated': 1}},
{u'update': {u'table': u'products', u'updated': 3}}]}{'error': None,
'items': [{u'update': {u'table': u'products', u'updated': 1}},
{u'update': {u'table': u'products', u'updated': 3}}]}{"items":[{"update":{"table":"products","updated":1}},{"update":{"table":"products","updated":3}}],"errors":false}class BulkResponse {
items: [{update={_index=products, _id=1, created=false, result=updated, status=200}}, {update={_index=products, _id=2, created=false, result=updated, status=200}}]
error: null
additionalProperties: {errors=false}
}class BulkResponse {
items: [{update={_index=products, _id=1, created=false, result=updated, status=200}}, {update={_index=products, _id=2, created=false, result=updated, status=200}}]
error: null
additionalProperties: {errors=false}
}class BulkResponse {
items: [{update={_index=products, _id=1, created=false, result=updated, status=200}}, {update={_index=products, _id=2, created=false, result=updated, status=200}}]
error: null
additionalProperties: {errors=false}
}{
"items":
[
{
"update":
{
"table":"test",
"updated":1
}
},
{
"update":
{
"table":"test",
"updated":1
}
}
],
"errors":false
}{
"items":
[
{
"update":
{
"table":"test",
"updated":1
}
},
{
"update":
{
"table":"test",
"updated":1
}
}
],
"errors":false
}请记住,如果批量操作在导致错误的第一个查询处停止。
attr_update_reserve=size
attr_update_reserve 是一个针对每个表的设置,用于确定为二进制大对象属性更新保留的空间。此设置是可选的,默认值为 128k。
当二进制大对象属性(MVA、字符串、JSON)更新时,它们的长度可能会改变。如果更新后的字符串(或 MVA 或 JSON)比旧字符串短,则会覆盖 .spb 文件中的旧字符串。但是,如果更新后的字符串更长,则更新将写入 .spb 文件的末尾。此文件是内存映射的,这意味着调整其大小可能是一个相当慢的过程,具体取决于操作系统实现的内存映射文件。
为了避免频繁调整大小,可以使用此选项指定在 .spb 文件末尾保留的额外空间。
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
- CONFIG
create table products(title text, price float) attr_update_reserve = '1M'POST /cli -d "
create table products(title text, price float) attr_update_reserve = '1M'"$params = [
'body' => [
'settings' => [
'attr_update_reserve' => '1M'
],
'columns' => [
'title'=>['type'=>'text'],
'price'=>['type'=>'float']
]
],
'table' => 'products'
];
$index = new \Manticoresearch\Index($client);
$index->create($params);utilsApi.sql('create table products(title text, price float) attr_update_reserve = \'1M\'')await utilsApi.sql('create table products(title text, price float) attr_update_reserve = \'1M\'')res = await utilsApi.sql('create table products(title text, price float) attr_update_reserve = \'1M\'');utilsApi.sql("create table products(title text, price float) attr_update_reserve = '1M'", true);utilsApi.Sql("create table products(title text, price float) attr_update_reserve = '1M'", true);utils_api.sql("create table products(title text, price float) attr_update_reserve = '1M'", Some(true)).await;utilsApi.sql("create table test(content text, name string, cat int) attr_update_reserve = '1M'");apiClient.UtilsAPI.Sql(context.Background()).Body("create table test(content text, name string, cat int) attr_update_reserve = '1M'").Execute()table products {
attr_update_reserve = 1M
type = rt
path = tbl
rt_field = title
rt_attr_uint = price
}attr_flush_period = 900 # persist updates to disk every 15 minutes
在更新属性时,更改首先被写入属性的内存副本。此设置允许设置将更新刷新到磁盘之间的间隔。默认值为 0,这禁用了周期性刷新,但刷新仍会在正常关闭时发生。
删除文档仅在实时模式中支持以下表格类型:
您可以根据其ID或某些条件从表格中删除现有文档。
此外,批量删除可用于删除多个文档。
通过SQL和JSON接口均可实现文档的删除。
对于SQL,成功操作的响应将指示删除的行数。
对于JSON,使用json/delete端点。服务器将以JSON对象形式响应,指示操作是否成功以及删除的行数。
建议使用表清空而不是删除来从表中删除所有文档,因为这是一个更快的操作。
在这个示例中,我们从名为test的表中删除匹配全文查询test document的所有文档:
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
mysql> SELECT * FROM TEST;
+------+------+-------------+------+
| id | gid | mva1 | mva2 |
+------+------+-------------+------+
| 100 | 1000 | 100,201 | 100 |
| 101 | 1001 | 101,202 | 101 |
| 102 | 1002 | 102,203 | 102 |
| 103 | 1003 | 103,204 | 103 |
| 104 | 1004 | 104,204,205 | 104 |
| 105 | 1005 | 105,206 | 105 |
| 106 | 1006 | 106,207 | 106 |
| 107 | 1007 | 107,208 | 107 |
+------+------+-------------+------+
8 rows in set (0.00 sec)
mysql> DELETE FROM TEST WHERE MATCH ('test document');
Query OK, 2 rows affected (0.00 sec)
mysql> SELECT * FROM TEST;
+------+------+-------------+------+
| id | gid | mva1 | mva2 |
+------+------+-------------+------+
| 100 | 1000 | 100,201 | 100 |
| 101 | 1001 | 101,202 | 101 |
| 102 | 1002 | 102,203 | 102 |
| 103 | 1003 | 103,204 | 103 |
| 104 | 1004 | 104,204,205 | 104 |
| 105 | 1005 | 105,206 | 105 |
+------+------+-------------+------+
6 rows in set (0.00 sec)POST /delete -d '
{
"table":"test",
"query":
{
"match": { "*": "test document" }
}
}'query中的JSON包含一个用于全文搜索的子句;它与JSON/update中的语法相同。
$index->deleteDocuments(new MatchPhrase('test document','*'));indexApi.delete({"table" : "test", "query": { "match": { "*": "test document" }}})indexApi.delete({"table" : "test", "query": { "match": { "*": "test document" }}})res = await indexApi.delete({"table" : "test", "query": { "match": { "*": "test document" }}});DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest();
query = new HashMap<String,Object>();
query.put("match",new HashMap<String,Object>(){{
put("*","test document");
}});
deleteRequest.index("test").setQuery(query);
indexApi.delete(deleteRequest);Dictionary<string, Object> match = new Dictionary<string, Object>();
match.Add("*", "test document");
Dictionary<string, Object> query = new Dictionary<string, Object>();
query.Add("match", match);
DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest(index: "test", query: query);
indexApi.Delete(deleteRequest);let match_expr = HashMap::new();
match_expr.insert("*".to_string(), serde_json::json!("test document"));
let query = SearchQuery {
match: Some(serde_json::json!(match_expr).into()),
..Default::default()
};
let delete_req = DeleteDocumentRequest::new("test".to_string());
index_api.delete(delete_req).await;res = await indexApi.delete({
index: 'test',
query: { match: { '*': 'test document' } },
});deleteRequest := manticoresearch.NewDeleteDocumentRequest("test")
matchExpr := map[string]interface{} {"*": "test document"}
deleteQuery := map[string]interface{} {"match": matchExpr }
deleteRequest.SetQuery(deleteQuery){
"table":"test",
"deleted":2,
}Array(
[_index] => test
[deleted] => 2
){'deleted': 5, 'id': None, 'table': 'test', 'result': None}{'deleted': 5, 'id': None, 'table': 'test', 'result': None}{"table":"test","deleted":5}class DeleteResponse {
index: test
deleted: 5
id: null
result: null
}class DeleteResponse {
index: test
deleted: 5
id: null
result: null
}class DeleteResponse {
index: test
deleted: 5
id: null
result: null
}{"table":"test","deleted":5}{"table":"test","deleted":5}这里 - 从名为test的表中删除具有id等于1的文档:
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
mysql> DELETE FROM TEST WHERE id=1;
Query OK, 1 rows affected (0.00 sec)POST /delete -d '
{
"table": "test",
"id": 1
}'id中的JSON是需要删除的行id。
$index->deleteDocument(1);indexApi.delete({"table" : "test", "id" : 1})indexApi.delete({"table" : "test", "id" : 1})res = await indexApi.delete({"table" : "test", "id" : 1});DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest();
deleteRequest.index("test").setId(1L);
indexApi.delete(deleteRequest);DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest(index: "test", id: 1);
indexApi.Delete(deleteRequest);let delete_req = DeleteDocumentRequest {
table: "test".to_string(),
id: serde_json::json!(1),
..Default::default(),
};
index_api.delete(delete_req).await;res = await indexApi.delete({ index: 'test', id: 1 });deleteRequest := manticoresearch.NewDeleteDocumentRequest("test")
deleteRequest.SetId(1){
"table": "test",
"_id": 1,
"found": true,
"result": "deleted"
}Array(
[_index] => test
[_id] => 1
[found] => true
[result] => deleted
){'deleted': None, 'id': 1, 'table': 'test', 'result': 'deleted'}{'deleted': None, 'id': 1, 'table': 'test', 'result': 'deleted'}{"table":"test","_id":1,"result":"deleted"}class DeleteResponse {
index: test
_id: 1
result: deleted
}class DeleteResponse {
index: test
_id: 1
result: deleted
}class DeleteResponse {
index: test
_id: 1
result: deleted
}{"table":"test","_id":1,"result":"deleted"}{"table":"test","_id":1,"result":"deleted"}这里,从名为test的表中删除具有id匹配值的文档:
注意,带有id=N或id IN (X,Y)的形式的删除操作最快,因为它们在不执行搜索的情况下删除文档。
还请注意,响应中仅包含对应于_id字段的第一个被删除文档的id。
- SQL
- JSON
- PHP
DELETE FROM TEST WHERE id IN (1,2);POST /delete -d '
{
"table":"test",
"id": [1,2]
}'$index->deleteDocumentsByIds([1,2]);Query OK, 2 rows affected (0.00 sec) {
"table":"test",
"_id":1,
"found":true,
"result":"deleted"
}Array(
[_index] => test
[_id] => 1
[found] => true
[result] => deleted
)Manticore SQL 允许为DELETE语句使用复杂的条件。
例如,这里我们正在从名为test的表中删除匹配全文查询test document且具有属性mva1的值大于206或mva1值为100或103的文档:
- SQL
DELETE FROM TEST WHERE MATCH ('test document') AND ( mva1>206 or mva1 in (100, 103) );
SELECT * FROM TEST;Query OK, 4 rows affected (0.00 sec)
+------+------+-------------+------+
| id | gid | mva1 | mva2 |
+------+------+-------------+------+
| 101 | 1001 | 101,202 | 101 |
| 102 | 1002 | 102,203 | 102 |
| 104 | 1004 | 104,204,205 | 104 |
| 105 | 1005 | 105,206 | 105 |
+------+------+-------------+------+
6 rows in set (0.00 sec)这是从集群cluster的表test中删除文档的一个示例。请注意,我们必须提供集群名称属性以及表属性以从复制集群内的表中删除行:
- SQL
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
delete from cluster:test where id=100;POST /delete -d '
{
"cluster": "cluster",
"table": "test",
"id": 100
}'cluster中的JSON是包含所需表的复制集群的名称
$index->setCluster('cluster');
$index->deleteDocument(100);indexApi.delete({"cluster":"cluster","table" : "test", "id" : 1})indexApi.delete({"cluster":"cluster","table" : "test", "id" : 1})indexApi.delete({"cluster":"cluster_1","table" : "test", "id" : 1})DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest();
deleteRequest.cluster("cluster").index("test").setId(1L);
indexApi.delete(deleteRequest);DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest(index: "test", cluster: "cluster", id: 1);
indexApi.Delete(deleteRequest);let delete_req = DeleteDocumentRequest {
table: "test".to_string(),
cluster: "cluster".to_string(),
id: serde_json::json!(1),
..Default::default(),
};
index_api.delete(delete_req).await;res = await indexApi.delete({ cluster: 'cluster_1', index: 'test', id: 1 });deleteRequest := manticoresearch.NewDeleteDocumentRequest("test")
deleteRequest.SetCluster("cluster_1")
deleteRequest.SetId(1)Array(
[_index] => test
[_id] => 100
[found] => true
[result] => deleted
){'deleted': None, 'id': 1, 'table': 'test', 'result': 'deleted'}{'deleted': None, 'id': 1, 'table': 'test', 'result': 'deleted'}{"table":"test","_id":1,"result":"deleted"}class DeleteResponse {
index: test
_id: 1
result: deleted
}class DeleteResponse {
index: test
_id: 1
result: deleted
}class DeleteResponse {
index: test
_id: 1
result: deleted
}{"table":"test","_id":1,"result":"deleted"}{"table":"test","_id":1,"result":"deleted"}你也可以使用 /bulk 端点,在一次调用中执行多个删除操作。此端点仅适用于 Content-Type 设置为 application/x-ndjson 的数据。数据应格式化为换行符分隔的 JSON(NDJSON)。本质上,这意味着每一行应恰好包含一个 JSON 语句,并以换行符 \n 和可能的 \r 结尾。
- JSON
- PHP
- Python
- Python-asyncio
- javascript
- Java
- C#
- Rust
- TypeScript
- Go
POST /bulk
{ "delete" : { "table" : "test", "id" : 1 } }
{ "delete" : { "table" : "test", "query": { "equals": { "int_data" : 20 } } } }$client->bulk([
['delete' => [
'table' => 'test',
'id' => 1
]
],
['delete'=>[
'table' => 'test',
'query' => [
'equals' => ['int_data' => 20]
]
]
]
]);docs = [ \
{ "delete" : { "table" : "test", "id": 1 } }, \
{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } } ]
indexApi.bulk('\n'.join(map(json.dumps,docs)))docs = [ \
{ "delete" : { "table" : "test", "id": 1 } }, \
{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } } ]
indexApi.bulk('\n'.join(map(json.dumps,docs)))docs = [
{ "delete" : { "table" : "test", "id": 1 } },
{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } } ];
res = await indexApi.bulk(docs.map(e=>JSON.stringify(e)).join('\n'));String body = "{ "delete" : { "table" : "test", "id": 1 } } "+"\n"+
"{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } }"+"\n";
indexApi.bulk(body);string body = "{ "delete" : { "table" : "test", "id": 1 } } "+"\n"+
"{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } }"+"\n";
indexApi.Bulk(body);let bulk_body = r#"{ "delete" : { "table" : "test", "id": 1 } }
{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } }"
"#;
index_api.bulk(bulk_body).await;docs = [
{ "delete" : { "table" : "test", "id": 1 } },
{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } }
];
body = await indexApi.bulk(
docs.map((e) => JSON.stringify(e)).join("\n")
);
res = await indexApi.bulk(body);docs = []string {
`{ "delete" : { "table" : "test", "id": 1 } }`,
`{ "delete" : { "table" : "test", "query": { "equals": { "int_data": 20 } } } }`
]
body = strings.Join(docs, "\n")
resp, httpRes, err := manticoreclient.IndexAPI.Bulk(context.Background()).Body(body).Execute(){
"items":
[
{
"bulk":
{
"table":"test",
"_id":0,
"created":0,
"deleted":2,
"updated":0,
"result":"created",
"status":201
}
}
],
"errors":false
}Array(
[items] => Array
(
[0] => Array
(
[bulk] => Array
(
[_index] => test
[_id] => 0
[created] => 0
[deleted] => 2
[updated] => 0
[result] => created
[status] => 201
)
)
)
[current_line] => 3
[skipped_lines] => 0
[errors] =>
[error] =>
){
'error': None,
'items': [{u'delete': {u'table': test', u'deleted': 2}}]
}{
'error': None,
'items': [{u'delete': {u'table': test', u'deleted': 2}}]
}{"items":[{"delete":{"table":"test","deleted":2}}],"errors":false}class BulkResponse {
items: [{delete={_index=test, _id=0, created=false, deleted=2, result=created, status=200}}]
error: null
additionalProperties: {errors=false}
}class BulkResponse {
items: [{replace={_index=test, _id=0, created=false, deleted=2, result=created, status=200}}]
error: null
additionalProperties: {errors=false}
}class BulkResponse {
items: [{replace={_index=test, _id=0, created=false, deleted=2, result=created, status=200}}]
error: null
additionalProperties: {errors=false}
}{"items":[{"delete":{"table":"test","deleted":2}}],"errors":false}{"items":[{"delete":{"table":"test","deleted":2}}],"errors":false}Manticore 支持基本的事务功能,用于删除和插入实时表和过滤表中的数据,但不包括尝试向包含实时或过滤表的分布式表写入的情况。每次对表的更改首先保存在一个内部变更集里,然后才实际提交到表中。默认情况下,每个命令都包裹在一个单独的自动事务中,使其透明:你只需“插入”一些内容,在完成之后可以看到插入的结果,而无需担心事务。然而,这种行为可以通过手动开始和提交事务来显式管理。
支持事务的命令如下:
以下命令不支持事务:
- UPDATE(这与REPLACE不同,因为UPDATE执行就地属性更新)
- ALTER - 用于更新表结构
- TRUNCATE - 用于清空实时表
- ATTACH - 用于将普通表附加到实时表
- CREATE - 用于创建表
- DROP - 用于删除表
请注意,Manticore 中的事务并不旨在提供隔离性。Manticore 中事务的目的在于允许你累积多个写操作,并在提交时一次性执行所有这些操作,或者如果需要的话,可以回滚所有这些操作。事务与二进制日志集成以确保持久性和一致性。
SET AUTOCOMMIT = {0 | 1}
SET AUTOCOMMIT 控制当前会话的自动提交模式。默认情况下,AUTOCOMMIT 设置为 1。在这种默认设置下,你不需要担心事务,因为任何对任何表进行更改的语句都会隐式地包裹在一个单独的事务中。将其设置为 0 允许你手动管理事务,这意味着它们不会在你显式提交之前可见。
事务仅限于一个实时或过滤表,并且也有大小限制。它们是原子的、一致的、过度隔离的和持久的。过度隔离意味着这些更改不仅对并发事务不可见,甚至对当前会话本身也不可见。
START TRANSACTION | BEGIN
COMMIT
ROLLBACK
BEGIN 语句(或其别名 START TRANSACTION)强制提交任何现有的事务(如果有),并开始一个新的事务。
COMMIT 语句提交当前事务,使所有更改永久化。
ROLLBACK 语句回滚当前事务,取消所有更改。
当你使用其中一个 /bulk JSON 端点(批量插入,批量替换,批量删除)时,可以通过在文档后添加一个空行来强制提交一批文档。
insert into indexrt (id, content, title, channel_id, published) values (1, 'aa', 'blabla', 1, 10);
Query OK, 1 rows affected (0.00 sec)
select * from indexrt where id=1;
+------+------------+-----------+--------+
| id | channel_id | published | title |
+------+------------+-----------+--------+
| 1 | 1 | 10 | blabla |
+------+------------+-----------+--------+
1 row in set (0.00 sec)
插入的值立即在随后的 'select' 语句中可见。
set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
insert into indexrt (id, content, title, channel_id, published) values (3, 'aa', 'bb', 1, 1);
Query OK, 1 row affected (0.00 sec)
insert into indexrt (id, content, title, channel_id, published) values (4, 'aa', 'bb', 1, 1);
Query OK, 1 row affected (0.00 sec)
select * from indexrt where id=3;
Empty set (0.01 sec)
select * from indexrt where id=4;
Empty set (0.00 sec)
在这种情况下,更改不会自动提交。因此,即使在同一会话中,插入的内容也是不可见的,因为它们尚未提交。尽管没有 BEGIN 语句,一个事务仍然隐式启动。
要使更改可见,你需要提交事务:
commit;
Query OK, 0 rows affected (0.00 sec)
select * from indexrt where id=4;
+------+------------+-----------+-------+
| id | channel_id | published | title |
+------+------------+-----------+-------+
| 4 | 1 | 1 | bb |
+------+------------+-----------+-------+
1 row in set (0.00 sec)
select * from indexrt where id=3;
+------+------------+-----------+-------+
| id | channel_id | published | title |
+------+------------+-----------+-------+
| 3 | 1 | 1 | bb |
+------+------------+-----------+-------+
1 row in set (0.00 sec)
在提交语句之后,插入的内容在表中可见。
通过使用 BEGIN 和 COMMIT,你可以明确定义事务的边界,因此在这种情况下不需要担心自动提交。
begin;
Query OK, 0 rows affected (0.00 sec)
insert into indexrt (id, content, title, channel_id, published) values (2, 'aa', 'bb', 1, 1);
Query OK, 1 row affected (0.00 sec)
select * from indexrt where id=2;
Empty set (0.01 sec)
commit;
Query OK, 0 rows affected (0.01 sec)
select * from indexrt where id=2;
+------+------------+-----------+-------+
| id | channel_id | published | title |
+------+------------+-----------+-------+
| 2 | 1 | 1 | bb |
+------+------------+-----------+-------+
1 row in set (0.01 sec)