1#include <iostream>
2#include <memory>
3#include <vector>
4
5#include "mochow/Mochow.h"
6
7int main() {
8    mochow::ClientOptions options;
9    options.endpoint = "http://127.0.0.1:5287";  // $您的实例访问端点
10    options.credentials.account = "root";
11    options.credentials.api_key = "$您的账户API密钥";
12
13    auto client_result = mochow::MochowClient::Create(options);
14    if (!client_result.IsOk()) {
15        std::cerr << "create client failed: "
16                  << client_result.GetStatus().Message() << std::endl;
17        return 1;
18    }
19    std::shared_ptr<mochow::MochowClient> client = client_result.MoveValue();
20    mochow::Database db = client->GetDatabase("db_test");
21    mochow::Table table = db.GetTable("book_vector");
22
23    std::vector<mochow::Index> indexes = {
24        // 向量索引
25        mochow::Index::Hnsw("vector_idx",
26                            "vector",
27                            mochow::MetricType::L2,
28                            mochow::HnswParams{32, 200})
29            .AutoBuild(true)
30            .AutoBuildPolicy(mochow::AutoBuildPolicy::Periodical(
31                24 * 3600, "2026-01-01 12:00:00")),
32        // 标量二级索引
33        mochow::Index::Secondary("book_name_idx", "bookName"),
34        // FILTERING 索引，AGGREGATED_BITMAP 结构可加速范围过滤
35        mochow::Index::FilteringWithFields(
36            "publish_time_filtering",
37            {mochow::FilteringIndexField(
38                "publishTime",
39                mochow::FilteringIndexStructureType::AggregatedBitmap)}),
40        // 持久化 BITMAP / AGGREGATED_BITMAP 索引
41        mochow::Index::PersistentBitmap("region_bitmap", "region"),
42        mochow::Index::PersistentAggregatedBitmap(
43            "views_aggregated_bitmap",
44            "views",
45            mochow::PersistentAggregatedBitmapParams{4, 12}),
46    };
47
48    mochow::Status status = table.CreateIndexes(indexes);
49    if (!status.IsOk()) {
50        std::cerr << "create indexes failed: " << status.Message()
51                  << ", request_id=" << status.RequestId() << std::endl;
52        return 1;
53    }
54
55    (void)client->Close();
56    return 0;
57}

1#include <chrono>
2#include <iostream>
3#include <memory>
4#include <thread>
5#include <vector>
6
7#include "mochow/Mochow.h"
8
9int main() {
10    mochow::ClientOptions options;
11    options.endpoint = "http://127.0.0.1:5287";  // $您的实例访问端点
12    options.credentials.account = "root";
13    options.credentials.api_key = "$您的账户API密钥";
14
15    auto client_result = mochow::MochowClient::Create(options);
16    if (!client_result.IsOk()) {
17        std::cerr << "create client failed: "
18                  << client_result.GetStatus().Message() << std::endl;
19        return 1;
20    }
21    std::shared_ptr<mochow::MochowClient> client = client_result.MoveValue();
22    mochow::Database db = client->GetDatabase("db_test");
23    mochow::Table table = db.GetTable("book_segments");
24
25    mochow::Index inverted_index = mochow::Index::Inverted(
26        "segment_inverted_idx",
27        {"segment"},
28        mochow::InvertedIndexParams()
29            .Analyzer(mochow::InvertedIndexAnalyzer::Default)
30            .ParseMode(mochow::InvertedIndexParseMode::Coarse)
31            .CaseSensitive(true)
32            .StopWords(mochow::StopWordsParams(mochow::StopWordsMode::Custom,
33                                               {"呀", "啊", "哦"})),
34        {mochow::InvertedIndexFieldAttribute::Analyzed});
35
36    mochow::Status status = table.CreateIndexes({inverted_index});
37    if (!status.IsOk()) {
38        std::cerr << "create inverted index failed: " << status.Message()
39                  << std::endl;
40        return 1;
41    }
42
43    // 倒排索引异步构建，等待 state 变为 NORMAL 后才能发起 BM25/Hybrid 检索
44    for (int i = 0; i < 60; ++i) {
45        mochow::IndexInfo index_info;
46        status = table.DescribeIndex("segment_inverted_idx", &index_info);
47        if (!status.IsOk()) {
48            std::cerr << "describe index failed: " << status.Message()
49                      << std::endl;
50            return 1;
51        }
52        if (index_info.state == "NORMAL") {
53            break;
54        }
55        std::this_thread::sleep_for(std::chrono::seconds(2));
56    }
57
58    (void)client->Close();
59    return 0;
60}

1#include <iostream>
2#include <memory>
3
4#include "mochow/Mochow.h"
5
6int main() {
7    mochow::ClientOptions options;
8    options.endpoint = "http://127.0.0.1:5287";  // $您的实例访问端点
9    options.credentials.account = "root";
10    options.credentials.api_key = "$您的账户API密钥";
11
12    auto client_result = mochow::MochowClient::Create(options);
13    if (!client_result.IsOk()) {
14        std::cerr << "create client failed: "
15                  << client_result.GetStatus().Message() << std::endl;
16        return 1;
17    }
18    std::shared_ptr<mochow::MochowClient> client = client_result.MoveValue();
19    mochow::Database db = client->GetDatabase("db_test");
20    mochow::Table table = db.GetTable("book_vector");
21
22    mochow::Status status = table.DropIndex("vector_idx");
23    if (!status.IsOk()) {
24        std::cerr << "drop index failed: " << status.Message() << std::endl;
25        return 1;
26    }
27
28    (void)client->Close();
29    return 0;
30}

1#include <chrono>
2#include <iostream>
3#include <memory>
4#include <thread>
5
6#include "mochow/Mochow.h"
7
8int main() {
9    mochow::ClientOptions options;
10    options.endpoint = "http://127.0.0.1:5287";  // $您的实例访问端点
11    options.credentials.account = "root";
12    options.credentials.api_key = "$您的账户API密钥";
13
14    auto client_result = mochow::MochowClient::Create(options);
15    if (!client_result.IsOk()) {
16        std::cerr << "create client failed: "
17                  << client_result.GetStatus().Message() << std::endl;
18        return 1;
19    }
20    std::shared_ptr<mochow::MochowClient> client = client_result.MoveValue();
21    mochow::Database db = client->GetDatabase("db_test");
22    mochow::Table table = db.GetTable("book_vector");
23
24    mochow::Status status = table.RebuildIndex("vector_idx");
25    if (!status.IsOk()) {
26        std::cerr << "rebuild index failed: " << status.Message() << std::endl;
27        return 1;
28    }
29
30    for (int i = 0; i < 90; ++i) {
31        mochow::IndexInfo index_info;
32        status = table.DescribeIndex("vector_idx", &index_info);
33        if (!status.IsOk()) {
34            std::cerr << "describe index failed: " << status.Message()
35                      << std::endl;
36            return 1;
37        }
38        if (index_info.state == "NORMAL") {
39            break;
40        }
41        std::this_thread::sleep_for(std::chrono::seconds(1));
42    }
43
44    (void)client->Close();
45    return 0;
46}

1#include <iostream>
2#include <memory>
3
4#include "mochow/Mochow.h"
5
6int main() {
7    mochow::ClientOptions options;
8    options.endpoint = "http://127.0.0.1:5287";  // $您的实例访问端点
9    options.credentials.account = "root";
10    options.credentials.api_key = "$您的账户API密钥";
11
12    auto client_result = mochow::MochowClient::Create(options);
13    if (!client_result.IsOk()) {
14        std::cerr << "create client failed: "
15                  << client_result.GetStatus().Message() << std::endl;
16        return 1;
17    }
18    std::shared_ptr<mochow::MochowClient> client = client_result.MoveValue();
19    mochow::Database db = client->GetDatabase("db_test");
20    mochow::Table table = db.GetTable("book_vector");
21
22    mochow::IndexInfo index_info;
23    mochow::Status status = table.DescribeIndex("vector_idx", &index_info);
24    if (!status.IsOk()) {
25        std::cerr << "describe index failed: " << status.Message() << std::endl;
26        return 1;
27    }
28
29    std::cout << "index: " << index_info.index.Name()
30              << ", field: " << index_info.index.FieldName()
31              << ", auto_build: " << index_info.index.AutoBuild()
32              << ", state: " << index_info.state << std::endl;
33    if (index_info.has_build_completion_rate) {
34        std::cout << "build_completion_rate: "
35                  << index_info.build_completion_rate << std::endl;
36    }
37
38    (void)client->Close();
39    return 0;
40}

1#include <iostream>
2#include <memory>
3
4#include "mochow/Mochow.h"
5
6int main() {
7    mochow::ClientOptions options;
8    options.endpoint = "http://127.0.0.1:5287";  // $您的实例访问端点
9    options.credentials.account = "root";
10    options.credentials.api_key = "$您的账户API密钥";
11
12    auto client_result = mochow::MochowClient::Create(options);
13    if (!client_result.IsOk()) {
14        std::cerr << "create client failed: "
15                  << client_result.GetStatus().Message() << std::endl;
16        return 1;
17    }
18    std::shared_ptr<mochow::MochowClient> client = client_result.MoveValue();
19    mochow::Database db = client->GetDatabase("db_test");
20    mochow::Table table = db.GetTable("book_vector");
21
22    mochow::ModifyIndexRequest modify_index;
23    modify_index.WithIndexName("vector_idx")
24                .WithAutoBuild(true)
25                .WithAutoBuildPolicy(
26                    mochow::AutoBuildPolicy::Timing("2026-06-06 00:00:00"));
27
28    mochow::Status status = table.ModifyIndex(modify_index);
29    if (!status.IsOk()) {
30        std::cerr << "modify index failed: " << status.Message() << std::endl;
31        return 1;
32    }
33
34    (void)client->Close();
35    return 0;
36}