diff --git a/CHANGELOG.md b/CHANGELOG.md index c847f410ce..9c9dd3df81 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -680,7 +680,7 @@ Please mark all change in change log and use the issue from GitHub - MS-67 Fix license check bug - MS-76 Fix pipeline crash bug - MS-100 cmake: fix AWS build issue -- MS-101 change AWS build type to Release +- MS-101 Change AWS build type to Release ## Improvement diff --git a/core/src/config/Config.cpp b/core/src/config/Config.cpp index e7ef144370..d173cbbe85 100644 --- a/core/src/config/Config.cpp +++ b/core/src/config/Config.cpp @@ -261,7 +261,7 @@ Config::ResetDefaultConfig() { /* db config */ CONFIG_CHECK(SetDBConfigBackendUrl(CONFIG_DB_BACKEND_URL_DEFAULT)); - CONFIG_CHECK(SetDBConfigPreloadCollection(CONFIG_DB_PRELOAD_TABLE_DEFAULT)); + CONFIG_CHECK(SetDBConfigPreloadCollection(CONFIG_DB_PRELOAD_COLLECTION_DEFAULT)); CONFIG_CHECK(SetDBConfigArchiveDiskThreshold(CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT)); CONFIG_CHECK(SetDBConfigArchiveDaysThreshold(CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT)); CONFIG_CHECK(SetDBConfigAutoFlushInterval(CONFIG_DB_AUTO_FLUSH_INTERVAL_DEFAULT)); @@ -353,7 +353,7 @@ Config::SetConfigCli(const std::string& parent_key, const std::string& child_key } else if (parent_key == CONFIG_DB) { if (child_key == CONFIG_DB_BACKEND_URL) { status = SetDBConfigBackendUrl(value); - } else if (child_key == CONFIG_DB_PRELOAD_TABLE) { + } else if (child_key == CONFIG_DB_PRELOAD_COLLECTION) { status = SetDBConfigPreloadCollection(value); } else if (child_key == CONFIG_DB_AUTO_FLUSH_INTERVAL) { status = SetDBConfigAutoFlushInterval(value); @@ -795,7 +795,7 @@ Config::CheckDBConfigPreloadCollection(const std::string& value) { bool exist = false; auto status = DBWrapper::DB()->HasNativeCollection(collection, exist); if (!(status.ok() && exist)) { - return Status(SERVER_TABLE_NOT_EXIST, "Collection " + collection + " not exist"); + return Status(SERVER_COLLECTION_NOT_EXIST, "Collection " + collection + " not exist"); } table_set.insert(collection); } @@ -1503,7 +1503,7 @@ Config::GetDBConfigArchiveDaysThreshold(int64_t& value) { Status Config::GetDBConfigPreloadCollection(std::string& value) { - value = GetConfigStr(CONFIG_DB, CONFIG_DB_PRELOAD_TABLE); + value = GetConfigStr(CONFIG_DB, CONFIG_DB_PRELOAD_COLLECTION); return Status::OK(); } @@ -1856,7 +1856,7 @@ Status Config::SetDBConfigPreloadCollection(const std::string& value) { CONFIG_CHECK(CheckDBConfigPreloadCollection(value)); std::string cor_value = value == "*" ? "\'*\'" : value; - return SetConfigValueInMem(CONFIG_DB, CONFIG_DB_PRELOAD_TABLE, cor_value); + return SetConfigValueInMem(CONFIG_DB, CONFIG_DB_PRELOAD_COLLECTION, cor_value); } Status diff --git a/core/src/config/Config.h b/core/src/config/Config.h index 6ed6d443b0..aa32fc091d 100644 --- a/core/src/config/Config.h +++ b/core/src/config/Config.h @@ -57,8 +57,8 @@ static const char* CONFIG_DB_ARCHIVE_DISK_THRESHOLD = "archive_disk_threshold"; static const char* CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT = "0"; static const char* CONFIG_DB_ARCHIVE_DAYS_THRESHOLD = "archive_days_threshold"; static const char* CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT = "0"; -static const char* CONFIG_DB_PRELOAD_TABLE = "preload_table"; -static const char* CONFIG_DB_PRELOAD_TABLE_DEFAULT = ""; +static const char* CONFIG_DB_PRELOAD_COLLECTION = "preload_table"; +static const char* CONFIG_DB_PRELOAD_COLLECTION_DEFAULT = ""; static const char* CONFIG_DB_AUTO_FLUSH_INTERVAL = "auto_flush_interval"; static const char* CONFIG_DB_AUTO_FLUSH_INTERVAL_DEFAULT = "1"; diff --git a/core/src/db/Utils.cpp b/core/src/db/Utils.cpp index a6b51375d1..2c2a767b49 100644 --- a/core/src/db/Utils.cpp +++ b/core/src/db/Utils.cpp @@ -43,7 +43,7 @@ ConstructParentFolder(const std::string& db_path, const meta::SegmentSchema& tab } static std::string -GetTableFileParentFolder(const DBMetaOptions& options, const meta::SegmentSchema& table_file) { +GetCollectionFileParentFolder(const DBMetaOptions& options, const meta::SegmentSchema& table_file) { uint64_t path_count = options.slave_paths_.size() + 1; std::string target_path = options.path_; uint64_t index = 0; @@ -102,7 +102,7 @@ CreateCollectionPath(const DBMetaOptions& options, const std::string& collection } Status -DeleteTablePath(const DBMetaOptions& options, const std::string& collection_id, bool force) { +DeleteCollectionPath(const DBMetaOptions& options, const std::string& collection_id, bool force) { std::vector paths = options.slave_paths_; paths.push_back(options.path_); @@ -136,7 +136,7 @@ DeleteTablePath(const DBMetaOptions& options, const std::string& collection_id, Status CreateCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file) { - std::string parent_path = GetTableFileParentFolder(options, table_file); + std::string parent_path = GetCollectionFileParentFolder(options, table_file); auto status = server::CommonUtil::CreateDirectory(parent_path); fiu_do_on("CreateCollectionFilePath.fail_create", status = Status(DB_INVALID_PATH, "")); @@ -151,14 +151,14 @@ CreateCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& tabl } Status -GetTableFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file) { +GetCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file) { std::string parent_path = ConstructParentFolder(options.path_, table_file); std::string file_path = parent_path + "/" + table_file.file_id_; bool s3_enable = false; server::Config& config = server::Config::GetInstance(); config.GetStorageConfigS3Enable(s3_enable); - fiu_do_on("GetTableFilePath.enable_s3", s3_enable = true); + fiu_do_on("GetCollectionFilePath.enable_s3", s3_enable = true); if (s3_enable) { /* need not check file existence */ table_file.location_ = file_path; @@ -188,15 +188,15 @@ GetTableFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file) } Status -DeleteTableFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file) { - utils::GetTableFilePath(options, table_file); +DeleteCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file) { + utils::GetCollectionFilePath(options, table_file); boost::filesystem::remove(table_file.location_); return Status::OK(); } Status DeleteSegment(const DBMetaOptions& options, meta::SegmentSchema& table_file) { - utils::GetTableFilePath(options, table_file); + utils::GetCollectionFilePath(options, table_file); std::string segment_dir; GetParentPath(table_file.location_, segment_dir); boost::filesystem::remove_all(segment_dir); diff --git a/core/src/db/Utils.h b/core/src/db/Utils.h index ceef9c27b5..b57167295e 100644 --- a/core/src/db/Utils.h +++ b/core/src/db/Utils.h @@ -28,14 +28,14 @@ GetMicroSecTimeStamp(); Status CreateCollectionPath(const DBMetaOptions& options, const std::string& collection_id); Status -DeleteTablePath(const DBMetaOptions& options, const std::string& collection_id, bool force = true); +DeleteCollectionPath(const DBMetaOptions& options, const std::string& collection_id, bool force = true); Status CreateCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file); Status -GetTableFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file); +GetCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file); Status -DeleteTableFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file); +DeleteCollectionFilePath(const DBMetaOptions& options, meta::SegmentSchema& table_file); Status DeleteSegment(const DBMetaOptions& options, meta::SegmentSchema& table_file); diff --git a/core/src/db/insert/MemTable.cpp b/core/src/db/insert/MemTable.cpp index 84b8306522..6a0d77bced 100644 --- a/core/src/db/insert/MemTable.cpp +++ b/core/src/db/insert/MemTable.cpp @@ -122,7 +122,7 @@ MemTable::Serialize(uint64_t wal_lsn, bool apply_delete) { } // Update flush lsn - auto status = meta_->UpdateTableFlushLSN(collection_id_, wal_lsn); + auto status = meta_->UpdateCollectionFlushLSN(collection_id_, wal_lsn); if (!status.ok()) { std::string err_msg = "Failed to write flush lsn to meta: " + status.ToString(); ENGINE_LOG_ERROR << err_msg; diff --git a/core/src/db/meta/Meta.h b/core/src/db/meta/Meta.h index 0e7286f665..7f85c2caa5 100644 --- a/core/src/db/meta/Meta.h +++ b/core/src/db/meta/Meta.h @@ -58,7 +58,7 @@ class Meta { UpdateCollectionFlag(const std::string& collection_id, int64_t flag) = 0; virtual Status - UpdateTableFlushLSN(const std::string& collection_id, uint64_t flush_lsn) = 0; + UpdateCollectionFlushLSN(const std::string& collection_id, uint64_t flush_lsn) = 0; virtual Status GetCollectionFlushLSN(const std::string& collection_id, uint64_t& flush_lsn) = 0; @@ -67,13 +67,14 @@ class Meta { DropCollection(const std::string& collection_id) = 0; virtual Status - DeleteTableFiles(const std::string& collection_id) = 0; + DeleteCollectionFiles(const std::string& collection_id) = 0; virtual Status CreateCollectionFile(SegmentSchema& file_schema) = 0; virtual Status - GetTableFiles(const std::string& collection_id, const std::vector& ids, SegmentsSchema& table_files) = 0; + GetCollectionFiles(const std::string& collection_id, const std::vector& ids, + SegmentsSchema& table_files) = 0; virtual Status GetCollectionFilesBySegmentId(const std::string& segment_id, SegmentsSchema& table_files) = 0; diff --git a/core/src/db/meta/MySQLMetaImpl.cpp b/core/src/db/meta/MySQLMetaImpl.cpp index d9932b47a9..1cb8495273 100644 --- a/core/src/db/meta/MySQLMetaImpl.cpp +++ b/core/src/db/meta/MySQLMetaImpl.cpp @@ -187,7 +187,7 @@ MySQLMetaImpl::~MySQLMetaImpl() { } Status -MySQLMetaImpl::NextTableId(std::string& collection_id) { +MySQLMetaImpl::NextCollectionId(std::string& collection_id) { std::lock_guard lock(genid_mutex_); // avoid duplicated id std::stringstream ss; SafeIDGenerator& id_generator = SafeIDGenerator::GetInstance(); @@ -335,10 +335,10 @@ MySQLMetaImpl::Initialize() { InitializeQuery << "CREATE TABLE IF NOT EXISTS " << TABLES_SCHEMA.name() << " (" << TABLES_SCHEMA.ToString() + ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::Initialize: " << InitializeQuery.str(); + ENGINE_LOG_DEBUG << "Initialize: " << InitializeQuery.str(); bool initialize_query_exec = InitializeQuery.exec(); - fiu_do_on("MySQLMetaImpl.Initialize.fail_create_table_scheme", initialize_query_exec = false); + fiu_do_on("MySQLMetaImpl.Initialize.fail_create_collection_scheme", initialize_query_exec = false); if (!initialize_query_exec) { std::string msg = "Failed to create meta collection 'Tables' in MySQL"; ENGINE_LOG_ERROR << msg; @@ -349,10 +349,10 @@ MySQLMetaImpl::Initialize() { InitializeQuery << "CREATE TABLE IF NOT EXISTS " << TABLEFILES_SCHEMA.name() << " (" << TABLEFILES_SCHEMA.ToString() + ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::Initialize: " << InitializeQuery.str(); + ENGINE_LOG_DEBUG << "Initialize: " << InitializeQuery.str(); initialize_query_exec = InitializeQuery.exec(); - fiu_do_on("MySQLMetaImpl.Initialize.fail_create_table_files", initialize_query_exec = false); + fiu_do_on("MySQLMetaImpl.Initialize.fail_create_collection_files", initialize_query_exec = false); if (!initialize_query_exec) { std::string msg = "Failed to create meta collection 'TableFiles' in MySQL"; ENGINE_LOG_ERROR << msg; @@ -363,7 +363,7 @@ MySQLMetaImpl::Initialize() { InitializeQuery << "CREATE TABLE IF NOT EXISTS " << ENVIRONMENT_SCHEMA.name() << " (" << ENVIRONMENT_SCHEMA.ToString() + ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::Initialize: " << InitializeQuery.str(); + ENGINE_LOG_DEBUG << "Initialize: " << InitializeQuery.str(); initialize_query_exec = InitializeQuery.exec(); if (!initialize_query_exec) { @@ -376,7 +376,7 @@ MySQLMetaImpl::Initialize() { } Status -MySQLMetaImpl::CreateCollection(CollectionSchema& table_schema) { +MySQLMetaImpl::CreateCollection(CollectionSchema& collection_schema) { try { server::MetricCollector metric; { @@ -389,22 +389,21 @@ MySQLMetaImpl::CreateCollection(CollectionSchema& table_schema) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query createTableQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); - if (table_schema.collection_id_.empty()) { - NextTableId(table_schema.collection_id_); + if (collection_schema.collection_id_.empty()) { + NextCollectionId(collection_schema.collection_id_); } else { - createTableQuery << "SELECT state FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote - << table_schema.collection_id_ << ";"; + statement << "SELECT state FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote + << collection_schema.collection_id_ << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CreateCollection: " << createTableQuery.str(); + ENGINE_LOG_DEBUG << "CreateCollection: " << statement.str(); - mysqlpp::StoreQueryResult res = createTableQuery.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (res.num_rows() == 1) { int state = res[0]["state"]; - fiu_do_on("MySQLMetaImpl.CreateCollectionTable.schema_TO_DELETE", - state = CollectionSchema::TO_DELETE); + fiu_do_on("MySQLMetaImpl.CreateCollection.schema_TO_DELETE", state = CollectionSchema::TO_DELETE); if (CollectionSchema::TO_DELETE == state) { return Status(DB_ERROR, "Collection already exists and it is in delete state, please wait a second"); @@ -414,51 +413,50 @@ MySQLMetaImpl::CreateCollection(CollectionSchema& table_schema) { } } - table_schema.id_ = -1; - table_schema.created_on_ = utils::GetMicroSecTimeStamp(); + collection_schema.id_ = -1; + collection_schema.created_on_ = utils::GetMicroSecTimeStamp(); std::string id = "NULL"; // auto-increment - std::string& collection_id = table_schema.collection_id_; - std::string state = std::to_string(table_schema.state_); - std::string dimension = std::to_string(table_schema.dimension_); - std::string created_on = std::to_string(table_schema.created_on_); - std::string flag = std::to_string(table_schema.flag_); - std::string index_file_size = std::to_string(table_schema.index_file_size_); - std::string engine_type = std::to_string(table_schema.engine_type_); - std::string& index_params = table_schema.index_params_; - std::string metric_type = std::to_string(table_schema.metric_type_); - std::string& owner_table = table_schema.owner_collection_; - std::string& partition_tag = table_schema.partition_tag_; - std::string& version = table_schema.version_; - std::string flush_lsn = std::to_string(table_schema.flush_lsn_); + std::string& collection_id = collection_schema.collection_id_; + std::string state = std::to_string(collection_schema.state_); + std::string dimension = std::to_string(collection_schema.dimension_); + std::string created_on = std::to_string(collection_schema.created_on_); + std::string flag = std::to_string(collection_schema.flag_); + std::string index_file_size = std::to_string(collection_schema.index_file_size_); + std::string engine_type = std::to_string(collection_schema.engine_type_); + std::string& index_params = collection_schema.index_params_; + std::string metric_type = std::to_string(collection_schema.metric_type_); + std::string& owner_collection = collection_schema.owner_collection_; + std::string& partition_tag = collection_schema.partition_tag_; + std::string& version = collection_schema.version_; + std::string flush_lsn = std::to_string(collection_schema.flush_lsn_); - createTableQuery << "INSERT INTO " << META_TABLES << " VALUES(" << id << ", " << mysqlpp::quote - << collection_id << ", " << state << ", " << dimension << ", " << created_on << ", " - << flag << ", " << index_file_size << ", " << engine_type << ", " << mysqlpp::quote - << index_params << ", " << metric_type << ", " << mysqlpp::quote << owner_table << ", " - << mysqlpp::quote << partition_tag << ", " << mysqlpp::quote << version << ", " - << flush_lsn << ");"; + statement << "INSERT INTO " << META_TABLES << " VALUES(" << id << ", " << mysqlpp::quote << collection_id + << ", " << state << ", " << dimension << ", " << created_on << ", " << flag << ", " + << index_file_size << ", " << engine_type << ", " << mysqlpp::quote << index_params << ", " + << metric_type << ", " << mysqlpp::quote << owner_collection << ", " << mysqlpp::quote + << partition_tag << ", " << mysqlpp::quote << version << ", " << flush_lsn << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CreateCollection: " << createTableQuery.str(); + ENGINE_LOG_DEBUG << "CreateCollection: " << statement.str(); - if (mysqlpp::SimpleResult res = createTableQuery.execute()) { - table_schema.id_ = res.insert_id(); // Might need to use SELECT LAST_INSERT_ID()? + if (mysqlpp::SimpleResult res = statement.execute()) { + collection_schema.id_ = res.insert_id(); // Might need to use SELECT LAST_INSERT_ID()? // Consume all results to avoid "Commands out of sync" error } else { - return HandleException("Add Collection Error", createTableQuery.error()); + return HandleException("Failed to create collection", statement.error()); } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully create collection: " << table_schema.collection_id_; - return utils::CreateCollectionPath(options_, table_schema.collection_id_); + ENGINE_LOG_DEBUG << "Successfully create collection: " << collection_schema.collection_id_; + return utils::CreateCollectionPath(options_, collection_schema.collection_id_); } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CREATING TABLE", e.what()); + return HandleException("Failed to create collection", e.what()); } } Status -MySQLMetaImpl::DescribeCollection(CollectionSchema& table_schema) { +MySQLMetaImpl::DescribeCollection(CollectionSchema& collection_schema) { try { server::MetricCollector metric; mysqlpp::StoreQueryResult res; @@ -472,38 +470,38 @@ MySQLMetaImpl::DescribeCollection(CollectionSchema& table_schema) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query describeTableQuery = connectionPtr->query(); - describeTableQuery - << "SELECT id, state, dimension, created_on, flag, index_file_size, engine_type, index_params" - << " , metric_type ,owner_table, partition_tag, version, flush_lsn" - << " FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote << table_schema.collection_id_ - << " AND state <> " << std::to_string(CollectionSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, state, dimension, created_on, flag, index_file_size, engine_type, index_params" + << " , metric_type ,owner_table, partition_tag, version, flush_lsn" + << " FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote + << collection_schema.collection_id_ << " AND state <> " + << std::to_string(CollectionSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DescribeCollection: " << describeTableQuery.str(); + ENGINE_LOG_DEBUG << "DescribeCollection: " << statement.str(); - res = describeTableQuery.store(); + res = statement.store(); } // Scoped Connection if (res.num_rows() == 1) { const mysqlpp::Row& resRow = res[0]; - table_schema.id_ = resRow["id"]; // implicit conversion - table_schema.state_ = resRow["state"]; - table_schema.dimension_ = resRow["dimension"]; - table_schema.created_on_ = resRow["created_on"]; - table_schema.flag_ = resRow["flag"]; - table_schema.index_file_size_ = resRow["index_file_size"]; - table_schema.engine_type_ = resRow["engine_type"]; - resRow["index_params"].to_string(table_schema.index_params_); - table_schema.metric_type_ = resRow["metric_type"]; - resRow["owner_table"].to_string(table_schema.owner_collection_); - resRow["partition_tag"].to_string(table_schema.partition_tag_); - resRow["version"].to_string(table_schema.version_); - table_schema.flush_lsn_ = resRow["flush_lsn"]; + collection_schema.id_ = resRow["id"]; // implicit conversion + collection_schema.state_ = resRow["state"]; + collection_schema.dimension_ = resRow["dimension"]; + collection_schema.created_on_ = resRow["created_on"]; + collection_schema.flag_ = resRow["flag"]; + collection_schema.index_file_size_ = resRow["index_file_size"]; + collection_schema.engine_type_ = resRow["engine_type"]; + resRow["index_params"].to_string(collection_schema.index_params_); + collection_schema.metric_type_ = resRow["metric_type"]; + resRow["owner_table"].to_string(collection_schema.owner_collection_); + resRow["partition_tag"].to_string(collection_schema.partition_tag_); + resRow["version"].to_string(collection_schema.version_); + collection_schema.flush_lsn_ = resRow["flush_lsn"]; } else { - return Status(DB_NOT_FOUND, "Collection " + table_schema.collection_id_ + " not found"); + return Status(DB_NOT_FOUND, "Collection " + collection_schema.collection_id_ + " not found"); } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DESCRIBING TABLE", e.what()); + return HandleException("Failed to describe collection", e.what()); } return Status::OK(); @@ -533,7 +531,7 @@ MySQLMetaImpl::HasCollection(const std::string& collection_id, bool& has_or_not) << " AS " << mysqlpp::quote << "check" << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::HasCollection: " << HasCollectionQuery.str(); + ENGINE_LOG_DEBUG << "HasCollection: " << HasCollectionQuery.str(); res = HasCollectionQuery.store(); } // Scoped Connection @@ -541,14 +539,14 @@ MySQLMetaImpl::HasCollection(const std::string& collection_id, bool& has_or_not) int check = res[0]["check"]; has_or_not = (check == 1); } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CHECKING IF TABLE EXISTS", e.what()); + return HandleException("Failed to check collection existence", e.what()); } return Status::OK(); } Status -MySQLMetaImpl::AllCollections(std::vector& table_schema_array) { +MySQLMetaImpl::AllCollections(std::vector& collection_schema_array) { try { server::MetricCollector metric; mysqlpp::StoreQueryResult res; @@ -556,41 +554,41 @@ MySQLMetaImpl::AllCollections(std::vector& table_schema_array) mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_); bool is_null_connection = (connectionPtr == nullptr); - fiu_do_on("MySQLMetaImpl.AllTable.null_connection", is_null_connection = true); - fiu_do_on("MySQLMetaImpl.AllTable.throw_exception", throw std::exception();); + fiu_do_on("MySQLMetaImpl.AllCollection.null_connection", is_null_connection = true); + fiu_do_on("MySQLMetaImpl.AllCollection.throw_exception", throw std::exception();); if (is_null_connection) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query allTablesQuery = connectionPtr->query(); - allTablesQuery << "SELECT id, table_id, dimension, engine_type, index_params, index_file_size, metric_type" - << " ,owner_table, partition_tag, version, flush_lsn" - << " FROM " << META_TABLES << " WHERE state <> " - << std::to_string(CollectionSchema::TO_DELETE) << " AND owner_table = \"\";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, dimension, engine_type, index_params, index_file_size, metric_type" + << " ,owner_table, partition_tag, version, flush_lsn" + << " FROM " << META_TABLES << " WHERE state <> " << std::to_string(CollectionSchema::TO_DELETE) + << " AND owner_table = \"\";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::AllCollections: " << allTablesQuery.str(); + ENGINE_LOG_DEBUG << "AllCollections: " << statement.str(); - res = allTablesQuery.store(); + res = statement.store(); } // Scoped Connection for (auto& resRow : res) { - CollectionSchema table_schema; - table_schema.id_ = resRow["id"]; // implicit conversion - resRow["table_id"].to_string(table_schema.collection_id_); - table_schema.dimension_ = resRow["dimension"]; - table_schema.index_file_size_ = resRow["index_file_size"]; - table_schema.engine_type_ = resRow["engine_type"]; - resRow["index_params"].to_string(table_schema.index_params_); - table_schema.metric_type_ = resRow["metric_type"]; - resRow["owner_table"].to_string(table_schema.owner_collection_); - resRow["partition_tag"].to_string(table_schema.partition_tag_); - resRow["version"].to_string(table_schema.version_); - table_schema.flush_lsn_ = resRow["flush_lsn"]; + CollectionSchema collection_schema; + collection_schema.id_ = resRow["id"]; // implicit conversion + resRow["table_id"].to_string(collection_schema.collection_id_); + collection_schema.dimension_ = resRow["dimension"]; + collection_schema.index_file_size_ = resRow["index_file_size"]; + collection_schema.engine_type_ = resRow["engine_type"]; + resRow["index_params"].to_string(collection_schema.index_params_); + collection_schema.metric_type_ = resRow["metric_type"]; + resRow["owner_table"].to_string(collection_schema.owner_collection_); + resRow["partition_tag"].to_string(collection_schema.partition_tag_); + resRow["version"].to_string(collection_schema.version_); + collection_schema.flush_lsn_ = resRow["flush_lsn"]; - table_schema_array.emplace_back(table_schema); + collection_schema_array.emplace_back(collection_schema); } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DESCRIBING ALL TABLES", e.what()); + return HandleException("Failed to get all collections", e.what()); } return Status::OK(); @@ -612,67 +610,65 @@ MySQLMetaImpl::DropCollection(const std::string& collection_id) { } // soft delete collection - mysqlpp::Query deleteTableQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); // - deleteTableQuery << "UPDATE " << META_TABLES - << " SET state = " << std::to_string(CollectionSchema::TO_DELETE) - << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; + statement << "UPDATE " << META_TABLES << " SET state = " << std::to_string(CollectionSchema::TO_DELETE) + << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DeleteTable: " << deleteTableQuery.str(); + ENGINE_LOG_DEBUG << "DeleteCollection: " << statement.str(); - if (!deleteTableQuery.exec()) { - return HandleException("QUERY ERROR WHEN DELETING TABLE", deleteTableQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to drop collection", statement.error()); } } // Scoped Connection bool is_writable_mode{mode_ == DBOptions::MODE::CLUSTER_WRITABLE}; fiu_do_on("MySQLMetaImpl.DropCollection.CLUSTER_WRITABLE_MODE", is_writable_mode = true); if (is_writable_mode) { - DeleteTableFiles(collection_id); + DeleteCollectionFiles(collection_id); } - ENGINE_LOG_DEBUG << "Successfully delete collection, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Successfully delete collection: " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DELETING TABLE", e.what()); + return HandleException("Failed to drop collection", e.what()); } return Status::OK(); } Status -MySQLMetaImpl::DeleteTableFiles(const std::string& collection_id) { +MySQLMetaImpl::DeleteCollectionFiles(const std::string& collection_id) { try { server::MetricCollector metric; { mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_); bool is_null_connection = (connectionPtr == nullptr); - fiu_do_on("MySQLMetaImpl.DeleteTableFiles.null_connection", is_null_connection = true); - fiu_do_on("MySQLMetaImpl.DeleteTableFiles.throw_exception", throw std::exception();); + fiu_do_on("MySQLMetaImpl.DeleteCollectionFiles.null_connection", is_null_connection = true); + fiu_do_on("MySQLMetaImpl.DeleteCollectionFiles.throw_exception", throw std::exception();); if (is_null_connection) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } // soft delete collection files - mysqlpp::Query deleteTableFilesQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); // - deleteTableFilesQuery << "UPDATE " << META_TABLEFILES - << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) - << " ,updated_time = " << std::to_string(utils::GetMicroSecTimeStamp()) - << " WHERE table_id = " << mysqlpp::quote << collection_id << " AND file_type <> " - << std::to_string(SegmentSchema::TO_DELETE) << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) + << " ,updated_time = " << std::to_string(utils::GetMicroSecTimeStamp()) + << " WHERE table_id = " << mysqlpp::quote << collection_id << " AND file_type <> " + << std::to_string(SegmentSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DeleteTableFiles: " << deleteTableFilesQuery.str(); + ENGINE_LOG_DEBUG << "DeleteCollectionFiles: " << statement.str(); - if (!deleteTableFilesQuery.exec()) { - return HandleException("QUERY ERROR WHEN DELETING TABLE FILES", deleteTableFilesQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to delete colletion files", statement.error()); } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully delete collection files, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Successfully delete collection files from " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DELETING TABLE FILES", e.what()); + return HandleException("Failed to delete colletion files", e.what()); } return Status::OK(); @@ -683,9 +679,9 @@ MySQLMetaImpl::CreateCollectionFile(SegmentSchema& file_schema) { if (file_schema.date_ == EmptyDate) { file_schema.date_ = utils::GetDate(); } - CollectionSchema table_schema; - table_schema.collection_id_ = file_schema.collection_id_; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = file_schema.collection_id_; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -697,15 +693,15 @@ MySQLMetaImpl::CreateCollectionFile(SegmentSchema& file_schema) { if (file_schema.segment_id_.empty()) { file_schema.segment_id_ = file_schema.file_id_; } - file_schema.dimension_ = table_schema.dimension_; + file_schema.dimension_ = collection_schema.dimension_; file_schema.file_size_ = 0; file_schema.row_count_ = 0; file_schema.created_on_ = utils::GetMicroSecTimeStamp(); file_schema.updated_time_ = file_schema.created_on_; - file_schema.index_file_size_ = table_schema.index_file_size_; - file_schema.index_params_ = table_schema.index_params_; - file_schema.engine_type_ = table_schema.engine_type_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.index_file_size_ = collection_schema.index_file_size_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.engine_type_ = collection_schema.engine_type_; + file_schema.metric_type_ = collection_schema.metric_type_; std::string id = "NULL"; // auto-increment std::string collection_id = file_schema.collection_id_; @@ -730,35 +726,34 @@ MySQLMetaImpl::CreateCollectionFile(SegmentSchema& file_schema) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query createTableFileQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); - createTableFileQuery << "INSERT INTO " << META_TABLEFILES << " VALUES(" << id << ", " << mysqlpp::quote - << collection_id << ", " << mysqlpp::quote << segment_id << ", " << engine_type << ", " - << mysqlpp::quote << file_id << ", " << file_type << ", " << file_size << ", " - << row_count << ", " << updated_time << ", " << created_on << ", " << date << ", " - << flush_lsn << ");"; + statement << "INSERT INTO " << META_TABLEFILES << " VALUES(" << id << ", " << mysqlpp::quote + << collection_id << ", " << mysqlpp::quote << segment_id << ", " << engine_type << ", " + << mysqlpp::quote << file_id << ", " << file_type << ", " << file_size << ", " << row_count + << ", " << updated_time << ", " << created_on << ", " << date << ", " << flush_lsn << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CreateCollectionFile: " << createTableFileQuery.str(); + ENGINE_LOG_DEBUG << "CreateCollectionFile: " << statement.str(); - if (mysqlpp::SimpleResult res = createTableFileQuery.execute()) { + if (mysqlpp::SimpleResult res = statement.execute()) { file_schema.id_ = res.insert_id(); // Might need to use SELECT LAST_INSERT_ID()? // Consume all results to avoid "Commands out of sync" error } else { - return HandleException("QUERY ERROR WHEN CREATING TABLE FILE", createTableFileQuery.error()); + return HandleException("Failed to create collection file", statement.error()); } } // Scoped Connection ENGINE_LOG_DEBUG << "Successfully create collection file, file id = " << file_schema.file_id_; return utils::CreateCollectionFilePath(options_, file_schema); } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CREATING TABLE FILE", e.what()); + return HandleException("Failed to create collection file", e.what()); } } Status -MySQLMetaImpl::GetTableFiles(const std::string& collection_id, const std::vector& ids, - SegmentsSchema& table_files) { +MySQLMetaImpl::GetCollectionFiles(const std::string& collection_id, const std::vector& ids, + SegmentsSchema& collection_files) { if (ids.empty()) { return Status::OK(); } @@ -776,27 +771,27 @@ MySQLMetaImpl::GetTableFiles(const std::string& collection_id, const std::vector mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_); bool is_null_connection = (connectionPtr == nullptr); - fiu_do_on("MySQLMetaImpl.GetTableFiles.null_connection", is_null_connection = true); - fiu_do_on("MySQLMetaImpl.GetTableFiles.throw_exception", throw std::exception();); + fiu_do_on("MySQLMetaImpl.GetCollectionFiles.null_connection", is_null_connection = true); + fiu_do_on("MySQLMetaImpl.GetCollectionFiles.throw_exception", throw std::exception();); if (is_null_connection) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query getTableFileQuery = connectionPtr->query(); - getTableFileQuery + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, segment_id, engine_type, file_id, file_type, file_size, row_count, date, created_on" << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id << " AND (" << idStr << ")" << " AND file_type <> " << std::to_string(SegmentSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::GetTableFiles: " << getTableFileQuery.str(); + ENGINE_LOG_DEBUG << "GetCollectionFiles: " << statement.str(); - res = getTableFileQuery.store(); + res = statement.store(); } // Scoped Connection - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + DescribeCollection(collection_schema); Status ret; for (auto& resRow : res) { @@ -804,32 +799,32 @@ MySQLMetaImpl::GetTableFiles(const std::string& collection_id, const std::vector file_schema.id_ = resRow["id"]; file_schema.collection_id_ = collection_id; resRow["segment_id"].to_string(file_schema.segment_id_); - file_schema.index_file_size_ = table_schema.index_file_size_; + file_schema.index_file_size_ = collection_schema.index_file_size_; file_schema.engine_type_ = resRow["engine_type"]; - file_schema.index_params_ = table_schema.index_params_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.metric_type_ = collection_schema.metric_type_; resRow["file_id"].to_string(file_schema.file_id_); file_schema.file_type_ = resRow["file_type"]; file_schema.file_size_ = resRow["file_size"]; file_schema.row_count_ = resRow["row_count"]; file_schema.date_ = resRow["date"]; file_schema.created_on_ = resRow["created_on"]; - file_schema.dimension_ = table_schema.dimension_; + file_schema.dimension_ = collection_schema.dimension_; - utils::GetTableFilePath(options_, file_schema); - table_files.emplace_back(file_schema); + utils::GetCollectionFilePath(options_, file_schema); + collection_files.emplace_back(file_schema); } ENGINE_LOG_DEBUG << "Get collection files by id"; return ret; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN RETRIEVING TABLE FILES", e.what()); + return HandleException("Failed to get collection files", e.what()); } } Status MySQLMetaImpl::GetCollectionFilesBySegmentId(const std::string& segment_id, - milvus::engine::meta::SegmentsSchema& table_files) { + milvus::engine::meta::SegmentsSchema& collection_files) { try { mysqlpp::StoreQueryResult res; { @@ -839,21 +834,21 @@ MySQLMetaImpl::GetCollectionFilesBySegmentId(const std::string& segment_id, return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query getTableFileQuery = connectionPtr->query(); - getTableFileQuery << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, " - << "row_count, date, created_on" - << " FROM " << META_TABLEFILES << " WHERE segment_id = " << mysqlpp::quote << segment_id - << " AND file_type <> " << std::to_string(SegmentSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, " + << "row_count, date, created_on" + << " FROM " << META_TABLEFILES << " WHERE segment_id = " << mysqlpp::quote << segment_id + << " AND file_type <> " << std::to_string(SegmentSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::GetCollectionFilesBySegmentId: " << getTableFileQuery.str(); + ENGINE_LOG_DEBUG << "GetCollectionFilesBySegmentId: " << statement.str(); - res = getTableFileQuery.store(); + res = statement.store(); } // Scoped Connection if (!res.empty()) { - CollectionSchema table_schema; - res[0]["table_id"].to_string(table_schema.collection_id_); - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + res[0]["table_id"].to_string(collection_schema.collection_id_); + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -861,29 +856,29 @@ MySQLMetaImpl::GetCollectionFilesBySegmentId(const std::string& segment_id, for (auto& resRow : res) { SegmentSchema file_schema; file_schema.id_ = resRow["id"]; - file_schema.collection_id_ = table_schema.collection_id_; + file_schema.collection_id_ = collection_schema.collection_id_; resRow["segment_id"].to_string(file_schema.segment_id_); - file_schema.index_file_size_ = table_schema.index_file_size_; + file_schema.index_file_size_ = collection_schema.index_file_size_; file_schema.engine_type_ = resRow["engine_type"]; - file_schema.index_params_ = table_schema.index_params_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.metric_type_ = collection_schema.metric_type_; resRow["file_id"].to_string(file_schema.file_id_); file_schema.file_type_ = resRow["file_type"]; file_schema.file_size_ = resRow["file_size"]; file_schema.row_count_ = resRow["row_count"]; file_schema.date_ = resRow["date"]; file_schema.created_on_ = resRow["created_on"]; - file_schema.dimension_ = table_schema.dimension_; + file_schema.dimension_ = collection_schema.dimension_; - utils::GetTableFilePath(options_, file_schema); - table_files.emplace_back(file_schema); + utils::GetCollectionFilePath(options_, file_schema); + collection_files.emplace_back(file_schema); } } ENGINE_LOG_DEBUG << "Get collection files by segment id"; return Status::OK(); } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN RETRIEVING TABLE FILES BY SEGMENT ID", e.what()); + return HandleException("Failed to get collection files by segment id", e.what()); } } @@ -908,7 +903,7 @@ MySQLMetaImpl::UpdateCollectionIndex(const std::string& collection_id, const Col << collection_id << " AND state <> " << std::to_string(CollectionSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionIndex: " << updateCollectionIndexParamQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionIndex: " << updateCollectionIndexParamQuery.str(); mysqlpp::StoreQueryResult res = updateCollectionIndexParamQuery.store(); @@ -927,10 +922,10 @@ MySQLMetaImpl::UpdateCollectionIndex(const std::string& collection_id, const Col << index.extra_params_.dump() << " ,metric_type = " << index.metric_type_ << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionIndex: " << updateCollectionIndexParamQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionIndex: " << updateCollectionIndexParamQuery.str(); if (!updateCollectionIndexParamQuery.exec()) { - return HandleException("QUERY ERROR WHEN UPDATING TABLE INDEX PARAM", + return HandleException("Failed to update collection index", updateCollectionIndexParamQuery.error()); } } else { @@ -938,9 +933,9 @@ MySQLMetaImpl::UpdateCollectionIndex(const std::string& collection_id, const Col } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully update collection index, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Successfully update collection index for " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE INDEX PARAM", e.what()); + return HandleException("Failed to update collection index", e.what()); } return Status::OK(); @@ -961,27 +956,27 @@ MySQLMetaImpl::UpdateCollectionFlag(const std::string& collection_id, int64_t fl return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query updateTableFlagQuery = connectionPtr->query(); - updateTableFlagQuery << "UPDATE " << META_TABLES << " SET flag = " << flag - << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "UPDATE " << META_TABLES << " SET flag = " << flag << " WHERE table_id = " << mysqlpp::quote + << collection_id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFlag: " << updateTableFlagQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFlag: " << statement.str(); - if (!updateTableFlagQuery.exec()) { - return HandleException("QUERY ERROR WHEN UPDATING TABLE FLAG", updateTableFlagQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to update collection flag", statement.error()); } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully update collection flag, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Successfully update collection flag for " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FLAG", e.what()); + return HandleException("Failed to update collection flag", e.what()); } return Status::OK(); } Status -MySQLMetaImpl::UpdateTableFlushLSN(const std::string& collection_id, uint64_t flush_lsn) { +MySQLMetaImpl::UpdateCollectionFlushLSN(const std::string& collection_id, uint64_t flush_lsn) { try { server::MetricCollector metric; @@ -992,20 +987,20 @@ MySQLMetaImpl::UpdateTableFlushLSN(const std::string& collection_id, uint64_t fl return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query updateTableFlagQuery = connectionPtr->query(); - updateTableFlagQuery << "UPDATE " << META_TABLES << " SET flush_lsn = " << flush_lsn - << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "UPDATE " << META_TABLES << " SET flush_lsn = " << flush_lsn + << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFlushLSN: " << updateTableFlagQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFlushLSN: " << statement.str(); - if (!updateTableFlagQuery.exec()) { - return HandleException("QUERY ERROR WHEN UPDATING TABLE FLUSH_LSN", updateTableFlagQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to update collection lsn", statement.error()); } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully update collection flush_lsn, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Successfully update collection flush_lsn for " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FLUSH_LSN", e.what()); + return HandleException("Failed to update collection lsn", e.what()); } return Status::OK(); @@ -1027,7 +1022,7 @@ MySQLMetaImpl::GetCollectionFlushLSN(const std::string& collection_id, uint64_t& statement << "SELECT flush_lsn FROM " << META_TABLES << " WHERE collection_id = " << mysqlpp::quote << collection_id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::GetCollectionFlushLSN: " << statement.str(); + ENGINE_LOG_DEBUG << "GetCollectionFlushLSN: " << statement.str(); res = statement.store(); } // Scoped Connection @@ -1036,7 +1031,7 @@ MySQLMetaImpl::GetCollectionFlushLSN(const std::string& collection_id, uint64_t& flush_lsn = res[0]["flush_lsn"]; } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN GET TABLE FLUSH_LSN", e.what()); + return HandleException("Failed to get collection lsn", e.what()); } return Status::OK(); @@ -1059,16 +1054,16 @@ MySQLMetaImpl::UpdateCollectionFile(SegmentSchema& file_schema) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query updateTableFileQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); // if the collection has been deleted, just mark the collection file as TO_DELETE // clean thread will delete the file later - updateTableFileQuery << "SELECT state FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote - << file_schema.collection_id_ << ";"; + statement << "SELECT state FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote + << file_schema.collection_id_ << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFile: " << updateTableFileQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFile: " << statement.str(); - mysqlpp::StoreQueryResult res = updateTableFileQuery.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (res.num_rows() == 1) { int state = res[0]["state"]; @@ -1090,25 +1085,24 @@ MySQLMetaImpl::UpdateCollectionFile(SegmentSchema& file_schema) { std::string created_on = std::to_string(file_schema.created_on_); std::string date = std::to_string(file_schema.date_); - updateTableFileQuery << "UPDATE " << META_TABLEFILES << " SET table_id = " << mysqlpp::quote - << collection_id << " ,engine_type = " << engine_type - << " ,file_id = " << mysqlpp::quote << file_id << " ,file_type = " << file_type - << " ,file_size = " << file_size << " ,row_count = " << row_count - << " ,updated_time = " << updated_time << " ,created_on = " << created_on - << " ,date = " << date << " WHERE id = " << id << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET table_id = " << mysqlpp::quote << collection_id + << " ,engine_type = " << engine_type << " ,file_id = " << mysqlpp::quote << file_id + << " ,file_type = " << file_type << " ,file_size = " << file_size << " ,row_count = " << row_count + << " ,updated_time = " << updated_time << " ,created_on = " << created_on << " ,date = " << date + << " WHERE id = " << id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFile: " << updateTableFileQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFile: " << statement.str(); - if (!updateTableFileQuery.exec()) { + if (!statement.exec()) { ENGINE_LOG_DEBUG << "collection_id= " << file_schema.collection_id_ << " file_id=" << file_schema.file_id_; - return HandleException("QUERY ERROR WHEN UPDATING TABLE FILE", updateTableFileQuery.error()); + return HandleException("Failed to update collection file", statement.error()); } } // Scoped Connection - ENGINE_LOG_DEBUG << "Update single collection file, file id = " << file_schema.file_id_; + ENGINE_LOG_DEBUG << "Update single collection file, file id: " << file_schema.file_id_; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILE", e.what()); + return HandleException("Failed to update collection file", e.what()); } return Status::OK(); @@ -1126,24 +1120,22 @@ MySQLMetaImpl::UpdateCollectionFilesToIndex(const std::string& collection_id) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query updateTableFilesToIndexQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); - updateTableFilesToIndexQuery << "UPDATE " << META_TABLEFILES - << " SET file_type = " << std::to_string(SegmentSchema::TO_INDEX) - << " WHERE table_id = " << mysqlpp::quote << collection_id - << " AND row_count >= " << std::to_string(meta::BUILD_INDEX_THRESHOLD) - << " AND file_type = " << std::to_string(SegmentSchema::RAW) << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET file_type = " << std::to_string(SegmentSchema::TO_INDEX) + << " WHERE table_id = " << mysqlpp::quote << collection_id + << " AND row_count >= " << std::to_string(meta::BUILD_INDEX_THRESHOLD) + << " AND file_type = " << std::to_string(SegmentSchema::RAW) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFilesToIndex: " << updateTableFilesToIndexQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFilesToIndex: " << statement.str(); - if (!updateTableFilesToIndexQuery.exec()) { - return HandleException("QUERY ERROR WHEN UPDATING TABLE FILE TO INDEX", - updateTableFilesToIndexQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to update collection files to index", statement.error()); } - ENGINE_LOG_DEBUG << "Update files to to_index, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Update files to to_index for " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILES TO INDEX", e.what()); + return HandleException("Failed to update collection files to index", e.what()); } return Status::OK(); @@ -1163,7 +1155,7 @@ MySQLMetaImpl::UpdateCollectionFiles(SegmentsSchema& files) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query updateTableFilesQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); std::map has_collections; for (auto& file_schema : files) { @@ -1171,16 +1163,16 @@ MySQLMetaImpl::UpdateCollectionFiles(SegmentsSchema& files) { continue; } - updateTableFilesQuery << "SELECT EXISTS" - << " (SELECT 1 FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote - << file_schema.collection_id_ << " AND state <> " - << std::to_string(CollectionSchema::TO_DELETE) << ")" - << " AS " << mysqlpp::quote << "check" - << ";"; + statement << "SELECT EXISTS" + << " (SELECT 1 FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote + << file_schema.collection_id_ << " AND state <> " + << std::to_string(CollectionSchema::TO_DELETE) << ")" + << " AS " << mysqlpp::quote << "check" + << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFiles: " << updateTableFilesQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFiles: " << statement.str(); - mysqlpp::StoreQueryResult res = updateTableFilesQuery.store(); + mysqlpp::StoreQueryResult res = statement.store(); int check = res[0]["check"]; has_collections[file_schema.collection_id_] = (check == 1); @@ -1203,24 +1195,23 @@ MySQLMetaImpl::UpdateCollectionFiles(SegmentsSchema& files) { std::string created_on = std::to_string(file_schema.created_on_); std::string date = std::to_string(file_schema.date_); - updateTableFilesQuery << "UPDATE " << META_TABLEFILES << " SET table_id = " << mysqlpp::quote - << collection_id << " ,engine_type = " << engine_type - << " ,file_id = " << mysqlpp::quote << file_id << " ,file_type = " << file_type - << " ,file_size = " << file_size << " ,row_count = " << row_count - << " ,updated_time = " << updated_time << " ,created_on = " << created_on - << " ,date = " << date << " WHERE id = " << id << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET table_id = " << mysqlpp::quote << collection_id + << " ,engine_type = " << engine_type << " ,file_id = " << mysqlpp::quote << file_id + << " ,file_type = " << file_type << " ,file_size = " << file_size + << " ,row_count = " << row_count << " ,updated_time = " << updated_time + << " ,created_on = " << created_on << " ,date = " << date << " WHERE id = " << id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFiles: " << updateTableFilesQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFiles: " << statement.str(); - if (!updateTableFilesQuery.exec()) { - return HandleException("QUERY ERROR WHEN UPDATING TABLE FILES", updateTableFilesQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to update collection files", statement.error()); } } } // Scoped Connection ENGINE_LOG_DEBUG << "Update " << files.size() << " collection files"; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILES", e.what()); + return HandleException("Failed to update collection files", e.what()); } return Status::OK(); @@ -1238,20 +1229,19 @@ MySQLMetaImpl::UpdateCollectionFilesRowCount(SegmentsSchema& files) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query updateTableFilesQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); for (auto& file : files) { std::string row_count = std::to_string(file.row_count_); std::string updated_time = std::to_string(utils::GetMicroSecTimeStamp()); - updateTableFilesQuery << "UPDATE " << META_TABLEFILES << " SET row_count = " << row_count - << " , updated_time = " << updated_time << " WHERE file_id = " << file.file_id_ - << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET row_count = " << row_count + << " , updated_time = " << updated_time << " WHERE file_id = " << file.file_id_ << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateCollectionFilesRowCount: " << updateTableFilesQuery.str(); + ENGINE_LOG_DEBUG << "UpdateCollectionFilesRowCount: " << statement.str(); - if (!updateTableFilesQuery.exec()) { - return HandleException("QUERY ERROR WHEN UPDATING TABLE FILES", updateTableFilesQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to update collection files row count", statement.error()); } ENGINE_LOG_DEBUG << "Update file " << file.file_id_ << " row count to " << file.row_count_; @@ -1260,7 +1250,7 @@ MySQLMetaImpl::UpdateCollectionFilesRowCount(SegmentsSchema& files) { ENGINE_LOG_DEBUG << "Update " << files.size() << " collection files"; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILES ROW COUNT", e.what()); + return HandleException("Failed to update collection files row count", e.what()); } return Status::OK(); @@ -1281,15 +1271,14 @@ MySQLMetaImpl::DescribeCollectionIndex(const std::string& collection_id, Collect return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query describeCollectionIndexQuery = connectionPtr->query(); - describeCollectionIndexQuery << "SELECT engine_type, index_params, index_file_size, metric_type" - << " FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote - << collection_id << " AND state <> " - << std::to_string(CollectionSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT engine_type, index_params, index_file_size, metric_type" + << " FROM " << META_TABLES << " WHERE table_id = " << mysqlpp::quote << collection_id + << " AND state <> " << std::to_string(CollectionSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DescribeCollectionIndex: " << describeCollectionIndexQuery.str(); + ENGINE_LOG_DEBUG << "DescribeCollectionIndex: " << statement.str(); - mysqlpp::StoreQueryResult res = describeCollectionIndexQuery.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (res.num_rows() == 1) { const mysqlpp::Row& resRow = res[0]; @@ -1304,7 +1293,7 @@ MySQLMetaImpl::DescribeCollectionIndex(const std::string& collection_id, Collect } } // Scoped Connection } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN UPDATING TABLE FLAG", e.what()); + return HandleException("Failed to describe collection index", e.what()); } return Status::OK(); @@ -1325,54 +1314,50 @@ MySQLMetaImpl::DropCollectionIndex(const std::string& collection_id) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query dropCollectionIndexQuery = connectionPtr->query(); + mysqlpp::Query statement = connectionPtr->query(); // soft delete index files - dropCollectionIndexQuery << "UPDATE " << META_TABLEFILES - << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) - << " ,updated_time = " << utils::GetMicroSecTimeStamp() - << " WHERE table_id = " << mysqlpp::quote << collection_id - << " AND file_type = " << std::to_string(SegmentSchema::INDEX) << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) + << " ,updated_time = " << utils::GetMicroSecTimeStamp() << " WHERE table_id = " << mysqlpp::quote + << collection_id << " AND file_type = " << std::to_string(SegmentSchema::INDEX) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropCollectionIndex: " << dropCollectionIndexQuery.str(); + ENGINE_LOG_DEBUG << "DropCollectionIndex: " << statement.str(); - if (!dropCollectionIndexQuery.exec()) { - return HandleException("QUERY ERROR WHEN DROPPING TABLE INDEX", dropCollectionIndexQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to drop collection index", statement.error()); } // set all backup file to raw - dropCollectionIndexQuery << "UPDATE " << META_TABLEFILES - << " SET file_type = " << std::to_string(SegmentSchema::RAW) - << " ,updated_time = " << utils::GetMicroSecTimeStamp() - << " WHERE table_id = " << mysqlpp::quote << collection_id - << " AND file_type = " << std::to_string(SegmentSchema::BACKUP) << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET file_type = " << std::to_string(SegmentSchema::RAW) + << " ,updated_time = " << utils::GetMicroSecTimeStamp() << " WHERE table_id = " << mysqlpp::quote + << collection_id << " AND file_type = " << std::to_string(SegmentSchema::BACKUP) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropCollectionIndex: " << dropCollectionIndexQuery.str(); + ENGINE_LOG_DEBUG << "DropCollectionIndex: " << statement.str(); - if (!dropCollectionIndexQuery.exec()) { - return HandleException("QUERY ERROR WHEN DROPPING TABLE INDEX", dropCollectionIndexQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to drop collection index", statement.error()); } // set collection index type to raw - dropCollectionIndexQuery << "UPDATE " << META_TABLES << " SET engine_type = " - << " (CASE" - << " WHEN metric_type in (" << (int32_t)MetricType::HAMMING << " ," - << (int32_t)MetricType::JACCARD << " ," << (int32_t)MetricType::TANIMOTO << ")" - << " THEN " << (int32_t)EngineType::FAISS_BIN_IDMAP << " ELSE " - << (int32_t)EngineType::FAISS_IDMAP << " END)" - << " , index_params = '{}'" - << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; + statement << "UPDATE " << META_TABLES << " SET engine_type = " + << " (CASE" + << " WHEN metric_type in (" << (int32_t)MetricType::HAMMING << " ," + << (int32_t)MetricType::JACCARD << " ," << (int32_t)MetricType::TANIMOTO << ")" + << " THEN " << (int32_t)EngineType::FAISS_BIN_IDMAP << " ELSE " + << (int32_t)EngineType::FAISS_IDMAP << " END)" + << " , index_params = '{}'" + << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropCollectionIndex: " << dropCollectionIndexQuery.str(); + ENGINE_LOG_DEBUG << "DropCollectionIndex: " << statement.str(); - if (!dropCollectionIndexQuery.exec()) { - return HandleException("QUERY ERROR WHEN DROPPING TABLE INDEX", dropCollectionIndexQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to drop collection index", statement.error()); } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully drop collection index, collection id = " << collection_id; + ENGINE_LOG_DEBUG << "Successfully drop collection index for " << collection_id; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DROPPING TABLE INDEX", e.what()); + return HandleException("Failed to drop collection index", e.what()); } return Status::OK(); @@ -1383,15 +1368,15 @@ MySQLMetaImpl::CreatePartition(const std::string& collection_id, const std::stri const std::string& tag, uint64_t lsn) { server::MetricCollector metric; - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } // not allow create partition under partition - if (!table_schema.owner_collection_.empty()) { + if (!collection_schema.owner_collection_.empty()) { return Status(DB_ERROR, "Nested partition is not allowed"); } @@ -1409,19 +1394,19 @@ MySQLMetaImpl::CreatePartition(const std::string& collection_id, const std::stri if (partition_name == "") { // generate unique partition name - NextTableId(table_schema.collection_id_); + NextCollectionId(collection_schema.collection_id_); } else { - table_schema.collection_id_ = partition_name; + collection_schema.collection_id_ = partition_name; } - table_schema.id_ = -1; - table_schema.flag_ = 0; - table_schema.created_on_ = utils::GetMicroSecTimeStamp(); - table_schema.owner_collection_ = collection_id; - table_schema.partition_tag_ = valid_tag; - table_schema.flush_lsn_ = lsn; + collection_schema.id_ = -1; + collection_schema.flag_ = 0; + collection_schema.created_on_ = utils::GetMicroSecTimeStamp(); + collection_schema.owner_collection_ = collection_id; + collection_schema.partition_tag_ = valid_tag; + collection_schema.flush_lsn_ = lsn; - status = CreateCollection(table_schema); + status = CreateCollection(collection_schema); fiu_do_on("MySQLMetaImpl.CreatePartition.aleady_exist", status = Status(DB_ALREADY_EXIST, "")); if (status.code() == DB_ALREADY_EXIST) { return Status(DB_ALREADY_EXIST, "Partition already exists"); @@ -1451,15 +1436,15 @@ MySQLMetaImpl::ShowPartitions(const std::string& collection_id, return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query allPartitionsQuery = connectionPtr->query(); - allPartitionsQuery << "SELECT table_id, id, state, dimension, created_on, flag, index_file_size," - << " engine_type, index_params, metric_type, partition_tag, version FROM " << META_TABLES - << " WHERE owner_table = " << mysqlpp::quote << collection_id << " AND state <> " - << std::to_string(CollectionSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT table_id, id, state, dimension, created_on, flag, index_file_size," + << " engine_type, index_params, metric_type, partition_tag, version FROM " << META_TABLES + << " WHERE owner_table = " << mysqlpp::quote << collection_id << " AND state <> " + << std::to_string(CollectionSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::AllCollections: " << allPartitionsQuery.str(); + ENGINE_LOG_DEBUG << "AllCollections: " << statement.str(); - res = allPartitionsQuery.store(); + res = statement.store(); } // Scoped Connection for (auto& resRow : res) { @@ -1481,7 +1466,7 @@ MySQLMetaImpl::ShowPartitions(const std::string& collection_id, partition_schema_array.emplace_back(partition_schema); } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN SHOW PARTITIONS", e.what()); + return HandleException("Failed to show partitions", e.what()); } return Status::OK(); @@ -1508,14 +1493,14 @@ MySQLMetaImpl::GetPartitionName(const std::string& collection_id, const std::str return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query allPartitionsQuery = connectionPtr->query(); - allPartitionsQuery << "SELECT table_id FROM " << META_TABLES << " WHERE owner_table = " << mysqlpp::quote - << collection_id << " AND partition_tag = " << mysqlpp::quote << valid_tag - << " AND state <> " << std::to_string(CollectionSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT table_id FROM " << META_TABLES << " WHERE owner_table = " << mysqlpp::quote + << collection_id << " AND partition_tag = " << mysqlpp::quote << valid_tag << " AND state <> " + << std::to_string(CollectionSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::AllCollections: " << allPartitionsQuery.str(); + ENGINE_LOG_DEBUG << "AllCollections: " << statement.str(); - res = allPartitionsQuery.store(); + res = statement.store(); } // Scoped Connection if (res.num_rows() > 0) { @@ -1525,7 +1510,7 @@ MySQLMetaImpl::GetPartitionName(const std::string& collection_id, const std::str return Status(DB_NOT_FOUND, "Partition " + valid_tag + " of collection " + collection_id + " not found"); } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN GET PARTITION NAME", e.what()); + return HandleException("Failed to get partition name", e.what()); } return Status::OK(); @@ -1548,52 +1533,51 @@ MySQLMetaImpl::FilesToSearch(const std::string& collection_id, SegmentsSchema& f return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query filesToSearchQuery = connectionPtr->query(); - filesToSearchQuery - << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, row_count, date" - << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, row_count, date" + << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id; // End - filesToSearchQuery << " AND" - << " (file_type = " << std::to_string(SegmentSchema::RAW) - << " OR file_type = " << std::to_string(SegmentSchema::TO_INDEX) - << " OR file_type = " << std::to_string(SegmentSchema::INDEX) << ");"; + statement << " AND" + << " (file_type = " << std::to_string(SegmentSchema::RAW) + << " OR file_type = " << std::to_string(SegmentSchema::TO_INDEX) + << " OR file_type = " << std::to_string(SegmentSchema::INDEX) << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToSearch: " << filesToSearchQuery.str(); + ENGINE_LOG_DEBUG << "FilesToSearch: " << statement.str(); - res = filesToSearchQuery.store(); + res = statement.store(); } // Scoped Connection - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } Status ret; for (auto& resRow : res) { - SegmentSchema table_file; - table_file.id_ = resRow["id"]; // implicit conversion - resRow["table_id"].to_string(table_file.collection_id_); - resRow["segment_id"].to_string(table_file.segment_id_); - table_file.index_file_size_ = table_schema.index_file_size_; - table_file.engine_type_ = resRow["engine_type"]; - table_file.index_params_ = table_schema.index_params_; - table_file.metric_type_ = table_schema.metric_type_; - resRow["file_id"].to_string(table_file.file_id_); - table_file.file_type_ = resRow["file_type"]; - table_file.file_size_ = resRow["file_size"]; - table_file.row_count_ = resRow["row_count"]; - table_file.date_ = resRow["date"]; - table_file.dimension_ = table_schema.dimension_; + SegmentSchema collection_file; + collection_file.id_ = resRow["id"]; // implicit conversion + resRow["table_id"].to_string(collection_file.collection_id_); + resRow["segment_id"].to_string(collection_file.segment_id_); + collection_file.index_file_size_ = collection_schema.index_file_size_; + collection_file.engine_type_ = resRow["engine_type"]; + collection_file.index_params_ = collection_schema.index_params_; + collection_file.metric_type_ = collection_schema.metric_type_; + resRow["file_id"].to_string(collection_file.file_id_); + collection_file.file_type_ = resRow["file_type"]; + collection_file.file_size_ = resRow["file_size"]; + collection_file.row_count_ = resRow["row_count"]; + collection_file.date_ = resRow["date"]; + collection_file.dimension_ = collection_schema.dimension_; - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - files.emplace_back(table_file); + files.emplace_back(collection_file); } if (res.size() > 0) { @@ -1601,7 +1585,7 @@ MySQLMetaImpl::FilesToSearch(const std::string& collection_id, SegmentsSchema& f } return ret; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES TO SEARCH", e.what()); + return HandleException("Failed to get files to search", e.what()); } } @@ -1613,9 +1597,9 @@ MySQLMetaImpl::FilesToMerge(const std::string& collection_id, SegmentsSchema& fi server::MetricCollector metric; // check collection existence - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -1631,47 +1615,46 @@ MySQLMetaImpl::FilesToMerge(const std::string& collection_id, SegmentsSchema& fi return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query filesToMergeQuery = connectionPtr->query(); - filesToMergeQuery << "SELECT id, table_id, segment_id, file_id, file_type, file_size, row_count, date, " - "engine_type, created_on" - << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id - << " AND file_type = " << std::to_string(SegmentSchema::RAW) - << " ORDER BY row_count DESC;"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, segment_id, file_id, file_type, file_size, row_count, date, " + "engine_type, created_on" + << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id + << " AND file_type = " << std::to_string(SegmentSchema::RAW) << " ORDER BY row_count DESC;"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToMerge: " << filesToMergeQuery.str(); + ENGINE_LOG_DEBUG << "FilesToMerge: " << statement.str(); - res = filesToMergeQuery.store(); + res = statement.store(); } // Scoped Connection Status ret; int64_t to_merge_files = 0; for (auto& resRow : res) { - SegmentSchema table_file; - table_file.file_size_ = resRow["file_size"]; - if (table_file.file_size_ >= table_schema.index_file_size_) { + SegmentSchema collection_file; + collection_file.file_size_ = resRow["file_size"]; + if (collection_file.file_size_ >= collection_schema.index_file_size_) { continue; // skip large file } - table_file.id_ = resRow["id"]; // implicit conversion - resRow["table_id"].to_string(table_file.collection_id_); - resRow["segment_id"].to_string(table_file.segment_id_); - resRow["file_id"].to_string(table_file.file_id_); - table_file.file_type_ = resRow["file_type"]; - table_file.row_count_ = resRow["row_count"]; - table_file.date_ = resRow["date"]; - table_file.index_file_size_ = table_schema.index_file_size_; - table_file.engine_type_ = resRow["engine_type"]; - table_file.index_params_ = table_schema.index_params_; - table_file.metric_type_ = table_schema.metric_type_; - table_file.created_on_ = resRow["created_on"]; - table_file.dimension_ = table_schema.dimension_; + collection_file.id_ = resRow["id"]; // implicit conversion + resRow["table_id"].to_string(collection_file.collection_id_); + resRow["segment_id"].to_string(collection_file.segment_id_); + resRow["file_id"].to_string(collection_file.file_id_); + collection_file.file_type_ = resRow["file_type"]; + collection_file.row_count_ = resRow["row_count"]; + collection_file.date_ = resRow["date"]; + collection_file.index_file_size_ = collection_schema.index_file_size_; + collection_file.engine_type_ = resRow["engine_type"]; + collection_file.index_params_ = collection_schema.index_params_; + collection_file.metric_type_ = collection_schema.metric_type_; + collection_file.created_on_ = resRow["created_on"]; + collection_file.dimension_ = collection_schema.dimension_; - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - files.emplace_back(table_file); + files.emplace_back(collection_file); ++to_merge_files; } @@ -1680,7 +1663,7 @@ MySQLMetaImpl::FilesToMerge(const std::string& collection_id, SegmentsSchema& fi } return ret; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES TO MERGE", e.what()); + return HandleException("Failed to get files to merge", e.what()); } } @@ -1701,53 +1684,53 @@ MySQLMetaImpl::FilesToIndex(SegmentsSchema& files) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query filesToIndexQuery = connectionPtr->query(); - filesToIndexQuery << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, " - "row_count, date, created_on" - << " FROM " << META_TABLEFILES - << " WHERE file_type = " << std::to_string(SegmentSchema::TO_INDEX) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, " + "row_count, date, created_on" + << " FROM " << META_TABLEFILES << " WHERE file_type = " << std::to_string(SegmentSchema::TO_INDEX) + << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToIndex: " << filesToIndexQuery.str(); + ENGINE_LOG_DEBUG << "FilesToIndex: " << statement.str(); - res = filesToIndexQuery.store(); + res = statement.store(); } // Scoped Connection Status ret; std::map groups; - SegmentSchema table_file; + SegmentSchema collection_file; for (auto& resRow : res) { - table_file.id_ = resRow["id"]; // implicit conversion - resRow["table_id"].to_string(table_file.collection_id_); - resRow["segment_id"].to_string(table_file.segment_id_); - table_file.engine_type_ = resRow["engine_type"]; - resRow["file_id"].to_string(table_file.file_id_); - table_file.file_type_ = resRow["file_type"]; - table_file.file_size_ = resRow["file_size"]; - table_file.row_count_ = resRow["row_count"]; - table_file.date_ = resRow["date"]; - table_file.created_on_ = resRow["created_on"]; + collection_file.id_ = resRow["id"]; // implicit conversion + resRow["table_id"].to_string(collection_file.collection_id_); + resRow["segment_id"].to_string(collection_file.segment_id_); + collection_file.engine_type_ = resRow["engine_type"]; + resRow["file_id"].to_string(collection_file.file_id_); + collection_file.file_type_ = resRow["file_type"]; + collection_file.file_size_ = resRow["file_size"]; + collection_file.row_count_ = resRow["row_count"]; + collection_file.date_ = resRow["date"]; + collection_file.created_on_ = resRow["created_on"]; - auto groupItr = groups.find(table_file.collection_id_); + auto groupItr = groups.find(collection_file.collection_id_); if (groupItr == groups.end()) { - CollectionSchema table_schema; - table_schema.collection_id_ = table_file.collection_id_; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_file.collection_id_; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } - groups[table_file.collection_id_] = table_schema; + groups[collection_file.collection_id_] = collection_schema; } - table_file.dimension_ = groups[table_file.collection_id_].dimension_; - table_file.index_file_size_ = groups[table_file.collection_id_].index_file_size_; - table_file.index_params_ = groups[table_file.collection_id_].index_params_; - table_file.metric_type_ = groups[table_file.collection_id_].metric_type_; + collection_file.dimension_ = groups[collection_file.collection_id_].dimension_; + collection_file.index_file_size_ = groups[collection_file.collection_id_].index_file_size_; + collection_file.index_params_ = groups[collection_file.collection_id_].index_params_; + collection_file.metric_type_ = groups[collection_file.collection_id_].metric_type_; - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - files.push_back(table_file); + files.push_back(collection_file); } if (res.size() > 0) { @@ -1755,7 +1738,7 @@ MySQLMetaImpl::FilesToIndex(SegmentsSchema& files) { } return ret; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES TO INDEX", e.what()); + return HandleException("Failed to get files to index", e.what()); } } @@ -1797,14 +1780,14 @@ MySQLMetaImpl::FilesByType(const std::string& collection_id, const std::vector& ids, SegmentsSchema& files) return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query filesToSearchQuery = connectionPtr->query(); - filesToSearchQuery - << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, row_count, date" - << " FROM " << META_TABLEFILES; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, file_size, row_count, date" + << " FROM " << META_TABLEFILES; std::stringstream idSS; for (auto& id : ids) { @@ -1935,57 +1917,57 @@ MySQLMetaImpl::FilesByID(const std::vector& ids, SegmentsSchema& files) std::string idStr = idSS.str(); idStr = idStr.substr(0, idStr.size() - 4); // remove the last " OR " - filesToSearchQuery << " WHERE (" << idStr << ")"; + statement << " WHERE (" << idStr << ")"; // End - filesToSearchQuery << " AND" - << " (file_type = " << std::to_string(SegmentSchema::RAW) - << " OR file_type = " << std::to_string(SegmentSchema::TO_INDEX) - << " OR file_type = " << std::to_string(SegmentSchema::INDEX) << ");"; + statement << " AND" + << " (file_type = " << std::to_string(SegmentSchema::RAW) + << " OR file_type = " << std::to_string(SegmentSchema::TO_INDEX) + << " OR file_type = " << std::to_string(SegmentSchema::INDEX) << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToSearch: " << filesToSearchQuery.str(); + ENGINE_LOG_DEBUG << "FilesToSearch: " << statement.str(); - res = filesToSearchQuery.store(); + res = statement.store(); } // Scoped Connection - std::map tables; + std::map collections; Status ret; for (auto& resRow : res) { - SegmentSchema table_file; - table_file.id_ = resRow["id"]; // implicit conversion - resRow["table_id"].to_string(table_file.collection_id_); - resRow["segment_id"].to_string(table_file.segment_id_); - table_file.engine_type_ = resRow["engine_type"]; - resRow["file_id"].to_string(table_file.file_id_); - table_file.file_type_ = resRow["file_type"]; - table_file.file_size_ = resRow["file_size"]; - table_file.row_count_ = resRow["row_count"]; - table_file.date_ = resRow["date"]; + SegmentSchema collection_file; + collection_file.id_ = resRow["id"]; // implicit conversion + resRow["table_id"].to_string(collection_file.collection_id_); + resRow["segment_id"].to_string(collection_file.segment_id_); + collection_file.engine_type_ = resRow["engine_type"]; + resRow["file_id"].to_string(collection_file.file_id_); + collection_file.file_type_ = resRow["file_type"]; + collection_file.file_size_ = resRow["file_size"]; + collection_file.row_count_ = resRow["row_count"]; + collection_file.date_ = resRow["date"]; - if (tables.find(table_file.collection_id_) == tables.end()) { - CollectionSchema table_schema; - table_schema.collection_id_ = table_file.collection_id_; - auto status = DescribeCollection(table_schema); + if (collections.find(collection_file.collection_id_) == collections.end()) { + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_file.collection_id_; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } - tables.insert(std::make_pair(table_file.collection_id_, table_schema)); + collections.insert(std::make_pair(collection_file.collection_id_, collection_schema)); } - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - files.emplace_back(table_file); + files.emplace_back(collection_file); } - for (auto& table_file : files) { - CollectionSchema& table_schema = tables[table_file.collection_id_]; - table_file.dimension_ = table_schema.dimension_; - table_file.index_file_size_ = table_schema.index_file_size_; - table_file.index_params_ = table_schema.index_params_; - table_file.metric_type_ = table_schema.metric_type_; + for (auto& collection_file : files) { + CollectionSchema& collection_schema = collections[collection_file.collection_id_]; + collection_file.dimension_ = collection_schema.dimension_; + collection_file.index_file_size_ = collection_schema.index_file_size_; + collection_file.index_params_ = collection_schema.index_params_; + collection_file.metric_type_ = collection_schema.metric_type_; } if (files.empty()) { @@ -1996,7 +1978,7 @@ MySQLMetaImpl::FilesByID(const std::vector& ids, SegmentsSchema& files) return ret; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES BY ID", e.what()); + return HandleException("Failed to get files by id", e.what()); } } @@ -2025,21 +2007,21 @@ MySQLMetaImpl::Archive() { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query archiveQuery = connectionPtr->query(); - archiveQuery << "UPDATE " << META_TABLEFILES - << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) - << " WHERE created_on < " << std::to_string(now - usecs) << " AND file_type <> " - << std::to_string(SegmentSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "UPDATE " << META_TABLEFILES + << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) << " WHERE created_on < " + << std::to_string(now - usecs) << " AND file_type <> " + << std::to_string(SegmentSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::Archive: " << archiveQuery.str(); + ENGINE_LOG_DEBUG << "Archive: " << statement.str(); - if (!archiveQuery.exec()) { - return HandleException("QUERY ERROR DURING ARCHIVE", archiveQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to archive", statement.error()); } ENGINE_LOG_DEBUG << "Archive old files"; } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DURING ARCHIVE", e.what()); + return HandleException("Failed to archive", e.what()); } } if (criteria == engine::ARCHIVE_CONF_DISK) { @@ -2072,14 +2054,14 @@ MySQLMetaImpl::Size(uint64_t& result) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query getSizeQuery = connectionPtr->query(); - getSizeQuery << "SELECT IFNULL(SUM(file_size),0) AS sum" - << " FROM " << META_TABLEFILES << " WHERE file_type <> " - << std::to_string(SegmentSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT IFNULL(SUM(file_size),0) AS sum" + << " FROM " << META_TABLEFILES << " WHERE file_type <> " + << std::to_string(SegmentSchema::TO_DELETE) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::Size: " << getSizeQuery.str(); + ENGINE_LOG_DEBUG << "Size: " << statement.str(); - res = getSizeQuery.store(); + res = statement.store(); } // Scoped Connection if (res.empty()) { @@ -2088,7 +2070,7 @@ MySQLMetaImpl::Size(uint64_t& result) { result = res[0]["sum"]; } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN RETRIEVING SIZE", e.what()); + return HandleException("Failed to get total files size", e.what()); } return Status::OK(); @@ -2106,26 +2088,26 @@ MySQLMetaImpl::CleanUpShadowFiles() { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query cleanUpQuery = connectionPtr->query(); - cleanUpQuery << "SELECT table_name" - << " FROM information_schema.tables" - << " WHERE table_schema = " << mysqlpp::quote << mysql_connection_pool_->getDB() - << " AND table_name = " << mysqlpp::quote << META_TABLEFILES << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT table_name" + << " FROM information_schema.tables" + << " WHERE table_schema = " << mysqlpp::quote << mysql_connection_pool_->getDB() + << " AND table_name = " << mysqlpp::quote << META_TABLEFILES << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUp: " << cleanUpQuery.str(); + ENGINE_LOG_DEBUG << "CleanUp: " << statement.str(); - mysqlpp::StoreQueryResult res = cleanUpQuery.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (!res.empty()) { ENGINE_LOG_DEBUG << "Remove collection file type as NEW"; - cleanUpQuery << "DELETE FROM " << META_TABLEFILES << " WHERE file_type IN (" - << std::to_string(SegmentSchema::NEW) << "," << std::to_string(SegmentSchema::NEW_MERGE) << "," - << std::to_string(SegmentSchema::NEW_INDEX) << ");"; + statement << "DELETE FROM " << META_TABLEFILES << " WHERE file_type IN (" + << std::to_string(SegmentSchema::NEW) << "," << std::to_string(SegmentSchema::NEW_MERGE) << "," + << std::to_string(SegmentSchema::NEW_INDEX) << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUp: " << cleanUpQuery.str(); + ENGINE_LOG_DEBUG << "CleanUp: " << statement.str(); - if (!cleanUpQuery.exec()) { - return HandleException("QUERY ERROR WHEN CLEANING UP FILES", cleanUpQuery.error()); + if (!statement.exec()) { + return HandleException("Failed to clean shadow files", statement.error()); } } @@ -2133,7 +2115,7 @@ MySQLMetaImpl::CleanUpShadowFiles() { ENGINE_LOG_DEBUG << "Clean " << res.size() << " files"; } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CLEANING UP FILES", e.what()); + return HandleException("Failed to clean shadow files", e.what()); } return Status::OK(); @@ -2142,7 +2124,7 @@ MySQLMetaImpl::CleanUpShadowFiles() { Status MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) { auto now = utils::GetMicroSecTimeStamp(); - std::set table_ids; + std::set collection_ids; std::map segment_ids; // remove to_delete files @@ -2160,49 +2142,50 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query query = connectionPtr->query(); - query << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, date" - << " FROM " << META_TABLEFILES << " WHERE file_type IN (" << std::to_string(SegmentSchema::TO_DELETE) - << "," << std::to_string(SegmentSchema::BACKUP) << ")" - << " AND updated_time < " << std::to_string(now - seconds * US_PS) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id, segment_id, engine_type, file_id, file_type, date" + << " FROM " << META_TABLEFILES << " WHERE file_type IN (" + << std::to_string(SegmentSchema::TO_DELETE) << "," << std::to_string(SegmentSchema::BACKUP) << ")" + << " AND updated_time < " << std::to_string(now - seconds * US_PS) << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << query.str(); + ENGINE_LOG_DEBUG << "CleanUpFilesWithTTL: " << statement.str(); - mysqlpp::StoreQueryResult res = query.store(); + mysqlpp::StoreQueryResult res = statement.store(); - SegmentSchema table_file; + SegmentSchema collection_file; std::vector delete_ids; int64_t clean_files = 0; for (auto& resRow : res) { - table_file.id_ = resRow["id"]; // implicit conversion - resRow["table_id"].to_string(table_file.collection_id_); - resRow["segment_id"].to_string(table_file.segment_id_); - table_file.engine_type_ = resRow["engine_type"]; - resRow["file_id"].to_string(table_file.file_id_); - table_file.date_ = resRow["date"]; - table_file.file_type_ = resRow["file_type"]; + collection_file.id_ = resRow["id"]; // implicit conversion + resRow["table_id"].to_string(collection_file.collection_id_); + resRow["segment_id"].to_string(collection_file.segment_id_); + collection_file.engine_type_ = resRow["engine_type"]; + resRow["file_id"].to_string(collection_file.file_id_); + collection_file.date_ = resRow["date"]; + collection_file.file_type_ = resRow["file_type"]; // check if the file can be deleted - if (OngoingFileChecker::GetInstance().IsIgnored(table_file)) { - ENGINE_LOG_DEBUG << "File:" << table_file.file_id_ + if (OngoingFileChecker::GetInstance().IsIgnored(collection_file)) { + ENGINE_LOG_DEBUG << "File:" << collection_file.file_id_ << " currently is in use, not able to delete now"; continue; // ignore this file, don't delete it } // erase file data from cache - // because GetTableFilePath won't able to generate file path after the file is deleted - utils::GetTableFilePath(options_, table_file); - server::CommonUtil::EraseFromCache(table_file.location_); + // because GetCollectionFilePath won't able to generate file path after the file is deleted + utils::GetCollectionFilePath(options_, collection_file); + server::CommonUtil::EraseFromCache(collection_file.location_); - if (table_file.file_type_ == (int)SegmentSchema::TO_DELETE) { + if (collection_file.file_type_ == (int)SegmentSchema::TO_DELETE) { // delete file from disk storage - utils::DeleteTableFilePath(options_, table_file); - ENGINE_LOG_DEBUG << "Remove file id:" << table_file.id_ << " location:" << table_file.location_; + utils::DeleteCollectionFilePath(options_, collection_file); + ENGINE_LOG_DEBUG << "Remove file id:" << collection_file.id_ + << " location:" << collection_file.location_; - delete_ids.emplace_back(std::to_string(table_file.id_)); - table_ids.insert(table_file.collection_id_); - segment_ids.insert(std::make_pair(table_file.segment_id_, table_file)); + delete_ids.emplace_back(std::to_string(collection_file.id_)); + collection_ids.insert(collection_file.collection_id_); + segment_ids.insert(std::make_pair(collection_file.segment_id_, collection_file)); clean_files++; } @@ -2217,12 +2200,12 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) std::string idsToDeleteStr = idsToDeleteSS.str(); idsToDeleteStr = idsToDeleteStr.substr(0, idsToDeleteStr.size() - 4); // remove the last " OR " - query << "DELETE FROM " << META_TABLEFILES << " WHERE " << idsToDeleteStr << ";"; + statement << "DELETE FROM " << META_TABLEFILES << " WHERE " << idsToDeleteStr << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << query.str(); + ENGINE_LOG_DEBUG << "CleanUpFilesWithTTL: " << statement.str(); - if (!query.exec()) { - return HandleException("QUERY ERROR WHEN CLEANING UP FILES WITH TTL", query.error()); + if (!statement.exec()) { + return HandleException("Failed to clean up with ttl", statement.error()); } } @@ -2231,10 +2214,10 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) } } // Scoped Connection } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CLEANING UP FILES WITH TTL", e.what()); + return HandleException("Failed to clean up with ttl", e.what()); } - // remove to_delete tables + // remove to_delete collections try { server::MetricCollector metric; @@ -2242,22 +2225,24 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_); bool is_null_connection = (connectionPtr == nullptr); - fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteTables_NUllConnection", + fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteCollections_NUllConnection", is_null_connection = true); - fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteTables_ThrowException", throw std::exception();); + fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteCollections_ThrowException", + throw std::exception();); if (is_null_connection) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query query = connectionPtr->query(); - query << "SELECT id, table_id" - << " FROM " << META_TABLES << " WHERE state = " << std::to_string(CollectionSchema::TO_DELETE) << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, table_id" + << " FROM " << META_TABLES << " WHERE state = " << std::to_string(CollectionSchema::TO_DELETE) + << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << query.str(); + ENGINE_LOG_DEBUG << "CleanUpFilesWithTTL: " << statement.str(); - mysqlpp::StoreQueryResult res = query.store(); + mysqlpp::StoreQueryResult res = statement.store(); - int64_t remove_tables = 0; + int64_t remove_collections = 0; if (!res.empty()) { std::stringstream idsToDeleteSS; for (auto& resRow : res) { @@ -2265,27 +2250,27 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) std::string collection_id; resRow["table_id"].to_string(collection_id); - utils::DeleteTablePath(options_, collection_id, false); // only delete empty folder - ++remove_tables; + utils::DeleteCollectionPath(options_, collection_id, false); // only delete empty folder + ++remove_collections; idsToDeleteSS << "id = " << std::to_string(id) << " OR "; } std::string idsToDeleteStr = idsToDeleteSS.str(); idsToDeleteStr = idsToDeleteStr.substr(0, idsToDeleteStr.size() - 4); // remove the last " OR " - query << "DELETE FROM " << META_TABLES << " WHERE " << idsToDeleteStr << ";"; + statement << "DELETE FROM " << META_TABLES << " WHERE " << idsToDeleteStr << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << query.str(); + ENGINE_LOG_DEBUG << "CleanUpFilesWithTTL: " << statement.str(); - if (!query.exec()) { - return HandleException("QUERY ERROR WHEN CLEANING UP TABLES WITH TTL", query.error()); + if (!statement.exec()) { + return HandleException("Failed to clean up with ttl", statement.error()); } } - if (remove_tables > 0) { - ENGINE_LOG_DEBUG << "Remove " << remove_tables << " tables from meta"; + if (remove_collections > 0) { + ENGINE_LOG_DEBUG << "Remove " << remove_collections << " collections from meta"; } } // Scoped Connection } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CLEANING UP TABLES WITH TTL", e.what()); + return HandleException("Failed to clean up with ttl", e.what()); } // remove deleted collection folder @@ -2297,38 +2282,39 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_); bool is_null_connection = (connectionPtr == nullptr); - fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedTableFolder_NUllConnection", + fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedCollectionFolder_NUllConnection", is_null_connection = true); - fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedTableFolder_ThrowException", + fiu_do_on("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedCollectionFolder_ThrowException", throw std::exception();); if (is_null_connection) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - for (auto& collection_id : table_ids) { - mysqlpp::Query query = connectionPtr->query(); - query << "SELECT file_id" - << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id << ";"; + for (auto& collection_id : collection_ids) { + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT file_id" + << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id + << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << query.str(); + ENGINE_LOG_DEBUG << "CleanUpFilesWithTTL: " << statement.str(); - mysqlpp::StoreQueryResult res = query.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (res.empty()) { - utils::DeleteTablePath(options_, collection_id); + utils::DeleteCollectionPath(options_, collection_id); } } - if (table_ids.size() > 0) { - ENGINE_LOG_DEBUG << "Remove " << table_ids.size() << " tables folder"; + if (collection_ids.size() > 0) { + ENGINE_LOG_DEBUG << "Remove " << collection_ids.size() << " collections folder"; } } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CLEANING UP TABLES WITH TTL", e.what()); + return HandleException("Failed to clean up with ttl", e.what()); } // remove deleted segment folder - // don't remove segment folder until all its tablefiles has been deleted + // don't remove segment folder until all its files has been deleted try { server::MetricCollector metric; @@ -2346,14 +2332,14 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) int64_t remove_segments = 0; for (auto& segment_id : segment_ids) { - mysqlpp::Query query = connectionPtr->query(); - query << "SELECT id" - << " FROM " << META_TABLEFILES << " WHERE segment_id = " << mysqlpp::quote << segment_id.first - << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id" + << " FROM " << META_TABLEFILES << " WHERE segment_id = " << mysqlpp::quote << segment_id.first + << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << query.str(); + ENGINE_LOG_DEBUG << "CleanUpFilesWithTTL: " << statement.str(); - mysqlpp::StoreQueryResult res = query.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (res.empty()) { utils::DeleteSegment(options_, segment_id.second); @@ -2369,7 +2355,7 @@ MySQLMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) } } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN CLEANING UP TABLES WITH TTL", e.what()); + return HandleException("Failed to clean up with ttl", e.what()); } return Status::OK(); @@ -2380,9 +2366,9 @@ MySQLMetaImpl::Count(const std::string& collection_id, uint64_t& result) { try { server::MetricCollector metric; - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; @@ -2399,16 +2385,16 @@ MySQLMetaImpl::Count(const std::string& collection_id, uint64_t& result) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query countQuery = connectionPtr->query(); - countQuery << "SELECT row_count" - << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id - << " AND (file_type = " << std::to_string(SegmentSchema::RAW) - << " OR file_type = " << std::to_string(SegmentSchema::TO_INDEX) - << " OR file_type = " << std::to_string(SegmentSchema::INDEX) << ");"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT row_count" + << " FROM " << META_TABLEFILES << " WHERE table_id = " << mysqlpp::quote << collection_id + << " AND (file_type = " << std::to_string(SegmentSchema::RAW) + << " OR file_type = " << std::to_string(SegmentSchema::TO_INDEX) + << " OR file_type = " << std::to_string(SegmentSchema::INDEX) << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::Count: " << countQuery.str(); + ENGINE_LOG_DEBUG << "Count: " << statement.str(); - res = countQuery.store(); + res = statement.store(); } // Scoped Connection result = 0; @@ -2417,7 +2403,7 @@ MySQLMetaImpl::Count(const std::string& collection_id, uint64_t& result) { result += size; } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN RETRIEVING COUNT", e.what()); + return HandleException("Failed to clean up with ttl", e.what()); } return Status::OK(); @@ -2436,17 +2422,17 @@ MySQLMetaImpl::DropAll() { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query dropTableQuery = connectionPtr->query(); - dropTableQuery << "DROP TABLE IF EXISTS " << TABLES_SCHEMA.name() << ", " << TABLEFILES_SCHEMA.name() << ";"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "DROP TABLE IF EXISTS " << TABLES_SCHEMA.name() << ", " << TABLEFILES_SCHEMA.name() << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropAll: " << dropTableQuery.str(); + ENGINE_LOG_DEBUG << "DropAll: " << statement.str(); - if (dropTableQuery.exec()) { + if (statement.exec()) { return Status::OK(); } - return HandleException("QUERY ERROR WHEN DROPPING ALL", dropTableQuery.error()); + return HandleException("Failed to drop all", statement.error()); } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DROPPING ALL", e.what()); + return HandleException("Failed to drop all", e.what()); } } @@ -2470,52 +2456,51 @@ MySQLMetaImpl::DiscardFiles(int64_t to_discard_size) { return Status(DB_ERROR, "Failed to connect to meta server(mysql)"); } - mysqlpp::Query discardFilesQuery = connectionPtr->query(); - discardFilesQuery << "SELECT id, file_size" - << " FROM " << META_TABLEFILES << " WHERE file_type <> " - << std::to_string(SegmentSchema::TO_DELETE) << " ORDER BY id ASC " - << " LIMIT 10;"; + mysqlpp::Query statement = connectionPtr->query(); + statement << "SELECT id, file_size" + << " FROM " << META_TABLEFILES << " WHERE file_type <> " + << std::to_string(SegmentSchema::TO_DELETE) << " ORDER BY id ASC " + << " LIMIT 10;"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DiscardFiles: " << discardFilesQuery.str(); + ENGINE_LOG_DEBUG << "DiscardFiles: " << statement.str(); - mysqlpp::StoreQueryResult res = discardFilesQuery.store(); + mysqlpp::StoreQueryResult res = statement.store(); if (res.num_rows() == 0) { return Status::OK(); } - SegmentSchema table_file; + SegmentSchema collection_file; std::stringstream idsToDiscardSS; for (auto& resRow : res) { if (to_discard_size <= 0) { break; } - table_file.id_ = resRow["id"]; - table_file.file_size_ = resRow["file_size"]; - idsToDiscardSS << "id = " << std::to_string(table_file.id_) << " OR "; - ENGINE_LOG_DEBUG << "Discard table_file.id=" << table_file.file_id_ - << " table_file.size=" << table_file.file_size_; - to_discard_size -= table_file.file_size_; + collection_file.id_ = resRow["id"]; + collection_file.file_size_ = resRow["file_size"]; + idsToDiscardSS << "id = " << std::to_string(collection_file.id_) << " OR "; + ENGINE_LOG_DEBUG << "Discard file id=" << collection_file.file_id_ + << " file size=" << collection_file.file_size_; + to_discard_size -= collection_file.file_size_; } std::string idsToDiscardStr = idsToDiscardSS.str(); idsToDiscardStr = idsToDiscardStr.substr(0, idsToDiscardStr.size() - 4); // remove the last " OR " - discardFilesQuery << "UPDATE " << META_TABLEFILES - << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) - << " ,updated_time = " << std::to_string(utils::GetMicroSecTimeStamp()) << " WHERE " - << idsToDiscardStr << ";"; + statement << "UPDATE " << META_TABLEFILES << " SET file_type = " << std::to_string(SegmentSchema::TO_DELETE) + << " ,updated_time = " << std::to_string(utils::GetMicroSecTimeStamp()) << " WHERE " + << idsToDiscardStr << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::DiscardFiles: " << discardFilesQuery.str(); + ENGINE_LOG_DEBUG << "DiscardFiles: " << statement.str(); - status = discardFilesQuery.exec(); + status = statement.exec(); if (!status) { - return HandleException("QUERY ERROR WHEN DISCARDING FILES", discardFilesQuery.error()); + return HandleException("Failed to discard files", statement.error()); } } // Scoped Connection return DiscardFiles(to_discard_size); } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN DISCARDING FILES", e.what()); + return HandleException("Failed to discard files", e.what()); } } @@ -2543,7 +2528,7 @@ MySQLMetaImpl::SetGlobalLastLSN(uint64_t lsn) { if (first_create) { // first time to get global lsn mysqlpp::Query statement = connectionPtr->query(); statement << "INSERT INTO " << META_ENVIRONMENT << " VALUES(" << lsn << ");"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::SetGlobalLastLSN: " << statement.str(); + ENGINE_LOG_DEBUG << "SetGlobalLastLSN: " << statement.str(); if (!statement.exec()) { return HandleException("QUERY ERROR WHEN SET GLOBAL LSN", statement.error()); @@ -2551,17 +2536,17 @@ MySQLMetaImpl::SetGlobalLastLSN(uint64_t lsn) { } else { mysqlpp::Query statement = connectionPtr->query(); statement << "UPDATE " << META_ENVIRONMENT << " SET global_lsn = " << lsn << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::SetGlobalLastLSN: " << statement.str(); + ENGINE_LOG_DEBUG << "SetGlobalLastLSN: " << statement.str(); if (!statement.exec()) { - return HandleException("QUERY ERROR WHEN SET GLOBAL LSN", statement.error()); + return HandleException("Failed to set global lsn", statement.error()); } } } // Scoped Connection - ENGINE_LOG_DEBUG << "Successfully update global_lsn = " << lsn; + ENGINE_LOG_DEBUG << "Successfully update global_lsn: " << lsn; } catch (std::exception& e) { - return HandleException("QUERY ERROR WHEN SET GLOBAL LSN", e.what()); + return HandleException("Failed to set global lsn", e.what()); } return Status::OK(); @@ -2582,7 +2567,7 @@ MySQLMetaImpl::GetGlobalLastLSN(uint64_t& lsn) { mysqlpp::Query statement = connectionPtr->query(); statement << "SELECT global_lsn FROM " << META_ENVIRONMENT << ";"; - ENGINE_LOG_DEBUG << "MySQLMetaImpl::GetGlobalLastLSN: " << statement.str(); + ENGINE_LOG_DEBUG << "GetGlobalLastLSN: " << statement.str(); res = statement.store(); } // Scoped Connection @@ -2591,7 +2576,7 @@ MySQLMetaImpl::GetGlobalLastLSN(uint64_t& lsn) { lsn = res[0]["global_lsn"]; } } catch (std::exception& e) { - return HandleException("GENERAL ERROR WHEN GET GLOBAL LSN", e.what()); + return HandleException("Failed to update global lsn", e.what()); } return Status::OK(); diff --git a/core/src/db/meta/MySQLMetaImpl.h b/core/src/db/meta/MySQLMetaImpl.h index 20dd398eb8..f449ebf2a6 100644 --- a/core/src/db/meta/MySQLMetaImpl.h +++ b/core/src/db/meta/MySQLMetaImpl.h @@ -32,32 +32,32 @@ class MySQLMetaImpl : public Meta { ~MySQLMetaImpl(); Status - CreateCollection(CollectionSchema& table_schema) override; + CreateCollection(CollectionSchema& collection_schema) override; Status - DescribeCollection(CollectionSchema& table_schema) override; + DescribeCollection(CollectionSchema& collection_schema) override; Status HasCollection(const std::string& collection_id, bool& has_or_not) override; Status - AllCollections(std::vector& table_schema_array) override; + AllCollections(std::vector& collection_schema_array) override; Status DropCollection(const std::string& collection_id) override; Status - DeleteTableFiles(const std::string& collection_id) override; + DeleteCollectionFiles(const std::string& collection_id) override; Status CreateCollectionFile(SegmentSchema& file_schema) override; Status - GetTableFiles(const std::string& collection_id, const std::vector& ids, - SegmentsSchema& table_files) override; + GetCollectionFiles(const std::string& collection_id, const std::vector& ids, + SegmentsSchema& collection_files) override; Status - GetCollectionFilesBySegmentId(const std::string& segment_id, SegmentsSchema& table_files) override; + GetCollectionFilesBySegmentId(const std::string& segment_id, SegmentsSchema& collection_files) override; Status UpdateCollectionIndex(const std::string& collection_id, const CollectionIndex& index) override; @@ -66,7 +66,7 @@ class MySQLMetaImpl : public Meta { UpdateCollectionFlag(const std::string& collection_id, int64_t flag) override; Status - UpdateTableFlushLSN(const std::string& collection_id, uint64_t flush_lsn) override; + UpdateCollectionFlushLSN(const std::string& collection_id, uint64_t flush_lsn) override; Status GetCollectionFlushLSN(const std::string& collection_id, uint64_t& flush_lsn) override; @@ -116,7 +116,7 @@ class MySQLMetaImpl : public Meta { FilesByType(const std::string& collection_id, const std::vector& file_types, SegmentsSchema& files) override; Status - FilesByID(const std::vector& ids, SegmentsSchema& table_files) override; + FilesByID(const std::vector& ids, SegmentsSchema& collection_files) override; Status Archive() override; @@ -146,7 +146,7 @@ class MySQLMetaImpl : public Meta { Status NextFileId(std::string& file_id); Status - NextTableId(std::string& collection_id); + NextCollectionId(std::string& collection_id); Status DiscardFiles(int64_t to_discard_size); diff --git a/core/src/db/meta/SqliteMetaImpl.cpp b/core/src/db/meta/SqliteMetaImpl.cpp index d28d87f7a4..06542babbf 100644 --- a/core/src/db/meta/SqliteMetaImpl.cpp +++ b/core/src/db/meta/SqliteMetaImpl.cpp @@ -99,7 +99,7 @@ SqliteMetaImpl::~SqliteMetaImpl() { } Status -SqliteMetaImpl::NextTableId(std::string& collection_id) { +SqliteMetaImpl::NextCollectionId(std::string& collection_id) { std::lock_guard lock(genid_mutex_); // avoid duplicated id std::stringstream ss; SafeIDGenerator& id_generator = SafeIDGenerator::GetInstance(); @@ -164,19 +164,19 @@ SqliteMetaImpl::Initialize() { } Status -SqliteMetaImpl::CreateCollection(CollectionSchema& table_schema) { +SqliteMetaImpl::CreateCollection(CollectionSchema& collection_schema) { try { server::MetricCollector metric; // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here std::lock_guard meta_lock(meta_mutex_); - if (table_schema.collection_id_ == "") { - NextTableId(table_schema.collection_id_); + if (collection_schema.collection_id_ == "") { + NextCollectionId(collection_schema.collection_id_); } else { fiu_do_on("SqliteMetaImpl.CreateCollection.throw_exception", throw std::exception()); auto collection = ConnectorPtr->select(columns(&CollectionSchema::state_), - where(c(&CollectionSchema::collection_id_) == table_schema.collection_id_)); + where(c(&CollectionSchema::collection_id_) == collection_schema.collection_id_)); if (collection.size() == 1) { if (CollectionSchema::TO_DELETE == std::get<0>(collection[0])) { return Status(DB_ERROR, "Collection already exists and it is in delete state, please wait a second"); @@ -187,27 +187,27 @@ SqliteMetaImpl::CreateCollection(CollectionSchema& table_schema) { } } - table_schema.id_ = -1; - table_schema.created_on_ = utils::GetMicroSecTimeStamp(); + collection_schema.id_ = -1; + collection_schema.created_on_ = utils::GetMicroSecTimeStamp(); try { fiu_do_on("SqliteMetaImpl.CreateCollection.insert_throw_exception", throw std::exception()); - auto id = ConnectorPtr->insert(table_schema); - table_schema.id_ = id; + auto id = ConnectorPtr->insert(collection_schema); + collection_schema.id_ = id; } catch (std::exception& e) { return HandleException("Encounter exception when create collection", e.what()); } - ENGINE_LOG_DEBUG << "Successfully create collection: " << table_schema.collection_id_; + ENGINE_LOG_DEBUG << "Successfully create collection: " << collection_schema.collection_id_; - return utils::CreateCollectionPath(options_, table_schema.collection_id_); + return utils::CreateCollectionPath(options_, collection_schema.collection_id_); } catch (std::exception& e) { return HandleException("Encounter exception when create collection", e.what()); } } Status -SqliteMetaImpl::DescribeCollection(CollectionSchema& table_schema) { +SqliteMetaImpl::DescribeCollection(CollectionSchema& collection_schema) { try { server::MetricCollector metric; @@ -219,25 +219,25 @@ SqliteMetaImpl::DescribeCollection(CollectionSchema& table_schema) { &CollectionSchema::flag_, &CollectionSchema::index_file_size_, &CollectionSchema::engine_type_, &CollectionSchema::index_params_, &CollectionSchema::metric_type_, &CollectionSchema::owner_collection_, &CollectionSchema::partition_tag_, &CollectionSchema::version_, &CollectionSchema::flush_lsn_), - where(c(&CollectionSchema::collection_id_) == table_schema.collection_id_ and + where(c(&CollectionSchema::collection_id_) == collection_schema.collection_id_ and c(&CollectionSchema::state_) != (int)CollectionSchema::TO_DELETE)); if (groups.size() == 1) { - table_schema.id_ = std::get<0>(groups[0]); - table_schema.state_ = std::get<1>(groups[0]); - table_schema.dimension_ = std::get<2>(groups[0]); - table_schema.created_on_ = std::get<3>(groups[0]); - table_schema.flag_ = std::get<4>(groups[0]); - table_schema.index_file_size_ = std::get<5>(groups[0]); - table_schema.engine_type_ = std::get<6>(groups[0]); - table_schema.index_params_ = std::get<7>(groups[0]); - table_schema.metric_type_ = std::get<8>(groups[0]); - table_schema.owner_collection_ = std::get<9>(groups[0]); - table_schema.partition_tag_ = std::get<10>(groups[0]); - table_schema.version_ = std::get<11>(groups[0]); - table_schema.flush_lsn_ = std::get<12>(groups[0]); + collection_schema.id_ = std::get<0>(groups[0]); + collection_schema.state_ = std::get<1>(groups[0]); + collection_schema.dimension_ = std::get<2>(groups[0]); + collection_schema.created_on_ = std::get<3>(groups[0]); + collection_schema.flag_ = std::get<4>(groups[0]); + collection_schema.index_file_size_ = std::get<5>(groups[0]); + collection_schema.engine_type_ = std::get<6>(groups[0]); + collection_schema.index_params_ = std::get<7>(groups[0]); + collection_schema.metric_type_ = std::get<8>(groups[0]); + collection_schema.owner_collection_ = std::get<9>(groups[0]); + collection_schema.partition_tag_ = std::get<10>(groups[0]); + collection_schema.version_ = std::get<11>(groups[0]); + collection_schema.flush_lsn_ = std::get<12>(groups[0]); } else { - return Status(DB_NOT_FOUND, "Collection " + table_schema.collection_id_ + " not found"); + return Status(DB_NOT_FOUND, "Collection " + collection_schema.collection_id_ + " not found"); } } catch (std::exception& e) { return HandleException("Encounter exception when describe collection", e.what()); @@ -253,10 +253,10 @@ SqliteMetaImpl::HasCollection(const std::string& collection_id, bool& has_or_not try { fiu_do_on("SqliteMetaImpl.HasCollection.throw_exception", throw std::exception()); server::MetricCollector metric; - auto tables = ConnectorPtr->select( + auto collections = ConnectorPtr->select( columns(&CollectionSchema::id_), where(c(&CollectionSchema::collection_id_) == collection_id and c(&CollectionSchema::state_) != (int)CollectionSchema::TO_DELETE)); - if (tables.size() == 1) { + if (collections.size() == 1) { has_or_not = true; } else { has_or_not = false; @@ -269,7 +269,7 @@ SqliteMetaImpl::HasCollection(const std::string& collection_id, bool& has_or_not } Status -SqliteMetaImpl::AllCollections(std::vector& table_schema_array) { +SqliteMetaImpl::AllCollections(std::vector& collection_schema_array) { try { fiu_do_on("SqliteMetaImpl.AllCollections.throw_exception", throw std::exception()); server::MetricCollector metric; @@ -295,10 +295,10 @@ SqliteMetaImpl::AllCollections(std::vector& table_schema_array schema.version_ = std::get<11>(collection); schema.flush_lsn_ = std::get<12>(collection); - table_schema_array.emplace_back(schema); + collection_schema_array.emplace_back(schema); } } catch (std::exception& e) { - return HandleException("Encounter exception when lookup all tables", e.what()); + return HandleException("Encounter exception when lookup all collections", e.what()); } return Status::OK(); @@ -328,9 +328,9 @@ SqliteMetaImpl::DropCollection(const std::string& collection_id) { } Status -SqliteMetaImpl::DeleteTableFiles(const std::string& collection_id) { +SqliteMetaImpl::DeleteCollectionFiles(const std::string& collection_id) { try { - fiu_do_on("SqliteMetaImpl.DeleteTableFiles.throw_exception", throw std::exception()); + fiu_do_on("SqliteMetaImpl.DeleteCollectionFiles.throw_exception", throw std::exception()); server::MetricCollector metric; @@ -356,9 +356,9 @@ SqliteMetaImpl::CreateCollectionFile(SegmentSchema& file_schema) { if (file_schema.date_ == EmptyDate) { file_schema.date_ = utils::GetDate(); } - CollectionSchema table_schema; - table_schema.collection_id_ = file_schema.collection_id_; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = file_schema.collection_id_; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -371,15 +371,15 @@ SqliteMetaImpl::CreateCollectionFile(SegmentSchema& file_schema) { if (file_schema.segment_id_.empty()) { file_schema.segment_id_ = file_schema.file_id_; } - file_schema.dimension_ = table_schema.dimension_; + file_schema.dimension_ = collection_schema.dimension_; file_schema.file_size_ = 0; file_schema.row_count_ = 0; file_schema.created_on_ = utils::GetMicroSecTimeStamp(); file_schema.updated_time_ = file_schema.created_on_; - file_schema.index_file_size_ = table_schema.index_file_size_; - file_schema.index_params_ = table_schema.index_params_; - file_schema.engine_type_ = table_schema.engine_type_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.index_file_size_ = collection_schema.index_file_size_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.engine_type_ = collection_schema.engine_type_; + file_schema.metric_type_ = collection_schema.metric_type_; // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here std::lock_guard meta_lock(meta_mutex_); @@ -397,21 +397,21 @@ SqliteMetaImpl::CreateCollectionFile(SegmentSchema& file_schema) { } Status -SqliteMetaImpl::GetTableFiles(const std::string& collection_id, const std::vector& ids, - SegmentsSchema& table_files) { +SqliteMetaImpl::GetCollectionFiles(const std::string& collection_id, const std::vector& ids, + SegmentsSchema& collection_files) { try { - fiu_do_on("SqliteMetaImpl.GetTableFiles.throw_exception", throw std::exception()); + fiu_do_on("SqliteMetaImpl.GetCollectionFiles.throw_exception", throw std::exception()); - table_files.clear(); + collection_files.clear(); auto files = ConnectorPtr->select( columns(&SegmentSchema::id_, &SegmentSchema::segment_id_, &SegmentSchema::file_id_, &SegmentSchema::file_type_, &SegmentSchema::file_size_, &SegmentSchema::row_count_, &SegmentSchema::date_, &SegmentSchema::engine_type_, &SegmentSchema::created_on_), where(c(&SegmentSchema::collection_id_) == collection_id and in(&SegmentSchema::id_, ids) and c(&SegmentSchema::file_type_) != (int)SegmentSchema::TO_DELETE)); - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -429,14 +429,14 @@ SqliteMetaImpl::GetTableFiles(const std::string& collection_id, const std::vecto file_schema.date_ = std::get<6>(file); file_schema.engine_type_ = std::get<7>(file); file_schema.created_on_ = std::get<8>(file); - file_schema.dimension_ = table_schema.dimension_; - file_schema.index_file_size_ = table_schema.index_file_size_; - file_schema.index_params_ = table_schema.index_params_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.dimension_ = collection_schema.dimension_; + file_schema.index_file_size_ = collection_schema.index_file_size_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.metric_type_ = collection_schema.metric_type_; - utils::GetTableFilePath(options_, file_schema); + utils::GetCollectionFilePath(options_, file_schema); - table_files.emplace_back(file_schema); + collection_files.emplace_back(file_schema); } ENGINE_LOG_DEBUG << "Get collection files by id"; @@ -448,9 +448,9 @@ SqliteMetaImpl::GetTableFiles(const std::string& collection_id, const std::vecto Status SqliteMetaImpl::GetCollectionFilesBySegmentId(const std::string& segment_id, - milvus::engine::meta::SegmentsSchema& table_files) { + milvus::engine::meta::SegmentsSchema& collection_files) { try { - table_files.clear(); + collection_files.clear(); auto files = ConnectorPtr->select( columns(&SegmentSchema::id_, &SegmentSchema::collection_id_, &SegmentSchema::segment_id_, &SegmentSchema::file_id_, &SegmentSchema::file_type_, &SegmentSchema::file_size_, @@ -460,16 +460,16 @@ SqliteMetaImpl::GetCollectionFilesBySegmentId(const std::string& segment_id, c(&SegmentSchema::file_type_) != (int)SegmentSchema::TO_DELETE)); if (!files.empty()) { - CollectionSchema table_schema; - table_schema.collection_id_ = std::get<1>(files[0]); - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = std::get<1>(files[0]); + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } for (auto& file : files) { SegmentSchema file_schema; - file_schema.collection_id_ = table_schema.collection_id_; + file_schema.collection_id_ = collection_schema.collection_id_; file_schema.id_ = std::get<0>(file); file_schema.segment_id_ = std::get<2>(file); file_schema.file_id_ = std::get<3>(file); @@ -479,13 +479,13 @@ SqliteMetaImpl::GetCollectionFilesBySegmentId(const std::string& segment_id, file_schema.date_ = std::get<7>(file); file_schema.engine_type_ = std::get<8>(file); file_schema.created_on_ = std::get<9>(file); - file_schema.dimension_ = table_schema.dimension_; - file_schema.index_file_size_ = table_schema.index_file_size_; - file_schema.index_params_ = table_schema.index_params_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.dimension_ = collection_schema.dimension_; + file_schema.index_file_size_ = collection_schema.index_file_size_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.metric_type_ = collection_schema.metric_type_; - utils::GetTableFilePath(options_, file_schema); - table_files.emplace_back(file_schema); + utils::GetCollectionFilePath(options_, file_schema); + collection_files.emplace_back(file_schema); } } @@ -514,7 +514,7 @@ SqliteMetaImpl::UpdateCollectionFlag(const std::string& collection_id, int64_t f } Status -SqliteMetaImpl::UpdateTableFlushLSN(const std::string& collection_id, uint64_t flush_lsn) { +SqliteMetaImpl::UpdateCollectionFlushLSN(const std::string& collection_id, uint64_t flush_lsn) { try { server::MetricCollector metric; @@ -560,12 +560,12 @@ SqliteMetaImpl::UpdateCollectionFile(SegmentSchema& file_schema) { // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here std::lock_guard meta_lock(meta_mutex_); - auto tables = ConnectorPtr->select(columns(&CollectionSchema::state_), + auto collections = ConnectorPtr->select(columns(&CollectionSchema::state_), where(c(&CollectionSchema::collection_id_) == file_schema.collection_id_)); // if the collection has been deleted, just mark the collection file as TO_DELETE // clean thread will delete the file later - if (tables.size() < 1 || std::get<0>(tables[0]) == (int)CollectionSchema::TO_DELETE) { + if (collections.size() < 1 || std::get<0>(collections[0]) == (int)CollectionSchema::TO_DELETE) { file_schema.file_type_ = SegmentSchema::TO_DELETE; } @@ -594,10 +594,10 @@ SqliteMetaImpl::UpdateCollectionFiles(SegmentsSchema& files) { if (has_collections.find(file.collection_id_) != has_collections.end()) { continue; } - auto tables = ConnectorPtr->select(columns(&CollectionSchema::id_), + auto collections = ConnectorPtr->select(columns(&CollectionSchema::id_), where(c(&CollectionSchema::collection_id_) == file.collection_id_ and c(&CollectionSchema::state_) != (int)CollectionSchema::TO_DELETE)); - if (tables.size() >= 1) { + if (collections.size() >= 1) { has_collections[file.collection_id_] = true; } else { has_collections[file.collection_id_] = false; @@ -657,31 +657,31 @@ SqliteMetaImpl::UpdateCollectionIndex(const std::string& collection_id, const Co // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here std::lock_guard meta_lock(meta_mutex_); - auto tables = ConnectorPtr->select( + auto collections = ConnectorPtr->select( columns(&CollectionSchema::id_, &CollectionSchema::state_, &CollectionSchema::dimension_, &CollectionSchema::created_on_, &CollectionSchema::flag_, &CollectionSchema::index_file_size_, &CollectionSchema::owner_collection_, &CollectionSchema::partition_tag_, &CollectionSchema::version_, &CollectionSchema::flush_lsn_), where(c(&CollectionSchema::collection_id_) == collection_id and c(&CollectionSchema::state_) != (int)CollectionSchema::TO_DELETE)); - if (tables.size() > 0) { - meta::CollectionSchema table_schema; - table_schema.id_ = std::get<0>(tables[0]); - table_schema.collection_id_ = collection_id; - table_schema.state_ = std::get<1>(tables[0]); - table_schema.dimension_ = std::get<2>(tables[0]); - table_schema.created_on_ = std::get<3>(tables[0]); - table_schema.flag_ = std::get<4>(tables[0]); - table_schema.index_file_size_ = std::get<5>(tables[0]); - table_schema.owner_collection_ = std::get<6>(tables[0]); - table_schema.partition_tag_ = std::get<7>(tables[0]); - table_schema.version_ = std::get<8>(tables[0]); - table_schema.flush_lsn_ = std::get<9>(tables[0]); - table_schema.engine_type_ = index.engine_type_; - table_schema.index_params_ = index.extra_params_.dump(); - table_schema.metric_type_ = index.metric_type_; + if (collections.size() > 0) { + meta::CollectionSchema collection_schema; + collection_schema.id_ = std::get<0>(collections[0]); + collection_schema.collection_id_ = collection_id; + collection_schema.state_ = std::get<1>(collections[0]); + collection_schema.dimension_ = std::get<2>(collections[0]); + collection_schema.created_on_ = std::get<3>(collections[0]); + collection_schema.flag_ = std::get<4>(collections[0]); + collection_schema.index_file_size_ = std::get<5>(collections[0]); + collection_schema.owner_collection_ = std::get<6>(collections[0]); + collection_schema.partition_tag_ = std::get<7>(collections[0]); + collection_schema.version_ = std::get<8>(collections[0]); + collection_schema.flush_lsn_ = std::get<9>(collections[0]); + collection_schema.engine_type_ = index.engine_type_; + collection_schema.index_params_ = index.extra_params_.dump(); + collection_schema.metric_type_ = index.metric_type_; - ConnectorPtr->update(table_schema); + ConnectorPtr->update(collection_schema); } else { return Status(DB_NOT_FOUND, "Collection " + collection_id + " not found"); } @@ -796,15 +796,15 @@ SqliteMetaImpl::CreatePartition(const std::string& collection_id, const std::str uint64_t lsn) { server::MetricCollector metric; - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } // not allow create partition under partition - if (!table_schema.owner_collection_.empty()) { + if (!collection_schema.owner_collection_.empty()) { return Status(DB_ERROR, "Nested partition is not allowed"); } @@ -822,19 +822,19 @@ SqliteMetaImpl::CreatePartition(const std::string& collection_id, const std::str if (partition_name == "") { // generate unique partition name - NextTableId(table_schema.collection_id_); + NextCollectionId(collection_schema.collection_id_); } else { - table_schema.collection_id_ = partition_name; + collection_schema.collection_id_ = partition_name; } - table_schema.id_ = -1; - table_schema.flag_ = 0; - table_schema.created_on_ = utils::GetMicroSecTimeStamp(); - table_schema.owner_collection_ = collection_id; - table_schema.partition_tag_ = valid_tag; - table_schema.flush_lsn_ = lsn; + collection_schema.id_ = -1; + collection_schema.flag_ = 0; + collection_schema.created_on_ = utils::GetMicroSecTimeStamp(); + collection_schema.owner_collection_ = collection_id; + collection_schema.partition_tag_ = valid_tag; + collection_schema.flush_lsn_ = lsn; - status = CreateCollection(table_schema); + status = CreateCollection(collection_schema); if (status.code() == DB_ALREADY_EXIST) { return Status(DB_ALREADY_EXIST, "Partition already exists"); } @@ -925,47 +925,47 @@ SqliteMetaImpl::FilesToSearch(const std::string& collection_id, SegmentsSchema& &SegmentSchema::file_id_, &SegmentSchema::file_type_, &SegmentSchema::file_size_, &SegmentSchema::row_count_, &SegmentSchema::date_, &SegmentSchema::engine_type_); - auto match_tableid = c(&SegmentSchema::collection_id_) == collection_id; + auto match_collectionid = c(&SegmentSchema::collection_id_) == collection_id; std::vector file_types = {(int)SegmentSchema::RAW, (int)SegmentSchema::TO_INDEX, (int)SegmentSchema::INDEX}; auto match_type = in(&SegmentSchema::file_type_, file_types); - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } // perform query decltype(ConnectorPtr->select(select_columns)) selected; - auto filter = where(match_tableid and match_type); + auto filter = where(match_collectionid and match_type); selected = ConnectorPtr->select(select_columns, filter); Status ret; for (auto& file : selected) { - SegmentSchema table_file; - table_file.id_ = std::get<0>(file); - table_file.collection_id_ = std::get<1>(file); - table_file.segment_id_ = std::get<2>(file); - table_file.file_id_ = std::get<3>(file); - table_file.file_type_ = std::get<4>(file); - table_file.file_size_ = std::get<5>(file); - table_file.row_count_ = std::get<6>(file); - table_file.date_ = std::get<7>(file); - table_file.engine_type_ = std::get<8>(file); - table_file.dimension_ = table_schema.dimension_; - table_file.index_file_size_ = table_schema.index_file_size_; - table_file.index_params_ = table_schema.index_params_; - table_file.metric_type_ = table_schema.metric_type_; + SegmentSchema collection_file; + collection_file.id_ = std::get<0>(file); + collection_file.collection_id_ = std::get<1>(file); + collection_file.segment_id_ = std::get<2>(file); + collection_file.file_id_ = std::get<3>(file); + collection_file.file_type_ = std::get<4>(file); + collection_file.file_size_ = std::get<5>(file); + collection_file.row_count_ = std::get<6>(file); + collection_file.date_ = std::get<7>(file); + collection_file.engine_type_ = std::get<8>(file); + collection_file.dimension_ = collection_schema.dimension_; + collection_file.index_file_size_ = collection_schema.index_file_size_; + collection_file.index_params_ = collection_schema.index_params_; + collection_file.metric_type_ = collection_schema.metric_type_; - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - files.emplace_back(table_file); + files.emplace_back(collection_file); } if (files.empty()) { ENGINE_LOG_ERROR << "No file to search for collection: " << collection_id; @@ -990,9 +990,9 @@ SqliteMetaImpl::FilesToMerge(const std::string& collection_id, SegmentsSchema& f server::MetricCollector metric; // check collection existence - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -1009,31 +1009,31 @@ SqliteMetaImpl::FilesToMerge(const std::string& collection_id, SegmentsSchema& f Status result; int64_t to_merge_files = 0; for (auto& file : selected) { - SegmentSchema table_file; - table_file.file_size_ = std::get<5>(file); - if (table_file.file_size_ >= table_schema.index_file_size_) { + SegmentSchema collection_file; + collection_file.file_size_ = std::get<5>(file); + if (collection_file.file_size_ >= collection_schema.index_file_size_) { continue; // skip large file } - table_file.id_ = std::get<0>(file); - table_file.collection_id_ = std::get<1>(file); - table_file.segment_id_ = std::get<2>(file); - table_file.file_id_ = std::get<3>(file); - table_file.file_type_ = std::get<4>(file); - table_file.row_count_ = std::get<6>(file); - table_file.date_ = std::get<7>(file); - table_file.created_on_ = std::get<8>(file); - table_file.dimension_ = table_schema.dimension_; - table_file.index_file_size_ = table_schema.index_file_size_; - table_file.index_params_ = table_schema.index_params_; - table_file.metric_type_ = table_schema.metric_type_; + collection_file.id_ = std::get<0>(file); + collection_file.collection_id_ = std::get<1>(file); + collection_file.segment_id_ = std::get<2>(file); + collection_file.file_id_ = std::get<3>(file); + collection_file.file_type_ = std::get<4>(file); + collection_file.row_count_ = std::get<6>(file); + collection_file.date_ = std::get<7>(file); + collection_file.created_on_ = std::get<8>(file); + collection_file.dimension_ = collection_schema.dimension_; + collection_file.index_file_size_ = collection_schema.index_file_size_; + collection_file.index_params_ = collection_schema.index_params_; + collection_file.metric_type_ = collection_schema.metric_type_; - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { result = status; } - files.emplace_back(table_file); + files.emplace_back(collection_file); ++to_merge_files; } @@ -1063,42 +1063,42 @@ SqliteMetaImpl::FilesToIndex(SegmentsSchema& files) { where(c(&SegmentSchema::file_type_) == (int)SegmentSchema::TO_INDEX)); std::map groups; - SegmentSchema table_file; + SegmentSchema collection_file; Status ret; for (auto& file : selected) { - table_file.id_ = std::get<0>(file); - table_file.collection_id_ = std::get<1>(file); - table_file.segment_id_ = std::get<2>(file); - table_file.file_id_ = std::get<3>(file); - table_file.file_type_ = std::get<4>(file); - table_file.file_size_ = std::get<5>(file); - table_file.row_count_ = std::get<6>(file); - table_file.date_ = std::get<7>(file); - table_file.engine_type_ = std::get<8>(file); - table_file.created_on_ = std::get<9>(file); + collection_file.id_ = std::get<0>(file); + collection_file.collection_id_ = std::get<1>(file); + collection_file.segment_id_ = std::get<2>(file); + collection_file.file_id_ = std::get<3>(file); + collection_file.file_type_ = std::get<4>(file); + collection_file.file_size_ = std::get<5>(file); + collection_file.row_count_ = std::get<6>(file); + collection_file.date_ = std::get<7>(file); + collection_file.engine_type_ = std::get<8>(file); + collection_file.created_on_ = std::get<9>(file); - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - auto groupItr = groups.find(table_file.collection_id_); + auto groupItr = groups.find(collection_file.collection_id_); if (groupItr == groups.end()) { - CollectionSchema table_schema; - table_schema.collection_id_ = table_file.collection_id_; - auto status = DescribeCollection(table_schema); - fiu_do_on("SqliteMetaImpl_FilesToIndex_TableNotFound", + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_file.collection_id_; + auto status = DescribeCollection(collection_schema); + fiu_do_on("SqliteMetaImpl_FilesToIndex_CollectionNotFound", status = Status(DB_NOT_FOUND, "collection not found")); if (!status.ok()) { return status; } - groups[table_file.collection_id_] = table_schema; + groups[collection_file.collection_id_] = collection_schema; } - table_file.dimension_ = groups[table_file.collection_id_].dimension_; - table_file.index_file_size_ = groups[table_file.collection_id_].index_file_size_; - table_file.index_params_ = groups[table_file.collection_id_].index_params_; - table_file.metric_type_ = groups[table_file.collection_id_].metric_type_; - files.push_back(table_file); + collection_file.dimension_ = groups[collection_file.collection_id_].dimension_; + collection_file.index_file_size_ = groups[collection_file.collection_id_].index_file_size_; + collection_file.index_params_ = groups[collection_file.collection_id_].index_params_; + collection_file.metric_type_ = groups[collection_file.collection_id_].metric_type_; + files.push_back(collection_file); } if (selected.size() > 0) { @@ -1118,9 +1118,9 @@ SqliteMetaImpl::FilesByType(const std::string& collection_id, const std::vector< Status ret = Status::OK(); - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } @@ -1151,10 +1151,10 @@ SqliteMetaImpl::FilesByType(const std::string& collection_id, const std::vector< file_schema.engine_type_ = std::get<7>(file); file_schema.created_on_ = std::get<8>(file); - file_schema.dimension_ = table_schema.dimension_; - file_schema.index_file_size_ = table_schema.index_file_size_; - file_schema.index_params_ = table_schema.index_params_; - file_schema.metric_type_ = table_schema.metric_type_; + file_schema.dimension_ = collection_schema.dimension_; + file_schema.index_file_size_ = collection_schema.index_file_size_; + file_schema.index_params_ = collection_schema.index_params_; + file_schema.metric_type_ = collection_schema.metric_type_; switch (file_schema.file_type_) { case (int)SegmentSchema::RAW:++raw_count; @@ -1174,7 +1174,7 @@ SqliteMetaImpl::FilesByType(const std::string& collection_id, const std::vector< default:break; } - auto status = utils::GetTableFilePath(options_, file_schema); + auto status = utils::GetCollectionFilePath(options_, file_schema); if (!status.ok()) { ret = status; } @@ -1243,44 +1243,44 @@ SqliteMetaImpl::FilesByID(const std::vector& ids, SegmentsSchema& files) auto filter = where(match_fileid and match_type); selected = ConnectorPtr->select(select_columns, filter); - std::map tables; + std::map collections; Status ret; for (auto& file : selected) { - SegmentSchema table_file; - table_file.id_ = std::get<0>(file); - table_file.collection_id_ = std::get<1>(file); - table_file.segment_id_ = std::get<2>(file); - table_file.file_id_ = std::get<3>(file); - table_file.file_type_ = std::get<4>(file); - table_file.file_size_ = std::get<5>(file); - table_file.row_count_ = std::get<6>(file); - table_file.date_ = std::get<7>(file); - table_file.engine_type_ = std::get<8>(file); + SegmentSchema collection_file; + collection_file.id_ = std::get<0>(file); + collection_file.collection_id_ = std::get<1>(file); + collection_file.segment_id_ = std::get<2>(file); + collection_file.file_id_ = std::get<3>(file); + collection_file.file_type_ = std::get<4>(file); + collection_file.file_size_ = std::get<5>(file); + collection_file.row_count_ = std::get<6>(file); + collection_file.date_ = std::get<7>(file); + collection_file.engine_type_ = std::get<8>(file); - if (tables.find(table_file.collection_id_) == tables.end()) { - CollectionSchema table_schema; - table_schema.collection_id_ = table_file.collection_id_; - auto status = DescribeCollection(table_schema); + if (collections.find(collection_file.collection_id_) == collections.end()) { + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_file.collection_id_; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; } - tables.insert(std::make_pair(table_file.collection_id_, table_schema)); + collections.insert(std::make_pair(collection_file.collection_id_, collection_schema)); } - auto status = utils::GetTableFilePath(options_, table_file); + auto status = utils::GetCollectionFilePath(options_, collection_file); if (!status.ok()) { ret = status; } - files.emplace_back(table_file); + files.emplace_back(collection_file); } - for (auto& table_file : files) { - CollectionSchema& table_schema = tables[table_file.collection_id_]; - table_file.dimension_ = table_schema.dimension_; - table_file.index_file_size_ = table_schema.index_file_size_; - table_file.index_params_ = table_schema.index_params_; - table_file.metric_type_ = table_schema.metric_type_; + for (auto& collection_file : files) { + CollectionSchema& collection_schema = collections[collection_file.collection_id_]; + collection_file.dimension_ = collection_schema.dimension_; + collection_file.index_file_size_ = collection_schema.index_file_size_; + collection_file.index_params_ = collection_schema.index_params_; + collection_file.metric_type_ = collection_schema.metric_type_; } if (files.empty()) { @@ -1400,7 +1400,7 @@ SqliteMetaImpl::CleanUpShadowFiles() { Status SqliteMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/) { auto now = utils::GetMicroSecTimeStamp(); - std::set table_ids; + std::set collection_ids; std::map segment_ids; // remove to_delete files @@ -1427,40 +1427,40 @@ SqliteMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/ int64_t clean_files = 0; auto commited = ConnectorPtr->transaction([&]() mutable { - SegmentSchema table_file; + SegmentSchema collection_file; for (auto& file : files) { - table_file.id_ = std::get<0>(file); - table_file.collection_id_ = std::get<1>(file); - table_file.segment_id_ = std::get<2>(file); - table_file.engine_type_ = std::get<3>(file); - table_file.file_id_ = std::get<4>(file); - table_file.file_type_ = std::get<5>(file); - table_file.date_ = std::get<6>(file); + collection_file.id_ = std::get<0>(file); + collection_file.collection_id_ = std::get<1>(file); + collection_file.segment_id_ = std::get<2>(file); + collection_file.engine_type_ = std::get<3>(file); + collection_file.file_id_ = std::get<4>(file); + collection_file.file_type_ = std::get<5>(file); + collection_file.date_ = std::get<6>(file); // check if the file can be deleted - if (OngoingFileChecker::GetInstance().IsIgnored(table_file)) { - ENGINE_LOG_DEBUG << "File:" << table_file.file_id_ + if (OngoingFileChecker::GetInstance().IsIgnored(collection_file)) { + ENGINE_LOG_DEBUG << "File:" << collection_file.file_id_ << " currently is in use, not able to delete now"; continue; // ignore this file, don't delete it } // erase from cache, must do this before file deleted, - // because GetTableFilePath won't able to generate file path after the file is deleted + // because GetCollectionFilePath won't able to generate file path after the file is deleted // TODO(zhiru): clean up - utils::GetTableFilePath(options_, table_file); - server::CommonUtil::EraseFromCache(table_file.location_); + utils::GetCollectionFilePath(options_, collection_file); + server::CommonUtil::EraseFromCache(collection_file.location_); - if (table_file.file_type_ == (int)SegmentSchema::TO_DELETE) { + if (collection_file.file_type_ == (int)SegmentSchema::TO_DELETE) { // delete file from meta - ConnectorPtr->remove(table_file.id_); + ConnectorPtr->remove(collection_file.id_); // delete file from disk storage - utils::DeleteTableFilePath(options_, table_file); + utils::DeleteCollectionFilePath(options_, collection_file); - ENGINE_LOG_DEBUG << "Remove file id:" << table_file.file_id_ << " location:" - << table_file.location_; - table_ids.insert(table_file.collection_id_); - segment_ids.insert(std::make_pair(table_file.segment_id_, table_file)); + ENGINE_LOG_DEBUG << "Remove file id:" << collection_file.file_id_ << " location:" + << collection_file.location_; + collection_ids.insert(collection_file.collection_id_); + segment_ids.insert(std::make_pair(collection_file.segment_id_, collection_file)); ++clean_files; } @@ -1480,33 +1480,33 @@ SqliteMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/ return HandleException("Encounter exception when clean collection files", e.what()); } - // remove to_delete tables + // remove to_delete collections try { - fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTable_ThrowException", throw std::exception()); + fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollection_ThrowException", throw std::exception()); server::MetricCollector metric; // multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here std::lock_guard meta_lock(meta_mutex_); - auto tables = ConnectorPtr->select(columns(&CollectionSchema::id_, &CollectionSchema::collection_id_), + auto collections = ConnectorPtr->select(columns(&CollectionSchema::id_, &CollectionSchema::collection_id_), where(c(&CollectionSchema::state_) == (int)CollectionSchema::TO_DELETE)); auto commited = ConnectorPtr->transaction([&]() mutable { - for (auto& collection : tables) { - utils::DeleteTablePath(options_, std::get<1>(collection), false); // only delete empty folder + for (auto& collection : collections) { + utils::DeleteCollectionPath(options_, std::get<1>(collection), false); // only delete empty folder ConnectorPtr->remove(std::get<0>(collection)); } return true; }); - fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTable_Failcommited", commited = false); + fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollection_Failcommited", commited = false); if (!commited) { return HandleException("CleanUpFilesWithTTL error: sqlite transaction failed"); } - if (tables.size() > 0) { - ENGINE_LOG_DEBUG << "Remove " << tables.size() << " tables from meta"; + if (collections.size() > 0) { + ENGINE_LOG_DEBUG << "Remove " << collections.size() << " collections from meta"; } } catch (std::exception& e) { return HandleException("Encounter exception when clean collection files", e.what()); @@ -1515,28 +1515,28 @@ SqliteMetaImpl::CleanUpFilesWithTTL(uint64_t seconds /*, CleanUpFilter* filter*/ // remove deleted collection folder // don't remove collection folder until all its files has been deleted try { - fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTableFolder_ThrowException", throw std::exception()); + fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollectionFolder_ThrowException", throw std::exception()); server::MetricCollector metric; - int64_t remove_tables = 0; - for (auto& collection_id : table_ids) { + int64_t remove_collections = 0; + for (auto& collection_id : collection_ids) { auto selected = ConnectorPtr->select(columns(&SegmentSchema::file_id_), where(c(&SegmentSchema::collection_id_) == collection_id)); if (selected.size() == 0) { - utils::DeleteTablePath(options_, collection_id); - ++remove_tables; + utils::DeleteCollectionPath(options_, collection_id); + ++remove_collections; } } - if (remove_tables) { - ENGINE_LOG_DEBUG << "Remove " << remove_tables << " tables folder"; + if (remove_collections) { + ENGINE_LOG_DEBUG << "Remove " << remove_collections << " collections folder"; } } catch (std::exception& e) { return HandleException("Encounter exception when delete collection folder", e.what()); } // remove deleted segment folder - // don't remove segment folder until all its tablefiles has been deleted + // don't remove segment folder until all its files has been deleted try { fiu_do_on("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveSegmentFolder_ThrowException", throw std::exception()); server::MetricCollector metric; @@ -1577,9 +1577,9 @@ SqliteMetaImpl::Count(const std::string& collection_id, uint64_t& result) { columns(&SegmentSchema::row_count_), where(in(&SegmentSchema::file_type_, file_types) and c(&SegmentSchema::collection_id_) == collection_id)); - CollectionSchema table_schema; - table_schema.collection_id_ = collection_id; - auto status = DescribeCollection(table_schema); + CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_id; + auto status = DescribeCollection(collection_schema); if (!status.ok()) { return status; @@ -1632,17 +1632,17 @@ SqliteMetaImpl::DiscardFiles(int64_t to_discard_size) { order_by(&SegmentSchema::id_), limit(10)); std::vector ids; - SegmentSchema table_file; + SegmentSchema collection_file; for (auto& file : selected) { if (to_discard_size <= 0) break; - table_file.id_ = std::get<0>(file); - table_file.file_size_ = std::get<1>(file); - ids.push_back(table_file.id_); - ENGINE_LOG_DEBUG << "Discard table_file.id=" << table_file.file_id_ - << " table_file.size=" << table_file.file_size_; - to_discard_size -= table_file.file_size_; + collection_file.id_ = std::get<0>(file); + collection_file.file_size_ = std::get<1>(file); + ids.push_back(collection_file.id_); + ENGINE_LOG_DEBUG << "Discard file id=" << collection_file.file_id_ + << " file size=" << collection_file.file_size_; + to_discard_size -= collection_file.file_size_; } if (ids.size() == 0) { diff --git a/core/src/db/meta/SqliteMetaImpl.h b/core/src/db/meta/SqliteMetaImpl.h index d22223fde2..6446b4849a 100644 --- a/core/src/db/meta/SqliteMetaImpl.h +++ b/core/src/db/meta/SqliteMetaImpl.h @@ -31,32 +31,32 @@ class SqliteMetaImpl : public Meta { ~SqliteMetaImpl(); Status - CreateCollection(CollectionSchema& table_schema) override; + CreateCollection(CollectionSchema& collection_schema) override; Status - DescribeCollection(CollectionSchema& table_schema) override; + DescribeCollection(CollectionSchema& collection_schema) override; Status HasCollection(const std::string& collection_id, bool& has_or_not) override; Status - AllCollections(std::vector& table_schema_array) override; + AllCollections(std::vector& collection_schema_array) override; Status DropCollection(const std::string& collection_id) override; Status - DeleteTableFiles(const std::string& collection_id) override; + DeleteCollectionFiles(const std::string& collection_id) override; Status CreateCollectionFile(SegmentSchema& file_schema) override; Status - GetTableFiles(const std::string& collection_id, const std::vector& ids, - SegmentsSchema& table_files) override; + GetCollectionFiles(const std::string& collection_id, const std::vector& ids, + SegmentsSchema& collection_files) override; Status - GetCollectionFilesBySegmentId(const std::string& segment_id, SegmentsSchema& table_files) override; + GetCollectionFilesBySegmentId(const std::string& segment_id, SegmentsSchema& collection_files) override; Status UpdateCollectionIndex(const std::string& collection_id, const CollectionIndex& index) override; @@ -65,7 +65,7 @@ class SqliteMetaImpl : public Meta { UpdateCollectionFlag(const std::string& collection_id, int64_t flag) override; Status - UpdateTableFlushLSN(const std::string& collection_id, uint64_t flush_lsn) override; + UpdateCollectionFlushLSN(const std::string& collection_id, uint64_t flush_lsn) override; Status GetCollectionFlushLSN(const std::string& collection_id, uint64_t& flush_lsn) override; @@ -145,7 +145,7 @@ class SqliteMetaImpl : public Meta { Status NextFileId(std::string& file_id); Status - NextTableId(std::string& collection_id); + NextCollectionId(std::string& collection_id); Status DiscardFiles(int64_t to_discard_size); diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc index 3c127bcb18..2276765803 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc @@ -20,13 +20,13 @@ namespace milvus { namespace grpc { static const char* MilvusService_method_names[] = { - "/milvus.grpc.MilvusService/CreateTable", - "/milvus.grpc.MilvusService/HasTable", - "/milvus.grpc.MilvusService/DescribeTable", - "/milvus.grpc.MilvusService/CountTable", - "/milvus.grpc.MilvusService/ShowTables", - "/milvus.grpc.MilvusService/ShowTableInfo", - "/milvus.grpc.MilvusService/DropTable", + "/milvus.grpc.MilvusService/CreateCollection", + "/milvus.grpc.MilvusService/HasCollection", + "/milvus.grpc.MilvusService/DescribeCollection", + "/milvus.grpc.MilvusService/CountCollection", + "/milvus.grpc.MilvusService/ShowCollections", + "/milvus.grpc.MilvusService/ShowCollectionInfo", + "/milvus.grpc.MilvusService/DropCollection", "/milvus.grpc.MilvusService/CreateIndex", "/milvus.grpc.MilvusService/DescribeIndex", "/milvus.grpc.MilvusService/DropIndex", @@ -41,7 +41,7 @@ static const char* MilvusService_method_names[] = { "/milvus.grpc.MilvusService/SearchInFiles", "/milvus.grpc.MilvusService/Cmd", "/milvus.grpc.MilvusService/DeleteByID", - "/milvus.grpc.MilvusService/PreloadTable", + "/milvus.grpc.MilvusService/PreloadCollection", "/milvus.grpc.MilvusService/Flush", "/milvus.grpc.MilvusService/Compact", }; @@ -53,13 +53,13 @@ std::unique_ptr< MilvusService::Stub> MilvusService::NewStub(const std::shared_p } MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) - : channel_(channel), rpcmethod_CreateTable_(MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HasTable_(MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DescribeTable_(MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_CountTable_(MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowTables_(MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowTableInfo_(MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DropTable_(MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + : channel_(channel), rpcmethod_CreateCollection_(MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HasCollection_(MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DescribeCollection_(MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CountCollection_(MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowCollections_(MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowCollectionInfo_(MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DropCollection_(MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_CreateIndex_(MilvusService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DescribeIndex_(MilvusService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DropIndex_(MilvusService_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) @@ -74,205 +74,205 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan , rpcmethod_SearchInFiles_(MilvusService_method_names[18], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Cmd_(MilvusService_method_names[19], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DeleteByID_(MilvusService_method_names[20], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_PreloadTable_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PreloadCollection_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Flush_(MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Compact_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} -::grpc::Status MilvusService::Stub::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateTable_, context, request, response); +::grpc::Status MilvusService::Stub::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasTable_, context, request, response); +::grpc::Status MilvusService::Stub::HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeTable_, context, request, response); +::grpc::Status MilvusService::Stub::DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionSchema* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableSchema>::Create(channel_.get(), cq, rpcmethod_DescribeTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* MilvusService::Stub::AsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionSchema>::Create(channel_.get(), cq, rpcmethod_DescribeCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableSchema>::Create(channel_.get(), cq, rpcmethod_DescribeTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* MilvusService::Stub::PrepareAsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionSchema>::Create(channel_.get(), cq, rpcmethod_DescribeCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountTable_, context, request, response); +::grpc::Status MilvusService::Stub::CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::AsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::PrepareAsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowTables_, context, request, response); +::grpc::Status MilvusService::Stub::ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::CollectionNameList* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowCollections_, context, request, response); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* MilvusService::Stub::AsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionNameList>::Create(channel_.get(), cq, rpcmethod_ShowCollections_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* MilvusService::Stub::PrepareAsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionNameList>::Create(channel_.get(), cq, rpcmethod_ShowCollections_, context, request, false); } -::grpc::Status MilvusService::Stub::ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableInfo* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowTableInfo_, context, request, response); +::grpc::Status MilvusService::Stub::ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowCollectionInfo_, context, request, response); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* MilvusService::Stub::AsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableInfo>::Create(channel_.get(), cq, rpcmethod_ShowTableInfo_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::AsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowCollectionInfo_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* MilvusService::Stub::PrepareAsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableInfo>::Create(channel_.get(), cq, rpcmethod_ShowTableInfo_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::PrepareAsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowCollectionInfo_, context, request, false); } -::grpc::Status MilvusService::Stub::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropTable_, context, request, response); +::grpc::Status MilvusService::Stub::DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropCollection_, context, request, false); } ::grpc::Status MilvusService::Stub::CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) { @@ -303,11 +303,11 @@ void MilvusService::Stub::experimental_async::CreateIndex(::grpc::ClientContext* return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateIndex_, context, request, false); } -::grpc::Status MilvusService::Stub::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) { +::grpc::Status MilvusService::Stub::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::IndexParam* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeIndex_, context, request, response); } -void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function f) { +void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, std::move(f)); } @@ -315,7 +315,7 @@ void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContex ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, reactor); } @@ -323,19 +323,19 @@ void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContex ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::IndexParam>::Create(channel_.get(), cq, rpcmethod_DescribeIndex_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::IndexParam>::Create(channel_.get(), cq, rpcmethod_DescribeIndex_, context, request, false); } -::grpc::Status MilvusService::Stub::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Stub::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropIndex_, context, request, response); } -void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { +void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, std::move(f)); } @@ -343,7 +343,7 @@ void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* c ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, reactor); } @@ -351,11 +351,11 @@ void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* c ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropIndex_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropIndex_, context, request, false); } @@ -387,11 +387,11 @@ void MilvusService::Stub::experimental_async::CreatePartition(::grpc::ClientCont return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreatePartition_, context, request, false); } -::grpc::Status MilvusService::Stub::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::PartitionList* response) { +::grpc::Status MilvusService::Stub::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::PartitionList* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowPartitions_, context, request, response); } -void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, std::function f) { +void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, std::move(f)); } @@ -399,7 +399,7 @@ void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientConte ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, reactor); } @@ -407,11 +407,11 @@ void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientConte ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::PartitionList>::Create(channel_.get(), cq, rpcmethod_ShowPartitions_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::PartitionList>::Create(channel_.get(), cq, rpcmethod_ShowPartitions_, context, request, false); } @@ -667,32 +667,32 @@ void MilvusService::Stub::experimental_async::DeleteByID(::grpc::ClientContext* return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteByID_, context, request, false); } -::grpc::Status MilvusService::Stub::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadTable_, context, request, response); +::grpc::Status MilvusService::Stub::PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadCollection_, context, request, false); } ::grpc::Status MilvusService::Stub::Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) { @@ -723,11 +723,11 @@ void MilvusService::Stub::experimental_async::Flush(::grpc::ClientContext* conte return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Flush_, context, request, false); } -::grpc::Status MilvusService::Stub::Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Stub::Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Compact_, context, request, response); } -void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { +void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, std::move(f)); } @@ -735,7 +735,7 @@ void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* con ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, reactor); } @@ -743,11 +743,11 @@ void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* con ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Compact_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Compact_, context, request, false); } @@ -755,38 +755,38 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableSchema, ::milvus::grpc::Status>( - std::mem_fn(&MilvusService::Service::CreateTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::CreateCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>( - std::mem_fn(&MilvusService::Service::HasTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( + std::mem_fn(&MilvusService::Service::HasCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>( - std::mem_fn(&MilvusService::Service::DescribeTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>( + std::mem_fn(&MilvusService::Service::DescribeCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>( - std::mem_fn(&MilvusService::Service::CountTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( + std::mem_fn(&MilvusService::Service::CountCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::TableNameList>( - std::mem_fn(&MilvusService::Service::ShowTables), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>( + std::mem_fn(&MilvusService::Service::ShowCollections), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>( - std::mem_fn(&MilvusService::Service::ShowTableInfo), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( + std::mem_fn(&MilvusService::Service::ShowCollectionInfo), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( - std::mem_fn(&MilvusService::Service::DropTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::DropCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, @@ -795,12 +795,12 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>( std::mem_fn(&MilvusService::Service::DescribeIndex), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::DropIndex), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[10], @@ -810,7 +810,7 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>( std::mem_fn(&MilvusService::Service::ShowPartitions), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[12], @@ -860,8 +860,8 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( - std::mem_fn(&MilvusService::Service::PreloadTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::PreloadCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, @@ -870,56 +870,56 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Compact), this))); } MilvusService::Service::~Service() { } -::grpc::Status MilvusService::Service::CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::CreateCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) { +::grpc::Status MilvusService::Service::HasCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) { +::grpc::Status MilvusService::Service::DescribeCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) { +::grpc::Status MilvusService::Service::CountCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) { +::grpc::Status MilvusService::Service::ShowCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::ShowTableInfo(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response) { +::grpc::Status MilvusService::Service::ShowCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::DropCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; @@ -933,14 +933,14 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) { +::grpc::Status MilvusService::Service::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; @@ -954,7 +954,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response) { +::grpc::Status MilvusService::Service::ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response) { (void) context; (void) request; (void) response; @@ -1024,7 +1024,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; @@ -1038,7 +1038,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::Compact(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.h b/core/src/grpc/gen-milvus/milvus.grpc.pb.h index 511445f4df..c9f00d5e92 100644 --- a/core/src/grpc/gen-milvus/milvus.grpc.pb.h +++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.h @@ -48,98 +48,98 @@ class MilvusService final { public: virtual ~StubInterface() {} // * - // @brief This method is used to create table + // @brief This method is used to create collection // - // @param TableSchema, use to provide table information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status - virtual ::grpc::Status CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateTableRaw(context, request, cq)); + virtual ::grpc::Status CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateCollectionRaw(context, request, cq)); } // * - // @brief This method is used to test table existence. + // @brief This method is used to test collection existence. // - // @param TableName, table name is going to be tested. + // @param CollectionName, collection name is going to be tested. // // @return BoolReply - virtual ::grpc::Status HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasTableRaw(context, request, cq)); + virtual ::grpc::Status HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasCollectionRaw(context, request, cq)); } // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableSchema - virtual ::grpc::Status DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>> AsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>>(AsyncDescribeTableRaw(context, request, cq)); + // @return CollectionSchema + virtual ::grpc::Status DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionSchema* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>> AsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>>(AsyncDescribeCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>> PrepareAsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>>(PrepareAsyncDescribeTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>> PrepareAsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>>(PrepareAsyncDescribeCollectionRaw(context, request, cq)); } // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableRowCount - virtual ::grpc::Status CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>> AsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>>(AsyncCountTableRaw(context, request, cq)); + // @return CollectionRowCount + virtual ::grpc::Status CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> AsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(AsyncCountCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountCollectionRaw(context, request, cq)); } // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // - // @return TableNameList - virtual ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq)); + // @return CollectionNameList + virtual ::grpc::Status ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::CollectionNameList* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>> AsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>>(AsyncShowCollectionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>> PrepareAsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>>(PrepareAsyncShowCollectionsRaw(context, request, cq)); } // * - // @brief This method is used to get table detail information. + // @brief This method is used to get collection detail information. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableInfo - virtual ::grpc::Status ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableInfo* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>> AsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>>(AsyncShowTableInfoRaw(context, request, cq)); + // @return CollectionInfo + virtual ::grpc::Status ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> AsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(AsyncShowCollectionInfoRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>> PrepareAsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>>(PrepareAsyncShowTableInfoRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowCollectionInfoRaw(context, request, cq)); } // * - // @brief This method is used to delete table. + // @brief This method is used to delete collection. // - // @param TableName, table name is going to be deleted. + // @param CollectionName, collection name is going to be deleted. // - // @return TableNameList - virtual ::grpc::Status DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropTableRaw(context, request, cq)); + // @return CollectionNameList + virtual ::grpc::Status DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropCollectionRaw(context, request, cq)); } // * - // @brief This method is used to build index by table in sync mode. + // @brief This method is used to build index by collection in sync mode. // // @param IndexParam, index paramters. // @@ -154,27 +154,27 @@ class MilvusService final { // * // @brief This method is used to describe index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return IndexParam - virtual ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::IndexParam* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>>(AsyncDescribeIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>>(PrepareAsyncDescribeIndexRaw(context, request, cq)); } // * // @brief This method is used to drop index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropIndexRaw(context, request, cq)); } // * @@ -193,14 +193,14 @@ class MilvusService final { // * // @brief This method is used to show partition information // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return PartitionList - virtual ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::PartitionList* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::PartitionList* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>>(AsyncShowPartitionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>>(PrepareAsyncShowPartitionsRaw(context, request, cq)); } // * @@ -217,7 +217,7 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropPartitionRaw(context, request, cq)); } // * - // @brief This method is used to add vector array to table. + // @brief This method is used to add vector array to collection. // // @param InsertParam, insert parameters. // @@ -245,7 +245,7 @@ class MilvusService final { // * // @brief This method is used to get vector ids from a segment // - // @param GetVectorIDsParam, target table and segment + // @param GetVectorIDsParam, target collection and segment // // @return VectorIds virtual ::grpc::Status GetVectorIDs(::grpc::ClientContext* context, const ::milvus::grpc::GetVectorIDsParam& request, ::milvus::grpc::VectorIds* response) = 0; @@ -256,7 +256,7 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>>(PrepareAsyncGetVectorIDsRaw(context, request, cq)); } // * - // @brief This method is used to query vector in table. + // @brief This method is used to query vector in collection. // // @param SearchParam, search parameters. // @@ -321,17 +321,17 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDeleteByIDRaw(context, request, cq)); } // * - // @brief This method is used to preload table + // @brief This method is used to preload collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadTableRaw(context, request, cq)); + virtual ::grpc::Status PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } // * // @brief This method is used to flush buffer into storage. @@ -347,93 +347,93 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncFlushRaw(context, request, cq)); } // * - // @brief This method is used to compact table + // @brief This method is used to compact collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCompactRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } class experimental_async_interface { public: virtual ~experimental_async_interface() {} // * - // @brief This method is used to create table + // @brief This method is used to create collection // - // @param TableSchema, use to provide table information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status - virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to test table existence. + // @brief This method is used to test collection existence. // - // @param TableName, table name is going to be tested. + // @param CollectionName, collection name is going to be tested. // // @return BoolReply - virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function) = 0; - virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) = 0; - virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableSchema - virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function) = 0; - virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function) = 0; - virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionSchema + virtual void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, std::function) = 0; + virtual void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, std::function) = 0; + virtual void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableRowCount - virtual void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function) = 0; - virtual void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function) = 0; - virtual void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionRowCount + virtual void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // - // @return TableNameList - virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function) = 0; - virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function) = 0; - virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionNameList + virtual void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, std::function) = 0; + virtual void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, std::function) = 0; + virtual void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to get table detail information. + // @brief This method is used to get collection detail information. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableInfo - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, std::function) = 0; - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, std::function) = 0; - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionInfo + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to delete table. + // @brief This method is used to delete collection. // - // @param TableName, table name is going to be deleted. + // @param CollectionName, collection name is going to be deleted. // - // @return TableNameList - virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionNameList + virtual void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to build index by table in sync mode. + // @brief This method is used to build index by collection in sync mode. // // @param IndexParam, index paramters. // @@ -445,22 +445,22 @@ class MilvusService final { // * // @brief This method is used to describe index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return IndexParam - virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function) = 0; + virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, std::function) = 0; virtual void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function) = 0; - virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to drop index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; virtual void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to create partition @@ -475,12 +475,12 @@ class MilvusService final { // * // @brief This method is used to show partition information // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return PartitionList - virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, std::function) = 0; + virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, std::function) = 0; virtual void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, std::function) = 0; - virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to drop partition @@ -493,7 +493,7 @@ class MilvusService final { virtual void DropPartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DropPartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to add vector array to table. + // @brief This method is used to add vector array to collection. // // @param InsertParam, insert parameters. // @@ -515,7 +515,7 @@ class MilvusService final { // * // @brief This method is used to get vector ids from a segment // - // @param GetVectorIDsParam, target table and segment + // @param GetVectorIDsParam, target collection and segment // // @return VectorIds virtual void GetVectorIDs(::grpc::ClientContext* context, const ::milvus::grpc::GetVectorIDsParam* request, ::milvus::grpc::VectorIds* response, std::function) = 0; @@ -523,7 +523,7 @@ class MilvusService final { virtual void GetVectorIDs(::grpc::ClientContext* context, const ::milvus::grpc::GetVectorIDsParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void GetVectorIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to query vector in table. + // @brief This method is used to query vector in collection. // // @param SearchParam, search parameters. // @@ -573,15 +573,15 @@ class MilvusService final { virtual void DeleteByID(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DeleteByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to preload table + // @brief This method is used to preload collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to flush buffer into storage. // @@ -593,42 +593,42 @@ class MilvusService final { virtual void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to compact table + // @brief This method is used to compact collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; }; virtual class experimental_async_interface* experimental_async() { return nullptr; } private: - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>* AsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>* PrepareAsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>* AsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>* PrepareAsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* AsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>* AsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>* PrepareAsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* AsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) = 0; @@ -647,64 +647,64 @@ class MilvusService final { virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); - ::grpc::Status CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateTableRaw(context, request, cq)); + ::grpc::Status CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateCollectionRaw(context, request, cq)); } - ::grpc::Status HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasTableRaw(context, request, cq)); + ::grpc::Status HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasCollectionRaw(context, request, cq)); } - ::grpc::Status DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>> AsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>>(AsyncDescribeTableRaw(context, request, cq)); + ::grpc::Status DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionSchema* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>> AsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>>(AsyncDescribeCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>> PrepareAsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>>(PrepareAsyncDescribeTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>> PrepareAsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>>(PrepareAsyncDescribeCollectionRaw(context, request, cq)); } - ::grpc::Status CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> AsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(AsyncCountTableRaw(context, request, cq)); + ::grpc::Status CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> AsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(AsyncCountCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountCollectionRaw(context, request, cq)); } - ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq)); + ::grpc::Status ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::CollectionNameList* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>> AsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>>(AsyncShowCollectionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>> PrepareAsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>>(PrepareAsyncShowCollectionsRaw(context, request, cq)); } - ::grpc::Status ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableInfo* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>> AsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>>(AsyncShowTableInfoRaw(context, request, cq)); + ::grpc::Status ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> AsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(AsyncShowCollectionInfoRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>> PrepareAsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>>(PrepareAsyncShowTableInfoRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowCollectionInfoRaw(context, request, cq)); } - ::grpc::Status DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropTableRaw(context, request, cq)); + ::grpc::Status DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropCollectionRaw(context, request, cq)); } ::grpc::Status CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) { @@ -713,18 +713,18 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateIndexRaw(context, request, cq)); } - ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::IndexParam* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>>(AsyncDescribeIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>>(PrepareAsyncDescribeIndexRaw(context, request, cq)); } - ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropIndexRaw(context, request, cq)); } ::grpc::Status CreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::milvus::grpc::Status* response) override; @@ -734,11 +734,11 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreatePartitionRaw(context, request, cq)); } - ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::PartitionList* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::PartitionList* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>>(AsyncShowPartitionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>>(PrepareAsyncShowPartitionsRaw(context, request, cq)); } ::grpc::Status DropPartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::milvus::grpc::Status* response) override; @@ -804,12 +804,12 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDeleteByID(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDeleteByIDRaw(context, request, cq)); } - ::grpc::Status PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadTableRaw(context, request, cq)); + ::grpc::Status PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } ::grpc::Status Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncFlush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) { @@ -818,63 +818,63 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncFlush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncFlushRaw(context, request, cq)); } - ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCompactRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } class experimental_async final : public StubInterface::experimental_async_interface { public: - void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function) override; - void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function) override; - void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) override; - void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function) override; - void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function) override; - void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function) override; - void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function) override; - void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function) override; - void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function) override; - void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, std::function) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, std::function) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; - void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, std::function) override; + void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, std::function) override; + void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, std::function) override; + void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, std::function) override; + void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, std::function) override; + void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, std::function) override; void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function) override; + void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, std::function) override; void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function) override; - void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; + void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, std::function) override; void CreatePartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void CreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreatePartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, std::function) override; + void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, std::function) override; void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, std::function) override; - void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DropPartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, std::function) override; void DropPartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; @@ -912,17 +912,17 @@ class MilvusService final { void DeleteByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void DeleteByID(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DeleteByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; - void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; + void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; private: friend class Stub; @@ -935,30 +935,30 @@ class MilvusService final { private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class experimental_async async_stub_{this}; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* AsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* PrepareAsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* AsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* PrepareAsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* AsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* AsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* PrepareAsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* AsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) override; @@ -977,19 +977,19 @@ class MilvusService final { ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - const ::grpc::internal::RpcMethod rpcmethod_CreateTable_; - const ::grpc::internal::RpcMethod rpcmethod_HasTable_; - const ::grpc::internal::RpcMethod rpcmethod_DescribeTable_; - const ::grpc::internal::RpcMethod rpcmethod_CountTable_; - const ::grpc::internal::RpcMethod rpcmethod_ShowTables_; - const ::grpc::internal::RpcMethod rpcmethod_ShowTableInfo_; - const ::grpc::internal::RpcMethod rpcmethod_DropTable_; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_CreateCollection_; + const ::grpc::internal::RpcMethod rpcmethod_HasCollection_; + const ::grpc::internal::RpcMethod rpcmethod_DescribeCollection_; + const ::grpc::internal::RpcMethod rpcmethod_CountCollection_; + const ::grpc::internal::RpcMethod rpcmethod_ShowCollections_; + const ::grpc::internal::RpcMethod rpcmethod_ShowCollectionInfo_; + const ::grpc::internal::RpcMethod rpcmethod_DropCollection_; const ::grpc::internal::RpcMethod rpcmethod_CreateIndex_; const ::grpc::internal::RpcMethod rpcmethod_DescribeIndex_; const ::grpc::internal::RpcMethod rpcmethod_DropIndex_; @@ -1004,7 +1004,7 @@ class MilvusService final { const ::grpc::internal::RpcMethod rpcmethod_SearchInFiles_; const ::grpc::internal::RpcMethod rpcmethod_Cmd_; const ::grpc::internal::RpcMethod rpcmethod_DeleteByID_; - const ::grpc::internal::RpcMethod rpcmethod_PreloadTable_; + const ::grpc::internal::RpcMethod rpcmethod_PreloadCollection_; const ::grpc::internal::RpcMethod rpcmethod_Flush_; const ::grpc::internal::RpcMethod rpcmethod_Compact_; }; @@ -1015,56 +1015,56 @@ class MilvusService final { Service(); virtual ~Service(); // * - // @brief This method is used to create table + // @brief This method is used to create collection // - // @param TableSchema, use to provide table information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status - virtual ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status CreateCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to test table existence. + // @brief This method is used to test collection existence. // - // @param TableName, table name is going to be tested. + // @param CollectionName, collection name is going to be tested. // // @return BoolReply - virtual ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response); + virtual ::grpc::Status HasCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response); // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableSchema - virtual ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response); + // @return CollectionSchema + virtual ::grpc::Status DescribeCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response); // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableRowCount - virtual ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response); + // @return CollectionRowCount + virtual ::grpc::Status CountCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response); // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // - // @return TableNameList - virtual ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response); + // @return CollectionNameList + virtual ::grpc::Status ShowCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response); // * - // @brief This method is used to get table detail information. + // @brief This method is used to get collection detail information. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableInfo - virtual ::grpc::Status ShowTableInfo(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response); + // @return CollectionInfo + virtual ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response); // * - // @brief This method is used to delete table. + // @brief This method is used to delete collection. // - // @param TableName, table name is going to be deleted. + // @param CollectionName, collection name is going to be deleted. // - // @return TableNameList - virtual ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + // @return CollectionNameList + virtual ::grpc::Status DropCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to build index by table in sync mode. + // @brief This method is used to build index by collection in sync mode. // // @param IndexParam, index paramters. // @@ -1073,17 +1073,17 @@ class MilvusService final { // * // @brief This method is used to describe index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return IndexParam - virtual ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response); + virtual ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response); // * // @brief This method is used to drop index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * // @brief This method is used to create partition // @@ -1094,10 +1094,10 @@ class MilvusService final { // * // @brief This method is used to show partition information // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return PartitionList - virtual ::grpc::Status ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response); + virtual ::grpc::Status ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response); // * // @brief This method is used to drop partition // @@ -1106,7 +1106,7 @@ class MilvusService final { // @return Status virtual ::grpc::Status DropPartition(::grpc::ServerContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to add vector array to table. + // @brief This method is used to add vector array to collection. // // @param InsertParam, insert parameters. // @@ -1122,12 +1122,12 @@ class MilvusService final { // * // @brief This method is used to get vector ids from a segment // - // @param GetVectorIDsParam, target table and segment + // @param GetVectorIDsParam, target collection and segment // // @return VectorIds virtual ::grpc::Status GetVectorIDs(::grpc::ServerContext* context, const ::milvus::grpc::GetVectorIDsParam* request, ::milvus::grpc::VectorIds* response); // * - // @brief This method is used to query vector in table. + // @brief This method is used to query vector in collection. // // @param SearchParam, search parameters. // @@ -1162,12 +1162,12 @@ class MilvusService final { // @return status virtual ::grpc::Status DeleteByID(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByIDParam* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to preload table + // @brief This method is used to preload collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * // @brief This method is used to flush buffer into storage. // @@ -1176,150 +1176,150 @@ class MilvusService final { // @return Status virtual ::grpc::Status Flush(::grpc::ServerContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to compact table + // @brief This method is used to compact collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); }; template - class WithAsyncMethod_CreateTable : public BaseClass { + class WithAsyncMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_CreateTable() { + WithAsyncMethod_CreateCollection() { ::grpc::Service::MarkMethodAsync(0); } - ~WithAsyncMethod_CreateTable() override { + ~WithAsyncMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCreateTable(::grpc::ServerContext* context, ::milvus::grpc::TableSchema* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCreateCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionSchema* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_HasTable : public BaseClass { + class WithAsyncMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_HasTable() { + WithAsyncMethod_HasCollection() { ::grpc::Service::MarkMethodAsync(1); } - ~WithAsyncMethod_HasTable() override { + ~WithAsyncMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestHasTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestHasCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_DescribeTable : public BaseClass { + class WithAsyncMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_DescribeTable() { + WithAsyncMethod_DescribeCollection() { ::grpc::Service::MarkMethodAsync(2); } - ~WithAsyncMethod_DescribeTable() override { + ~WithAsyncMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDescribeTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableSchema>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDescribeCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionSchema>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_CountTable : public BaseClass { + class WithAsyncMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_CountTable() { + WithAsyncMethod_CountCollection() { ::grpc::Service::MarkMethodAsync(3); } - ~WithAsyncMethod_CountTable() override { + ~WithAsyncMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCountTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCountCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_ShowTables : public BaseClass { + class WithAsyncMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_ShowTables() { + WithAsyncMethod_ShowCollections() { ::grpc::Service::MarkMethodAsync(4); } - ~WithAsyncMethod_ShowTables() override { + ~WithAsyncMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTables(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableNameList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollections(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionNameList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_ShowTableInfo : public BaseClass { + class WithAsyncMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_ShowTableInfo() { + WithAsyncMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodAsync(5); } - ~WithAsyncMethod_ShowTableInfo() override { + ~WithAsyncMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTableInfo(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollectionInfo(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_DropTable : public BaseClass { + class WithAsyncMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_DropTable() { + WithAsyncMethod_DropCollection() { ::grpc::Service::MarkMethodAsync(6); } - ~WithAsyncMethod_DropTable() override { + ~WithAsyncMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDropTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDropCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1355,11 +1355,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDescribeIndex(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::IndexParam>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDescribeIndex(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::IndexParam>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1375,11 +1375,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDropIndex(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDropIndex(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1415,11 +1415,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowPartitions(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::PartitionList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowPartitions(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::PartitionList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1604,22 +1604,22 @@ class MilvusService final { } }; template - class WithAsyncMethod_PreloadTable : public BaseClass { + class WithAsyncMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_PreloadTable() { + WithAsyncMethod_PreloadCollection() { ::grpc::Service::MarkMethodAsync(21); } - ~WithAsyncMethod_PreloadTable() override { + ~WithAsyncMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPreloadTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestPreloadCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(21, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1655,231 +1655,231 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCompact(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCompact(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > AsyncService; + typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > AsyncService; template - class ExperimentalWithCallbackMethod_CreateTable : public BaseClass { + class ExperimentalWithCallbackMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_CreateTable() { + ExperimentalWithCallbackMethod_CreateCollection() { ::grpc::Service::experimental().MarkMethodCallback(0, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableSchema* request, + const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->CreateTable(context, request, response, controller); + return this->CreateCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_CreateTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>*>( + void SetMessageAllocatorFor_CreateCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(0)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_CreateTable() override { + ~ExperimentalWithCallbackMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_HasTable : public BaseClass { + class ExperimentalWithCallbackMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_HasTable() { + ExperimentalWithCallbackMethod_HasCollection() { ::grpc::Service::experimental().MarkMethodCallback(1, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->HasTable(context, request, response, controller); + return this->HasCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_HasTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>*>( + void SetMessageAllocatorFor_HasCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>*>( ::grpc::Service::experimental().GetHandler(1)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_HasTable() override { + ~ExperimentalWithCallbackMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_DescribeTable : public BaseClass { + class ExperimentalWithCallbackMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_DescribeTable() { + ExperimentalWithCallbackMethod_DescribeCollection() { ::grpc::Service::experimental().MarkMethodCallback(2, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableSchema* response, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->DescribeTable(context, request, response, controller); + return this->DescribeCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_DescribeTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>*>( + void SetMessageAllocatorFor_DescribeCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>*>( ::grpc::Service::experimental().GetHandler(2)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_DescribeTable() override { + ~ExperimentalWithCallbackMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_CountTable : public BaseClass { + class ExperimentalWithCallbackMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_CountTable() { + ExperimentalWithCallbackMethod_CountCollection() { ::grpc::Service::experimental().MarkMethodCallback(3, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableRowCount* response, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->CountTable(context, request, response, controller); + return this->CountCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_CountTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>*>( + void SetMessageAllocatorFor_CountCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>*>( ::grpc::Service::experimental().GetHandler(3)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_CountTable() override { + ~ExperimentalWithCallbackMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_ShowTables : public BaseClass { + class ExperimentalWithCallbackMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_ShowTables() { + ExperimentalWithCallbackMethod_ShowCollections() { ::grpc::Service::experimental().MarkMethodCallback(4, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>( [this](::grpc::ServerContext* context, const ::milvus::grpc::Command* request, - ::milvus::grpc::TableNameList* response, + ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->ShowTables(context, request, response, controller); + return this->ShowCollections(context, request, response, controller); })); } - void SetMessageAllocatorFor_ShowTables( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>*>( + void SetMessageAllocatorFor_ShowCollections( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>*>( ::grpc::Service::experimental().GetHandler(4)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_ShowTables() override { + ~ExperimentalWithCallbackMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_ShowTableInfo : public BaseClass { + class ExperimentalWithCallbackMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_ShowTableInfo() { + ExperimentalWithCallbackMethod_ShowCollectionInfo() { ::grpc::Service::experimental().MarkMethodCallback(5, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableInfo* response, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->ShowTableInfo(context, request, response, controller); + return this->ShowCollectionInfo(context, request, response, controller); })); } - void SetMessageAllocatorFor_ShowTableInfo( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>*>( + void SetMessageAllocatorFor_ShowCollectionInfo( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>*>( ::grpc::Service::experimental().GetHandler(5)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_ShowTableInfo() override { + ~ExperimentalWithCallbackMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_DropTable : public BaseClass { + class ExperimentalWithCallbackMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_DropTable() { + ExperimentalWithCallbackMethod_DropCollection() { ::grpc::Service::experimental().MarkMethodCallback(6, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->DropTable(context, request, response, controller); + return this->DropCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_DropTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + void SetMessageAllocatorFor_DropCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(6)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_DropTable() override { + ~ExperimentalWithCallbackMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_CreateIndex : public BaseClass { @@ -1919,17 +1919,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_DescribeIndex() { ::grpc::Service::experimental().MarkMethodCallback(8, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->DescribeIndex(context, request, response, controller); })); } void SetMessageAllocatorFor_DescribeIndex( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>*>( ::grpc::Service::experimental().GetHandler(8)) ->SetMessageAllocator(allocator); } @@ -1937,11 +1937,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_DropIndex : public BaseClass { @@ -1950,17 +1950,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_DropIndex() { ::grpc::Service::experimental().MarkMethodCallback(9, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->DropIndex(context, request, response, controller); })); } void SetMessageAllocatorFor_DropIndex( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(9)) ->SetMessageAllocator(allocator); } @@ -1968,11 +1968,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_CreatePartition : public BaseClass { @@ -2012,17 +2012,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_ShowPartitions() { ::grpc::Service::experimental().MarkMethodCallback(11, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->ShowPartitions(context, request, response, controller); })); } void SetMessageAllocatorFor_ShowPartitions( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>*>( ::grpc::Service::experimental().GetHandler(11)) ->SetMessageAllocator(allocator); } @@ -2030,11 +2030,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_DropPartition : public BaseClass { @@ -2316,35 +2316,35 @@ class MilvusService final { virtual void DeleteByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::DeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_PreloadTable : public BaseClass { + class ExperimentalWithCallbackMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_PreloadTable() { + ExperimentalWithCallbackMethod_PreloadCollection() { ::grpc::Service::experimental().MarkMethodCallback(21, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->PreloadTable(context, request, response, controller); + return this->PreloadCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_PreloadTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + void SetMessageAllocatorFor_PreloadCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(21)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_PreloadTable() override { + ~ExperimentalWithCallbackMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_Flush : public BaseClass { @@ -2384,17 +2384,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_Compact() { ::grpc::Service::experimental().MarkMethodCallback(23, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->Compact(context, request, response, controller); })); } void SetMessageAllocatorFor_Compact( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(23)) ->SetMessageAllocator(allocator); } @@ -2402,128 +2402,128 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; - typedef ExperimentalWithCallbackMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; + typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; template - class WithGenericMethod_CreateTable : public BaseClass { + class WithGenericMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_CreateTable() { + WithGenericMethod_CreateCollection() { ::grpc::Service::MarkMethodGeneric(0); } - ~WithGenericMethod_CreateTable() override { + ~WithGenericMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_HasTable : public BaseClass { + class WithGenericMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_HasTable() { + WithGenericMethod_HasCollection() { ::grpc::Service::MarkMethodGeneric(1); } - ~WithGenericMethod_HasTable() override { + ~WithGenericMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_DescribeTable : public BaseClass { + class WithGenericMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_DescribeTable() { + WithGenericMethod_DescribeCollection() { ::grpc::Service::MarkMethodGeneric(2); } - ~WithGenericMethod_DescribeTable() override { + ~WithGenericMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_CountTable : public BaseClass { + class WithGenericMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_CountTable() { + WithGenericMethod_CountCollection() { ::grpc::Service::MarkMethodGeneric(3); } - ~WithGenericMethod_CountTable() override { + ~WithGenericMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_ShowTables : public BaseClass { + class WithGenericMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_ShowTables() { + WithGenericMethod_ShowCollections() { ::grpc::Service::MarkMethodGeneric(4); } - ~WithGenericMethod_ShowTables() override { + ~WithGenericMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_ShowTableInfo : public BaseClass { + class WithGenericMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_ShowTableInfo() { + WithGenericMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodGeneric(5); } - ~WithGenericMethod_ShowTableInfo() override { + ~WithGenericMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_DropTable : public BaseClass { + class WithGenericMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_DropTable() { + WithGenericMethod_DropCollection() { ::grpc::Service::MarkMethodGeneric(6); } - ~WithGenericMethod_DropTable() override { + ~WithGenericMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2557,7 +2557,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2574,7 +2574,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2608,7 +2608,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2767,18 +2767,18 @@ class MilvusService final { } }; template - class WithGenericMethod_PreloadTable : public BaseClass { + class WithGenericMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_PreloadTable() { + WithGenericMethod_PreloadCollection() { ::grpc::Service::MarkMethodGeneric(21); } - ~WithGenericMethod_PreloadTable() override { + ~WithGenericMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2812,148 +2812,148 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithRawMethod_CreateTable : public BaseClass { + class WithRawMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_CreateTable() { + WithRawMethod_CreateCollection() { ::grpc::Service::MarkMethodRaw(0); } - ~WithRawMethod_CreateTable() override { + ~WithRawMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCreateTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCreateCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_HasTable : public BaseClass { + class WithRawMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_HasTable() { + WithRawMethod_HasCollection() { ::grpc::Service::MarkMethodRaw(1); } - ~WithRawMethod_HasTable() override { + ~WithRawMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestHasTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestHasCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_DescribeTable : public BaseClass { + class WithRawMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_DescribeTable() { + WithRawMethod_DescribeCollection() { ::grpc::Service::MarkMethodRaw(2); } - ~WithRawMethod_DescribeTable() override { + ~WithRawMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDescribeTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDescribeCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_CountTable : public BaseClass { + class WithRawMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_CountTable() { + WithRawMethod_CountCollection() { ::grpc::Service::MarkMethodRaw(3); } - ~WithRawMethod_CountTable() override { + ~WithRawMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCountTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCountCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_ShowTables : public BaseClass { + class WithRawMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_ShowTables() { + WithRawMethod_ShowCollections() { ::grpc::Service::MarkMethodRaw(4); } - ~WithRawMethod_ShowTables() override { + ~WithRawMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTables(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollections(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_ShowTableInfo : public BaseClass { + class WithRawMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_ShowTableInfo() { + WithRawMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodRaw(5); } - ~WithRawMethod_ShowTableInfo() override { + ~WithRawMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTableInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollectionInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_DropTable : public BaseClass { + class WithRawMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_DropTable() { + WithRawMethod_DropCollection() { ::grpc::Service::MarkMethodRaw(6); } - ~WithRawMethod_DropTable() override { + ~WithRawMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDropTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDropCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -2989,7 +2989,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3009,7 +3009,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3049,7 +3049,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3238,22 +3238,22 @@ class MilvusService final { } }; template - class WithRawMethod_PreloadTable : public BaseClass { + class WithRawMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_PreloadTable() { + WithRawMethod_PreloadCollection() { ::grpc::Service::MarkMethodRaw(21); } - ~WithRawMethod_PreloadTable() override { + ~WithRawMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPreloadTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestPreloadCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(21, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -3289,7 +3289,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3298,179 +3298,179 @@ class MilvusService final { } }; template - class ExperimentalWithRawCallbackMethod_CreateTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_CreateTable() { + ExperimentalWithRawCallbackMethod_CreateCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(0, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->CreateTable(context, request, response, controller); + this->CreateCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_CreateTable() override { + ~ExperimentalWithRawCallbackMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CreateTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CreateCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_HasTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_HasTable() { + ExperimentalWithRawCallbackMethod_HasCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(1, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->HasTable(context, request, response, controller); + this->HasCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_HasTable() override { + ~ExperimentalWithRawCallbackMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void HasTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void HasCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_DescribeTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_DescribeTable() { + ExperimentalWithRawCallbackMethod_DescribeCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(2, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->DescribeTable(context, request, response, controller); + this->DescribeCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_DescribeTable() override { + ~ExperimentalWithRawCallbackMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DescribeTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DescribeCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_CountTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_CountTable() { + ExperimentalWithRawCallbackMethod_CountCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(3, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->CountTable(context, request, response, controller); + this->CountCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_CountTable() override { + ~ExperimentalWithRawCallbackMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CountTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CountCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_ShowTables : public BaseClass { + class ExperimentalWithRawCallbackMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_ShowTables() { + ExperimentalWithRawCallbackMethod_ShowCollections() { ::grpc::Service::experimental().MarkMethodRawCallback(4, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->ShowTables(context, request, response, controller); + this->ShowCollections(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_ShowTables() override { + ~ExperimentalWithRawCallbackMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTables(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollections(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_ShowTableInfo : public BaseClass { + class ExperimentalWithRawCallbackMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_ShowTableInfo() { + ExperimentalWithRawCallbackMethod_ShowCollectionInfo() { ::grpc::Service::experimental().MarkMethodRawCallback(5, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->ShowTableInfo(context, request, response, controller); + this->ShowCollectionInfo(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_ShowTableInfo() override { + ~ExperimentalWithRawCallbackMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTableInfo(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_DropTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_DropTable() { + ExperimentalWithRawCallbackMethod_DropCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(6, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->DropTable(context, request, response, controller); + this->DropCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_DropTable() override { + ~ExperimentalWithRawCallbackMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DropTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DropCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithRawCallbackMethod_CreateIndex : public BaseClass { @@ -3516,7 +3516,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3541,7 +3541,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3591,7 +3591,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3823,29 +3823,29 @@ class MilvusService final { virtual void DeleteByID(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_PreloadTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_PreloadTable() { + ExperimentalWithRawCallbackMethod_PreloadCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(21, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->PreloadTable(context, request, response, controller); + this->PreloadCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_PreloadTable() override { + ~ExperimentalWithRawCallbackMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void PreloadTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithRawCallbackMethod_Flush : public BaseClass { @@ -3891,151 +3891,151 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual void Compact(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class WithStreamedUnaryMethod_CreateTable : public BaseClass { + class WithStreamedUnaryMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_CreateTable() { + WithStreamedUnaryMethod_CreateCollection() { ::grpc::Service::MarkMethodStreamed(0, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateTable::StreamedCreateTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateCollection::StreamedCreateCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_CreateTable() override { + ~WithStreamedUnaryMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedCreateTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableSchema,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedCreateCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionSchema,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_HasTable : public BaseClass { + class WithStreamedUnaryMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_HasTable() { + WithStreamedUnaryMethod_HasCollection() { ::grpc::Service::MarkMethodStreamed(1, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasTable::StreamedHasTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasCollection::StreamedHasCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_HasTable() override { + ~WithStreamedUnaryMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedHasTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedHasCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_DescribeTable : public BaseClass { + class WithStreamedUnaryMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_DescribeTable() { + WithStreamedUnaryMethod_DescribeCollection() { ::grpc::Service::MarkMethodStreamed(2, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>(std::bind(&WithStreamedUnaryMethod_DescribeTable::StreamedDescribeTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>(std::bind(&WithStreamedUnaryMethod_DescribeCollection::StreamedDescribeCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_DescribeTable() override { + ~WithStreamedUnaryMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDescribeTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableSchema>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDescribeCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionSchema>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_CountTable : public BaseClass { + class WithStreamedUnaryMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_CountTable() { + WithStreamedUnaryMethod_CountCollection() { ::grpc::Service::MarkMethodStreamed(3, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>(std::bind(&WithStreamedUnaryMethod_CountTable::StreamedCountTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>(std::bind(&WithStreamedUnaryMethod_CountCollection::StreamedCountCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_CountTable() override { + ~WithStreamedUnaryMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedCountTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableRowCount>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedCountCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionRowCount>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_ShowTables : public BaseClass { + class WithStreamedUnaryMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_ShowTables() { + WithStreamedUnaryMethod_ShowCollections() { ::grpc::Service::MarkMethodStreamed(4, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(std::bind(&WithStreamedUnaryMethod_ShowTables::StreamedShowTables, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>(std::bind(&WithStreamedUnaryMethod_ShowCollections::StreamedShowCollections, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_ShowTables() override { + ~WithStreamedUnaryMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedShowTables(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::TableNameList>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedShowCollections(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::CollectionNameList>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_ShowTableInfo : public BaseClass { + class WithStreamedUnaryMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_ShowTableInfo() { + WithStreamedUnaryMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodStreamed(5, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>(std::bind(&WithStreamedUnaryMethod_ShowTableInfo::StreamedShowTableInfo, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>(std::bind(&WithStreamedUnaryMethod_ShowCollectionInfo::StreamedShowCollectionInfo, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_ShowTableInfo() override { + ~WithStreamedUnaryMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedShowTableInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableInfo>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedShowCollectionInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionInfo>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_DropTable : public BaseClass { + class WithStreamedUnaryMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_DropTable() { + WithStreamedUnaryMethod_DropCollection() { ::grpc::Service::MarkMethodStreamed(6, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropTable::StreamedDropTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropCollection::StreamedDropCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_DropTable() override { + ~WithStreamedUnaryMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDropTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDropCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CreateIndex : public BaseClass { @@ -4064,18 +4064,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_DescribeIndex() { ::grpc::Service::MarkMethodStreamed(8, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>(std::bind(&WithStreamedUnaryMethod_DescribeIndex::StreamedDescribeIndex, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>(std::bind(&WithStreamedUnaryMethod_DescribeIndex::StreamedDescribeIndex, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DescribeIndex() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDescribeIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::IndexParam>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDescribeIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::IndexParam>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_DropIndex : public BaseClass { @@ -4084,18 +4084,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_DropIndex() { ::grpc::Service::MarkMethodStreamed(9, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropIndex::StreamedDropIndex, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropIndex::StreamedDropIndex, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DropIndex() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDropIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDropIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CreatePartition : public BaseClass { @@ -4124,18 +4124,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_ShowPartitions() { ::grpc::Service::MarkMethodStreamed(11, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>(std::bind(&WithStreamedUnaryMethod_ShowPartitions::StreamedShowPartitions, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>(std::bind(&WithStreamedUnaryMethod_ShowPartitions::StreamedShowPartitions, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_ShowPartitions() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedShowPartitions(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::PartitionList>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedShowPartitions(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::PartitionList>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_DropPartition : public BaseClass { @@ -4318,24 +4318,24 @@ class MilvusService final { virtual ::grpc::Status StreamedDeleteByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::DeleteByIDParam,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_PreloadTable : public BaseClass { + class WithStreamedUnaryMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_PreloadTable() { + WithStreamedUnaryMethod_PreloadCollection() { ::grpc::Service::MarkMethodStreamed(21, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadTable::StreamedPreloadTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadCollection::StreamedPreloadCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_PreloadTable() override { + ~WithStreamedUnaryMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedPreloadTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedPreloadCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Flush : public BaseClass { @@ -4364,22 +4364,22 @@ class MilvusService final { public: WithStreamedUnaryMethod_Compact() { ::grpc::Service::MarkMethodStreamed(23, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Compact::StreamedCompact, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Compact::StreamedCompact, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Compact() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > StreamedService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace grpc diff --git a/core/src/grpc/gen-milvus/milvus.pb.cc b/core/src/grpc/gen-milvus/milvus.pb.cc index 3886e57da1..ed3d048ff6 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.cc +++ b/core/src/grpc/gen-milvus/milvus.pb.cc @@ -27,18 +27,18 @@ class KeyValuePairDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _KeyValuePair_default_instance_; -class TableNameDefaultTypeInternal { +class CollectionNameDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableName_default_instance_; -class TableNameListDefaultTypeInternal { + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionName_default_instance_; +class CollectionNameListDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableNameList_default_instance_; -class TableSchemaDefaultTypeInternal { + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionNameList_default_instance_; +class CollectionSchemaDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableSchema_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionSchema_default_instance_; class PartitionParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -83,10 +83,10 @@ class BoolReplyDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _BoolReply_default_instance_; -class TableRowCountDefaultTypeInternal { +class CollectionRowCountDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableRowCount_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionRowCount_default_instance_; class CommandDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -111,10 +111,10 @@ class PartitionStatDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _PartitionStat_default_instance_; -class TableInfoDefaultTypeInternal { +class CollectionInfoDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableInfo_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionInfo_default_instance_; class VectorIdentityDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -144,6 +144,82 @@ static void InitDefaultsscc_info_BoolReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BoolReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; +static void InitDefaultsscc_info_CollectionInfo_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionInfo_default_instance_; + new (ptr) ::milvus::grpc::CollectionInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_CollectionInfo_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_CollectionInfo_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_PartitionStat_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionName_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionName_default_instance_; + new (ptr) ::milvus::grpc::CollectionName(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionName::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CollectionName_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CollectionName_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_CollectionNameList_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionNameList_default_instance_; + new (ptr) ::milvus::grpc::CollectionNameList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionNameList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionNameList_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionNameList_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionRowCount_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionRowCount_default_instance_; + new (ptr) ::milvus::grpc::CollectionRowCount(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionRowCount::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionRowCount_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionRowCount_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionSchema_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionSchema_default_instance_; + new (ptr) ::milvus::grpc::CollectionSchema(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionSchema::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_CollectionSchema_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_CollectionSchema_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_Command_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -379,82 +455,6 @@ static void InitDefaultsscc_info_StringReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; -static void InitDefaultsscc_info_TableInfo_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableInfo_default_instance_; - new (ptr) ::milvus::grpc::TableInfo(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableInfo::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TableInfo_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TableInfo_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base, - &scc_info_PartitionStat_milvus_2eproto.base,}}; - -static void InitDefaultsscc_info_TableName_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableName_default_instance_; - new (ptr) ::milvus::grpc::TableName(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableName::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TableName_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TableName_milvus_2eproto}, {}}; - -static void InitDefaultsscc_info_TableNameList_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableNameList_default_instance_; - new (ptr) ::milvus::grpc::TableNameList(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableNameList::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableNameList_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableNameList_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base,}}; - -static void InitDefaultsscc_info_TableRowCount_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableRowCount_default_instance_; - new (ptr) ::milvus::grpc::TableRowCount(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableRowCount::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableRowCount_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableRowCount_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base,}}; - -static void InitDefaultsscc_info_TableSchema_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableSchema_default_instance_; - new (ptr) ::milvus::grpc::TableSchema(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableSchema::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TableSchema_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TableSchema_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base, - &scc_info_KeyValuePair_milvus_2eproto.base,}}; - static void InitDefaultsscc_info_TopKQueryResult_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -528,35 +528,35 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, key_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, value_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionName, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionName, collection_name_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, table_names_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, collection_names_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, table_name_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, dimension_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, index_file_size_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, metric_type_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, extra_params_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, dimension_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, index_file_size_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, metric_type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, extra_params_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, tag_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionList, _internal_metadata_), @@ -577,7 +577,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, row_record_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, row_id_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, partition_tag_), @@ -594,7 +594,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, partition_tag_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, query_record_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, topk_), @@ -611,7 +611,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, partition_tag_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, id_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, topk_), @@ -640,12 +640,12 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, status_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, bool_reply_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, table_row_count_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, collection_row_count_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::Command, _internal_metadata_), ~0u, // no _extensions_ @@ -658,7 +658,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, index_type_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, extra_params_), ~0u, // no _has_bits_ @@ -666,13 +666,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::FlushParam, table_name_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FlushParam, collection_name_array_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, id_array_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::SegmentStat, _internal_metadata_), @@ -692,19 +692,19 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionStat, total_row_count_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionStat, segments_stat_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, total_row_count_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, partitions_stat_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, total_row_count_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, partitions_stat_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, id_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorData, _internal_metadata_), @@ -718,14 +718,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, segment_name_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::milvus::grpc::KeyValuePair)}, - { 7, -1, sizeof(::milvus::grpc::TableName)}, - { 13, -1, sizeof(::milvus::grpc::TableNameList)}, - { 20, -1, sizeof(::milvus::grpc::TableSchema)}, + { 7, -1, sizeof(::milvus::grpc::CollectionName)}, + { 13, -1, sizeof(::milvus::grpc::CollectionNameList)}, + { 20, -1, sizeof(::milvus::grpc::CollectionSchema)}, { 31, -1, sizeof(::milvus::grpc::PartitionParam)}, { 38, -1, sizeof(::milvus::grpc::PartitionList)}, { 45, -1, sizeof(::milvus::grpc::RowRecord)}, @@ -737,14 +737,14 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 96, -1, sizeof(::milvus::grpc::TopKQueryResult)}, { 105, -1, sizeof(::milvus::grpc::StringReply)}, { 112, -1, sizeof(::milvus::grpc::BoolReply)}, - { 119, -1, sizeof(::milvus::grpc::TableRowCount)}, + { 119, -1, sizeof(::milvus::grpc::CollectionRowCount)}, { 126, -1, sizeof(::milvus::grpc::Command)}, { 132, -1, sizeof(::milvus::grpc::IndexParam)}, { 141, -1, sizeof(::milvus::grpc::FlushParam)}, { 147, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, { 154, -1, sizeof(::milvus::grpc::SegmentStat)}, { 163, -1, sizeof(::milvus::grpc::PartitionStat)}, - { 171, -1, sizeof(::milvus::grpc::TableInfo)}, + { 171, -1, sizeof(::milvus::grpc::CollectionInfo)}, { 179, -1, sizeof(::milvus::grpc::VectorIdentity)}, { 186, -1, sizeof(::milvus::grpc::VectorData)}, { 193, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, @@ -752,9 +752,9 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::milvus::grpc::_KeyValuePair_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableName_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableNameList_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableSchema_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionName_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionNameList_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionSchema_default_instance_), reinterpret_cast(&::milvus::grpc::_PartitionParam_default_instance_), reinterpret_cast(&::milvus::grpc::_PartitionList_default_instance_), reinterpret_cast(&::milvus::grpc::_RowRecord_default_instance_), @@ -766,14 +766,14 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::grpc::_TopKQueryResult_default_instance_), reinterpret_cast(&::milvus::grpc::_StringReply_default_instance_), reinterpret_cast(&::milvus::grpc::_BoolReply_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableRowCount_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionRowCount_default_instance_), reinterpret_cast(&::milvus::grpc::_Command_default_instance_), reinterpret_cast(&::milvus::grpc::_IndexParam_default_instance_), reinterpret_cast(&::milvus::grpc::_FlushParam_default_instance_), reinterpret_cast(&::milvus::grpc::_DeleteByIDParam_default_instance_), reinterpret_cast(&::milvus::grpc::_SegmentStat_default_instance_), reinterpret_cast(&::milvus::grpc::_PartitionStat_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableInfo_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionInfo_default_instance_), reinterpret_cast(&::milvus::grpc::_VectorIdentity_default_instance_), reinterpret_cast(&::milvus::grpc::_VectorData_default_instance_), reinterpret_cast(&::milvus::grpc::_GetVectorIDsParam_default_instance_), @@ -782,110 +782,120 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\014milvus.proto\022\013milvus.grpc\032\014status.prot" "o\"*\n\014KeyValuePair\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030" - "\002 \001(\t\"\037\n\tTableName\022\022\n\ntable_name\030\001 \001(\t\"I" - "\n\rTableNameList\022#\n\006status\030\001 \001(\0132\023.milvus" - ".grpc.Status\022\023\n\013table_names\030\002 \003(\t\"\270\001\n\013Ta" - "bleSchema\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\022\n\ntable_name\030\002 \001(\t\022\021\n\tdimension\030" - "\003 \001(\003\022\027\n\017index_file_size\030\004 \001(\003\022\023\n\013metric" - "_type\030\005 \001(\005\022/\n\014extra_params\030\006 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"1\n\016PartitionParam\022\022" - "\n\ntable_name\030\001 \001(\t\022\013\n\003tag\030\002 \001(\t\"Q\n\rParti" - "tionList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.S" - "tatus\022\033\n\023partition_tag_array\030\002 \003(\t\"4\n\tRo" - "wRecord\022\022\n\nfloat_data\030\001 \003(\002\022\023\n\013binary_da" - "ta\030\002 \001(\014\"\261\001\n\013InsertParam\022\022\n\ntable_name\030\001" + "\002 \001(\t\")\n\016CollectionName\022\027\n\017collection_na" + "me\030\001 \001(\t\"S\n\022CollectionNameList\022#\n\006status" + "\030\001 \001(\0132\023.milvus.grpc.Status\022\030\n\020collectio" + "n_names\030\002 \003(\t\"\302\001\n\020CollectionSchema\022#\n\006st" + "atus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017colle" + "ction_name\030\002 \001(\t\022\021\n\tdimension\030\003 \001(\003\022\027\n\017i" + "ndex_file_size\030\004 \001(\003\022\023\n\013metric_type\030\005 \001(" + "\005\022/\n\014extra_params\030\006 \003(\0132\031.milvus.grpc.Ke" + "yValuePair\"6\n\016PartitionParam\022\027\n\017collecti" + "on_name\030\001 \001(\t\022\013\n\003tag\030\002 \001(\t\"Q\n\rPartitionL" + "ist\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\033\n\023partition_tag_array\030\002 \003(\t\"4\n\tRowReco" + "rd\022\022\n\nfloat_data\030\001 \003(\002\022\023\n\013binary_data\030\002 " + "\001(\014\"\266\001\n\013InsertParam\022\027\n\017collection_name\030\001" " \001(\t\0220\n\020row_record_array\030\002 \003(\0132\026.milvus." "grpc.RowRecord\022\024\n\014row_id_array\030\003 \003(\003\022\025\n\r" "partition_tag\030\004 \001(\t\022/\n\014extra_params\030\005 \003(" "\0132\031.milvus.grpc.KeyValuePair\"I\n\tVectorId" "s\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027" - "\n\017vector_id_array\030\002 \003(\003\"\261\001\n\013SearchParam\022" - "\022\n\ntable_name\030\001 \001(\t\022\033\n\023partition_tag_arr" - "ay\030\002 \003(\t\0222\n\022query_record_array\030\003 \003(\0132\026.m" - "ilvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014ex" - "tra_params\030\005 \003(\0132\031.milvus.grpc.KeyValueP" - "air\"[\n\022SearchInFilesParam\022\025\n\rfile_id_arr" - "ay\030\001 \003(\t\022.\n\014search_param\030\002 \001(\0132\030.milvus." - "grpc.SearchParam\"\215\001\n\017SearchByIDParam\022\022\n\n" - "table_name\030\001 \001(\t\022\033\n\023partition_tag_array\030" - "\002 \003(\t\022\n\n\002id\030\003 \001(\003\022\014\n\004topk\030\004 \001(\003\022/\n\014extra" - "_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePair" - "\"g\n\017TopKQueryResult\022#\n\006status\030\001 \001(\0132\023.mi" - "lvus.grpc.Status\022\017\n\007row_num\030\002 \001(\003\022\013\n\003ids" - "\030\003 \003(\003\022\021\n\tdistances\030\004 \003(\002\"H\n\013StringReply" - "\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\024\n" - "\014string_reply\030\002 \001(\t\"D\n\tBoolReply\022#\n\006stat" - "us\030\001 \001(\0132\023.milvus.grpc.Status\022\022\n\nbool_re" - "ply\030\002 \001(\010\"M\n\rTableRowCount\022#\n\006status\030\001 \001" - "(\0132\023.milvus.grpc.Status\022\027\n\017table_row_cou" - "nt\030\002 \001(\003\"\026\n\007Command\022\013\n\003cmd\030\001 \001(\t\"\212\001\n\nInd" - "exParam\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St" - "atus\022\022\n\ntable_name\030\002 \001(\t\022\022\n\nindex_type\030\003" - " \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc" - ".KeyValuePair\"&\n\nFlushParam\022\030\n\020table_nam" - "e_array\030\001 \003(\t\"7\n\017DeleteByIDParam\022\022\n\ntabl" - "e_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"]\n\013Segmen" - "tStat\022\024\n\014segment_name\030\001 \001(\t\022\021\n\trow_count" - "\030\002 \001(\003\022\022\n\nindex_name\030\003 \001(\t\022\021\n\tdata_size\030" - "\004 \001(\003\"f\n\rPartitionStat\022\013\n\003tag\030\001 \001(\t\022\027\n\017t" - "otal_row_count\030\002 \001(\003\022/\n\rsegments_stat\030\003 " - "\003(\0132\030.milvus.grpc.SegmentStat\"~\n\tTableIn" - "fo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" - "\027\n\017total_row_count\030\002 \001(\003\0223\n\017partitions_s" - "tat\030\003 \003(\0132\032.milvus.grpc.PartitionStat\"0\n" - "\016VectorIdentity\022\022\n\ntable_name\030\001 \001(\t\022\n\n\002i" - "d\030\002 \001(\003\"^\n\nVectorData\022#\n\006status\030\001 \001(\0132\023." - "milvus.grpc.Status\022+\n\013vector_data\030\002 \001(\0132" - "\026.milvus.grpc.RowRecord\"=\n\021GetVectorIDsP" - "aram\022\022\n\ntable_name\030\001 \001(\t\022\024\n\014segment_name" - "\030\002 \001(\t2\313\014\n\rMilvusService\022>\n\013CreateTable\022" - "\030.milvus.grpc.TableSchema\032\023.milvus.grpc." - "Status\"\000\022<\n\010HasTable\022\026.milvus.grpc.Table" - "Name\032\026.milvus.grpc.BoolReply\"\000\022C\n\rDescri" - "beTable\022\026.milvus.grpc.TableName\032\030.milvus" - ".grpc.TableSchema\"\000\022B\n\nCountTable\022\026.milv" - "us.grpc.TableName\032\032.milvus.grpc.TableRow" - "Count\"\000\022@\n\nShowTables\022\024.milvus.grpc.Comm" - "and\032\032.milvus.grpc.TableNameList\"\000\022A\n\rSho" - "wTableInfo\022\026.milvus.grpc.TableName\032\026.mil" - "vus.grpc.TableInfo\"\000\022:\n\tDropTable\022\026.milv" - "us.grpc.TableName\032\023.milvus.grpc.Status\"\000" - "\022=\n\013CreateIndex\022\027.milvus.grpc.IndexParam" - "\032\023.milvus.grpc.Status\"\000\022B\n\rDescribeIndex" - "\022\026.milvus.grpc.TableName\032\027.milvus.grpc.I" - "ndexParam\"\000\022:\n\tDropIndex\022\026.milvus.grpc.T" - "ableName\032\023.milvus.grpc.Status\"\000\022E\n\017Creat" - "ePartition\022\033.milvus.grpc.PartitionParam\032" - "\023.milvus.grpc.Status\"\000\022F\n\016ShowPartitions" - "\022\026.milvus.grpc.TableName\032\032.milvus.grpc.P" - "artitionList\"\000\022C\n\rDropPartition\022\033.milvus" - ".grpc.PartitionParam\032\023.milvus.grpc.Statu" - "s\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertParam\032" - "\026.milvus.grpc.VectorIds\"\000\022G\n\rGetVectorBy" - "ID\022\033.milvus.grpc.VectorIdentity\032\027.milvus" - ".grpc.VectorData\"\000\022H\n\014GetVectorIDs\022\036.mil" - "vus.grpc.GetVectorIDsParam\032\026.milvus.grpc" - ".VectorIds\"\000\022B\n\006Search\022\030.milvus.grpc.Sea" - "rchParam\032\034.milvus.grpc.TopKQueryResult\"\000" - "\022J\n\nSearchByID\022\034.milvus.grpc.SearchByIDP" - "aram\032\034.milvus.grpc.TopKQueryResult\"\000\022P\n\r" - "SearchInFiles\022\037.milvus.grpc.SearchInFile" - "sParam\032\034.milvus.grpc.TopKQueryResult\"\000\0227" - "\n\003Cmd\022\024.milvus.grpc.Command\032\030.milvus.grp" - "c.StringReply\"\000\022A\n\nDeleteByID\022\034.milvus.g" - "rpc.DeleteByIDParam\032\023.milvus.grpc.Status" - "\"\000\022=\n\014PreloadTable\022\026.milvus.grpc.TableNa" - "me\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022\027.mil" - "vus.grpc.FlushParam\032\023.milvus.grpc.Status" - "\"\000\0228\n\007Compact\022\026.milvus.grpc.TableName\032\023." - "milvus.grpc.Status\"\000b\006proto3" + "\n\017vector_id_array\030\002 \003(\003\"\266\001\n\013SearchParam\022" + "\027\n\017collection_name\030\001 \001(\t\022\033\n\023partition_ta" + "g_array\030\002 \003(\t\0222\n\022query_record_array\030\003 \003(" + "\0132\026.milvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022" + "/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.KeyV" + "aluePair\"[\n\022SearchInFilesParam\022\025\n\rfile_i" + "d_array\030\001 \003(\t\022.\n\014search_param\030\002 \001(\0132\030.mi" + "lvus.grpc.SearchParam\"\222\001\n\017SearchByIDPara" + "m\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023partition_" + "tag_array\030\002 \003(\t\022\n\n\002id\030\003 \001(\003\022\014\n\004topk\030\004 \001(" + "\003\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.Ke" + "yValuePair\"g\n\017TopKQueryResult\022#\n\006status\030" + "\001 \001(\0132\023.milvus.grpc.Status\022\017\n\007row_num\030\002 " + "\001(\003\022\013\n\003ids\030\003 \003(\003\022\021\n\tdistances\030\004 \003(\002\"H\n\013S" + "tringReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" + ".Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tBoolRep" + "ly\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" + "\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionRowCoun" + "t\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\034" + "\n\024collection_row_count\030\002 \001(\003\"\026\n\007Command\022" + "\013\n\003cmd\030\001 \001(\t\"\217\001\n\nIndexParam\022#\n\006status\030\001 " + "\001(\0132\023.milvus.grpc.Status\022\027\n\017collection_n" + "ame\030\002 \001(\t\022\022\n\nindex_type\030\003 \001(\005\022/\n\014extra_p" + "arams\030\004 \003(\0132\031.milvus.grpc.KeyValuePair\"+" + "\n\nFlushParam\022\035\n\025collection_name_array\030\001 " + "\003(\t\"<\n\017DeleteByIDParam\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"]\n\013SegmentStat" + "\022\024\n\014segment_name\030\001 \001(\t\022\021\n\trow_count\030\002 \001(" + "\003\022\022\n\nindex_name\030\003 \001(\t\022\021\n\tdata_size\030\004 \001(\003" + "\"f\n\rPartitionStat\022\013\n\003tag\030\001 \001(\t\022\027\n\017total_" + "row_count\030\002 \001(\003\022/\n\rsegments_stat\030\003 \003(\0132\030" + ".milvus.grpc.SegmentStat\"\203\001\n\016CollectionI" + "nfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\027\n\017total_row_count\030\002 \001(\003\0223\n\017partitions_" + "stat\030\003 \003(\0132\032.milvus.grpc.PartitionStat\"5" + "\n\016VectorIdentity\022\027\n\017collection_name\030\001 \001(" + "\t\022\n\n\002id\030\002 \001(\003\"^\n\nVectorData\022#\n\006status\030\001 " + "\001(\0132\023.milvus.grpc.Status\022+\n\013vector_data\030" + "\002 \001(\0132\026.milvus.grpc.RowRecord\"B\n\021GetVect" + "orIDsParam\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014s" + "egment_name\030\002 \001(\t2\276\r\n\rMilvusService\022H\n\020C" + "reateCollection\022\035.milvus.grpc.Collection" + "Schema\032\023.milvus.grpc.Status\"\000\022F\n\rHasColl" + "ection\022\033.milvus.grpc.CollectionName\032\026.mi" + "lvus.grpc.BoolReply\"\000\022R\n\022DescribeCollect" + "ion\022\033.milvus.grpc.CollectionName\032\035.milvu" + "s.grpc.CollectionSchema\"\000\022Q\n\017CountCollec" + "tion\022\033.milvus.grpc.CollectionName\032\037.milv" + "us.grpc.CollectionRowCount\"\000\022J\n\017ShowColl" + "ections\022\024.milvus.grpc.Command\032\037.milvus.g" + "rpc.CollectionNameList\"\000\022P\n\022ShowCollecti" + "onInfo\022\033.milvus.grpc.CollectionName\032\033.mi" + "lvus.grpc.CollectionInfo\"\000\022D\n\016DropCollec" + "tion\022\033.milvus.grpc.CollectionName\032\023.milv" + "us.grpc.Status\"\000\022=\n\013CreateIndex\022\027.milvus" + ".grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022" + "G\n\rDescribeIndex\022\033.milvus.grpc.Collectio" + "nName\032\027.milvus.grpc.IndexParam\"\000\022\?\n\tDrop" + "Index\022\033.milvus.grpc.CollectionName\032\023.mil" + "vus.grpc.Status\"\000\022E\n\017CreatePartition\022\033.m" + "ilvus.grpc.PartitionParam\032\023.milvus.grpc." + "Status\"\000\022K\n\016ShowPartitions\022\033.milvus.grpc" + ".CollectionName\032\032.milvus.grpc.PartitionL" + "ist\"\000\022C\n\rDropPartition\022\033.milvus.grpc.Par" + "titionParam\032\023.milvus.grpc.Status\"\000\022<\n\006In" + "sert\022\030.milvus.grpc.InsertParam\032\026.milvus." + "grpc.VectorIds\"\000\022G\n\rGetVectorByID\022\033.milv" + "us.grpc.VectorIdentity\032\027.milvus.grpc.Vec" + "torData\"\000\022H\n\014GetVectorIDs\022\036.milvus.grpc." + "GetVectorIDsParam\032\026.milvus.grpc.VectorId" + "s\"\000\022B\n\006Search\022\030.milvus.grpc.SearchParam\032" + "\034.milvus.grpc.TopKQueryResult\"\000\022J\n\nSearc" + "hByID\022\034.milvus.grpc.SearchByIDParam\032\034.mi" + "lvus.grpc.TopKQueryResult\"\000\022P\n\rSearchInF" + "iles\022\037.milvus.grpc.SearchInFilesParam\032\034." + "milvus.grpc.TopKQueryResult\"\000\0227\n\003Cmd\022\024.m" + "ilvus.grpc.Command\032\030.milvus.grpc.StringR" + "eply\"\000\022A\n\nDeleteByID\022\034.milvus.grpc.Delet" + "eByIDParam\032\023.milvus.grpc.Status\"\000\022G\n\021Pre" + "loadCollection\022\033.milvus.grpc.CollectionN" + "ame\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022\027.mi" + "lvus.grpc.FlushParam\032\023.milvus.grpc.Statu" + "s\"\000\022=\n\007Compact\022\033.milvus.grpc.CollectionN" + "ame\032\023.milvus.grpc.Status\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = { &::descriptor_table_status_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[26] = { &scc_info_BoolReply_milvus_2eproto.base, + &scc_info_CollectionInfo_milvus_2eproto.base, + &scc_info_CollectionName_milvus_2eproto.base, + &scc_info_CollectionNameList_milvus_2eproto.base, + &scc_info_CollectionRowCount_milvus_2eproto.base, + &scc_info_CollectionSchema_milvus_2eproto.base, &scc_info_Command_milvus_2eproto.base, &scc_info_DeleteByIDParam_milvus_2eproto.base, &scc_info_FlushParam_milvus_2eproto.base, @@ -902,11 +912,6 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_SearchParam_milvus_2eproto.base, &scc_info_SegmentStat_milvus_2eproto.base, &scc_info_StringReply_milvus_2eproto.base, - &scc_info_TableInfo_milvus_2eproto.base, - &scc_info_TableName_milvus_2eproto.base, - &scc_info_TableNameList_milvus_2eproto.base, - &scc_info_TableRowCount_milvus_2eproto.base, - &scc_info_TableSchema_milvus_2eproto.base, &scc_info_TopKQueryResult_milvus_2eproto.base, &scc_info_VectorData_milvus_2eproto.base, &scc_info_VectorIdentity_milvus_2eproto.base, @@ -915,7 +920,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 3988, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 4194, &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 26, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, file_level_metadata_milvus_2eproto, 26, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, @@ -1260,73 +1265,73 @@ void KeyValuePair::InternalSwap(KeyValuePair* other) { // =================================================================== -void TableName::InitAsDefaultInstance() { +void CollectionName::InitAsDefaultInstance() { } -class TableName::_Internal { +class CollectionName::_Internal { public: }; -TableName::TableName() +CollectionName::CollectionName() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableName) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionName) } -TableName::TableName(const TableName& from) +CollectionName::CollectionName(const CollectionName& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableName) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionName) } -void TableName::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableName_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionName::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionName_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -TableName::~TableName() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableName) +CollectionName::~CollectionName() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionName) SharedDtor(); } -void TableName::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionName::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void TableName::SetCachedSize(int size) const { +void CollectionName::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableName& TableName::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableName_milvus_2eproto.base); +const CollectionName& CollectionName::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionName_milvus_2eproto.base); return *internal_default_instance(); } -void TableName::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableName) +void CollectionName::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableName.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.CollectionName.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -1350,25 +1355,25 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableName::MergePartialFromCodedStream( +bool CollectionName::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableName) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionName) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.TableName.table_name")); + "milvus.grpc.CollectionName.collection_name")); } else { goto handle_unusual; } @@ -1387,65 +1392,65 @@ bool TableName::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableName) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionName) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableName) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionName) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableName::SerializeWithCachedSizes( +void CollectionName::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableName.table_name"); + "milvus.grpc.CollectionName.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionName) } -::PROTOBUF_NAMESPACE_ID::uint8* TableName::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionName::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableName.table_name"); + "milvus.grpc.CollectionName.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionName) return target; } -size_t TableName::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableName) +size_t CollectionName::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionName) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -1457,11 +1462,11 @@ size_t TableName::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -1469,133 +1474,133 @@ size_t TableName::ByteSizeLong() const { return total_size; } -void TableName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableName) +void CollectionName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionName) GOOGLE_DCHECK_NE(&from, this); - const TableName* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionName* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableName) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableName) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionName) MergeFrom(*source); } } -void TableName::MergeFrom(const TableName& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableName) +void CollectionName::MergeFrom(const CollectionName& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionName) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } } -void TableName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableName) +void CollectionName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionName) if (&from == this) return; Clear(); MergeFrom(from); } -void TableName::CopyFrom(const TableName& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableName) +void CollectionName::CopyFrom(const CollectionName& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionName) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableName::IsInitialized() const { +bool CollectionName::IsInitialized() const { return true; } -void TableName::InternalSwap(TableName* other) { +void CollectionName::InternalSwap(CollectionName* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); } -::PROTOBUF_NAMESPACE_ID::Metadata TableName::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionName::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== -void TableNameList::InitAsDefaultInstance() { - ::milvus::grpc::_TableNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionNameList::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableNameList::_Internal { +class CollectionNameList::_Internal { public: - static const ::milvus::grpc::Status& status(const TableNameList* msg); + static const ::milvus::grpc::Status& status(const CollectionNameList* msg); }; const ::milvus::grpc::Status& -TableNameList::_Internal::status(const TableNameList* msg) { +CollectionNameList::_Internal::status(const CollectionNameList* msg) { return *msg->status_; } -void TableNameList::clear_status() { +void CollectionNameList::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableNameList::TableNameList() +CollectionNameList::CollectionNameList() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableNameList) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionNameList) } -TableNameList::TableNameList(const TableNameList& from) +CollectionNameList::CollectionNameList(const CollectionNameList& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - table_names_(from.table_names_) { + collection_names_(from.collection_names_) { _internal_metadata_.MergeFrom(from._internal_metadata_); if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); } else { status_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableNameList) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionNameList) } -void TableNameList::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableNameList_milvus_2eproto.base); +void CollectionNameList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionNameList_milvus_2eproto.base); status_ = nullptr; } -TableNameList::~TableNameList() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableNameList) +CollectionNameList::~CollectionNameList() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionNameList) SharedDtor(); } -void TableNameList::SharedDtor() { +void CollectionNameList::SharedDtor() { if (this != internal_default_instance()) delete status_; } -void TableNameList::SetCachedSize(int size) const { +void CollectionNameList::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableNameList& TableNameList::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableNameList_milvus_2eproto.base); +const CollectionNameList& CollectionNameList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionNameList_milvus_2eproto.base); return *internal_default_instance(); } -void TableNameList::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableNameList) +void CollectionNameList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_names_.Clear(); + collection_names_.Clear(); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } @@ -1604,7 +1609,7 @@ void TableNameList::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -1618,13 +1623,13 @@ const char* TableNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ CHK_(ptr); } else goto handle_unusual; continue; - // repeated string table_names = 2; + // repeated string collection_names = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; do { ptr += 1; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_table_names(), ptr, ctx, "milvus.grpc.TableNameList.table_names"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_names(), ptr, ctx, "milvus.grpc.CollectionNameList.collection_names"); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); @@ -1650,11 +1655,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableNameList::MergePartialFromCodedStream( +bool CollectionNameList::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableNameList) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionNameList) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -1671,16 +1676,16 @@ bool TableNameList::MergePartialFromCodedStream( break; } - // repeated string table_names = 2; + // repeated string collection_names = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->add_table_names())); + input, this->add_collection_names())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_names(this->table_names_size() - 1).data(), - static_cast(this->table_names(this->table_names_size() - 1).length()), + this->collection_names(this->collection_names_size() - 1).data(), + static_cast(this->collection_names(this->collection_names_size() - 1).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.TableNameList.table_names")); + "milvus.grpc.CollectionNameList.collection_names")); } else { goto handle_unusual; } @@ -1699,18 +1704,18 @@ bool TableNameList::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableNameList) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionNameList) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableNameList) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionNameList) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableNameList::SerializeWithCachedSizes( +void CollectionNameList::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1720,26 +1725,26 @@ void TableNameList::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // repeated string table_names = 2; - for (int i = 0, n = this->table_names_size(); i < n; i++) { + // repeated string collection_names = 2; + for (int i = 0, n = this->collection_names_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_names(i).data(), static_cast(this->table_names(i).length()), + this->collection_names(i).data(), static_cast(this->collection_names(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableNameList.table_names"); + "milvus.grpc.CollectionNameList.collection_names"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( - 2, this->table_names(i), output); + 2, this->collection_names(i), output); } if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionNameList) } -::PROTOBUF_NAMESPACE_ID::uint8* TableNameList::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionNameList::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1750,26 +1755,26 @@ void TableNameList::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // repeated string table_names = 2; - for (int i = 0, n = this->table_names_size(); i < n; i++) { + // repeated string collection_names = 2; + for (int i = 0, n = this->collection_names_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_names(i).data(), static_cast(this->table_names(i).length()), + this->collection_names(i).data(), static_cast(this->collection_names(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableNameList.table_names"); + "milvus.grpc.CollectionNameList.collection_names"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - WriteStringToArray(2, this->table_names(i), target); + WriteStringToArray(2, this->collection_names(i), target); } if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionNameList) return target; } -size_t TableNameList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableNameList) +size_t CollectionNameList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionNameList) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -1781,12 +1786,12 @@ size_t TableNameList::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated string table_names = 2; + // repeated string collection_names = 2; total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->table_names_size()); - for (int i = 0, n = this->table_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_names_size()); + for (int i = 0, n = this->collection_names_size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_names(i)); + this->collection_names(i)); } // .milvus.grpc.Status status = 1; @@ -1801,98 +1806,98 @@ size_t TableNameList::ByteSizeLong() const { return total_size; } -void TableNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableNameList) +void CollectionNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionNameList) GOOGLE_DCHECK_NE(&from, this); - const TableNameList* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionNameList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableNameList) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableNameList) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionNameList) MergeFrom(*source); } } -void TableNameList::MergeFrom(const TableNameList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableNameList) +void CollectionNameList::MergeFrom(const CollectionNameList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionNameList) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - table_names_.MergeFrom(from.table_names_); + collection_names_.MergeFrom(from.collection_names_); if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } } -void TableNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableNameList) +void CollectionNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionNameList) if (&from == this) return; Clear(); MergeFrom(from); } -void TableNameList::CopyFrom(const TableNameList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableNameList) +void CollectionNameList::CopyFrom(const CollectionNameList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionNameList) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableNameList::IsInitialized() const { +bool CollectionNameList::IsInitialized() const { return true; } -void TableNameList::InternalSwap(TableNameList* other) { +void CollectionNameList::InternalSwap(CollectionNameList* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_names_.InternalSwap(CastToBase(&other->table_names_)); + collection_names_.InternalSwap(CastToBase(&other->collection_names_)); swap(status_, other->status_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableNameList::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionNameList::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== -void TableSchema::InitAsDefaultInstance() { - ::milvus::grpc::_TableSchema_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionSchema::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionSchema_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableSchema::_Internal { +class CollectionSchema::_Internal { public: - static const ::milvus::grpc::Status& status(const TableSchema* msg); + static const ::milvus::grpc::Status& status(const CollectionSchema* msg); }; const ::milvus::grpc::Status& -TableSchema::_Internal::status(const TableSchema* msg) { +CollectionSchema::_Internal::status(const CollectionSchema* msg) { return *msg->status_; } -void TableSchema::clear_status() { +void CollectionSchema::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableSchema::TableSchema() +CollectionSchema::CollectionSchema() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableSchema) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionSchema) } -TableSchema::TableSchema(const TableSchema& from) +CollectionSchema::CollectionSchema(const CollectionSchema& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); @@ -1902,44 +1907,44 @@ TableSchema::TableSchema(const TableSchema& from) ::memcpy(&dimension_, &from.dimension_, static_cast(reinterpret_cast(&metric_type_) - reinterpret_cast(&dimension_)) + sizeof(metric_type_)); - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableSchema) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionSchema) } -void TableSchema::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableSchema_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionSchema::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionSchema_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&status_, 0, static_cast( reinterpret_cast(&metric_type_) - reinterpret_cast(&status_)) + sizeof(metric_type_)); } -TableSchema::~TableSchema() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableSchema) +CollectionSchema::~CollectionSchema() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionSchema) SharedDtor(); } -void TableSchema::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionSchema::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete status_; } -void TableSchema::SetCachedSize(int size) const { +void CollectionSchema::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableSchema& TableSchema::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableSchema_milvus_2eproto.base); +const CollectionSchema& CollectionSchema::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionSchema_milvus_2eproto.base); return *internal_default_instance(); } -void TableSchema::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableSchema) +void CollectionSchema::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } @@ -1951,7 +1956,7 @@ void TableSchema::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -1965,10 +1970,10 @@ const char* TableSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); } else goto handle_unusual; continue; - // string table_name = 2; + // string collection_name = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableSchema.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.CollectionSchema.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -2025,11 +2030,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableSchema::MergePartialFromCodedStream( +bool CollectionSchema::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableSchema) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionSchema) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -2046,15 +2051,15 @@ bool TableSchema::MergePartialFromCodedStream( break; } - // string table_name = 2; + // string collection_name = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.TableSchema.table_name")); + "milvus.grpc.CollectionSchema.collection_name")); } else { goto handle_unusual; } @@ -2123,18 +2128,18 @@ bool TableSchema::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableSchema) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionSchema) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableSchema) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionSchema) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableSchema::SerializeWithCachedSizes( +void CollectionSchema::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2144,14 +2149,14 @@ void TableSchema::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableSchema.table_name"); + "milvus.grpc.CollectionSchema.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->table_name(), output); + 2, this->collection_name(), output); } // int64 dimension = 3; @@ -2182,12 +2187,12 @@ void TableSchema::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionSchema) } -::PROTOBUF_NAMESPACE_ID::uint8* TableSchema::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionSchema::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2198,15 +2203,15 @@ void TableSchema::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableSchema.table_name"); + "milvus.grpc.CollectionSchema.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 2, this->table_name(), target); + 2, this->collection_name(), target); } // int64 dimension = 3; @@ -2236,12 +2241,12 @@ void TableSchema::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionSchema) return target; } -size_t TableSchema::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableSchema) +size_t CollectionSchema::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionSchema) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -2264,11 +2269,11 @@ size_t TableSchema::ByteSizeLong() const { } } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // .milvus.grpc.Status status = 1; @@ -2304,32 +2309,32 @@ size_t TableSchema::ByteSizeLong() const { return total_size; } -void TableSchema::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableSchema) +void CollectionSchema::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionSchema) GOOGLE_DCHECK_NE(&from, this); - const TableSchema* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionSchema* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableSchema) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableSchema) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionSchema) MergeFrom(*source); } } -void TableSchema::MergeFrom(const TableSchema& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableSchema) +void CollectionSchema::MergeFrom(const CollectionSchema& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionSchema) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); @@ -2345,29 +2350,29 @@ void TableSchema::MergeFrom(const TableSchema& from) { } } -void TableSchema::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableSchema) +void CollectionSchema::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionSchema) if (&from == this) return; Clear(); MergeFrom(from); } -void TableSchema::CopyFrom(const TableSchema& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableSchema) +void CollectionSchema::CopyFrom(const CollectionSchema& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionSchema) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableSchema::IsInitialized() const { +bool CollectionSchema::IsInitialized() const { return true; } -void TableSchema::InternalSwap(TableSchema* other) { +void CollectionSchema::InternalSwap(CollectionSchema* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(status_, other->status_); swap(dimension_, other->dimension_); @@ -2375,7 +2380,7 @@ void TableSchema::InternalSwap(TableSchema* other) { swap(metric_type_, other->metric_type_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableSchema::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionSchema::GetMetadata() const { return GetMetadataStatic(); } @@ -2397,9 +2402,9 @@ PartitionParam::PartitionParam(const PartitionParam& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from.tag().empty()) { @@ -2410,7 +2415,7 @@ PartitionParam::PartitionParam(const PartitionParam& from) void PartitionParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PartitionParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -2420,7 +2425,7 @@ PartitionParam::~PartitionParam() { } void PartitionParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -2439,7 +2444,7 @@ void PartitionParam::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -2452,10 +2457,10 @@ const char* PartitionParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.PartitionParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.PartitionParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -2496,15 +2501,15 @@ bool PartitionParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.PartitionParam.table_name")); + "milvus.grpc.PartitionParam.collection_name")); } else { goto handle_unusual; } @@ -2553,14 +2558,14 @@ void PartitionParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.PartitionParam.table_name"); + "milvus.grpc.PartitionParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // string tag = 2; @@ -2586,15 +2591,15 @@ void PartitionParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.PartitionParam.table_name"); + "milvus.grpc.PartitionParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // string tag = 2; @@ -2629,11 +2634,11 @@ size_t PartitionParam::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // string tag = 2; @@ -2670,9 +2675,9 @@ void PartitionParam::MergeFrom(const PartitionParam& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.tag().size() > 0) { @@ -2701,7 +2706,7 @@ bool PartitionParam::IsInitialized() const { void PartitionParam::InternalSwap(PartitionParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); tag_.Swap(&other->tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); @@ -3388,9 +3393,9 @@ InsertParam::InsertParam(const InsertParam& from) row_id_array_(from.row_id_array_), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from.partition_tag().empty()) { @@ -3401,7 +3406,7 @@ InsertParam::InsertParam(const InsertParam& from) void InsertParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_InsertParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -3411,7 +3416,7 @@ InsertParam::~InsertParam() { } void InsertParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -3433,7 +3438,7 @@ void InsertParam::Clear() { row_record_array_.Clear(); row_id_array_.Clear(); extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -3446,10 +3451,10 @@ const char* InsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.InsertParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.InsertParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -3524,15 +3529,15 @@ bool InsertParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.InsertParam.table_name")); + "milvus.grpc.InsertParam.collection_name")); } else { goto handle_unusual; } @@ -3619,14 +3624,14 @@ void InsertParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.InsertParam.table_name"); + "milvus.grpc.InsertParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -3681,15 +3686,15 @@ void InsertParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.InsertParam.table_name"); + "milvus.grpc.InsertParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -3790,11 +3795,11 @@ size_t InsertParam::ByteSizeLong() const { } } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // string partition_tag = 4; @@ -3834,9 +3839,9 @@ void InsertParam::MergeFrom(const InsertParam& from) { row_record_array_.MergeFrom(from.row_record_array_); row_id_array_.MergeFrom(from.row_id_array_); extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.partition_tag().size() > 0) { @@ -3868,7 +3873,7 @@ void InsertParam::InternalSwap(InsertParam* other) { CastToBase(&row_record_array_)->InternalSwap(CastToBase(&other->row_record_array_)); row_id_array_.InternalSwap(&other->row_id_array_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); @@ -4240,9 +4245,9 @@ SearchParam::SearchParam(const SearchParam& from) query_record_array_(from.query_record_array_), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } topk_ = from.topk_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchParam) @@ -4250,7 +4255,7 @@ SearchParam::SearchParam(const SearchParam& from) void SearchParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); topk_ = PROTOBUF_LONGLONG(0); } @@ -4260,7 +4265,7 @@ SearchParam::~SearchParam() { } void SearchParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SearchParam::SetCachedSize(int size) const { @@ -4281,7 +4286,7 @@ void SearchParam::Clear() { partition_tag_array_.Clear(); query_record_array_.Clear(); extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); topk_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -4294,10 +4299,10 @@ const char* SearchParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.SearchParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -4374,15 +4379,15 @@ bool SearchParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.SearchParam.table_name")); + "milvus.grpc.SearchParam.collection_name")); } else { goto handle_unusual; } @@ -4467,14 +4472,14 @@ void SearchParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchParam.table_name"); + "milvus.grpc.SearchParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated string partition_tag_array = 2; @@ -4523,15 +4528,15 @@ void SearchParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchParam.table_name"); + "milvus.grpc.SearchParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated string partition_tag_array = 2; @@ -4616,11 +4621,11 @@ size_t SearchParam::ByteSizeLong() const { } } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // int64 topk = 4; @@ -4660,9 +4665,9 @@ void SearchParam::MergeFrom(const SearchParam& from) { partition_tag_array_.MergeFrom(from.partition_tag_array_); query_record_array_.MergeFrom(from.query_record_array_); extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.topk() != 0) { set_topk(from.topk()); @@ -4693,7 +4698,7 @@ void SearchParam::InternalSwap(SearchParam* other) { partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); CastToBase(&query_record_array_)->InternalSwap(CastToBase(&other->query_record_array_)); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(topk_, other->topk_); } @@ -5048,9 +5053,9 @@ SearchByIDParam::SearchByIDParam(const SearchByIDParam& from) partition_tag_array_(from.partition_tag_array_), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } ::memcpy(&id_, &from.id_, static_cast(reinterpret_cast(&topk_) - @@ -5060,7 +5065,7 @@ SearchByIDParam::SearchByIDParam(const SearchByIDParam& from) void SearchByIDParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchByIDParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&id_, 0, static_cast( reinterpret_cast(&topk_) - reinterpret_cast(&id_)) + sizeof(topk_)); @@ -5072,7 +5077,7 @@ SearchByIDParam::~SearchByIDParam() { } void SearchByIDParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SearchByIDParam::SetCachedSize(int size) const { @@ -5092,7 +5097,7 @@ void SearchByIDParam::Clear() { partition_tag_array_.Clear(); extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&id_, 0, static_cast( reinterpret_cast(&topk_) - reinterpret_cast(&id_)) + sizeof(topk_)); @@ -5107,10 +5112,10 @@ const char* SearchByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.SearchByIDParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchByIDParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -5182,15 +5187,15 @@ bool SearchByIDParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.SearchByIDParam.table_name")); + "milvus.grpc.SearchByIDParam.collection_name")); } else { goto handle_unusual; } @@ -5277,14 +5282,14 @@ void SearchByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchByIDParam.table_name"); + "milvus.grpc.SearchByIDParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated string partition_tag_array = 2; @@ -5329,15 +5334,15 @@ void SearchByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchByIDParam.table_name"); + "milvus.grpc.SearchByIDParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated string partition_tag_array = 2; @@ -5408,11 +5413,11 @@ size_t SearchByIDParam::ByteSizeLong() const { } } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // int64 id = 3; @@ -5458,9 +5463,9 @@ void SearchByIDParam::MergeFrom(const SearchByIDParam& from) { partition_tag_array_.MergeFrom(from.partition_tag_array_); extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.id() != 0) { set_id(from.id()); @@ -5493,7 +5498,7 @@ void SearchByIDParam::InternalSwap(SearchByIDParam* other) { _internal_metadata_.Swap(&other->_internal_metadata_); partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(id_, other->id_); swap(topk_, other->topk_); @@ -6609,31 +6614,31 @@ void BoolReply::InternalSwap(BoolReply* other) { // =================================================================== -void TableRowCount::InitAsDefaultInstance() { - ::milvus::grpc::_TableRowCount_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionRowCount::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionRowCount_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableRowCount::_Internal { +class CollectionRowCount::_Internal { public: - static const ::milvus::grpc::Status& status(const TableRowCount* msg); + static const ::milvus::grpc::Status& status(const CollectionRowCount* msg); }; const ::milvus::grpc::Status& -TableRowCount::_Internal::status(const TableRowCount* msg) { +CollectionRowCount::_Internal::status(const CollectionRowCount* msg) { return *msg->status_; } -void TableRowCount::clear_status() { +void CollectionRowCount::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableRowCount::TableRowCount() +CollectionRowCount::CollectionRowCount() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionRowCount) } -TableRowCount::TableRowCount(const TableRowCount& from) +CollectionRowCount::CollectionRowCount(const CollectionRowCount& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -6642,37 +6647,37 @@ TableRowCount::TableRowCount(const TableRowCount& from) } else { status_ = nullptr; } - table_row_count_ = from.table_row_count_; - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableRowCount) + collection_row_count_ = from.collection_row_count_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionRowCount) } -void TableRowCount::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableRowCount_milvus_2eproto.base); +void CollectionRowCount::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionRowCount_milvus_2eproto.base); ::memset(&status_, 0, static_cast( - reinterpret_cast(&table_row_count_) - - reinterpret_cast(&status_)) + sizeof(table_row_count_)); + reinterpret_cast(&collection_row_count_) - + reinterpret_cast(&status_)) + sizeof(collection_row_count_)); } -TableRowCount::~TableRowCount() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableRowCount) +CollectionRowCount::~CollectionRowCount() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionRowCount) SharedDtor(); } -void TableRowCount::SharedDtor() { +void CollectionRowCount::SharedDtor() { if (this != internal_default_instance()) delete status_; } -void TableRowCount::SetCachedSize(int size) const { +void CollectionRowCount::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableRowCount& TableRowCount::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableRowCount_milvus_2eproto.base); +const CollectionRowCount& CollectionRowCount::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionRowCount_milvus_2eproto.base); return *internal_default_instance(); } -void TableRowCount::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableRowCount) +void CollectionRowCount::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6681,12 +6686,12 @@ void TableRowCount::Clear() { delete status_; } status_ = nullptr; - table_row_count_ = PROTOBUF_LONGLONG(0); + collection_row_count_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -6700,10 +6705,10 @@ const char* TableRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ CHK_(ptr); } else goto handle_unusual; continue; - // int64 table_row_count = 2; + // int64 collection_row_count = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - table_row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + collection_row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6727,11 +6732,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableRowCount::MergePartialFromCodedStream( +bool CollectionRowCount::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionRowCount) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -6748,13 +6753,13 @@ bool TableRowCount::MergePartialFromCodedStream( break; } - // int64 table_row_count = 2; + // int64 collection_row_count = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( - input, &table_row_count_))); + input, &collection_row_count_))); } else { goto handle_unusual; } @@ -6773,18 +6778,18 @@ bool TableRowCount::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionRowCount) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionRowCount) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableRowCount::SerializeWithCachedSizes( +void CollectionRowCount::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -6794,21 +6799,21 @@ void TableRowCount::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // int64 table_row_count = 2; - if (this->table_row_count() != 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->table_row_count(), output); + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->collection_row_count(), output); } if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionRowCount) } -::PROTOBUF_NAMESPACE_ID::uint8* TableRowCount::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionRowCount::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -6819,21 +6824,21 @@ void TableRowCount::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // int64 table_row_count = 2; - if (this->table_row_count() != 0) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->table_row_count(), target); + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->collection_row_count(), target); } if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionRowCount) return target; } -size_t TableRowCount::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableRowCount) +size_t CollectionRowCount::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionRowCount) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -6852,11 +6857,11 @@ size_t TableRowCount::ByteSizeLong() const { *status_); } - // int64 table_row_count = 2; - if (this->table_row_count() != 0) { + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->table_row_count()); + this->collection_row_count()); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -6864,23 +6869,23 @@ size_t TableRowCount::ByteSizeLong() const { return total_size; } -void TableRowCount::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionRowCount) GOOGLE_DCHECK_NE(&from, this); - const TableRowCount* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionRowCount* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionRowCount) MergeFrom(*source); } } -void TableRowCount::MergeFrom(const TableRowCount& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::MergeFrom(const CollectionRowCount& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionRowCount) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6889,37 +6894,37 @@ void TableRowCount::MergeFrom(const TableRowCount& from) { if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } - if (from.table_row_count() != 0) { - set_table_row_count(from.table_row_count()); + if (from.collection_row_count() != 0) { + set_collection_row_count(from.collection_row_count()); } } -void TableRowCount::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionRowCount) if (&from == this) return; Clear(); MergeFrom(from); } -void TableRowCount::CopyFrom(const TableRowCount& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::CopyFrom(const CollectionRowCount& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionRowCount) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableRowCount::IsInitialized() const { +bool CollectionRowCount::IsInitialized() const { return true; } -void TableRowCount::InternalSwap(TableRowCount* other) { +void CollectionRowCount::InternalSwap(CollectionRowCount* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); swap(status_, other->status_); - swap(table_row_count_, other->table_row_count_); + swap(collection_row_count_, other->collection_row_count_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableRowCount::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionRowCount::GetMetadata() const { return GetMetadataStatic(); } @@ -7224,9 +7229,9 @@ IndexParam::IndexParam(const IndexParam& from) _internal_metadata_(nullptr), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); @@ -7239,7 +7244,7 @@ IndexParam::IndexParam(const IndexParam& from) void IndexParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_IndexParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&status_, 0, static_cast( reinterpret_cast(&index_type_) - reinterpret_cast(&status_)) + sizeof(index_type_)); @@ -7251,7 +7256,7 @@ IndexParam::~IndexParam() { } void IndexParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete status_; } @@ -7271,7 +7276,7 @@ void IndexParam::Clear() { (void) cached_has_bits; extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } @@ -7295,10 +7300,10 @@ const char* IndexParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: CHK_(ptr); } else goto handle_unusual; continue; - // string table_name = 2; + // string collection_name = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.IndexParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.IndexParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -7362,15 +7367,15 @@ bool IndexParam::MergePartialFromCodedStream( break; } - // string table_name = 2; + // string collection_name = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.IndexParam.table_name")); + "milvus.grpc.IndexParam.collection_name")); } else { goto handle_unusual; } @@ -7434,14 +7439,14 @@ void IndexParam::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.IndexParam.table_name"); + "milvus.grpc.IndexParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->table_name(), output); + 2, this->collection_name(), output); } // int32 index_type = 3; @@ -7478,15 +7483,15 @@ void IndexParam::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.IndexParam.table_name"); + "milvus.grpc.IndexParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 2, this->table_name(), target); + 2, this->collection_name(), target); } // int32 index_type = 3; @@ -7534,11 +7539,11 @@ size_t IndexParam::ByteSizeLong() const { } } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // .milvus.grpc.Status status = 1; @@ -7583,9 +7588,9 @@ void IndexParam::MergeFrom(const IndexParam& from) { (void) cached_has_bits; extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); @@ -7617,7 +7622,7 @@ void IndexParam::InternalSwap(IndexParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(status_, other->status_); swap(index_type_, other->index_type_); @@ -7644,7 +7649,7 @@ FlushParam::FlushParam() FlushParam::FlushParam(const FlushParam& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - table_name_array_(from.table_name_array_) { + collection_name_array_(from.collection_name_array_) { _internal_metadata_.MergeFrom(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:milvus.grpc.FlushParam) } @@ -7676,7 +7681,7 @@ void FlushParam::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_array_.Clear(); + collection_name_array_.Clear(); _internal_metadata_.Clear(); } @@ -7688,13 +7693,13 @@ const char* FlushParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // repeated string table_name_array = 1; + // repeated string collection_name_array = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; do { ptr += 1; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_table_name_array(), ptr, ctx, "milvus.grpc.FlushParam.table_name_array"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_name_array(), ptr, ctx, "milvus.grpc.FlushParam.collection_name_array"); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); @@ -7730,16 +7735,16 @@ bool FlushParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // repeated string table_name_array = 1; + // repeated string collection_name_array = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->add_table_name_array())); + input, this->add_collection_name_array())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name_array(this->table_name_array_size() - 1).data(), - static_cast(this->table_name_array(this->table_name_array_size() - 1).length()), + this->collection_name_array(this->collection_name_array_size() - 1).data(), + static_cast(this->collection_name_array(this->collection_name_array_size() - 1).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.FlushParam.table_name_array")); + "milvus.grpc.FlushParam.collection_name_array")); } else { goto handle_unusual; } @@ -7773,14 +7778,14 @@ void FlushParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated string table_name_array = 1; - for (int i = 0, n = this->table_name_array_size(); i < n; i++) { + // repeated string collection_name_array = 1; + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name_array(i).data(), static_cast(this->table_name_array(i).length()), + this->collection_name_array(i).data(), static_cast(this->collection_name_array(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.FlushParam.table_name_array"); + "milvus.grpc.FlushParam.collection_name_array"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( - 1, this->table_name_array(i), output); + 1, this->collection_name_array(i), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -7796,14 +7801,14 @@ void FlushParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated string table_name_array = 1; - for (int i = 0, n = this->table_name_array_size(); i < n; i++) { + // repeated string collection_name_array = 1; + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name_array(i).data(), static_cast(this->table_name_array(i).length()), + this->collection_name_array(i).data(), static_cast(this->collection_name_array(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.FlushParam.table_name_array"); + "milvus.grpc.FlushParam.collection_name_array"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - WriteStringToArray(1, this->table_name_array(i), target); + WriteStringToArray(1, this->collection_name_array(i), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -7827,12 +7832,12 @@ size_t FlushParam::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated string table_name_array = 1; + // repeated string collection_name_array = 1; total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->table_name_array_size()); - for (int i = 0, n = this->table_name_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_name_array_size()); + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name_array(i)); + this->collection_name_array(i)); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -7862,7 +7867,7 @@ void FlushParam::MergeFrom(const FlushParam& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - table_name_array_.MergeFrom(from.table_name_array_); + collection_name_array_.MergeFrom(from.collection_name_array_); } void FlushParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -7886,7 +7891,7 @@ bool FlushParam::IsInitialized() const { void FlushParam::InternalSwap(FlushParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_array_.InternalSwap(CastToBase(&other->table_name_array_)); + collection_name_array_.InternalSwap(CastToBase(&other->collection_name_array_)); } ::PROTOBUF_NAMESPACE_ID::Metadata FlushParam::GetMetadata() const { @@ -7912,16 +7917,16 @@ DeleteByIDParam::DeleteByIDParam(const DeleteByIDParam& from) _internal_metadata_(nullptr), id_array_(from.id_array_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } // @@protoc_insertion_point(copy_constructor:milvus.grpc.DeleteByIDParam) } void DeleteByIDParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DeleteByIDParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } DeleteByIDParam::~DeleteByIDParam() { @@ -7930,7 +7935,7 @@ DeleteByIDParam::~DeleteByIDParam() { } void DeleteByIDParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void DeleteByIDParam::SetCachedSize(int size) const { @@ -7949,7 +7954,7 @@ void DeleteByIDParam::Clear() { (void) cached_has_bits; id_array_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -7961,10 +7966,10 @@ const char* DeleteByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.DeleteByIDParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.DeleteByIDParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -8008,15 +8013,15 @@ bool DeleteByIDParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.DeleteByIDParam.table_name")); + "milvus.grpc.DeleteByIDParam.collection_name")); } else { goto handle_unusual; } @@ -8066,14 +8071,14 @@ void DeleteByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.DeleteByIDParam.table_name"); + "milvus.grpc.DeleteByIDParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated int64 id_array = 2; @@ -8100,15 +8105,15 @@ void DeleteByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.DeleteByIDParam.table_name"); + "milvus.grpc.DeleteByIDParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated int64 id_array = 2; @@ -8160,11 +8165,11 @@ size_t DeleteByIDParam::ByteSizeLong() const { total_size += data_size; } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -8195,9 +8200,9 @@ void DeleteByIDParam::MergeFrom(const DeleteByIDParam& from) { (void) cached_has_bits; id_array_.MergeFrom(from.id_array_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } } @@ -8223,7 +8228,7 @@ void DeleteByIDParam::InternalSwap(DeleteByIDParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); id_array_.InternalSwap(&other->id_array_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); } @@ -9025,31 +9030,31 @@ void PartitionStat::InternalSwap(PartitionStat* other) { // =================================================================== -void TableInfo::InitAsDefaultInstance() { - ::milvus::grpc::_TableInfo_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionInfo::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionInfo_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableInfo::_Internal { +class CollectionInfo::_Internal { public: - static const ::milvus::grpc::Status& status(const TableInfo* msg); + static const ::milvus::grpc::Status& status(const CollectionInfo* msg); }; const ::milvus::grpc::Status& -TableInfo::_Internal::status(const TableInfo* msg) { +CollectionInfo::_Internal::status(const CollectionInfo* msg) { return *msg->status_; } -void TableInfo::clear_status() { +void CollectionInfo::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableInfo::TableInfo() +CollectionInfo::CollectionInfo() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableInfo) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionInfo) } -TableInfo::TableInfo(const TableInfo& from) +CollectionInfo::CollectionInfo(const CollectionInfo& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), partitions_stat_(from.partitions_stat_) { @@ -9060,36 +9065,36 @@ TableInfo::TableInfo(const TableInfo& from) status_ = nullptr; } total_row_count_ = from.total_row_count_; - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableInfo) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionInfo) } -void TableInfo::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableInfo_milvus_2eproto.base); +void CollectionInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionInfo_milvus_2eproto.base); ::memset(&status_, 0, static_cast( reinterpret_cast(&total_row_count_) - reinterpret_cast(&status_)) + sizeof(total_row_count_)); } -TableInfo::~TableInfo() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableInfo) +CollectionInfo::~CollectionInfo() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionInfo) SharedDtor(); } -void TableInfo::SharedDtor() { +void CollectionInfo::SharedDtor() { if (this != internal_default_instance()) delete status_; } -void TableInfo::SetCachedSize(int size) const { +void CollectionInfo::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableInfo& TableInfo::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableInfo_milvus_2eproto.base); +const CollectionInfo& CollectionInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionInfo_milvus_2eproto.base); return *internal_default_instance(); } -void TableInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableInfo) +void CollectionInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9104,7 +9109,7 @@ void TableInfo::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -9157,11 +9162,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableInfo::MergePartialFromCodedStream( +bool CollectionInfo::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableInfo) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionInfo) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -9214,18 +9219,18 @@ bool TableInfo::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableInfo) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionInfo) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableInfo) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionInfo) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableInfo::SerializeWithCachedSizes( +void CollectionInfo::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -9253,12 +9258,12 @@ void TableInfo::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionInfo) } -::PROTOBUF_NAMESPACE_ID::uint8* TableInfo::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionInfo::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -9286,12 +9291,12 @@ void TableInfo::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionInfo) return target; } -size_t TableInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableInfo) +size_t CollectionInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionInfo) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -9333,23 +9338,23 @@ size_t TableInfo::ByteSizeLong() const { return total_size; } -void TableInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableInfo) +void CollectionInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionInfo) GOOGLE_DCHECK_NE(&from, this); - const TableInfo* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionInfo* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableInfo) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableInfo) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionInfo) MergeFrom(*source); } } -void TableInfo::MergeFrom(const TableInfo& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableInfo) +void CollectionInfo::MergeFrom(const CollectionInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionInfo) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -9364,25 +9369,25 @@ void TableInfo::MergeFrom(const TableInfo& from) { } } -void TableInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableInfo) +void CollectionInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionInfo) if (&from == this) return; Clear(); MergeFrom(from); } -void TableInfo::CopyFrom(const TableInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableInfo) +void CollectionInfo::CopyFrom(const CollectionInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionInfo) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableInfo::IsInitialized() const { +bool CollectionInfo::IsInitialized() const { return true; } -void TableInfo::InternalSwap(TableInfo* other) { +void CollectionInfo::InternalSwap(CollectionInfo* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&partitions_stat_)->InternalSwap(CastToBase(&other->partitions_stat_)); @@ -9390,7 +9395,7 @@ void TableInfo::InternalSwap(TableInfo* other) { swap(total_row_count_, other->total_row_count_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableInfo::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionInfo::GetMetadata() const { return GetMetadataStatic(); } @@ -9412,9 +9417,9 @@ VectorIdentity::VectorIdentity(const VectorIdentity& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } id_ = from.id_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorIdentity) @@ -9422,7 +9427,7 @@ VectorIdentity::VectorIdentity(const VectorIdentity& from) void VectorIdentity::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorIdentity_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); id_ = PROTOBUF_LONGLONG(0); } @@ -9432,7 +9437,7 @@ VectorIdentity::~VectorIdentity() { } void VectorIdentity::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void VectorIdentity::SetCachedSize(int size) const { @@ -9450,7 +9455,7 @@ void VectorIdentity::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); id_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -9463,10 +9468,10 @@ const char* VectorIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.VectorIdentity.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.VectorIdentity.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -9507,15 +9512,15 @@ bool VectorIdentity::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.VectorIdentity.table_name")); + "milvus.grpc.VectorIdentity.collection_name")); } else { goto handle_unusual; } @@ -9562,14 +9567,14 @@ void VectorIdentity::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.VectorIdentity.table_name"); + "milvus.grpc.VectorIdentity.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // int64 id = 2; @@ -9590,15 +9595,15 @@ void VectorIdentity::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.VectorIdentity.table_name"); + "milvus.grpc.VectorIdentity.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // int64 id = 2; @@ -9627,11 +9632,11 @@ size_t VectorIdentity::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // int64 id = 2; @@ -9668,9 +9673,9 @@ void VectorIdentity::MergeFrom(const VectorIdentity& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.id() != 0) { set_id(from.id()); @@ -9698,7 +9703,7 @@ bool VectorIdentity::IsInitialized() const { void VectorIdentity::InternalSwap(VectorIdentity* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(id_, other->id_); } @@ -10058,9 +10063,9 @@ GetVectorIDsParam::GetVectorIDsParam(const GetVectorIDsParam& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from.segment_name().empty()) { @@ -10071,7 +10076,7 @@ GetVectorIDsParam::GetVectorIDsParam(const GetVectorIDsParam& from) void GetVectorIDsParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GetVectorIDsParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -10081,7 +10086,7 @@ GetVectorIDsParam::~GetVectorIDsParam() { } void GetVectorIDsParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); segment_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -10100,7 +10105,7 @@ void GetVectorIDsParam::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); segment_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -10113,10 +10118,10 @@ const char* GetVectorIDsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.GetVectorIDsParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.GetVectorIDsParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -10157,15 +10162,15 @@ bool GetVectorIDsParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.GetVectorIDsParam.table_name")); + "milvus.grpc.GetVectorIDsParam.collection_name")); } else { goto handle_unusual; } @@ -10214,14 +10219,14 @@ void GetVectorIDsParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.GetVectorIDsParam.table_name"); + "milvus.grpc.GetVectorIDsParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // string segment_name = 2; @@ -10247,15 +10252,15 @@ void GetVectorIDsParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.GetVectorIDsParam.table_name"); + "milvus.grpc.GetVectorIDsParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // string segment_name = 2; @@ -10290,11 +10295,11 @@ size_t GetVectorIDsParam::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // string segment_name = 2; @@ -10331,9 +10336,9 @@ void GetVectorIDsParam::MergeFrom(const GetVectorIDsParam& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.segment_name().size() > 0) { @@ -10362,7 +10367,7 @@ bool GetVectorIDsParam::IsInitialized() const { void GetVectorIDsParam::InternalSwap(GetVectorIDsParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); segment_name_.Swap(&other->segment_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); @@ -10380,14 +10385,14 @@ PROTOBUF_NAMESPACE_OPEN template<> PROTOBUF_NOINLINE ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage< ::milvus::grpc::KeyValuePair >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::KeyValuePair >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableName* Arena::CreateMaybeMessage< ::milvus::grpc::TableName >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableName >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionName >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionName >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage< ::milvus::grpc::TableNameList >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableNameList >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionNameList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionNameList >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage< ::milvus::grpc::TableSchema >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableSchema >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionSchema* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionSchema >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionSchema >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage< ::milvus::grpc::PartitionParam >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::PartitionParam >(arena); @@ -10422,8 +10427,8 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::StringReply* Arena::CreateMaybeMess template<> PROTOBUF_NOINLINE ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage< ::milvus::grpc::BoolReply >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::BoolReply >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage< ::milvus::grpc::TableRowCount >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableRowCount >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionRowCount >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionRowCount >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::Command* Arena::CreateMaybeMessage< ::milvus::grpc::Command >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::Command >(arena); @@ -10443,8 +10448,8 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::SegmentStat* Arena::CreateMaybeMess template<> PROTOBUF_NOINLINE ::milvus::grpc::PartitionStat* Arena::CreateMaybeMessage< ::milvus::grpc::PartitionStat >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::PartitionStat >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableInfo* Arena::CreateMaybeMessage< ::milvus::grpc::TableInfo >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableInfo >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionInfo >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionInfo >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorIdentity* Arena::CreateMaybeMessage< ::milvus::grpc::VectorIdentity >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::VectorIdentity >(arena); diff --git a/core/src/grpc/gen-milvus/milvus.pb.h b/core/src/grpc/gen-milvus/milvus.pb.h index 4528f278e1..88113f73f7 100644 --- a/core/src/grpc/gen-milvus/milvus.pb.h +++ b/core/src/grpc/gen-milvus/milvus.pb.h @@ -60,6 +60,21 @@ namespace grpc { class BoolReply; class BoolReplyDefaultTypeInternal; extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_; +class CollectionInfo; +class CollectionInfoDefaultTypeInternal; +extern CollectionInfoDefaultTypeInternal _CollectionInfo_default_instance_; +class CollectionName; +class CollectionNameDefaultTypeInternal; +extern CollectionNameDefaultTypeInternal _CollectionName_default_instance_; +class CollectionNameList; +class CollectionNameListDefaultTypeInternal; +extern CollectionNameListDefaultTypeInternal _CollectionNameList_default_instance_; +class CollectionRowCount; +class CollectionRowCountDefaultTypeInternal; +extern CollectionRowCountDefaultTypeInternal _CollectionRowCount_default_instance_; +class CollectionSchema; +class CollectionSchemaDefaultTypeInternal; +extern CollectionSchemaDefaultTypeInternal _CollectionSchema_default_instance_; class Command; class CommandDefaultTypeInternal; extern CommandDefaultTypeInternal _Command_default_instance_; @@ -108,21 +123,6 @@ extern SegmentStatDefaultTypeInternal _SegmentStat_default_instance_; class StringReply; class StringReplyDefaultTypeInternal; extern StringReplyDefaultTypeInternal _StringReply_default_instance_; -class TableInfo; -class TableInfoDefaultTypeInternal; -extern TableInfoDefaultTypeInternal _TableInfo_default_instance_; -class TableName; -class TableNameDefaultTypeInternal; -extern TableNameDefaultTypeInternal _TableName_default_instance_; -class TableNameList; -class TableNameListDefaultTypeInternal; -extern TableNameListDefaultTypeInternal _TableNameList_default_instance_; -class TableRowCount; -class TableRowCountDefaultTypeInternal; -extern TableRowCountDefaultTypeInternal _TableRowCount_default_instance_; -class TableSchema; -class TableSchemaDefaultTypeInternal; -extern TableSchemaDefaultTypeInternal _TableSchema_default_instance_; class TopKQueryResult; class TopKQueryResultDefaultTypeInternal; extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_; @@ -139,6 +139,11 @@ extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_; } // namespace milvus PROTOBUF_NAMESPACE_OPEN template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*); +template<> ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage<::milvus::grpc::CollectionInfo>(Arena*); +template<> ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage<::milvus::grpc::CollectionName>(Arena*); +template<> ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage<::milvus::grpc::CollectionNameList>(Arena*); +template<> ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage<::milvus::grpc::CollectionRowCount>(Arena*); +template<> ::milvus::grpc::CollectionSchema* Arena::CreateMaybeMessage<::milvus::grpc::CollectionSchema>(Arena*); template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*); template<> ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByIDParam>(Arena*); template<> ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage<::milvus::grpc::FlushParam>(Arena*); @@ -155,11 +160,6 @@ template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvu template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*); template<> ::milvus::grpc::SegmentStat* Arena::CreateMaybeMessage<::milvus::grpc::SegmentStat>(Arena*); template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*); -template<> ::milvus::grpc::TableInfo* Arena::CreateMaybeMessage<::milvus::grpc::TableInfo>(Arena*); -template<> ::milvus::grpc::TableName* Arena::CreateMaybeMessage<::milvus::grpc::TableName>(Arena*); -template<> ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage<::milvus::grpc::TableNameList>(Arena*); -template<> ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage<::milvus::grpc::TableRowCount>(Arena*); -template<> ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage<::milvus::grpc::TableSchema>(Arena*); template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*); template<> ::milvus::grpc::VectorData* Arena::CreateMaybeMessage<::milvus::grpc::VectorData>(Arena*); template<> ::milvus::grpc::VectorIdentity* Arena::CreateMaybeMessage<::milvus::grpc::VectorIdentity>(Arena*); @@ -320,23 +320,23 @@ class KeyValuePair : }; // ------------------------------------------------------------------- -class TableName : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableName) */ { +class CollectionName : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionName) */ { public: - TableName(); - virtual ~TableName(); + CollectionName(); + virtual ~CollectionName(); - TableName(const TableName& from); - TableName(TableName&& from) noexcept - : TableName() { + CollectionName(const CollectionName& from); + CollectionName(CollectionName&& from) noexcept + : CollectionName() { *this = ::std::move(from); } - inline TableName& operator=(const TableName& from) { + inline CollectionName& operator=(const CollectionName& from) { CopyFrom(from); return *this; } - inline TableName& operator=(TableName&& from) noexcept { + inline CollectionName& operator=(CollectionName&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -354,37 +354,37 @@ class TableName : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableName& default_instance(); + static const CollectionName& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableName* internal_default_instance() { - return reinterpret_cast( - &_TableName_default_instance_); + static inline const CollectionName* internal_default_instance() { + return reinterpret_cast( + &_CollectionName_default_instance_); } static constexpr int kIndexInFileMessages = 1; - friend void swap(TableName& a, TableName& b) { + friend void swap(CollectionName& a, CollectionName& b) { a.Swap(&b); } - inline void Swap(TableName* other) { + inline void Swap(CollectionName* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableName* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionName* New() const final { + return CreateMaybeMessage(nullptr); } - TableName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableName& from); - void MergeFrom(const TableName& from); + void CopyFrom(const CollectionName& from); + void MergeFrom(const CollectionName& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -405,10 +405,10 @@ class TableName : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableName* other); + void InternalSwap(CollectionName* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableName"; + return "milvus.grpc.CollectionName"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -433,47 +433,47 @@ class TableName : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableName) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionName) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; // ------------------------------------------------------------------- -class TableNameList : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableNameList) */ { +class CollectionNameList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionNameList) */ { public: - TableNameList(); - virtual ~TableNameList(); + CollectionNameList(); + virtual ~CollectionNameList(); - TableNameList(const TableNameList& from); - TableNameList(TableNameList&& from) noexcept - : TableNameList() { + CollectionNameList(const CollectionNameList& from); + CollectionNameList(CollectionNameList&& from) noexcept + : CollectionNameList() { *this = ::std::move(from); } - inline TableNameList& operator=(const TableNameList& from) { + inline CollectionNameList& operator=(const CollectionNameList& from) { CopyFrom(from); return *this; } - inline TableNameList& operator=(TableNameList&& from) noexcept { + inline CollectionNameList& operator=(CollectionNameList&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -491,37 +491,37 @@ class TableNameList : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableNameList& default_instance(); + static const CollectionNameList& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableNameList* internal_default_instance() { - return reinterpret_cast( - &_TableNameList_default_instance_); + static inline const CollectionNameList* internal_default_instance() { + return reinterpret_cast( + &_CollectionNameList_default_instance_); } static constexpr int kIndexInFileMessages = 2; - friend void swap(TableNameList& a, TableNameList& b) { + friend void swap(CollectionNameList& a, CollectionNameList& b) { a.Swap(&b); } - inline void Swap(TableNameList* other) { + inline void Swap(CollectionNameList* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableNameList* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionNameList* New() const final { + return CreateMaybeMessage(nullptr); } - TableNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableNameList& from); - void MergeFrom(const TableNameList& from); + void CopyFrom(const CollectionNameList& from); + void MergeFrom(const CollectionNameList& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -542,10 +542,10 @@ class TableNameList : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableNameList* other); + void InternalSwap(CollectionNameList* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableNameList"; + return "milvus.grpc.CollectionNameList"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -570,25 +570,25 @@ class TableNameList : // accessors ------------------------------------------------------- enum : int { - kTableNamesFieldNumber = 2, + kCollectionNamesFieldNumber = 2, kStatusFieldNumber = 1, }; - // repeated string table_names = 2; - int table_names_size() const; - void clear_table_names(); - const std::string& table_names(int index) const; - std::string* mutable_table_names(int index); - void set_table_names(int index, const std::string& value); - void set_table_names(int index, std::string&& value); - void set_table_names(int index, const char* value); - void set_table_names(int index, const char* value, size_t size); - std::string* add_table_names(); - void add_table_names(const std::string& value); - void add_table_names(std::string&& value); - void add_table_names(const char* value); - void add_table_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& table_names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_table_names(); + // repeated string collection_names = 2; + int collection_names_size() const; + void clear_collection_names(); + const std::string& collection_names(int index) const; + std::string* mutable_collection_names(int index); + void set_collection_names(int index, const std::string& value); + void set_collection_names(int index, std::string&& value); + void set_collection_names(int index, const char* value); + void set_collection_names(int index, const char* value, size_t size); + std::string* add_collection_names(); + void add_collection_names(const std::string& value); + void add_collection_names(std::string&& value); + void add_collection_names(const char* value); + void add_collection_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collection_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collection_names(); // .milvus.grpc.Status status = 1; bool has_status() const; @@ -598,35 +598,35 @@ class TableNameList : ::milvus::grpc::Status* mutable_status(); void set_allocated_status(::milvus::grpc::Status* status); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableNameList) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionNameList) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField table_names_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collection_names_; ::milvus::grpc::Status* status_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; // ------------------------------------------------------------------- -class TableSchema : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableSchema) */ { +class CollectionSchema : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionSchema) */ { public: - TableSchema(); - virtual ~TableSchema(); + CollectionSchema(); + virtual ~CollectionSchema(); - TableSchema(const TableSchema& from); - TableSchema(TableSchema&& from) noexcept - : TableSchema() { + CollectionSchema(const CollectionSchema& from); + CollectionSchema(CollectionSchema&& from) noexcept + : CollectionSchema() { *this = ::std::move(from); } - inline TableSchema& operator=(const TableSchema& from) { + inline CollectionSchema& operator=(const CollectionSchema& from) { CopyFrom(from); return *this; } - inline TableSchema& operator=(TableSchema&& from) noexcept { + inline CollectionSchema& operator=(CollectionSchema&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -644,37 +644,37 @@ class TableSchema : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableSchema& default_instance(); + static const CollectionSchema& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableSchema* internal_default_instance() { - return reinterpret_cast( - &_TableSchema_default_instance_); + static inline const CollectionSchema* internal_default_instance() { + return reinterpret_cast( + &_CollectionSchema_default_instance_); } static constexpr int kIndexInFileMessages = 3; - friend void swap(TableSchema& a, TableSchema& b) { + friend void swap(CollectionSchema& a, CollectionSchema& b) { a.Swap(&b); } - inline void Swap(TableSchema* other) { + inline void Swap(CollectionSchema* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableSchema* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionSchema* New() const final { + return CreateMaybeMessage(nullptr); } - TableSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableSchema& from); - void MergeFrom(const TableSchema& from); + void CopyFrom(const CollectionSchema& from); + void MergeFrom(const CollectionSchema& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -695,10 +695,10 @@ class TableSchema : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableSchema* other); + void InternalSwap(CollectionSchema* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableSchema"; + return "milvus.grpc.CollectionSchema"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -724,7 +724,7 @@ class TableSchema : enum : int { kExtraParamsFieldNumber = 6, - kTableNameFieldNumber = 2, + kCollectionNameFieldNumber = 2, kStatusFieldNumber = 1, kDimensionFieldNumber = 3, kIndexFileSizeFieldNumber = 4, @@ -741,16 +741,16 @@ class TableSchema : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 2; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // .milvus.grpc.Status status = 1; bool has_status() const; @@ -775,13 +775,13 @@ class TableSchema : ::PROTOBUF_NAMESPACE_ID::int32 metric_type() const; void set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableSchema) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionSchema) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::milvus::grpc::Status* status_; ::PROTOBUF_NAMESPACE_ID::int64 dimension_; ::PROTOBUF_NAMESPACE_ID::int64 index_file_size_; @@ -904,19 +904,19 @@ class PartitionParam : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kTagFieldNumber = 2, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // string tag = 2; void clear_tag(); @@ -934,7 +934,7 @@ class PartitionParam : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -1361,7 +1361,7 @@ class InsertParam : kRowRecordArrayFieldNumber = 2, kRowIdArrayFieldNumber = 3, kExtraParamsFieldNumber = 5, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kPartitionTagFieldNumber = 4, }; // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -1397,16 +1397,16 @@ class InsertParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // string partition_tag = 4; void clear_partition_tag(); @@ -1428,7 +1428,7 @@ class InsertParam : ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > row_id_array_; mutable std::atomic _row_id_array_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -1699,7 +1699,7 @@ class SearchParam : kPartitionTagArrayFieldNumber = 2, kQueryRecordArrayFieldNumber = 3, kExtraParamsFieldNumber = 5, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kTopkFieldNumber = 4, }; // repeated string partition_tag_array = 2; @@ -1741,16 +1741,16 @@ class SearchParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // int64 topk = 4; void clear_topk(); @@ -1765,7 +1765,7 @@ class SearchParam : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > query_record_array_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::int64 topk_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -2040,7 +2040,7 @@ class SearchByIDParam : enum : int { kPartitionTagArrayFieldNumber = 2, kExtraParamsFieldNumber = 5, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kIdFieldNumber = 3, kTopkFieldNumber = 4, }; @@ -2072,16 +2072,16 @@ class SearchByIDParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // int64 id = 3; void clear_id(); @@ -2100,7 +2100,7 @@ class SearchByIDParam : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::int64 id_; ::PROTOBUF_NAMESPACE_ID::int64 topk_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -2565,23 +2565,23 @@ class BoolReply : }; // ------------------------------------------------------------------- -class TableRowCount : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableRowCount) */ { +class CollectionRowCount : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionRowCount) */ { public: - TableRowCount(); - virtual ~TableRowCount(); + CollectionRowCount(); + virtual ~CollectionRowCount(); - TableRowCount(const TableRowCount& from); - TableRowCount(TableRowCount&& from) noexcept - : TableRowCount() { + CollectionRowCount(const CollectionRowCount& from); + CollectionRowCount(CollectionRowCount&& from) noexcept + : CollectionRowCount() { *this = ::std::move(from); } - inline TableRowCount& operator=(const TableRowCount& from) { + inline CollectionRowCount& operator=(const CollectionRowCount& from) { CopyFrom(from); return *this; } - inline TableRowCount& operator=(TableRowCount&& from) noexcept { + inline CollectionRowCount& operator=(CollectionRowCount&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -2599,37 +2599,37 @@ class TableRowCount : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableRowCount& default_instance(); + static const CollectionRowCount& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableRowCount* internal_default_instance() { - return reinterpret_cast( - &_TableRowCount_default_instance_); + static inline const CollectionRowCount* internal_default_instance() { + return reinterpret_cast( + &_CollectionRowCount_default_instance_); } static constexpr int kIndexInFileMessages = 15; - friend void swap(TableRowCount& a, TableRowCount& b) { + friend void swap(CollectionRowCount& a, CollectionRowCount& b) { a.Swap(&b); } - inline void Swap(TableRowCount* other) { + inline void Swap(CollectionRowCount* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableRowCount* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionRowCount* New() const final { + return CreateMaybeMessage(nullptr); } - TableRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableRowCount& from); - void MergeFrom(const TableRowCount& from); + void CopyFrom(const CollectionRowCount& from); + void MergeFrom(const CollectionRowCount& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -2650,10 +2650,10 @@ class TableRowCount : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableRowCount* other); + void InternalSwap(CollectionRowCount* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableRowCount"; + return "milvus.grpc.CollectionRowCount"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -2679,7 +2679,7 @@ class TableRowCount : enum : int { kStatusFieldNumber = 1, - kTableRowCountFieldNumber = 2, + kCollectionRowCountFieldNumber = 2, }; // .milvus.grpc.Status status = 1; bool has_status() const; @@ -2689,18 +2689,18 @@ class TableRowCount : ::milvus::grpc::Status* mutable_status(); void set_allocated_status(::milvus::grpc::Status* status); - // int64 table_row_count = 2; - void clear_table_row_count(); - ::PROTOBUF_NAMESPACE_ID::int64 table_row_count() const; - void set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); + // int64 collection_row_count = 2; + void clear_collection_row_count(); + ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count() const; + void set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionRowCount) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::milvus::grpc::Status* status_; - ::PROTOBUF_NAMESPACE_ID::int64 table_row_count_; + ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -2957,7 +2957,7 @@ class IndexParam : enum : int { kExtraParamsFieldNumber = 4, - kTableNameFieldNumber = 2, + kCollectionNameFieldNumber = 2, kStatusFieldNumber = 1, kIndexTypeFieldNumber = 3, }; @@ -2972,16 +2972,16 @@ class IndexParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 2; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // .milvus.grpc.Status status = 1; bool has_status() const; @@ -3002,7 +3002,7 @@ class IndexParam : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::milvus::grpc::Status* status_; ::PROTOBUF_NAMESPACE_ID::int32 index_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -3123,31 +3123,31 @@ class FlushParam : // accessors ------------------------------------------------------- enum : int { - kTableNameArrayFieldNumber = 1, + kCollectionNameArrayFieldNumber = 1, }; - // repeated string table_name_array = 1; - int table_name_array_size() const; - void clear_table_name_array(); - const std::string& table_name_array(int index) const; - std::string* mutable_table_name_array(int index); - void set_table_name_array(int index, const std::string& value); - void set_table_name_array(int index, std::string&& value); - void set_table_name_array(int index, const char* value); - void set_table_name_array(int index, const char* value, size_t size); - std::string* add_table_name_array(); - void add_table_name_array(const std::string& value); - void add_table_name_array(std::string&& value); - void add_table_name_array(const char* value); - void add_table_name_array(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& table_name_array() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_table_name_array(); + // repeated string collection_name_array = 1; + int collection_name_array_size() const; + void clear_collection_name_array(); + const std::string& collection_name_array(int index) const; + std::string* mutable_collection_name_array(int index); + void set_collection_name_array(int index, const std::string& value); + void set_collection_name_array(int index, std::string&& value); + void set_collection_name_array(int index, const char* value); + void set_collection_name_array(int index, const char* value, size_t size); + std::string* add_collection_name_array(); + void add_collection_name_array(const std::string& value); + void add_collection_name_array(std::string&& value); + void add_collection_name_array(const char* value); + void add_collection_name_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collection_name_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collection_name_array(); // @@protoc_insertion_point(class_scope:milvus.grpc.FlushParam) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField table_name_array_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collection_name_array_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -3267,7 +3267,7 @@ class DeleteByIDParam : enum : int { kIdArrayFieldNumber = 2, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, }; // repeated int64 id_array = 2; int id_array_size() const; @@ -3280,16 +3280,16 @@ class DeleteByIDParam : ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_id_array(); - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // @@protoc_insertion_point(class_scope:milvus.grpc.DeleteByIDParam) private: @@ -3298,7 +3298,7 @@ class DeleteByIDParam : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_; mutable std::atomic _id_array_cached_byte_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -3625,23 +3625,23 @@ class PartitionStat : }; // ------------------------------------------------------------------- -class TableInfo : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableInfo) */ { +class CollectionInfo : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionInfo) */ { public: - TableInfo(); - virtual ~TableInfo(); + CollectionInfo(); + virtual ~CollectionInfo(); - TableInfo(const TableInfo& from); - TableInfo(TableInfo&& from) noexcept - : TableInfo() { + CollectionInfo(const CollectionInfo& from); + CollectionInfo(CollectionInfo&& from) noexcept + : CollectionInfo() { *this = ::std::move(from); } - inline TableInfo& operator=(const TableInfo& from) { + inline CollectionInfo& operator=(const CollectionInfo& from) { CopyFrom(from); return *this; } - inline TableInfo& operator=(TableInfo&& from) noexcept { + inline CollectionInfo& operator=(CollectionInfo&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -3659,37 +3659,37 @@ class TableInfo : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableInfo& default_instance(); + static const CollectionInfo& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableInfo* internal_default_instance() { - return reinterpret_cast( - &_TableInfo_default_instance_); + static inline const CollectionInfo* internal_default_instance() { + return reinterpret_cast( + &_CollectionInfo_default_instance_); } static constexpr int kIndexInFileMessages = 22; - friend void swap(TableInfo& a, TableInfo& b) { + friend void swap(CollectionInfo& a, CollectionInfo& b) { a.Swap(&b); } - inline void Swap(TableInfo* other) { + inline void Swap(CollectionInfo* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableInfo* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionInfo* New() const final { + return CreateMaybeMessage(nullptr); } - TableInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableInfo& from); - void MergeFrom(const TableInfo& from); + void CopyFrom(const CollectionInfo& from); + void MergeFrom(const CollectionInfo& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -3710,10 +3710,10 @@ class TableInfo : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableInfo* other); + void InternalSwap(CollectionInfo* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableInfo"; + return "milvus.grpc.CollectionInfo"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -3766,7 +3766,7 @@ class TableInfo : ::PROTOBUF_NAMESPACE_ID::int64 total_row_count() const; void set_total_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableInfo) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionInfo) private: class _Internal; @@ -3892,19 +3892,19 @@ class VectorIdentity : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kIdFieldNumber = 2, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // int64 id = 2; void clear_id(); @@ -3916,7 +3916,7 @@ class VectorIdentity : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::int64 id_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -4180,19 +4180,19 @@ class GetVectorIDsParam : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kSegmentNameFieldNumber = 2, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // string segment_name = 2; void clear_segment_name(); @@ -4210,7 +4210,7 @@ class GetVectorIDsParam : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr segment_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -4330,90 +4330,90 @@ inline void KeyValuePair::set_allocated_value(std::string* value) { // ------------------------------------------------------------------- -// TableName +// CollectionName -// string table_name = 1; -inline void TableName::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void CollectionName::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& TableName::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableName.table_name) - return table_name_.GetNoArena(); +inline const std::string& CollectionName::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionName.collection_name) + return collection_name_.GetNoArena(); } -inline void TableName::set_table_name(const std::string& value) { +inline void CollectionName::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.TableName.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionName.collection_name) } -inline void TableName::set_table_name(std::string&& value) { +inline void CollectionName::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableName.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionName.collection_name) } -inline void TableName::set_table_name(const char* value) { +inline void CollectionName::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TableName.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionName.collection_name) } -inline void TableName::set_table_name(const char* value, size_t size) { +inline void CollectionName::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableName.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionName.collection_name) } -inline std::string* TableName::mutable_table_name() { +inline std::string* CollectionName::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableName.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionName.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* TableName::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableName.table_name) +inline std::string* CollectionName::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionName.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void TableName::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void CollectionName::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableName.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionName.collection_name) } // ------------------------------------------------------------------- -// TableNameList +// CollectionNameList // .milvus.grpc.Status status = 1; -inline bool TableNameList::has_status() const { +inline bool CollectionNameList::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableNameList::status() const { +inline const ::milvus::grpc::Status& CollectionNameList::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableNameList::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableNameList.status) +inline ::milvus::grpc::Status* CollectionNameList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionNameList.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableNameList::mutable_status() { +inline ::milvus::grpc::Status* CollectionNameList::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.status) return status_; } -inline void TableNameList::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionNameList::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -4429,105 +4429,105 @@ inline void TableNameList::set_allocated_status(::milvus::grpc::Status* status) } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableNameList.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionNameList.status) } -// repeated string table_names = 2; -inline int TableNameList::table_names_size() const { - return table_names_.size(); +// repeated string collection_names = 2; +inline int CollectionNameList::collection_names_size() const { + return collection_names_.size(); } -inline void TableNameList::clear_table_names() { - table_names_.Clear(); +inline void CollectionNameList::clear_collection_names() { + collection_names_.Clear(); } -inline const std::string& TableNameList::table_names(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.table_names) - return table_names_.Get(index); +inline const std::string& CollectionNameList::collection_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Get(index); } -inline std::string* TableNameList::mutable_table_names(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.table_names) - return table_names_.Mutable(index); +inline std::string* CollectionNameList::mutable_collection_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Mutable(index); } -inline void TableNameList::set_table_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names) - table_names_.Mutable(index)->assign(value); +inline void CollectionNameList::set_collection_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names) + collection_names_.Mutable(index)->assign(value); } -inline void TableNameList::set_table_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names) - table_names_.Mutable(index)->assign(std::move(value)); +inline void CollectionNameList::set_collection_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names) + collection_names_.Mutable(index)->assign(std::move(value)); } -inline void TableNameList::set_table_names(int index, const char* value) { +inline void CollectionNameList::set_collection_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); - table_names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TableNameList.table_names) + collection_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::set_table_names(int index, const char* value, size_t size) { - table_names_.Mutable(index)->assign( +inline void CollectionNameList::set_collection_names(int index, const char* value, size_t size) { + collection_names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableNameList.table_names) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionNameList.collection_names) } -inline std::string* TableNameList::add_table_names() { - // @@protoc_insertion_point(field_add_mutable:milvus.grpc.TableNameList.table_names) - return table_names_.Add(); +inline std::string* CollectionNameList::add_collection_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Add(); } -inline void TableNameList::add_table_names(const std::string& value) { - table_names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names) +inline void CollectionNameList::add_collection_names(const std::string& value) { + collection_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::add_table_names(std::string&& value) { - table_names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names) +inline void CollectionNameList::add_collection_names(std::string&& value) { + collection_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::add_table_names(const char* value) { +inline void CollectionNameList::add_collection_names(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:milvus.grpc.TableNameList.table_names) + collection_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::add_table_names(const char* value, size_t size) { - table_names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:milvus.grpc.TableNameList.table_names) +inline void CollectionNameList::add_collection_names(const char* value, size_t size) { + collection_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.CollectionNameList.collection_names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -TableNameList::table_names() const { - // @@protoc_insertion_point(field_list:milvus.grpc.TableNameList.table_names) - return table_names_; +CollectionNameList::collection_names() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionNameList.collection_names) + return collection_names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -TableNameList::mutable_table_names() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableNameList.table_names) - return &table_names_; +CollectionNameList::mutable_collection_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionNameList.collection_names) + return &collection_names_; } // ------------------------------------------------------------------- -// TableSchema +// CollectionSchema // .milvus.grpc.Status status = 1; -inline bool TableSchema::has_status() const { +inline bool CollectionSchema::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableSchema::status() const { +inline const ::milvus::grpc::Status& CollectionSchema::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableSchema::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.status) +inline ::milvus::grpc::Status* CollectionSchema::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionSchema.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableSchema::mutable_status() { +inline ::milvus::grpc::Status* CollectionSchema::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionSchema.status) return status_; } -inline void TableSchema::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionSchema::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -4543,129 +4543,129 @@ inline void TableSchema::set_allocated_status(::milvus::grpc::Status* status) { } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionSchema.status) } -// string table_name = 2; -inline void TableSchema::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 2; +inline void CollectionSchema::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& TableSchema::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name) - return table_name_.GetNoArena(); +inline const std::string& CollectionSchema::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.collection_name) + return collection_name_.GetNoArena(); } -inline void TableSchema::set_table_name(const std::string& value) { +inline void CollectionSchema::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.collection_name) } -inline void TableSchema::set_table_name(std::string&& value) { +inline void CollectionSchema::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableSchema.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionSchema.collection_name) } -inline void TableSchema::set_table_name(const char* value) { +inline void CollectionSchema::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TableSchema.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionSchema.collection_name) } -inline void TableSchema::set_table_name(const char* value, size_t size) { +inline void CollectionSchema::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableSchema.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionSchema.collection_name) } -inline std::string* TableSchema::mutable_table_name() { +inline std::string* CollectionSchema::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionSchema.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* TableSchema::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name) +inline std::string* CollectionSchema::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionSchema.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void TableSchema::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void CollectionSchema::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionSchema.collection_name) } // int64 dimension = 3; -inline void TableSchema::clear_dimension() { +inline void CollectionSchema::clear_dimension() { dimension_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::dimension() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.dimension) +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionSchema::dimension() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.dimension) return dimension_; } -inline void TableSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { dimension_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.dimension) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.dimension) } // int64 index_file_size = 4; -inline void TableSchema::clear_index_file_size() { +inline void CollectionSchema::clear_index_file_size() { index_file_size_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::index_file_size() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.index_file_size) +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionSchema::index_file_size() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.index_file_size) return index_file_size_; } -inline void TableSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value) { index_file_size_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.index_file_size) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.index_file_size) } // int32 metric_type = 5; -inline void TableSchema::clear_metric_type() { +inline void CollectionSchema::clear_metric_type() { metric_type_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 TableSchema::metric_type() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.metric_type) +inline ::PROTOBUF_NAMESPACE_ID::int32 CollectionSchema::metric_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.metric_type) return metric_type_; } -inline void TableSchema::set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void CollectionSchema::set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value) { metric_type_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.metric_type) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.metric_type) } // repeated .milvus.grpc.KeyValuePair extra_params = 6; -inline int TableSchema::extra_params_size() const { +inline int CollectionSchema::extra_params_size() const { return extra_params_.size(); } -inline void TableSchema::clear_extra_params() { +inline void CollectionSchema::clear_extra_params() { extra_params_.Clear(); } -inline ::milvus::grpc::KeyValuePair* TableSchema::mutable_extra_params(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.extra_params) +inline ::milvus::grpc::KeyValuePair* CollectionSchema::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionSchema.extra_params) return extra_params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* -TableSchema::mutable_extra_params() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableSchema.extra_params) +CollectionSchema::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionSchema.extra_params) return &extra_params_; } -inline const ::milvus::grpc::KeyValuePair& TableSchema::extra_params(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.extra_params) +inline const ::milvus::grpc::KeyValuePair& CollectionSchema::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.extra_params) return extra_params_.Get(index); } -inline ::milvus::grpc::KeyValuePair* TableSchema::add_extra_params() { - // @@protoc_insertion_point(field_add:milvus.grpc.TableSchema.extra_params) +inline ::milvus::grpc::KeyValuePair* CollectionSchema::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionSchema.extra_params) return extra_params_.Add(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& -TableSchema::extra_params() const { - // @@protoc_insertion_point(field_list:milvus.grpc.TableSchema.extra_params) +CollectionSchema::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionSchema.extra_params) return extra_params_; } @@ -4673,55 +4673,55 @@ TableSchema::extra_params() const { // PartitionParam -// string table_name = 1; -inline void PartitionParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void PartitionParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& PartitionParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& PartitionParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.collection_name) + return collection_name_.GetNoArena(); } -inline void PartitionParam::set_table_name(const std::string& value) { +inline void PartitionParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.collection_name) } -inline void PartitionParam::set_table_name(std::string&& value) { +inline void PartitionParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.collection_name) } -inline void PartitionParam::set_table_name(const char* value) { +inline void PartitionParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.collection_name) } -inline void PartitionParam::set_table_name(const char* value, size_t size) { +inline void PartitionParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.collection_name) } -inline std::string* PartitionParam::mutable_table_name() { +inline std::string* PartitionParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* PartitionParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.table_name) +inline std::string* PartitionParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void PartitionParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void PartitionParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.collection_name) } // string tag = 2; @@ -4978,55 +4978,55 @@ inline void RowRecord::set_allocated_binary_data(std::string* binary_data) { // InsertParam -// string table_name = 1; -inline void InsertParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void InsertParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& InsertParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& InsertParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.collection_name) + return collection_name_.GetNoArena(); } -inline void InsertParam::set_table_name(const std::string& value) { +inline void InsertParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.collection_name) } -inline void InsertParam::set_table_name(std::string&& value) { +inline void InsertParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.collection_name) } -inline void InsertParam::set_table_name(const char* value) { +inline void InsertParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.collection_name) } -inline void InsertParam::set_table_name(const char* value, size_t size) { +inline void InsertParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.collection_name) } -inline std::string* InsertParam::mutable_table_name() { +inline std::string* InsertParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* InsertParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.table_name) +inline std::string* InsertParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void InsertParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void InsertParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.collection_name) } // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -5253,55 +5253,55 @@ VectorIds::mutable_vector_id_array() { // SearchParam -// string table_name = 1; -inline void SearchParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void SearchParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& SearchParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& SearchParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.collection_name) + return collection_name_.GetNoArena(); } -inline void SearchParam::set_table_name(const std::string& value) { +inline void SearchParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.collection_name) } -inline void SearchParam::set_table_name(std::string&& value) { +inline void SearchParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.collection_name) } -inline void SearchParam::set_table_name(const char* value) { +inline void SearchParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.collection_name) } -inline void SearchParam::set_table_name(const char* value, size_t size) { +inline void SearchParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.collection_name) } -inline std::string* SearchParam::mutable_table_name() { +inline std::string* SearchParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* SearchParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.table_name) +inline std::string* SearchParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void SearchParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void SearchParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.collection_name) } // repeated string partition_tag_array = 2; @@ -5567,55 +5567,55 @@ inline void SearchInFilesParam::set_allocated_search_param(::milvus::grpc::Searc // SearchByIDParam -// string table_name = 1; -inline void SearchByIDParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void SearchByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& SearchByIDParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.SearchByIDParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& SearchByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchByIDParam.collection_name) + return collection_name_.GetNoArena(); } -inline void SearchByIDParam::set_table_name(const std::string& value) { +inline void SearchByIDParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.SearchByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchByIDParam.collection_name) } -inline void SearchByIDParam::set_table_name(std::string&& value) { +inline void SearchByIDParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchByIDParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchByIDParam.collection_name) } -inline void SearchByIDParam::set_table_name(const char* value) { +inline void SearchByIDParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchByIDParam.collection_name) } -inline void SearchByIDParam::set_table_name(const char* value, size_t size) { +inline void SearchByIDParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchByIDParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchByIDParam.collection_name) } -inline std::string* SearchByIDParam::mutable_table_name() { +inline std::string* SearchByIDParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchByIDParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* SearchByIDParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.SearchByIDParam.table_name) +inline std::string* SearchByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchByIDParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void SearchByIDParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void SearchByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchByIDParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchByIDParam.collection_name) } // repeated string partition_tag_array = 2; @@ -6029,35 +6029,35 @@ inline void BoolReply::set_bool_reply(bool value) { // ------------------------------------------------------------------- -// TableRowCount +// CollectionRowCount // .milvus.grpc.Status status = 1; -inline bool TableRowCount::has_status() const { +inline bool CollectionRowCount::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableRowCount::status() const { +inline const ::milvus::grpc::Status& CollectionRowCount::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableRowCount::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableRowCount.status) +inline ::milvus::grpc::Status* CollectionRowCount::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionRowCount.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableRowCount::mutable_status() { +inline ::milvus::grpc::Status* CollectionRowCount::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableRowCount.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionRowCount.status) return status_; } -inline void TableRowCount::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionRowCount::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -6073,21 +6073,21 @@ inline void TableRowCount::set_allocated_status(::milvus::grpc::Status* status) } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableRowCount.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionRowCount.status) } -// int64 table_row_count = 2; -inline void TableRowCount::clear_table_row_count() { - table_row_count_ = PROTOBUF_LONGLONG(0); +// int64 collection_row_count = 2; +inline void CollectionRowCount::clear_collection_row_count() { + collection_row_count_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableRowCount::table_row_count() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.table_row_count) - return table_row_count_; +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionRowCount::collection_row_count() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.collection_row_count) + return collection_row_count_; } -inline void TableRowCount::set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionRowCount::set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { - table_row_count_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableRowCount.table_row_count) + collection_row_count_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionRowCount.collection_row_count) } // ------------------------------------------------------------------- @@ -6194,55 +6194,55 @@ inline void IndexParam::set_allocated_status(::milvus::grpc::Status* status) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.status) } -// string table_name = 2; -inline void IndexParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 2; +inline void IndexParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& IndexParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& IndexParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.collection_name) + return collection_name_.GetNoArena(); } -inline void IndexParam::set_table_name(const std::string& value) { +inline void IndexParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.collection_name) } -inline void IndexParam::set_table_name(std::string&& value) { +inline void IndexParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.collection_name) } -inline void IndexParam::set_table_name(const char* value) { +inline void IndexParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.collection_name) } -inline void IndexParam::set_table_name(const char* value, size_t size) { +inline void IndexParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.collection_name) } -inline std::string* IndexParam::mutable_table_name() { +inline std::string* IndexParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* IndexParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.table_name) +inline std::string* IndexParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void IndexParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void IndexParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.collection_name) } // int32 index_type = 3; @@ -6293,124 +6293,124 @@ IndexParam::extra_params() const { // FlushParam -// repeated string table_name_array = 1; -inline int FlushParam::table_name_array_size() const { - return table_name_array_.size(); +// repeated string collection_name_array = 1; +inline int FlushParam::collection_name_array_size() const { + return collection_name_array_.size(); } -inline void FlushParam::clear_table_name_array() { - table_name_array_.Clear(); +inline void FlushParam::clear_collection_name_array() { + collection_name_array_.Clear(); } -inline const std::string& FlushParam::table_name_array(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.FlushParam.table_name_array) - return table_name_array_.Get(index); +inline const std::string& FlushParam::collection_name_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Get(index); } -inline std::string* FlushParam::mutable_table_name_array(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.FlushParam.table_name_array) - return table_name_array_.Mutable(index); +inline std::string* FlushParam::mutable_collection_name_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Mutable(index); } -inline void FlushParam::set_table_name_array(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.table_name_array) - table_name_array_.Mutable(index)->assign(value); +inline void FlushParam::set_collection_name_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array) + collection_name_array_.Mutable(index)->assign(value); } -inline void FlushParam::set_table_name_array(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.table_name_array) - table_name_array_.Mutable(index)->assign(std::move(value)); +inline void FlushParam::set_collection_name_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array) + collection_name_array_.Mutable(index)->assign(std::move(value)); } -inline void FlushParam::set_table_name_array(int index, const char* value) { +inline void FlushParam::set_collection_name_array(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_array_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:milvus.grpc.FlushParam.table_name_array) + collection_name_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::set_table_name_array(int index, const char* value, size_t size) { - table_name_array_.Mutable(index)->assign( +inline void FlushParam::set_collection_name_array(int index, const char* value, size_t size) { + collection_name_array_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FlushParam.table_name_array) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FlushParam.collection_name_array) } -inline std::string* FlushParam::add_table_name_array() { - // @@protoc_insertion_point(field_add_mutable:milvus.grpc.FlushParam.table_name_array) - return table_name_array_.Add(); +inline std::string* FlushParam::add_collection_name_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Add(); } -inline void FlushParam::add_table_name_array(const std::string& value) { - table_name_array_.Add()->assign(value); - // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.table_name_array) +inline void FlushParam::add_collection_name_array(const std::string& value) { + collection_name_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::add_table_name_array(std::string&& value) { - table_name_array_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.table_name_array) +inline void FlushParam::add_collection_name_array(std::string&& value) { + collection_name_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::add_table_name_array(const char* value) { +inline void FlushParam::add_collection_name_array(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_array_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:milvus.grpc.FlushParam.table_name_array) + collection_name_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::add_table_name_array(const char* value, size_t size) { - table_name_array_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:milvus.grpc.FlushParam.table_name_array) +inline void FlushParam::add_collection_name_array(const char* value, size_t size) { + collection_name_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.FlushParam.collection_name_array) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -FlushParam::table_name_array() const { - // @@protoc_insertion_point(field_list:milvus.grpc.FlushParam.table_name_array) - return table_name_array_; +FlushParam::collection_name_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -FlushParam::mutable_table_name_array() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FlushParam.table_name_array) - return &table_name_array_; +FlushParam::mutable_collection_name_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FlushParam.collection_name_array) + return &collection_name_array_; } // ------------------------------------------------------------------- // DeleteByIDParam -// string table_name = 1; -inline void DeleteByIDParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void DeleteByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& DeleteByIDParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& DeleteByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.collection_name) + return collection_name_.GetNoArena(); } -inline void DeleteByIDParam::set_table_name(const std::string& value) { +inline void DeleteByIDParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.collection_name) } -inline void DeleteByIDParam::set_table_name(std::string&& value) { +inline void DeleteByIDParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByIDParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByIDParam.collection_name) } -inline void DeleteByIDParam::set_table_name(const char* value) { +inline void DeleteByIDParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.DeleteByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.DeleteByIDParam.collection_name) } -inline void DeleteByIDParam::set_table_name(const char* value, size_t size) { +inline void DeleteByIDParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.DeleteByIDParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.DeleteByIDParam.collection_name) } -inline std::string* DeleteByIDParam::mutable_table_name() { +inline std::string* DeleteByIDParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByIDParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* DeleteByIDParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByIDParam.table_name) +inline std::string* DeleteByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByIDParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void DeleteByIDParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void DeleteByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByIDParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByIDParam.collection_name) } // repeated int64 id_array = 2; @@ -6678,35 +6678,35 @@ PartitionStat::segments_stat() const { // ------------------------------------------------------------------- -// TableInfo +// CollectionInfo // .milvus.grpc.Status status = 1; -inline bool TableInfo::has_status() const { +inline bool CollectionInfo::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableInfo::status() const { +inline const ::milvus::grpc::Status& CollectionInfo::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableInfo.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableInfo::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableInfo.status) +inline ::milvus::grpc::Status* CollectionInfo::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionInfo.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableInfo::mutable_status() { +inline ::milvus::grpc::Status* CollectionInfo::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableInfo.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.status) return status_; } -inline void TableInfo::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionInfo::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -6722,50 +6722,50 @@ inline void TableInfo::set_allocated_status(::milvus::grpc::Status* status) { } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableInfo.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionInfo.status) } // int64 total_row_count = 2; -inline void TableInfo::clear_total_row_count() { +inline void CollectionInfo::clear_total_row_count() { total_row_count_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableInfo::total_row_count() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableInfo.total_row_count) +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionInfo::total_row_count() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.total_row_count) return total_row_count_; } -inline void TableInfo::set_total_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionInfo::set_total_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { total_row_count_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableInfo.total_row_count) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionInfo.total_row_count) } // repeated .milvus.grpc.PartitionStat partitions_stat = 3; -inline int TableInfo::partitions_stat_size() const { +inline int CollectionInfo::partitions_stat_size() const { return partitions_stat_.size(); } -inline void TableInfo::clear_partitions_stat() { +inline void CollectionInfo::clear_partitions_stat() { partitions_stat_.Clear(); } -inline ::milvus::grpc::PartitionStat* TableInfo::mutable_partitions_stat(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableInfo.partitions_stat) +inline ::milvus::grpc::PartitionStat* CollectionInfo::mutable_partitions_stat(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionStat >* -TableInfo::mutable_partitions_stat() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableInfo.partitions_stat) +CollectionInfo::mutable_partitions_stat() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionInfo.partitions_stat) return &partitions_stat_; } -inline const ::milvus::grpc::PartitionStat& TableInfo::partitions_stat(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableInfo.partitions_stat) +inline const ::milvus::grpc::PartitionStat& CollectionInfo::partitions_stat(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_.Get(index); } -inline ::milvus::grpc::PartitionStat* TableInfo::add_partitions_stat() { - // @@protoc_insertion_point(field_add:milvus.grpc.TableInfo.partitions_stat) +inline ::milvus::grpc::PartitionStat* CollectionInfo::add_partitions_stat() { + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_.Add(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionStat >& -TableInfo::partitions_stat() const { - // @@protoc_insertion_point(field_list:milvus.grpc.TableInfo.partitions_stat) +CollectionInfo::partitions_stat() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_; } @@ -6773,55 +6773,55 @@ TableInfo::partitions_stat() const { // VectorIdentity -// string table_name = 1; -inline void VectorIdentity::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void VectorIdentity::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& VectorIdentity::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.VectorIdentity.table_name) - return table_name_.GetNoArena(); +inline const std::string& VectorIdentity::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorIdentity.collection_name) + return collection_name_.GetNoArena(); } -inline void VectorIdentity::set_table_name(const std::string& value) { +inline void VectorIdentity::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.VectorIdentity.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorIdentity.collection_name) } -inline void VectorIdentity::set_table_name(std::string&& value) { +inline void VectorIdentity::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorIdentity.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorIdentity.collection_name) } -inline void VectorIdentity::set_table_name(const char* value) { +inline void VectorIdentity::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorIdentity.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorIdentity.collection_name) } -inline void VectorIdentity::set_table_name(const char* value, size_t size) { +inline void VectorIdentity::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorIdentity.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorIdentity.collection_name) } -inline std::string* VectorIdentity::mutable_table_name() { +inline std::string* VectorIdentity::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorIdentity.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorIdentity.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* VectorIdentity::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.VectorIdentity.table_name) +inline std::string* VectorIdentity::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorIdentity.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void VectorIdentity::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void VectorIdentity::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorIdentity.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorIdentity.collection_name) } // int64 id = 2; @@ -6942,55 +6942,55 @@ inline void VectorData::set_allocated_vector_data(::milvus::grpc::RowRecord* vec // GetVectorIDsParam -// string table_name = 1; -inline void GetVectorIDsParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void GetVectorIDsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& GetVectorIDsParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.GetVectorIDsParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& GetVectorIDsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GetVectorIDsParam.collection_name) + return collection_name_.GetNoArena(); } -inline void GetVectorIDsParam::set_table_name(const std::string& value) { +inline void GetVectorIDsParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.GetVectorIDsParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.GetVectorIDsParam.collection_name) } -inline void GetVectorIDsParam::set_table_name(std::string&& value) { +inline void GetVectorIDsParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.GetVectorIDsParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.GetVectorIDsParam.collection_name) } -inline void GetVectorIDsParam::set_table_name(const char* value) { +inline void GetVectorIDsParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.GetVectorIDsParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.GetVectorIDsParam.collection_name) } -inline void GetVectorIDsParam::set_table_name(const char* value, size_t size) { +inline void GetVectorIDsParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.GetVectorIDsParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.GetVectorIDsParam.collection_name) } -inline std::string* GetVectorIDsParam::mutable_table_name() { +inline std::string* GetVectorIDsParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.GetVectorIDsParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.GetVectorIDsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* GetVectorIDsParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.GetVectorIDsParam.table_name) +inline std::string* GetVectorIDsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.GetVectorIDsParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void GetVectorIDsParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void GetVectorIDsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetVectorIDsParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetVectorIDsParam.collection_name) } // string segment_name = 2; diff --git a/core/src/grpc/gen-status/status.pb.cc b/core/src/grpc/gen-status/status.pb.cc index c36cd18a02..32aedec9d2 100644 --- a/core/src/grpc/gen-status/status.pb.cc +++ b/core/src/grpc/gen-status/status.pb.cc @@ -61,21 +61,21 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = const char descriptor_table_protodef_status_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\014status.proto\022\013milvus.grpc\"D\n\006Status\022*\n" "\nerror_code\030\001 \001(\0162\026.milvus.grpc.ErrorCod" - "e\022\016\n\006reason\030\002 \001(\t*\230\004\n\tErrorCode\022\013\n\007SUCCE" + "e\022\016\n\006reason\030\002 \001(\t*\242\004\n\tErrorCode\022\013\n\007SUCCE" "SS\020\000\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FA" - "ILED\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\024\n\020TABLE_N" - "OT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021ILL" - "EGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020\010" - "\022\026\n\022ILLEGAL_TABLE_NAME\020\t\022\020\n\014ILLEGAL_TOPK" - "\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEGAL_VEC" - "TOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020\r\022\022\n\016F" - "ILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020\n\014CACH" - "E_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER\020\021\022\026\n\022" - "CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DELETE_FO" - "LDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021BUILD_" - "INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027\n\023ILLE" - "GAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY\020\030b\006pr" - "oto3" + "ILED\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\031\n\025COLLECT" + "ION_NOT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025" + "\n\021ILLEGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_T" + "YPE\020\010\022\033\n\027ILLEGAL_COLLECTION_NAME\020\t\022\020\n\014IL" + "LEGAL_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021I" + "LLEGAL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RES" + "ULT\020\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013META_FAILED" + "\020\017\022\020\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_CREATE_FO" + "LDER\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT" + "_DELETE_FOLDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024" + "\022\025\n\021BUILD_INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST" + "\020\026\022\027\n\023ILLEGAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_ME" + "MORY\020\030b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_status_2eproto_deps[1] = { }; @@ -85,7 +85,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_sta static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_status_2eproto_once; static bool descriptor_table_status_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto = { - &descriptor_table_status_2eproto_initialized, descriptor_table_protodef_status_2eproto, "status.proto", 644, + &descriptor_table_status_2eproto_initialized, descriptor_table_protodef_status_2eproto, "status.proto", 654, &descriptor_table_status_2eproto_once, descriptor_table_status_2eproto_sccs, descriptor_table_status_2eproto_deps, 1, 0, schemas, file_default_instances, TableStruct_status_2eproto::offsets, file_level_metadata_status_2eproto, 1, file_level_enum_descriptors_status_2eproto, file_level_service_descriptors_status_2eproto, diff --git a/core/src/grpc/gen-status/status.pb.h b/core/src/grpc/gen-status/status.pb.h index 346a61db69..94be8740cc 100644 --- a/core/src/grpc/gen-status/status.pb.h +++ b/core/src/grpc/gen-status/status.pb.h @@ -73,11 +73,11 @@ enum ErrorCode : int { UNEXPECTED_ERROR = 1, CONNECT_FAILED = 2, PERMISSION_DENIED = 3, - TABLE_NOT_EXISTS = 4, + COLLECTION_NOT_EXISTS = 4, ILLEGAL_ARGUMENT = 5, ILLEGAL_DIMENSION = 7, ILLEGAL_INDEX_TYPE = 8, - ILLEGAL_TABLE_NAME = 9, + ILLEGAL_COLLECTION_NAME = 9, ILLEGAL_TOPK = 10, ILLEGAL_ROWRECORD = 11, ILLEGAL_VECTOR_ID = 12, diff --git a/core/src/grpc/milvus.proto b/core/src/grpc/milvus.proto index 7a7393cef9..5e46842a87 100644 --- a/core/src/grpc/milvus.proto +++ b/core/src/grpc/milvus.proto @@ -13,27 +13,27 @@ message KeyValuePair { } /** - * @brief Table name + * @brief Collection name */ -message TableName { - string table_name = 1; +message CollectionName { + string collection_name = 1; } /** - * @brief Table name list + * @brief Collection name list */ -message TableNameList { +message CollectionNameList { Status status = 1; - repeated string table_names = 2; + repeated string collection_names = 2; } /** - * @brief Table schema + * @brief Collection schema * metric_type: 1-L2, 2-IP */ -message TableSchema { +message CollectionSchema { Status status = 1; - string table_name = 2; + string collection_name = 2; int64 dimension = 3; int64 index_file_size = 4; int32 metric_type = 5; @@ -44,7 +44,7 @@ message TableSchema { * @brief Params of partition */ message PartitionParam { - string table_name = 1; + string collection_name = 1; string tag = 2; } @@ -68,7 +68,7 @@ message RowRecord { * @brief Params to be inserted */ message InsertParam { - string table_name = 1; + string collection_name = 1; repeated RowRecord row_record_array = 2; repeated int64 row_id_array = 3; //optional string partition_tag = 4; @@ -87,7 +87,7 @@ message VectorIds { * @brief Params for searching vector */ message SearchParam { - string table_name = 1; + string collection_name = 1; repeated string partition_tag_array = 2; repeated RowRecord query_record_array = 3; int64 topk = 4; @@ -106,7 +106,7 @@ message SearchInFilesParam { * @brief Params for searching vector by ID */ message SearchByIDParam { - string table_name = 1; + string collection_name = 1; repeated string partition_tag_array = 2; int64 id = 3; int64 topk = 4; @@ -140,11 +140,11 @@ message BoolReply { } /** - * @brief Return table row count + * @brief Return collection row count */ -message TableRowCount { +message CollectionRowCount { Status status = 1; - int64 table_row_count = 2; + int64 collection_row_count = 2; } /** @@ -160,7 +160,7 @@ message Command { */ message IndexParam { Status status = 1; - string table_name = 2; + string collection_name = 2; int32 index_type = 3; repeated KeyValuePair extra_params = 4; } @@ -169,14 +169,14 @@ message IndexParam { * @brief Flush params */ message FlushParam { - repeated string table_name_array = 1; + repeated string collection_name_array = 1; } /** * @brief Flush params */ message DeleteByIDParam { - string table_name = 1; + string collection_name = 1; repeated int64 id_array = 2; } @@ -191,7 +191,7 @@ message SegmentStat { } /** - * @brief table statistics + * @brief collection statistics */ message PartitionStat { string tag = 1; @@ -200,9 +200,9 @@ message PartitionStat { } /** - * @brief table information + * @brief collection information */ -message TableInfo { +message CollectionInfo { Status status = 1; int64 total_row_count = 2; repeated PartitionStat partitions_stat = 3; @@ -212,7 +212,7 @@ message TableInfo { * @brief vector identity */ message VectorIdentity { - string table_name = 1; + string collection_name = 1; int64 id = 2; } @@ -228,76 +228,76 @@ message VectorData { * @brief get vector ids from a segment parameters */ message GetVectorIDsParam { - string table_name = 1; + string collection_name = 1; string segment_name = 2; } service MilvusService { /** - * @brief This method is used to create table + * @brief This method is used to create collection * - * @param TableSchema, use to provide table information to be created. + * @param CollectionSchema, use to provide collection information to be created. * * @return Status */ - rpc CreateTable(TableSchema) returns (Status){} + rpc CreateCollection(CollectionSchema) returns (Status){} /** - * @brief This method is used to test table existence. + * @brief This method is used to test collection existence. * - * @param TableName, table name is going to be tested. + * @param CollectionName, collection name is going to be tested. * * @return BoolReply */ - rpc HasTable(TableName) returns (BoolReply) {} + rpc HasCollection(CollectionName) returns (BoolReply) {} /** - * @brief This method is used to get table schema. + * @brief This method is used to get collection schema. * - * @param TableName, target table name. + * @param CollectionName, target collection name. * - * @return TableSchema + * @return CollectionSchema */ - rpc DescribeTable(TableName) returns (TableSchema) {} + rpc DescribeCollection(CollectionName) returns (CollectionSchema) {} /** - * @brief This method is used to get table schema. + * @brief This method is used to get collection schema. * - * @param TableName, target table name. + * @param CollectionName, target collection name. * - * @return TableRowCount + * @return CollectionRowCount */ - rpc CountTable(TableName) returns (TableRowCount) {} + rpc CountCollection(CollectionName) returns (CollectionRowCount) {} /** - * @brief This method is used to list all tables. + * @brief This method is used to list all collections. * * @param Command, dummy parameter. * - * @return TableNameList + * @return CollectionNameList */ - rpc ShowTables(Command) returns (TableNameList) {} + rpc ShowCollections(Command) returns (CollectionNameList) {} /** - * @brief This method is used to get table detail information. + * @brief This method is used to get collection detail information. * - * @param TableName, target table name. + * @param CollectionName, target collection name. * - * @return TableInfo + * @return CollectionInfo */ - rpc ShowTableInfo(TableName) returns (TableInfo) {} + rpc ShowCollectionInfo(CollectionName) returns (CollectionInfo) {} /** - * @brief This method is used to delete table. + * @brief This method is used to delete collection. * - * @param TableName, table name is going to be deleted. + * @param CollectionName, collection name is going to be deleted. * - * @return TableNameList + * @return CollectionNameList */ - rpc DropTable(TableName) returns (Status) {} + rpc DropCollection(CollectionName) returns (Status) {} /** - * @brief This method is used to build index by table in sync mode. + * @brief This method is used to build index by collection in sync mode. * * @param IndexParam, index paramters. * @@ -308,20 +308,20 @@ service MilvusService { /** * @brief This method is used to describe index * - * @param TableName, target table name. + * @param CollectionName, target collection name. * * @return IndexParam */ - rpc DescribeIndex(TableName) returns (IndexParam) {} + rpc DescribeIndex(CollectionName) returns (IndexParam) {} /** * @brief This method is used to drop index * - * @param TableName, target table name. + * @param CollectionName, target collection name. * * @return Status */ - rpc DropIndex(TableName) returns (Status) {} + rpc DropIndex(CollectionName) returns (Status) {} /** * @brief This method is used to create partition @@ -335,11 +335,11 @@ service MilvusService { /** * @brief This method is used to show partition information * - * @param TableName, target table name. + * @param CollectionName, target collection name. * * @return PartitionList */ - rpc ShowPartitions(TableName) returns (PartitionList) {} + rpc ShowPartitions(CollectionName) returns (PartitionList) {} /** * @brief This method is used to drop partition @@ -351,7 +351,7 @@ service MilvusService { rpc DropPartition(PartitionParam) returns (Status) {} /** - * @brief This method is used to add vector array to table. + * @brief This method is used to add vector array to collection. * * @param InsertParam, insert parameters. * @@ -371,14 +371,14 @@ service MilvusService { /** * @brief This method is used to get vector ids from a segment * - * @param GetVectorIDsParam, target table and segment + * @param GetVectorIDsParam, target collection and segment * * @return VectorIds */ rpc GetVectorIDs(GetVectorIDsParam) returns (VectorIds) {} /** - * @brief This method is used to query vector in table. + * @brief This method is used to query vector in collection. * * @param SearchParam, search parameters. * @@ -423,13 +423,13 @@ service MilvusService { rpc DeleteByID(DeleteByIDParam) returns (Status) {} /** - * @brief This method is used to preload table + * @brief This method is used to preload collection * - * @param TableName, target table name. + * @param CollectionName, target collection name. * * @return Status */ - rpc PreloadTable(TableName) returns (Status) {} + rpc PreloadCollection(CollectionName) returns (Status) {} /** * @brief This method is used to flush buffer into storage. @@ -441,11 +441,11 @@ service MilvusService { rpc Flush(FlushParam) returns (Status) {} /** - * @brief This method is used to compact table + * @brief This method is used to compact collection * - * @param TableName, target table name. + * @param CollectionName, target collection name. * * @return Status */ - rpc Compact(TableName) returns (Status) {} + rpc Compact(CollectionName) returns (Status) {} } diff --git a/core/src/grpc/status.proto b/core/src/grpc/status.proto index 3b6105bf89..a4f018a5fc 100644 --- a/core/src/grpc/status.proto +++ b/core/src/grpc/status.proto @@ -7,11 +7,11 @@ enum ErrorCode { UNEXPECTED_ERROR = 1; CONNECT_FAILED = 2; PERMISSION_DENIED = 3; - TABLE_NOT_EXISTS = 4; + COLLECTION_NOT_EXISTS = 4; ILLEGAL_ARGUMENT = 5; ILLEGAL_DIMENSION = 7; ILLEGAL_INDEX_TYPE = 8; - ILLEGAL_TABLE_NAME = 9; + ILLEGAL_COLLECTION_NAME = 9; ILLEGAL_TOPK = 10; ILLEGAL_ROWRECORD = 11; ILLEGAL_VECTOR_ID = 12; diff --git a/core/src/scheduler/job/DeleteJob.cpp b/core/src/scheduler/job/DeleteJob.cpp index a519af40c1..dd0b883123 100644 --- a/core/src/scheduler/job/DeleteJob.cpp +++ b/core/src/scheduler/job/DeleteJob.cpp @@ -27,7 +27,7 @@ void DeleteJob::WaitAndDelete() { std::unique_lock lock(mutex_); cv_.wait(lock, [&] { return done_resource == num_resource_; }); - meta_ptr_->DeleteTableFiles(collection_id_); + meta_ptr_->DeleteCollectionFiles(collection_id_); } void diff --git a/core/src/server/delivery/request/BaseRequest.cpp b/core/src/server/delivery/request/BaseRequest.cpp index f3ae37967b..ade8e6488c 100644 --- a/core/src/server/delivery/request/BaseRequest.cpp +++ b/core/src/server/delivery/request/BaseRequest.cpp @@ -130,7 +130,7 @@ BaseRequest::set_status(const Status& status) { } std::string -BaseRequest::TableNotExistMsg(const std::string& collection_name) { +BaseRequest::CollectionNotExistMsg(const std::string& collection_name) { return "Collection " + collection_name + " does not exist. Use milvus.has_collection to verify whether the collection exists. " "You also can check whether the collection name exists."; diff --git a/core/src/server/delivery/request/BaseRequest.h b/core/src/server/delivery/request/BaseRequest.h index b36042fd2e..98d1ca86b3 100644 --- a/core/src/server/delivery/request/BaseRequest.h +++ b/core/src/server/delivery/request/BaseRequest.h @@ -209,7 +209,7 @@ class BaseRequest { OnPostExecute(); std::string - TableNotExistMsg(const std::string& collection_name); + CollectionNotExistMsg(const std::string& collection_name); protected: const std::shared_ptr context_; diff --git a/core/src/server/delivery/request/CompactRequest.cpp b/core/src/server/delivery/request/CompactRequest.cpp index 68eb097a50..e6e29be6f5 100644 --- a/core/src/server/delivery/request/CompactRequest.cpp +++ b/core/src/server/delivery/request/CompactRequest.cpp @@ -49,18 +49,18 @@ CompactRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/CountCollectionRequest.cpp b/core/src/server/delivery/request/CountCollectionRequest.cpp index 0d3a363403..f8288d18f7 100644 --- a/core/src/server/delivery/request/CountCollectionRequest.cpp +++ b/core/src/server/delivery/request/CountCollectionRequest.cpp @@ -46,18 +46,18 @@ CountCollectionRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } @@ -71,7 +71,7 @@ CountCollectionRequest::OnExecute() { fiu_do_on("CountCollectionRequest.OnExecute.throw_std_exception", throw std::exception()); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } diff --git a/core/src/server/delivery/request/CreateCollectionRequest.cpp b/core/src/server/delivery/request/CreateCollectionRequest.cpp index 3e7afce84a..d138f7979a 100644 --- a/core/src/server/delivery/request/CreateCollectionRequest.cpp +++ b/core/src/server/delivery/request/CreateCollectionRequest.cpp @@ -93,13 +93,13 @@ CreateCollectionRequest::OnExecute() { // step 3: create collection status = DBWrapper::DB()->CreateCollection(collection_info); fiu_do_on("CreateCollectionRequest.OnExecute.db_already_exist", status = Status(milvus::DB_ALREADY_EXIST, "")); - fiu_do_on("CreateCollectionRequest.OnExecute.create_table_fail", + fiu_do_on("CreateCollectionRequest.OnExecute.create_collection_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); fiu_do_on("CreateCollectionRequest.OnExecute.throw_std_exception", throw std::exception()); if (!status.ok()) { // collection could exist if (status.code() == DB_ALREADY_EXIST) { - return Status(SERVER_INVALID_TABLE_NAME, status.message()); + return Status(SERVER_INVALID_COLLECTION_NAME, status.message()); } return status; } diff --git a/core/src/server/delivery/request/CreateIndexRequest.cpp b/core/src/server/delivery/request/CreateIndexRequest.cpp index eb0167612c..930bc6495b 100644 --- a/core/src/server/delivery/request/CreateIndexRequest.cpp +++ b/core/src/server/delivery/request/CreateIndexRequest.cpp @@ -52,21 +52,21 @@ CreateIndexRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); fiu_do_on("CreateIndexRequest.OnExecute.not_has_collection", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); fiu_do_on("CreateIndexRequest.OnExecute.throw_std.exception", throw std::exception()); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } @@ -75,7 +75,7 @@ CreateIndexRequest::OnExecute() { return status; } - status = ValidationUtil::ValidateIndexParams(json_params_, table_schema, index_type_); + status = ValidationUtil::ValidateIndexParams(json_params_, collection_schema, index_type_); if (!status.ok()) { return status; } diff --git a/core/src/server/delivery/request/CreatePartitionRequest.cpp b/core/src/server/delivery/request/CreatePartitionRequest.cpp index 7254b4b0d8..048440a31d 100644 --- a/core/src/server/delivery/request/CreatePartitionRequest.cpp +++ b/core/src/server/delivery/request/CreatePartitionRequest.cpp @@ -41,7 +41,7 @@ CreatePartitionRequest::OnExecute() { try { // step 1: check arguments auto status = ValidationUtil::ValidateCollectionName(collection_name_); - fiu_do_on("CreatePartitionRequest.OnExecute.invalid_table_name", + fiu_do_on("CreatePartitionRequest.OnExecute.invalid_collection_name", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { return status; @@ -59,20 +59,20 @@ CreatePartitionRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); fiu_do_on("CreatePartitionRequest.OnExecute.invalid_partition_tags", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } @@ -87,7 +87,7 @@ CreatePartitionRequest::OnExecute() { if (!status.ok()) { // partition could exist if (status.code() == DB_ALREADY_EXIST) { - return Status(SERVER_INVALID_TABLE_NAME, status.message()); + return Status(SERVER_INVALID_COLLECTION_NAME, status.message()); } return status; } diff --git a/core/src/server/delivery/request/DeleteByIDRequest.cpp b/core/src/server/delivery/request/DeleteByIDRequest.cpp index 49324bd433..9bc3399a56 100644 --- a/core/src/server/delivery/request/DeleteByIDRequest.cpp +++ b/core/src/server/delivery/request/DeleteByIDRequest.cpp @@ -52,26 +52,26 @@ DeleteByIDRequest::OnExecute() { } // step 2: check collection existence - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } // Check collection's index type supports delete - if (table_schema.engine_type_ == (int32_t)engine::EngineType::SPTAG_BKT || - table_schema.engine_type_ == (int32_t)engine::EngineType::SPTAG_KDT) { + if (collection_schema.engine_type_ == (int32_t)engine::EngineType::SPTAG_BKT || + collection_schema.engine_type_ == (int32_t)engine::EngineType::SPTAG_KDT) { std::string err_msg = - "Index type " + std::to_string(table_schema.engine_type_) + " does not support delete operation"; + "Index type " + std::to_string(collection_schema.engine_type_) + " does not support delete operation"; SERVER_LOG_ERROR << err_msg; return Status(SERVER_UNSUPPORTED_ERROR, err_msg); } diff --git a/core/src/server/delivery/request/DescribeCollectionRequest.cpp b/core/src/server/delivery/request/DescribeCollectionRequest.cpp index a8896dabc9..0a29a3bcd1 100644 --- a/core/src/server/delivery/request/DescribeCollectionRequest.cpp +++ b/core/src/server/delivery/request/DescribeCollectionRequest.cpp @@ -46,28 +46,28 @@ DescribeCollectionRequest::OnExecute() { // step 2: get collection info // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); - fiu_do_on("DescribeCollectionRequest.OnExecute.describe_table_fail", + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); + fiu_do_on("DescribeCollectionRequest.OnExecute.describe_collection_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); fiu_do_on("DescribeCollectionRequest.OnExecute.throw_std_exception", throw std::exception()); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } - schema_.collection_name_ = table_schema.collection_id_; - schema_.dimension_ = static_cast(table_schema.dimension_); - schema_.index_file_size_ = table_schema.index_file_size_; - schema_.metric_type_ = table_schema.metric_type_; + schema_.collection_name_ = collection_schema.collection_id_; + schema_.dimension_ = static_cast(collection_schema.dimension_); + schema_.index_file_size_ = collection_schema.index_file_size_; + schema_.metric_type_ = collection_schema.metric_type_; } catch (std::exception& ex) { return Status(SERVER_UNEXPECTED_ERROR, ex.what()); } diff --git a/core/src/server/delivery/request/DescribeIndexRequest.cpp b/core/src/server/delivery/request/DescribeIndexRequest.cpp index 639dea0da3..5949d1106c 100644 --- a/core/src/server/delivery/request/DescribeIndexRequest.cpp +++ b/core/src/server/delivery/request/DescribeIndexRequest.cpp @@ -46,18 +46,18 @@ DescribeIndexRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/DropCollectionRequest.cpp b/core/src/server/delivery/request/DropCollectionRequest.cpp index 12474f9b3e..ca32a36085 100644 --- a/core/src/server/delivery/request/DropCollectionRequest.cpp +++ b/core/src/server/delivery/request/DropCollectionRequest.cpp @@ -47,22 +47,22 @@ DropCollectionRequest::OnExecute() { // step 2: check collection existence // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); fiu_do_on("DropCollectionRequest.OnExecute.db_not_found", status = Status(milvus::DB_NOT_FOUND, "")); - fiu_do_on("DropCollectionRequest.OnExecute.describe_table_fail", + fiu_do_on("DropCollectionRequest.OnExecute.describe_collection_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); fiu_do_on("DropCollectionRequest.OnExecute.throw_std_exception", throw std::exception()); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } @@ -70,7 +70,7 @@ DropCollectionRequest::OnExecute() { // step 3: Drop collection status = DBWrapper::DB()->DropCollection(collection_name_); - fiu_do_on("DropCollectionRequest.OnExecute.drop_table_fail", + fiu_do_on("DropCollectionRequest.OnExecute.drop_collection_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { return status; diff --git a/core/src/server/delivery/request/DropIndexRequest.cpp b/core/src/server/delivery/request/DropIndexRequest.cpp index ae2868dfb3..1a0406ef73 100644 --- a/core/src/server/delivery/request/DropIndexRequest.cpp +++ b/core/src/server/delivery/request/DropIndexRequest.cpp @@ -45,19 +45,20 @@ DropIndexRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); - fiu_do_on("DropIndexRequest.OnExecute.table_not_exist", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); + fiu_do_on("DropIndexRequest.OnExecute.collection_not_exist", + status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/DropPartitionRequest.cpp b/core/src/server/delivery/request/DropPartitionRequest.cpp index fab87e61bb..c85f7ca7be 100644 --- a/core/src/server/delivery/request/DropPartitionRequest.cpp +++ b/core/src/server/delivery/request/DropPartitionRequest.cpp @@ -43,7 +43,7 @@ DropPartitionRequest::OnExecute() { // step 1: check collection name auto status = ValidationUtil::ValidateCollectionName(collection_name); - fiu_do_on("DropPartitionRequest.OnExecute.invalid_table_name", + fiu_do_on("DropPartitionRequest.OnExecute.invalid_collection_name", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { return status; @@ -53,7 +53,7 @@ DropPartitionRequest::OnExecute() { if (partition_tag == milvus::engine::DEFAULT_PARTITON_TAG) { std::string msg = "Default partition cannot be dropped."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } status = ValidationUtil::ValidatePartitionTags({partition_tag}); @@ -63,18 +63,18 @@ DropPartitionRequest::OnExecute() { // step 3: check collection // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/FlushRequest.cpp b/core/src/server/delivery/request/FlushRequest.cpp index 5689d47b01..c9d0a0f8c8 100644 --- a/core/src/server/delivery/request/FlushRequest.cpp +++ b/core/src/server/delivery/request/FlushRequest.cpp @@ -39,7 +39,7 @@ FlushRequest::Create(const std::shared_ptr& context, Status FlushRequest::OnExecute() { - std::string hdr = "FlushRequest flush tables: "; + std::string hdr = "FlushRequest flush collections: "; for (auto& name : collection_names_) { hdr += name; hdr += ", "; @@ -51,18 +51,18 @@ FlushRequest::OnExecute() { for (auto& name : collection_names_) { // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = name; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = name; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(name)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(name)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(name)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(name)); } } diff --git a/core/src/server/delivery/request/GetVectorByIDRequest.cpp b/core/src/server/delivery/request/GetVectorByIDRequest.cpp index b43bc01867..6d8934ae13 100644 --- a/core/src/server/delivery/request/GetVectorByIDRequest.cpp +++ b/core/src/server/delivery/request/GetVectorByIDRequest.cpp @@ -60,18 +60,18 @@ GetVectorByIDRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/GetVectorIDsRequest.cpp b/core/src/server/delivery/request/GetVectorIDsRequest.cpp index 3b239a4fd4..298ca4d7be 100644 --- a/core/src/server/delivery/request/GetVectorIDsRequest.cpp +++ b/core/src/server/delivery/request/GetVectorIDsRequest.cpp @@ -55,18 +55,18 @@ GetVectorIDsRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/HasCollectionRequest.cpp b/core/src/server/delivery/request/HasCollectionRequest.cpp index d953b659f2..5e16a4f345 100644 --- a/core/src/server/delivery/request/HasCollectionRequest.cpp +++ b/core/src/server/delivery/request/HasCollectionRequest.cpp @@ -46,16 +46,16 @@ HasCollectionRequest::OnExecute() { return status; } - // step 2: check table existence + // step 2: check collection existence status = DBWrapper::DB()->HasNativeCollection(collection_name_, has_collection_); fiu_do_on("HasCollectionRequest.OnExecute.throw_std_exception", throw std::exception()); // only process root collection, ignore partition collection if (has_collection_) { - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); - if (!table_schema.owner_collection_.empty()) { + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); + if (!collection_schema.owner_collection_.empty()) { has_collection_ = false; } } diff --git a/core/src/server/delivery/request/InsertRequest.cpp b/core/src/server/delivery/request/InsertRequest.cpp index 10e0752146..7dc84bf74f 100644 --- a/core/src/server/delivery/request/InsertRequest.cpp +++ b/core/src/server/delivery/request/InsertRequest.cpp @@ -77,25 +77,26 @@ InsertRequest::OnExecute() { // step 2: check collection existence // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); fiu_do_on("InsertRequest.OnExecute.db_not_found", status = Status(milvus::DB_NOT_FOUND, "")); - fiu_do_on("InsertRequest.OnExecute.describe_table_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + fiu_do_on("InsertRequest.OnExecute.describe_collection_fail", + status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { SERVER_LOG_ERROR << LogOut("[%s][%ld] Collection %s not found", "insert", 0, collection_name_.c_str()); - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { SERVER_LOG_ERROR << LogOut("[%s][%ld] Describe collection %s fail: %s", "insert", 0, collection_name_.c_str(), status.message().c_str()); return status; } } else { - if (!table_schema.owner_collection_.empty()) { + if (!collection_schema.owner_collection_.empty()) { SERVER_LOG_ERROR << LogOut("[%s][%ld] owner collection of %s is empty", "insert", 0, collection_name_.c_str()); - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } @@ -103,18 +104,18 @@ InsertRequest::OnExecute() { // all user provide id, or all internal id bool user_provide_ids = !vectors_data_.id_array_.empty(); fiu_do_on("InsertRequest.OnExecute.illegal_vector_id", user_provide_ids = false; - table_schema.flag_ = engine::meta::FLAG_MASK_HAS_USERID); + collection_schema.flag_ = engine::meta::FLAG_MASK_HAS_USERID); // user already provided id before, all insert action require user id - if ((table_schema.flag_ & engine::meta::FLAG_MASK_HAS_USERID) != 0 && !user_provide_ids) { + if ((collection_schema.flag_ & engine::meta::FLAG_MASK_HAS_USERID) != 0 && !user_provide_ids) { std::string msg = "Entities IDs are user-defined. Please provide IDs for all entities of the collection."; SERVER_LOG_ERROR << LogOut("[%s][%ld] %s", "insert", 0, msg.c_str()); return Status(SERVER_ILLEGAL_VECTOR_ID, msg); } fiu_do_on("InsertRequest.OnExecute.illegal_vector_id2", user_provide_ids = true; - table_schema.flag_ = engine::meta::FLAG_MASK_NO_USERID); + collection_schema.flag_ = engine::meta::FLAG_MASK_NO_USERID); // user didn't provided id before, no need to provide user id - if ((table_schema.flag_ & engine::meta::FLAG_MASK_NO_USERID) != 0 && user_provide_ids) { + if ((collection_schema.flag_ & engine::meta::FLAG_MASK_NO_USERID) != 0 && user_provide_ids) { std::string msg = "Entities IDs are auto-generated. All vectors of this collection must use auto-generated IDs."; return Status(SERVER_ILLEGAL_VECTOR_ID, msg); @@ -128,7 +129,7 @@ InsertRequest::OnExecute() { #endif // step 4: some metric type doesn't support float vectors if (!vectors_data_.float_data_.empty()) { // insert float vectors - if (engine::utils::IsBinaryMetricType(table_schema.metric_type_)) { + if (engine::utils::IsBinaryMetricType(collection_schema.metric_type_)) { std::string msg = "Collection metric type doesn't support float vectors."; SERVER_LOG_ERROR << LogOut("[%s][%ld] %s", "insert", 0, msg.c_str()); return Status(SERVER_INVALID_ROWRECORD_ARRAY, msg); @@ -141,14 +142,14 @@ InsertRequest::OnExecute() { return Status(SERVER_INVALID_ROWRECORD_ARRAY, msg); } - fiu_do_on("InsertRequest.OnExecute.invalid_dim", table_schema.dimension_ = -1); - if (vectors_data_.float_data_.size() / vector_count != table_schema.dimension_) { + fiu_do_on("InsertRequest.OnExecute.invalid_dim", collection_schema.dimension_ = -1); + if (vectors_data_.float_data_.size() / vector_count != collection_schema.dimension_) { std::string msg = "The vector dimension must be equal to the collection dimension."; SERVER_LOG_ERROR << LogOut("[%s][%ld] %s", "insert", 0, msg.c_str()); return Status(SERVER_INVALID_VECTOR_DIMENSION, msg); } } else if (!vectors_data_.binary_data_.empty()) { // insert binary vectors - if (!engine::utils::IsBinaryMetricType(table_schema.metric_type_)) { + if (!engine::utils::IsBinaryMetricType(collection_schema.metric_type_)) { std::string msg = "Collection metric type doesn't support binary vectors."; SERVER_LOG_ERROR << LogOut("[%s][%ld] %s", "insert", 0, msg.c_str()); return Status(SERVER_INVALID_ROWRECORD_ARRAY, msg); @@ -161,7 +162,7 @@ InsertRequest::OnExecute() { return Status(SERVER_INVALID_ROWRECORD_ARRAY, msg); } - if (vectors_data_.binary_data_.size() * 8 / vector_count != table_schema.dimension_) { + if (vectors_data_.binary_data_.size() * 8 / vector_count != collection_schema.dimension_) { std::string msg = "The vector dimension must be equal to the collection dimension."; SERVER_LOG_ERROR << LogOut("[%s][%ld] %s", "insert", 0, msg.c_str()); return Status(SERVER_INVALID_VECTOR_DIMENSION, msg); @@ -189,9 +190,9 @@ InsertRequest::OnExecute() { } // step 6: update collection flag - user_provide_ids ? table_schema.flag_ |= engine::meta::FLAG_MASK_HAS_USERID - : table_schema.flag_ |= engine::meta::FLAG_MASK_NO_USERID; - status = DBWrapper::DB()->UpdateCollectionFlag(collection_name_, table_schema.flag_); + user_provide_ids ? collection_schema.flag_ |= engine::meta::FLAG_MASK_HAS_USERID + : collection_schema.flag_ |= engine::meta::FLAG_MASK_NO_USERID; + status = DBWrapper::DB()->UpdateCollectionFlag(collection_name_, collection_schema.flag_); #ifdef MILVUS_ENABLE_PROFILING ProfilerStop(); diff --git a/core/src/server/delivery/request/PreloadCollectionRequest.cpp b/core/src/server/delivery/request/PreloadCollectionRequest.cpp index 4f4a849cca..ff7fcee6cf 100644 --- a/core/src/server/delivery/request/PreloadCollectionRequest.cpp +++ b/core/src/server/delivery/request/PreloadCollectionRequest.cpp @@ -45,24 +45,24 @@ PreloadCollectionRequest::OnExecute() { } // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } // step 2: check collection existence status = DBWrapper::DB()->PreloadCollection(collection_name_); - fiu_do_on("PreloadCollectionRequest.OnExecute.preload_table_fail", + fiu_do_on("PreloadCollectionRequest.OnExecute.preload_collection_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); fiu_do_on("PreloadCollectionRequest.OnExecute.throw_std_exception", throw std::exception()); if (!status.ok()) { diff --git a/core/src/server/delivery/request/SearchByIDRequest.cpp b/core/src/server/delivery/request/SearchByIDRequest.cpp index 823bb0b1f9..cf1e820016 100644 --- a/core/src/server/delivery/request/SearchByIDRequest.cpp +++ b/core/src/server/delivery/request/SearchByIDRequest.cpp @@ -80,23 +80,23 @@ SearchByIDRequest::OnExecute() { // step 4: check collection existence // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } // step 5: check search parameters - status = ValidationUtil::ValidateSearchParams(extra_params_, table_schema, topk_); + status = ValidationUtil::ValidateSearchParams(extra_params_, collection_schema, topk_); if (!status.ok()) { return status; } @@ -118,13 +118,13 @@ SearchByIDRequest::OnExecute() { #endif // step 7: check collection's index type supports search by id - if (table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IDMAP && - table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_BIN_IDMAP && - table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IVFFLAT && - table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_BIN_IVFFLAT && - table_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IVFSQ8) { - std::string err_msg = - "Index type " + std::to_string(table_schema.engine_type_) + " does not support SearchByID operation"; + if (collection_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IDMAP && + collection_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_BIN_IDMAP && + collection_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IVFFLAT && + collection_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_BIN_IVFFLAT && + collection_schema.engine_type_ != (int32_t)engine::EngineType::FAISS_IVFSQ8) { + std::string err_msg = "Index type " + std::to_string(collection_schema.engine_type_) + + " does not support SearchByID operation"; SERVER_LOG_ERROR << err_msg; return Status(SERVER_UNSUPPORTED_ERROR, err_msg); } diff --git a/core/src/server/delivery/request/SearchCombineRequest.cpp b/core/src/server/delivery/request/SearchCombineRequest.cpp index ce95cf3103..dc8578827c 100644 --- a/core/src/server/delivery/request/SearchCombineRequest.cpp +++ b/core/src/server/delivery/request/SearchCombineRequest.cpp @@ -239,15 +239,15 @@ SearchCombineRequest::OnExecute() { TimeRecorderAuto rc(hdr); - // step 1: check table existence - // only process root table, ignore partition table - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - auto status = DBWrapper::DB()->DescribeCollection(table_schema); + // step 1: check collection existence + // only process root collection, ignore partition collection + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + auto status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - status = Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + status = Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); FreeRequests(status); return status; } else { @@ -255,8 +255,8 @@ SearchCombineRequest::OnExecute() { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - status = Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + status = Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); FreeRequests(status); return status; } @@ -275,7 +275,7 @@ SearchCombineRequest::OnExecute() { continue; } - status = ValidationUtil::ValidateSearchParams(extra_params_, table_schema, request->TopK()); + status = ValidationUtil::ValidateSearchParams(extra_params_, collection_schema, request->TopK()); if (!status.ok()) { // check failed, erase request and let it return error status FreeRequest(request, status); @@ -283,7 +283,7 @@ SearchCombineRequest::OnExecute() { continue; } - status = ValidationUtil::ValidateVectorData(request->VectorsData(), table_schema); + status = ValidationUtil::ValidateVectorData(request->VectorsData(), collection_schema); if (!status.ok()) { // check failed, erase request and let it return error status FreeRequest(request, status); @@ -325,7 +325,7 @@ SearchCombineRequest::OnExecute() { } vectors_data_.vector_count_ = total_count; - uint16_t dimension = table_schema.dimension_; + uint16_t dimension = collection_schema.dimension_; bool is_float = true; if (!first_request->VectorsData().float_data_.empty()) { vectors_data_.float_data_.resize(total_count * dimension); diff --git a/core/src/server/delivery/request/SearchRequest.cpp b/core/src/server/delivery/request/SearchRequest.cpp index 8930db8964..bf3f4c3462 100644 --- a/core/src/server/delivery/request/SearchRequest.cpp +++ b/core/src/server/delivery/request/SearchRequest.cpp @@ -59,7 +59,7 @@ SearchRequest::OnPreExecute() { TimeRecorderAuto rc(LogOut("[%s][%ld] %s", "search", 0, hdr.c_str())); milvus::server::ContextChild tracer_pre(context_, "Pre Query"); - // step 1: check table name + // step 1: check collection name auto status = ValidationUtil::ValidateCollectionName(collection_name_); if (!status.ok()) { SERVER_LOG_ERROR << LogOut("[%s][%d] %s", "search", 0, status.message().c_str()); @@ -94,17 +94,18 @@ SearchRequest::OnExecute() { ", nq=" + std::to_string(vector_count) + ", k=" + std::to_string(topk_) + ")"; TimeRecorderAuto rc(LogOut("[%s][%d] %s", "search", 0, hdr.c_str())); - // step 4: check table existence - // only process root table, ignore partition table + // step 4: check collection existence + // only process root collection, ignore partition collection collection_schema_.collection_id_ = collection_name_; auto status = DBWrapper::DB()->DescribeCollection(collection_schema_); - fiu_do_on("SearchRequest.OnExecute.describe_table_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); + fiu_do_on("SearchRequest.OnExecute.describe_collection_fail", + status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { SERVER_LOG_ERROR << LogOut("[%s][%d] Collection %s not found: %s", "search", 0, collection_name_.c_str(), status.message().c_str()); - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { SERVER_LOG_ERROR << LogOut("[%s][%d] Error occurred when describing collection %s: %s", "search", 0, collection_name_.c_str(), status.message().c_str()); @@ -112,8 +113,8 @@ SearchRequest::OnExecute() { } } else { if (!collection_schema_.owner_collection_.empty()) { - SERVER_LOG_ERROR << LogOut("[%s][%d] %s", "search", 0, TableNotExistMsg(collection_name_).c_str()); - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + SERVER_LOG_ERROR << LogOut("[%s][%d] %s", "search", 0, CollectionNotExistMsg(collection_name_).c_str()); + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/ShowCollectionInfoRequest.cpp b/core/src/server/delivery/request/ShowCollectionInfoRequest.cpp index c82f882e3e..05bb4a92ae 100644 --- a/core/src/server/delivery/request/ShowCollectionInfoRequest.cpp +++ b/core/src/server/delivery/request/ShowCollectionInfoRequest.cpp @@ -70,18 +70,18 @@ ShowCollectionInfoRequest::OnExecute() { // step 2: check collection existence // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/delivery/request/ShowCollectionsRequest.cpp b/core/src/server/delivery/request/ShowCollectionsRequest.cpp index 3ee088be67..8115e8f7e8 100644 --- a/core/src/server/delivery/request/ShowCollectionsRequest.cpp +++ b/core/src/server/delivery/request/ShowCollectionsRequest.cpp @@ -23,14 +23,14 @@ namespace milvus { namespace server { ShowCollectionsRequest::ShowCollectionsRequest(const std::shared_ptr& context, - std::vector& table_name_list) - : BaseRequest(context, BaseRequest::kShowCollections), table_name_list_(table_name_list) { + std::vector& collection_name_list) + : BaseRequest(context, BaseRequest::kShowCollections), collection_name_list_(collection_name_list) { } BaseRequestPtr ShowCollectionsRequest::Create(const std::shared_ptr& context, - std::vector& table_name_list) { - return std::shared_ptr(new ShowCollectionsRequest(context, table_name_list)); + std::vector& collection_name_list) { + return std::shared_ptr(new ShowCollectionsRequest(context, collection_name_list)); } Status @@ -39,14 +39,14 @@ ShowCollectionsRequest::OnExecute() { std::vector schema_array; auto status = DBWrapper::DB()->AllCollections(schema_array); - fiu_do_on("ShowCollectionsRequest.OnExecute.show_tables_fail", + fiu_do_on("ShowCollectionsRequest.OnExecute.show_collections_fail", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { return status; } for (auto& schema : schema_array) { - table_name_list_.push_back(schema.collection_id_); + collection_name_list_.push_back(schema.collection_id_); } return Status::OK(); } diff --git a/core/src/server/delivery/request/ShowCollectionsRequest.h b/core/src/server/delivery/request/ShowCollectionsRequest.h index 8b65531342..f053d5ac34 100644 --- a/core/src/server/delivery/request/ShowCollectionsRequest.h +++ b/core/src/server/delivery/request/ShowCollectionsRequest.h @@ -23,17 +23,17 @@ namespace server { class ShowCollectionsRequest : public BaseRequest { public: static BaseRequestPtr - Create(const std::shared_ptr& context, std::vector& table_name_list); + Create(const std::shared_ptr& context, std::vector& collection_name_list); protected: ShowCollectionsRequest(const std::shared_ptr& context, - std::vector& table_name_list); + std::vector& collection_name_list); Status OnExecute() override; private: - std::vector& table_name_list_; + std::vector& collection_name_list_; }; } // namespace server diff --git a/core/src/server/delivery/request/ShowPartitionsRequest.cpp b/core/src/server/delivery/request/ShowPartitionsRequest.cpp index 4a3057ecbe..4b82ffeca1 100644 --- a/core/src/server/delivery/request/ShowPartitionsRequest.cpp +++ b/core/src/server/delivery/request/ShowPartitionsRequest.cpp @@ -43,7 +43,7 @@ ShowPartitionsRequest::OnExecute() { // step 1: check collection name auto status = ValidationUtil::ValidateCollectionName(collection_name_); - fiu_do_on("ShowPartitionsRequest.OnExecute.invalid_table_name", + fiu_do_on("ShowPartitionsRequest.OnExecute.invalid_collection_name", status = Status(milvus::SERVER_UNEXPECTED_ERROR, "")); if (!status.ok()) { return status; @@ -51,18 +51,18 @@ ShowPartitionsRequest::OnExecute() { // step 2: check collection existence // only process root collection, ignore partition collection - engine::meta::CollectionSchema table_schema; - table_schema.collection_id_ = collection_name_; - status = DBWrapper::DB()->DescribeCollection(table_schema); + engine::meta::CollectionSchema collection_schema; + collection_schema.collection_id_ = collection_name_; + status = DBWrapper::DB()->DescribeCollection(collection_schema); if (!status.ok()) { if (status.code() == DB_NOT_FOUND) { - return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(collection_name_)); + return Status(SERVER_COLLECTION_NOT_EXIST, CollectionNotExistMsg(collection_name_)); } else { return status; } } else { - if (!table_schema.owner_collection_.empty()) { - return Status(SERVER_INVALID_TABLE_NAME, TableNotExistMsg(collection_name_)); + if (!collection_schema.owner_collection_.empty()) { + return Status(SERVER_INVALID_COLLECTION_NAME, CollectionNotExistMsg(collection_name_)); } } diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.cpp b/core/src/server/grpc_impl/GrpcRequestHandler.cpp index 2650b8fe6b..8d583b5240 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.cpp +++ b/core/src/server/grpc_impl/GrpcRequestHandler.cpp @@ -39,9 +39,9 @@ ErrorMap(ErrorCode code) { {SERVER_CANNOT_CREATE_FILE, ::milvus::grpc::ErrorCode::CANNOT_CREATE_FILE}, {SERVER_CANNOT_DELETE_FOLDER, ::milvus::grpc::ErrorCode::CANNOT_DELETE_FOLDER}, {SERVER_CANNOT_DELETE_FILE, ::milvus::grpc::ErrorCode::CANNOT_DELETE_FILE}, - {SERVER_TABLE_NOT_EXIST, ::milvus::grpc::ErrorCode::TABLE_NOT_EXISTS}, - {SERVER_INVALID_TABLE_NAME, ::milvus::grpc::ErrorCode::ILLEGAL_TABLE_NAME}, - {SERVER_INVALID_TABLE_DIMENSION, ::milvus::grpc::ErrorCode::ILLEGAL_DIMENSION}, + {SERVER_COLLECTION_NOT_EXIST, ::milvus::grpc::ErrorCode::COLLECTION_NOT_EXISTS}, + {SERVER_INVALID_COLLECTION_NAME, ::milvus::grpc::ErrorCode::ILLEGAL_COLLECTION_NAME}, + {SERVER_INVALID_COLLECTION_DIMENSION, ::milvus::grpc::ErrorCode::ILLEGAL_DIMENSION}, {SERVER_INVALID_VECTOR_DIMENSION, ::milvus::grpc::ErrorCode::ILLEGAL_DIMENSION}, {SERVER_INVALID_INDEX_TYPE, ::milvus::grpc::ErrorCode::ILLEGAL_INDEX_TYPE}, @@ -143,7 +143,7 @@ ConstructPartitionStat(const PartitionStat& partition_stat, ::milvus::grpc::Part } void -ConstructTableInfo(const CollectionInfo& collection_info, ::milvus::grpc::TableInfo* response) { +ConstructCollectionInfo(const CollectionInfo& collection_info, ::milvus::grpc::CollectionInfo* response) { if (!response) { return; } @@ -239,12 +239,12 @@ GrpcRequestHandler::random_id() const { //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ::grpc::Status -GrpcRequestHandler::CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, - ::milvus::grpc::Status* response) { +GrpcRequestHandler::CreateCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionSchema* request, + ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); Status status = - request_handler_.CreateCollection(context_map_[context], request->table_name(), request->dimension(), + request_handler_.CreateCollection(context_map_[context], request->collection_name(), request->dimension(), request->index_file_size(), request->metric_type()); SET_RESPONSE(response, status, context); @@ -252,13 +252,13 @@ GrpcRequestHandler::CreateTable(::grpc::ServerContext* context, const ::milvus:: } ::grpc::Status -GrpcRequestHandler::HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::BoolReply* response) { +GrpcRequestHandler::HasCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::BoolReply* response) { CHECK_NULLPTR_RETURN(request); bool has_collection = false; - Status status = request_handler_.HasCollection(context_map_[context], request->table_name(), has_collection); + Status status = request_handler_.HasCollection(context_map_[context], request->collection_name(), has_collection); response->set_bool_reply(has_collection); SET_RESPONSE(response->mutable_status(), status, context); @@ -266,11 +266,11 @@ GrpcRequestHandler::HasTable(::grpc::ServerContext* context, const ::milvus::grp } ::grpc::Status -GrpcRequestHandler::DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::Status* response) { +GrpcRequestHandler::DropCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); - Status status = request_handler_.DropCollection(context_map_[context], request->table_name()); + Status status = request_handler_.DropCollection(context_map_[context], request->collection_name()); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; @@ -289,8 +289,8 @@ GrpcRequestHandler::CreateIndex(::grpc::ServerContext* context, const ::milvus:: } } - Status status = - request_handler_.CreateIndex(context_map_[context], request->table_name(), request->index_type(), json_params); + Status status = request_handler_.CreateIndex(context_map_[context], request->collection_name(), + request->index_type(), json_params); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; @@ -309,7 +309,7 @@ GrpcRequestHandler::Insert(::grpc::ServerContext* context, const ::milvus::grpc: // step 2: insert vectors Status status = - request_handler_.Insert(context_map_[context], request->table_name(), vectors, request->partition_tag()); + request_handler_.Insert(context_map_[context], request->collection_name(), vectors, request->partition_tag()); // step 3: return id array response->mutable_vector_id_array()->Resize(static_cast(vectors.id_array_.size()), 0); @@ -328,7 +328,8 @@ GrpcRequestHandler::GetVectorByID(::grpc::ServerContext* context, const ::milvus std::vector vector_ids = {request->id()}; engine::VectorsData vectors; - Status status = request_handler_.GetVectorByID(context_map_[context], request->table_name(), vector_ids, vectors); + Status status = + request_handler_.GetVectorByID(context_map_[context], request->collection_name(), vector_ids, vectors); if (!vectors.float_data_.empty()) { response->mutable_vector_data()->mutable_float_data()->Resize(vectors.float_data_.size(), 0); @@ -350,8 +351,8 @@ GrpcRequestHandler::GetVectorIDs(::grpc::ServerContext* context, const ::milvus: CHECK_NULLPTR_RETURN(request); std::vector vector_ids; - Status status = request_handler_.GetVectorIDs(context_map_[context], request->table_name(), request->segment_name(), - vector_ids); + Status status = request_handler_.GetVectorIDs(context_map_[context], request->collection_name(), + request->segment_name(), vector_ids); if (!vector_ids.empty()) { response->mutable_vector_id_array()->Resize(vector_ids.size(), -1); @@ -392,7 +393,7 @@ GrpcRequestHandler::Search(::grpc::ServerContext* context, const ::milvus::grpc: std::vector file_ids; TopKQueryResult result; fiu_do_on("GrpcRequestHandler.Search.not_empty_file_ids", file_ids.emplace_back("test_file_id")); - Status status = request_handler_.Search(context_map_[context], request->table_name(), vectors, request->topk(), + Status status = request_handler_.Search(context_map_[context], request->collection_name(), vectors, request->topk(), json_params, partitions, file_ids, result); // step 5: construct and return result @@ -427,7 +428,7 @@ GrpcRequestHandler::SearchByID(::grpc::ServerContext* context, const ::milvus::g // step 3: search vectors TopKQueryResult result; - Status status = request_handler_.SearchByID(context_map_[context], request->table_name(), request->id(), + Status status = request_handler_.SearchByID(context_map_[context], request->collection_name(), request->id(), request->topk(), json_params, partitions, result); // step 4: construct and return result @@ -473,7 +474,7 @@ GrpcRequestHandler::SearchInFiles(::grpc::ServerContext* context, const ::milvus // step 5: search vectors TopKQueryResult result; - Status status = request_handler_.Search(context_map_[context], search_request->table_name(), vectors, + Status status = request_handler_.Search(context_map_[context], search_request->collection_name(), vectors, search_request->topk(), json_params, partitions, file_ids, result); // step 6: construct and return result @@ -485,42 +486,43 @@ GrpcRequestHandler::SearchInFiles(::grpc::ServerContext* context, const ::milvus } ::grpc::Status -GrpcRequestHandler::DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableSchema* response) { +GrpcRequestHandler::DescribeCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionSchema* response) { CHECK_NULLPTR_RETURN(request); - CollectionSchema table_schema; - Status status = request_handler_.DescribeCollection(context_map_[context], request->table_name(), table_schema); - response->set_table_name(table_schema.collection_name_); - response->set_dimension(table_schema.dimension_); - response->set_index_file_size(table_schema.index_file_size_); - response->set_metric_type(table_schema.metric_type_); + CollectionSchema collection_schema; + Status status = + request_handler_.DescribeCollection(context_map_[context], request->collection_name(), collection_schema); + response->set_collection_name(collection_schema.collection_name_); + response->set_dimension(collection_schema.dimension_); + response->set_index_file_size(collection_schema.index_file_size_); + response->set_metric_type(collection_schema.metric_type_); SET_RESPONSE(response->mutable_status(), status, context); return ::grpc::Status::OK; } ::grpc::Status -GrpcRequestHandler::CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableRowCount* response) { +GrpcRequestHandler::CountCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionRowCount* response) { CHECK_NULLPTR_RETURN(request); int64_t row_count = 0; - Status status = request_handler_.CountCollection(context_map_[context], request->table_name(), row_count); - response->set_table_row_count(row_count); + Status status = request_handler_.CountCollection(context_map_[context], request->collection_name(), row_count); + response->set_collection_row_count(row_count); SET_RESPONSE(response->mutable_status(), status, context); return ::grpc::Status::OK; } ::grpc::Status -GrpcRequestHandler::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, - ::milvus::grpc::TableNameList* response) { +GrpcRequestHandler::ShowCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, + ::milvus::grpc::CollectionNameList* response) { CHECK_NULLPTR_RETURN(request); - std::vector tables; - Status status = request_handler_.ShowCollections(context_map_[context], tables); - for (auto& collection : tables) { - response->add_table_names(collection); + std::vector collections; + Status status = request_handler_.ShowCollections(context_map_[context], collections); + for (auto& collection : collections) { + response->add_collection_names(collection); } SET_RESPONSE(response->mutable_status(), status, context); @@ -528,13 +530,14 @@ GrpcRequestHandler::ShowTables(::grpc::ServerContext* context, const ::milvus::g } ::grpc::Status -GrpcRequestHandler::ShowTableInfo(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableInfo* response) { +GrpcRequestHandler::ShowCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionInfo* response) { CHECK_NULLPTR_RETURN(request); CollectionInfo collection_info; - Status status = request_handler_.ShowCollectionInfo(context_map_[context], request->table_name(), collection_info); - ConstructTableInfo(collection_info, response); + Status status = + request_handler_.ShowCollectionInfo(context_map_[context], request->collection_name(), collection_info); + ConstructCollectionInfo(collection_info, response); SET_RESPONSE(response->mutable_status(), status, context); return ::grpc::Status::OK; @@ -565,31 +568,31 @@ GrpcRequestHandler::DeleteByID(::grpc::ServerContext* context, const ::milvus::g } // step 2: delete vector - Status status = request_handler_.DeleteByID(context_map_[context], request->table_name(), vector_ids); + Status status = request_handler_.DeleteByID(context_map_[context], request->collection_name(), vector_ids); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; } ::grpc::Status -GrpcRequestHandler::PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::Status* response) { +GrpcRequestHandler::PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); - Status status = request_handler_.PreloadCollection(context_map_[context], request->table_name()); + Status status = request_handler_.PreloadCollection(context_map_[context], request->collection_name()); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; } ::grpc::Status -GrpcRequestHandler::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, +GrpcRequestHandler::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response) { CHECK_NULLPTR_RETURN(request); IndexParam param; - Status status = request_handler_.DescribeIndex(context_map_[context], request->table_name(), param); - response->set_table_name(param.collection_name_); + Status status = request_handler_.DescribeIndex(context_map_[context], request->collection_name(), param); + response->set_collection_name(param.collection_name_); response->set_index_type(param.index_type_); ::milvus::grpc::KeyValuePair* kv = response->add_extra_params(); kv->set_key(EXTRA_PARAM_KEY); @@ -600,11 +603,11 @@ GrpcRequestHandler::DescribeIndex(::grpc::ServerContext* context, const ::milvus } ::grpc::Status -GrpcRequestHandler::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, +GrpcRequestHandler::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); - Status status = request_handler_.DropIndex(context_map_[context], request->table_name()); + Status status = request_handler_.DropIndex(context_map_[context], request->collection_name()); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; @@ -615,19 +618,19 @@ GrpcRequestHandler::CreatePartition(::grpc::ServerContext* context, const ::milv ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); - Status status = request_handler_.CreatePartition(context_map_[context], request->table_name(), request->tag()); + Status status = request_handler_.CreatePartition(context_map_[context], request->collection_name(), request->tag()); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; } ::grpc::Status -GrpcRequestHandler::ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, +GrpcRequestHandler::ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response) { CHECK_NULLPTR_RETURN(request); std::vector partitions; - Status status = request_handler_.ShowPartitions(context_map_[context], request->table_name(), partitions); + Status status = request_handler_.ShowPartitions(context_map_[context], request->collection_name(), partitions); for (auto& partition : partitions) { response->add_partition_tag_array(partition.tag_); } @@ -642,7 +645,7 @@ GrpcRequestHandler::DropPartition(::grpc::ServerContext* context, const ::milvus ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); - Status status = request_handler_.DropPartition(context_map_[context], request->table_name(), request->tag()); + Status status = request_handler_.DropPartition(context_map_[context], request->collection_name(), request->tag()); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; @@ -654,8 +657,8 @@ GrpcRequestHandler::Flush(::grpc::ServerContext* context, const ::milvus::grpc:: CHECK_NULLPTR_RETURN(request); std::vector collection_names; - for (int32_t i = 0; i < request->table_name_array().size(); i++) { - collection_names.push_back(request->table_name_array(i)); + for (int32_t i = 0; i < request->collection_name_array().size(); i++) { + collection_names.push_back(request->collection_name_array(i)); } Status status = request_handler_.Flush(context_map_[context], collection_names); SET_RESPONSE(response, status, context); @@ -664,11 +667,11 @@ GrpcRequestHandler::Flush(::grpc::ServerContext* context, const ::milvus::grpc:: } ::grpc::Status -GrpcRequestHandler::Compact(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, +GrpcRequestHandler::Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { CHECK_NULLPTR_RETURN(request); - Status status = request_handler_.Compact(context_map_[context], request->table_name()); + Status status = request_handler_.Compact(context_map_[context], request->collection_name()); SET_RESPONSE(response, status, context); return ::grpc::Status::OK; diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.h b/core/src/server/grpc_impl/GrpcRequestHandler.h index 1180fe76fe..5f2781f350 100644 --- a/core/src/server/grpc_impl/GrpcRequestHandler.h +++ b/core/src/server/grpc_impl/GrpcRequestHandler.h @@ -82,12 +82,12 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // * // @brief This method is used to create collection // - // @param TableSchema, use to provide collection information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status ::grpc::Status - CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, - ::milvus::grpc::Status* response) override; + CreateCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionSchema* request, + ::milvus::grpc::Status* response) override; // * // @brief This method is used to test collection existence. // @@ -95,44 +95,44 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return BoolReply ::grpc::Status - HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::BoolReply* response) override; + HasCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::BoolReply* response) override; // * // @brief This method is used to get collection schema. // // @param CollectionName, target collection name. // - // @return TableSchema + // @return CollectionSchema ::grpc::Status - DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableSchema* response) override; + DescribeCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionSchema* response) override; // * // @brief This method is used to get collection schema. // // @param CollectionName, target collection name. // - // @return TableRowCount + // @return CollectionRowCount ::grpc::Status - CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableRowCount* response) override; + CountCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionRowCount* response) override; // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // // @return CollectionNameList ::grpc::Status - ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, - ::milvus::grpc::TableNameList* response) override; + ShowCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, + ::milvus::grpc::CollectionNameList* response) override; // * // @brief This method is used to get collection detail information. // // @param CollectionName, target collection name. // - // @return TableInfo + // @return CollectionInfo ::grpc::Status - ShowTableInfo(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableInfo* response); + ShowCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionInfo* response); // * // @brief This method is used to delete collection. @@ -141,8 +141,8 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return CollectionNameList ::grpc::Status - DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::Status* response) override; + DropCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response) override; // * // @brief This method is used to build index by collection in sync mode. // @@ -159,7 +159,7 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return IndexParam ::grpc::Status - DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, + DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response) override; // * // @brief This method is used to drop index @@ -168,7 +168,7 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return Status ::grpc::Status - DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, + DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) override; // * // @brief This method is used to create partition @@ -186,7 +186,7 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return PartitionList ::grpc::Status - ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, + ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response) override; // * // @brief This method is used to drop partition @@ -281,8 +281,8 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return Status ::grpc::Status - PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, - ::milvus::grpc::Status* response) override; + PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response) override; // * // @brief This method is used to flush buffer into storage. @@ -300,7 +300,8 @@ class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service, // // @return Status ::grpc::Status - Compact(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::Status* response); GrpcRequestHandler& RegisterRequestHandler(const RequestHandler& handler) { diff --git a/core/src/server/web_impl/Types.h b/core/src/server/web_impl/Types.h index 2f3f89d4b1..f8c0d0d6ee 100644 --- a/core/src/server/web_impl/Types.h +++ b/core/src/server/web_impl/Types.h @@ -39,12 +39,12 @@ enum StatusCode : int { UNEXPECTED_ERROR = 1, CONNECT_FAILED = 2, // reserved. PERMISSION_DENIED = 3, - TABLE_NOT_EXISTS = 4, // DB_NOT_FOUND || TABLE_NOT_EXISTS + COLLECTION_NOT_EXISTS = 4, // DB_NOT_FOUND || COLLECTION_NOT_EXISTS ILLEGAL_ARGUMENT = 5, ILLEGAL_RANGE = 6, ILLEGAL_DIMENSION = 7, ILLEGAL_INDEX_TYPE = 8, - ILLEGAL_TABLE_NAME = 9, + ILLEGAL_COLLECTION_NAME = 9, ILLEGAL_TOPK = 10, ILLEGAL_ROWRECORD = 11, ILLEGAL_VECTOR_ID = 12, diff --git a/core/src/server/web_impl/controller/WebController.hpp b/core/src/server/web_impl/controller/WebController.hpp index f326578405..d13f320382 100644 --- a/core/src/server/web_impl/controller/WebController.hpp +++ b/core/src/server/web_impl/controller/WebController.hpp @@ -286,7 +286,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createResponse(Status::CODE_200, response_str); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -314,7 +314,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_204, status_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -349,7 +349,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_201, status_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -379,7 +379,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createResponse(Status::CODE_200, result); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -407,7 +407,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_204, status_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -442,7 +442,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_201, status_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -474,7 +474,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_200, partition_list_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default:response = createDtoResponse(Status::CODE_400, status_dto); @@ -502,7 +502,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_204, status_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -529,7 +529,7 @@ class WebController : public oatpp::web::server::api::ApiController { switch (status_dto->code->getValue()) { case StatusCode::SUCCESS: return createResponse(Status::CODE_200, response); - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: return createDtoResponse(Status::CODE_404, status_dto); default: return createDtoResponse(Status::CODE_400, status_dto); @@ -553,7 +553,7 @@ class WebController : public oatpp::web::server::api::ApiController { switch (status_dto->code->getValue()) { case StatusCode::SUCCESS: return createResponse(Status::CODE_200, response); - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: return createDtoResponse(Status::CODE_404, status_dto); default: return createDtoResponse(Status::CODE_400, status_dto); @@ -580,7 +580,7 @@ class WebController : public oatpp::web::server::api::ApiController { switch (status_dto->code->getValue()) { case StatusCode::SUCCESS: return createResponse(Status::CODE_200, response); - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: return createDtoResponse(Status::CODE_404, status_dto); default: return createDtoResponse(Status::CODE_400, status_dto); @@ -603,7 +603,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createDtoResponse(Status::CODE_201, ids_dto); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: @@ -632,7 +632,7 @@ class WebController : public oatpp::web::server::api::ApiController { case StatusCode::SUCCESS: response = createResponse(Status::CODE_200, result); break; - case StatusCode::TABLE_NOT_EXISTS: + case StatusCode::COLLECTION_NOT_EXISTS: response = createDtoResponse(Status::CODE_404, status_dto); break; default: diff --git a/core/src/server/web_impl/handler/WebRequestHandler.cpp b/core/src/server/web_impl/handler/WebRequestHandler.cpp index a77260b898..27c81b557e 100644 --- a/core/src/server/web_impl/handler/WebRequestHandler.cpp +++ b/core/src/server/web_impl/handler/WebRequestHandler.cpp @@ -45,9 +45,9 @@ WebErrorMap(ErrorCode code) { {SERVER_CANNOT_CREATE_FILE, StatusCode::CANNOT_CREATE_FILE}, {SERVER_CANNOT_DELETE_FOLDER, StatusCode::CANNOT_DELETE_FOLDER}, {SERVER_CANNOT_DELETE_FILE, StatusCode::CANNOT_DELETE_FILE}, - {SERVER_TABLE_NOT_EXIST, StatusCode::TABLE_NOT_EXISTS}, - {SERVER_INVALID_TABLE_NAME, StatusCode::ILLEGAL_TABLE_NAME}, - {SERVER_INVALID_TABLE_DIMENSION, StatusCode::ILLEGAL_DIMENSION}, + {SERVER_COLLECTION_NOT_EXIST, StatusCode::COLLECTION_NOT_EXISTS}, + {SERVER_INVALID_COLLECTION_NAME, StatusCode::ILLEGAL_COLLECTION_NAME}, + {SERVER_INVALID_COLLECTION_DIMENSION, StatusCode::ILLEGAL_DIMENSION}, {SERVER_INVALID_VECTOR_DIMENSION, StatusCode::ILLEGAL_DIMENSION}, {SERVER_INVALID_INDEX_TYPE, StatusCode::ILLEGAL_INDEX_TYPE}, @@ -64,7 +64,7 @@ WebErrorMap(ErrorCode code) { {SERVER_BUILD_INDEX_ERROR, StatusCode::BUILD_INDEX_ERROR}, {SERVER_OUT_OF_MEMORY, StatusCode::OUT_OF_MEMORY}, - {DB_NOT_FOUND, StatusCode::TABLE_NOT_EXISTS}, + {DB_NOT_FOUND, StatusCode::COLLECTION_NOT_EXISTS}, {DB_META_TRANSACTION_FAILED, StatusCode::META_FAILED}, }; if (code < StatusCode::MAX) { diff --git a/core/src/utils/Error.h b/core/src/utils/Error.h index dd493072d2..aaf3612f03 100644 --- a/core/src/utils/Error.h +++ b/core/src/utils/Error.h @@ -64,9 +64,9 @@ constexpr ErrorCode SERVER_CANNOT_DELETE_FOLDER = ToServerErrorCode(10); constexpr ErrorCode SERVER_CANNOT_DELETE_FILE = ToServerErrorCode(11); constexpr ErrorCode SERVER_BUILD_INDEX_ERROR = ToServerErrorCode(12); -constexpr ErrorCode SERVER_TABLE_NOT_EXIST = ToServerErrorCode(100); -constexpr ErrorCode SERVER_INVALID_TABLE_NAME = ToServerErrorCode(101); -constexpr ErrorCode SERVER_INVALID_TABLE_DIMENSION = ToServerErrorCode(102); +constexpr ErrorCode SERVER_COLLECTION_NOT_EXIST = ToServerErrorCode(100); +constexpr ErrorCode SERVER_INVALID_COLLECTION_NAME = ToServerErrorCode(101); +constexpr ErrorCode SERVER_INVALID_COLLECTION_DIMENSION = ToServerErrorCode(102); constexpr ErrorCode SERVER_INVALID_VECTOR_DIMENSION = ToServerErrorCode(104); constexpr ErrorCode SERVER_INVALID_INDEX_TYPE = ToServerErrorCode(105); constexpr ErrorCode SERVER_INVALID_ROWRECORD = ToServerErrorCode(106); @@ -91,7 +91,7 @@ constexpr ErrorCode DB_ALREADY_EXIST = ToDbErrorCode(4); constexpr ErrorCode DB_INVALID_PATH = ToDbErrorCode(5); constexpr ErrorCode DB_INCOMPATIB_META = ToDbErrorCode(6); constexpr ErrorCode DB_INVALID_META_URI = ToDbErrorCode(7); -constexpr ErrorCode DB_EMPTY_TABLE = ToDbErrorCode(8); +constexpr ErrorCode DB_EMPTY_COLLECTION = ToDbErrorCode(8); constexpr ErrorCode DB_BLOOM_FILTER_ERROR = ToDbErrorCode(9); constexpr ErrorCode PARTITION_NOT_FOUND = ToDbErrorCode(10); diff --git a/core/src/utils/ValidationUtil.cpp b/core/src/utils/ValidationUtil.cpp index 6362074ea1..cba9cd988b 100644 --- a/core/src/utils/ValidationUtil.cpp +++ b/core/src/utils/ValidationUtil.cpp @@ -35,8 +35,8 @@ namespace milvus { namespace server { namespace { -constexpr size_t TABLE_NAME_SIZE_LIMIT = 255; -constexpr int64_t TABLE_DIMENSION_LIMIT = 32768; +constexpr size_t COLLECTION_NAME_SIZE_LIMIT = 255; +constexpr int64_t COLLECTION_DIMENSION_LIMIT = 32768; constexpr int32_t INDEX_FILE_SIZE_LIMIT = 4096; // index trigger size max = 4096 MB Status @@ -104,15 +104,15 @@ ValidationUtil::ValidateCollectionName(const std::string& collection_name) { if (collection_name.empty()) { std::string msg = "Collection name should not be empty."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } std::string invalid_msg = "Invalid collection name: " + collection_name + ". "; // Collection name size shouldn't exceed 16384. - if (collection_name.size() > TABLE_NAME_SIZE_LIMIT) { + if (collection_name.size() > COLLECTION_NAME_SIZE_LIMIT) { std::string msg = invalid_msg + "The length of a collection name must be less than 255 characters."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } // Collection name first character should be underscore or character. @@ -120,7 +120,7 @@ ValidationUtil::ValidateCollectionName(const std::string& collection_name) { if (first_char != '_' && std::isalpha(first_char) == 0) { std::string msg = invalid_msg + "The first character of a collection name must be an underscore or letter."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } int64_t table_name_size = collection_name.size(); @@ -129,7 +129,7 @@ ValidationUtil::ValidateCollectionName(const std::string& collection_name) { if (name_char != '_' && std::isalnum(name_char) == 0) { std::string msg = invalid_msg + "Collection name can only contain numbers, letters, and underscores."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } } @@ -138,10 +138,10 @@ ValidationUtil::ValidateCollectionName(const std::string& collection_name) { Status ValidationUtil::ValidateTableDimension(int64_t dimension, int64_t metric_type) { - if (dimension <= 0 || dimension > TABLE_DIMENSION_LIMIT) { + if (dimension <= 0 || dimension > COLLECTION_DIMENSION_LIMIT) { std::string msg = "Invalid collection dimension: " + std::to_string(dimension) + ". " + "The collection dimension must be within the range of 1 ~ " + - std::to_string(TABLE_DIMENSION_LIMIT) + "."; + std::to_string(COLLECTION_DIMENSION_LIMIT) + "."; SERVER_LOG_ERROR << msg; return Status(SERVER_INVALID_VECTOR_DIMENSION, msg); } @@ -216,7 +216,7 @@ ValidationUtil::ValidateIndexParams(const milvus::json& index_params, if (resset.empty()) { std::string msg = "Invalid collection dimension, unable to get reasonable values for 'm'"; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_DIMENSION, msg); + return Status(SERVER_INVALID_COLLECTION_DIMENSION, msg); } auto iter = std::find(std::begin(resset), std::end(resset), m_value); @@ -399,15 +399,15 @@ ValidationUtil::ValidatePartitionName(const std::string& partition_name) { if (partition_name.empty()) { std::string msg = "Partition name should not be empty."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } std::string invalid_msg = "Invalid partition name: " + partition_name + ". "; // Collection name size shouldn't exceed 16384. - if (partition_name.size() > TABLE_NAME_SIZE_LIMIT) { + if (partition_name.size() > COLLECTION_NAME_SIZE_LIMIT) { std::string msg = invalid_msg + "The length of a partition name must be less than 255 characters."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } // Collection name first character should be underscore or character. @@ -415,7 +415,7 @@ ValidationUtil::ValidatePartitionName(const std::string& partition_name) { if (first_char != '_' && std::isalpha(first_char) == 0) { std::string msg = invalid_msg + "The first character of a partition name must be an underscore or letter."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } int64_t table_name_size = partition_name.size(); @@ -424,7 +424,7 @@ ValidationUtil::ValidatePartitionName(const std::string& partition_name) { if (name_char != '_' && std::isalnum(name_char) == 0) { std::string msg = invalid_msg + "Partition name can only contain numbers, letters, and underscores."; SERVER_LOG_ERROR << msg; - return Status(SERVER_INVALID_TABLE_NAME, msg); + return Status(SERVER_INVALID_COLLECTION_NAME, msg); } } diff --git a/core/unittest/db/test_db.cpp b/core/unittest/db/test_db.cpp index 6df47f5b9e..4251930456 100644 --- a/core/unittest/db/test_db.cpp +++ b/core/unittest/db/test_db.cpp @@ -30,18 +30,18 @@ namespace { -static const char* TABLE_NAME = "test_group"; -static constexpr int64_t TABLE_DIM = 256; +static const char* COLLECTION_NAME = "test_group"; +static constexpr int64_t COLLECTION_DIM = 256; static constexpr int64_t VECTOR_COUNT = 25000; static constexpr int64_t INSERT_LOOP = 1000; static constexpr int64_t SECONDS_EACH_HOUR = 3600; static constexpr int64_t DAY_SECONDS = 24 * 60 * 60; milvus::engine::meta::CollectionSchema -BuildTableSchema() { +BuildCollectionSchema() { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = TABLE_NAME; + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = COLLECTION_NAME; return collection_info; } @@ -49,11 +49,11 @@ void BuildVectors(uint64_t n, uint64_t batch_index, milvus::engine::VectorsData& vectors) { vectors.vector_count_ = n; vectors.float_data_.clear(); - vectors.float_data_.resize(n * TABLE_DIM); + vectors.float_data_.resize(n * COLLECTION_DIM); float* data = vectors.float_data_.data(); for (uint64_t i = 0; i < n; i++) { - for (int64_t j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); - data[TABLE_DIM * i] += i / 2000.; + for (int64_t j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); + data[COLLECTION_DIM * i] += i / 2000.; vectors.id_array_.push_back(n * batch_index + i); } @@ -163,14 +163,14 @@ TEST_F(DBTest, CONFIG_TEST) { } TEST_F(DBTest, DB_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); uint64_t qb = 5; milvus::engine::VectorsData qxb; @@ -199,7 +199,7 @@ TEST_F(DBTest, DB_TEST) { START_TIMER; std::vector tags; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, qxb, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, qxb, result_ids, result_distances); ss << "Search " << j << " With Size " << count / milvus::engine::M << " M"; STOP_TIMER(ss.str()); @@ -222,14 +222,14 @@ TEST_F(DBTest, DB_TEST) { for (auto i = 0; i < loop; ++i) { if (i == 40) { - db_->InsertVectors(TABLE_NAME, "", qxb); + db_->InsertVectors(COLLECTION_NAME, "", qxb); ASSERT_EQ(qxb.id_array_.size(), qb); } else { uint64_t nb = 50; milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } @@ -242,7 +242,7 @@ TEST_F(DBTest, DB_TEST) { search.join(); uint64_t count; - stat = db_->GetCollectionRowCount(TABLE_NAME, count); + stat = db_->GetCollectionRowCount(COLLECTION_NAME, count); ASSERT_TRUE(stat.ok()); ASSERT_GT(count, 0); @@ -267,14 +267,14 @@ TEST_F(DBTest, SEARCH_TEST) { milvus::server::Config& config = milvus::server::Config::GetInstance(); milvus::Status s = config.LoadConfigFile(config_path); - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); // prepare raw data size_t nb = VECTOR_COUNT; @@ -282,21 +282,21 @@ TEST_F(DBTest, SEARCH_TEST) { size_t k = 5; milvus::engine::VectorsData xb, xq; xb.vector_count_ = nb; - xb.float_data_.resize(nb * TABLE_DIM); + xb.float_data_.resize(nb * COLLECTION_DIM); xq.vector_count_ = nq; - xq.float_data_.resize(nq * TABLE_DIM); + xq.float_data_.resize(nq * COLLECTION_DIM); xb.id_array_.resize(nb); std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution<> dis_xt(-1.0, 1.0); - for (size_t i = 0; i < nb * TABLE_DIM; i++) { + for (size_t i = 0; i < nb * COLLECTION_DIM; i++) { xb.float_data_[i] = dis_xt(gen); if (i < nb) { xb.id_array_[i] = i; } } - for (size_t i = 0; i < nq * TABLE_DIM; i++) { + for (size_t i = 0; i < nq * COLLECTION_DIM; i++) { xq.float_data_[i] = dis_xt(gen); } @@ -307,56 +307,56 @@ TEST_F(DBTest, SEARCH_TEST) { std::vector dis(k * nq); // insert data - stat = db_->InsertVectors(TABLE_NAME, "", xb); + stat = db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_TRUE(stat.ok()); milvus::json json_params = {{"nprobe", 10}}; milvus::engine::CollectionIndex index; index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; index.extra_params_ = {{"nlist", 16384}}; -// db_->CreateIndex(TABLE_NAME, index); // wait until build index finish +// db_->CreateIndex(COLLECTION_NAME, index); // wait until build index finish // // { // std::vector tags; // milvus::engine::ResultIds result_ids; // milvus::engine::ResultDistances result_distances; -// stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); +// stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); // ASSERT_TRUE(stat.ok()); // } // // index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFFLAT; // index.extra_params_ = {{"nlist", 16384}}; -// db_->CreateIndex(TABLE_NAME, index); // wait until build index finish +// db_->CreateIndex(COLLECTION_NAME, index); // wait until build index finish // // { // std::vector tags; // milvus::engine::ResultIds result_ids; // milvus::engine::ResultDistances result_distances; -// stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); +// stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); // ASSERT_TRUE(stat.ok()); // } index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFSQ8; index.extra_params_ = {{"nlist", 16384}}; - db_->CreateIndex(TABLE_NAME, index); // wait until build index finish + db_->CreateIndex(COLLECTION_NAME, index); // wait until build index finish { std::vector tags; milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); } #ifdef MILVUS_GPU_VERSION index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFSQ8H; - db_->CreateIndex(TABLE_NAME, index); // wait until build index finish + db_->CreateIndex(COLLECTION_NAME, index); // wait until build index finish { std::vector tags; milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); } #endif @@ -391,13 +391,13 @@ TEST_F(DBTest, SEARCH_TEST) { std::vector tags; milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); FIU_ENABLE_FIU("SqliteMetaImpl.FilesToSearch.throw_exception"); - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); ASSERT_FALSE(stat.ok()); fiu_disable("SqliteMetaImpl.FilesToSearch.throw_exception"); } @@ -406,7 +406,7 @@ TEST_F(DBTest, SEARCH_TEST) { #ifdef MILVUS_GPU_VERSION // test FAISS_IVFSQ8H optimizer index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFSQ8H; - db_->CreateIndex(TABLE_NAME, index); // wait until build index finish + db_->CreateIndex(COLLECTION_NAME, index); // wait until build index finish std::vector partition_tag; milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_dists; @@ -414,7 +414,7 @@ TEST_F(DBTest, SEARCH_TEST) { { result_ids.clear(); result_dists.clear(); - stat = db_->Query(dummy_context_, TABLE_NAME, partition_tag, k, json_params, xq, result_ids, result_dists); + stat = db_->Query(dummy_context_, COLLECTION_NAME, partition_tag, k, json_params, xq, result_ids, result_dists); ASSERT_TRUE(stat.ok()); } @@ -434,17 +434,17 @@ TEST_F(DBTest, SEARCH_TEST) { #endif } -TEST_F(DBTest, PRELOADTABLE_TEST) { +TEST_F(DBTest, PRELOAD_TEST) { fiu_init(0); - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int loop = 5; for (auto i = 0; i < loop; ++i) { @@ -452,43 +452,43 @@ TEST_F(DBTest, PRELOADTABLE_TEST) { milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } milvus::engine::CollectionIndex index; index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; - db_->CreateIndex(TABLE_NAME, index); // wait until build index finish + db_->CreateIndex(COLLECTION_NAME, index); // wait until build index finish int64_t prev_cache_usage = milvus::cache::CpuCacheMgr::GetInstance()->CacheUsage(); - stat = db_->PreloadCollection(TABLE_NAME); + stat = db_->PreloadCollection(COLLECTION_NAME); ASSERT_TRUE(stat.ok()); int64_t cur_cache_usage = milvus::cache::CpuCacheMgr::GetInstance()->CacheUsage(); ASSERT_TRUE(prev_cache_usage < cur_cache_usage); FIU_ENABLE_FIU("SqliteMetaImpl.FilesToSearch.throw_exception"); - stat = db_->PreloadCollection(TABLE_NAME); + stat = db_->PreloadCollection(COLLECTION_NAME); ASSERT_FALSE(stat.ok()); fiu_disable("SqliteMetaImpl.FilesToSearch.throw_exception"); // create a partition - stat = db_->CreatePartition(TABLE_NAME, "part0", "0"); + stat = db_->CreatePartition(COLLECTION_NAME, "part0", "0"); ASSERT_TRUE(stat.ok()); - stat = db_->PreloadCollection(TABLE_NAME); + stat = db_->PreloadCollection(COLLECTION_NAME); ASSERT_TRUE(stat.ok()); FIU_ENABLE_FIU("DBImpl.PreloadCollection.null_engine"); - stat = db_->PreloadCollection(TABLE_NAME); + stat = db_->PreloadCollection(COLLECTION_NAME); ASSERT_FALSE(stat.ok()); fiu_disable("DBImpl.PreloadCollection.null_engine"); FIU_ENABLE_FIU("DBImpl.PreloadCollection.exceed_cache"); - stat = db_->PreloadCollection(TABLE_NAME); + stat = db_->PreloadCollection(COLLECTION_NAME); ASSERT_FALSE(stat.ok()); fiu_disable("DBImpl.PreloadCollection.exceed_cache"); FIU_ENABLE_FIU("DBImpl.PreloadCollection.engine_throw_exception"); - stat = db_->PreloadCollection(TABLE_NAME); + stat = db_->PreloadCollection(COLLECTION_NAME); ASSERT_FALSE(stat.ok()); fiu_disable("DBImpl.PreloadCollection.engine_throw_exception"); } @@ -496,27 +496,27 @@ TEST_F(DBTest, PRELOADTABLE_TEST) { TEST_F(DBTest, SHUTDOWN_TEST) { db_->Stop(); - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_FALSE(stat.ok()); stat = db_->DescribeCollection(collection_info); ASSERT_FALSE(stat.ok()); - stat = db_->UpdateCollectionFlag(TABLE_NAME, 0); + stat = db_->UpdateCollectionFlag(COLLECTION_NAME, 0); ASSERT_FALSE(stat.ok()); - stat = db_->CreatePartition(TABLE_NAME, "part0", "0"); + stat = db_->CreatePartition(COLLECTION_NAME, "part0", "0"); ASSERT_FALSE(stat.ok()); stat = db_->DropPartition("part0"); ASSERT_FALSE(stat.ok()); - stat = db_->DropPartitionByTag(TABLE_NAME, "0"); + stat = db_->DropPartitionByTag(COLLECTION_NAME, "0"); ASSERT_FALSE(stat.ok()); std::vector partition_schema_array; - stat = db_->ShowPartitions(TABLE_NAME, partition_schema_array); + stat = db_->ShowPartitions(COLLECTION_NAME, partition_schema_array); ASSERT_FALSE(stat.ok()); std::vector collection_infos; @@ -562,7 +562,7 @@ TEST_F(DBTest, SHUTDOWN_TEST) { stat = db_->DescribeIndex(collection_info.collection_id_, index); ASSERT_FALSE(stat.ok()); - stat = db_->DropIndex(TABLE_NAME); + stat = db_->DropIndex(COLLECTION_NAME); ASSERT_FALSE(stat.ok()); std::vector tags; @@ -598,7 +598,7 @@ TEST_F(DBTest, SHUTDOWN_TEST) { TEST_F(DBTest, BACK_TIMER_THREAD_1) { fiu_init(0); - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); milvus::Status stat; // test background timer thread { @@ -607,13 +607,13 @@ TEST_F(DBTest, BACK_TIMER_THREAD_1) { stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); - // insert some vector to create some tablefiles + // insert some vector to create some collection files int loop = 10; for (auto i = 0; i < loop; ++i) { int64_t nb = VECTOR_COUNT; milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } @@ -633,18 +633,18 @@ TEST_F(DBTest, BACK_TIMER_THREAD_1) { TEST_F(DBTest, BACK_TIMER_THREAD_2) { fiu_init(0); milvus::Status stat; - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); - // insert some vector to create some tablefiles + // insert some vector to create some collection files int loop = 10; for (auto i = 0; i < loop; ++i) { int64_t nb = VECTOR_COUNT; milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } @@ -657,18 +657,18 @@ TEST_F(DBTest, BACK_TIMER_THREAD_2) { TEST_F(DBTest, BACK_TIMER_THREAD_3) { fiu_init(0); milvus::Status stat; - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); - // insert some vector to create some tablefiles + // insert some vector to create some collection files int loop = 10; for (auto i = 0; i < loop; ++i) { int64_t nb = VECTOR_COUNT; milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } @@ -682,18 +682,18 @@ TEST_F(DBTest, BACK_TIMER_THREAD_3) { TEST_F(DBTest, BACK_TIMER_THREAD_4) { fiu_init(0); milvus::Status stat; - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); - // insert some vector to create some tablefiles + // insert some vector to create some collection files int loop = 10; for (auto i = 0; i < loop; ++i) { int64_t nb = VECTOR_COUNT; milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } @@ -705,14 +705,14 @@ TEST_F(DBTest, BACK_TIMER_THREAD_4) { } TEST_F(DBTest, INDEX_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); uint64_t nb = VECTOR_COUNT; milvus::engine::VectorsData xb; BuildVectors(nb, 0, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); milvus::engine::CollectionIndex index; @@ -755,14 +755,14 @@ TEST_F(DBTest, INDEX_TEST) { } TEST_F(DBTest, PARTITION_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); // create partition and insert data const int64_t PARTITION_COUNT = 5; const int64_t INSERT_BATCH = 2000; - std::string collection_name = TABLE_NAME; + std::string collection_name = COLLECTION_NAME; for (int64_t i = 0; i < PARTITION_COUNT; i++) { std::string partition_tag = std::to_string(i); std::string partition_name = collection_name + "_" + partition_tag; @@ -790,7 +790,7 @@ TEST_F(DBTest, PARTITION_TEST) { ASSERT_EQ(vector_ids.size(), INSERT_BATCH); // insert data into not existed partition - stat = db_->InsertVectors(TABLE_NAME, "notexist", xb); + stat = db_->InsertVectors(COLLECTION_NAME, "notexist", xb); ASSERT_FALSE(stat.ok()); } @@ -835,17 +835,17 @@ TEST_F(DBTest, PARTITION_TEST) { fiu_disable("DBImpl.WaitCollectionIndexRecursively.not_empty_err_msg"); uint64_t row_count = 0; - stat = db_->GetCollectionRowCount(TABLE_NAME, row_count); + stat = db_->GetCollectionRowCount(COLLECTION_NAME, row_count); ASSERT_TRUE(stat.ok()); ASSERT_EQ(row_count, INSERT_BATCH * PARTITION_COUNT); FIU_ENABLE_FIU("SqliteMetaImpl.Count.throw_exception"); - stat = db_->GetCollectionRowCount(TABLE_NAME, row_count); + stat = db_->GetCollectionRowCount(COLLECTION_NAME, row_count); ASSERT_FALSE(stat.ok()); fiu_disable("SqliteMetaImpl.Count.throw_exception"); FIU_ENABLE_FIU("DBImpl.GetCollectionRowCountRecursively.fail_get_collection_rowcount_for_partition"); - stat = db_->GetCollectionRowCount(TABLE_NAME, row_count); + stat = db_->GetCollectionRowCount(COLLECTION_NAME, row_count); ASSERT_FALSE(stat.ok()); fiu_disable("DBImpl.GetCollectionRowCountRecursively.fail_get_collection_rowcount_for_partition"); } @@ -863,7 +863,7 @@ TEST_F(DBTest, PARTITION_TEST) { milvus::engine::ResultDistances result_distances; milvus::json json_params = {{"nprobe", nprobe}}; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, topk, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, topk, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids.size() / topk, nq); @@ -871,7 +871,7 @@ TEST_F(DBTest, PARTITION_TEST) { tags.clear(); result_ids.clear(); result_distances.clear(); - stat = db_->Query(dummy_context_, TABLE_NAME, tags, topk, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, topk, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids.size() / topk, nq); @@ -879,7 +879,7 @@ TEST_F(DBTest, PARTITION_TEST) { tags.push_back("\\d"); result_ids.clear(); result_distances.clear(); - stat = db_->Query(dummy_context_, TABLE_NAME, tags, topk, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, topk, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids.size() / topk, nq); } @@ -908,15 +908,15 @@ TEST_F(DBTest, PARTITION_TEST) { } TEST_F(DBTest2, ARHIVE_DISK_CHECK) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); - std::vector table_schema_array; - stat = db_->AllCollections(table_schema_array); + std::vector collection_schema_array; + stat = db_->AllCollections(collection_schema_array); ASSERT_TRUE(stat.ok()); bool bfound = false; - for (auto& schema : table_schema_array) { - if (schema.collection_id_ == TABLE_NAME) { + for (auto& schema : collection_schema_array) { + if (schema.collection_id_ == COLLECTION_NAME) { bfound = true; break; } @@ -924,10 +924,10 @@ TEST_F(DBTest2, ARHIVE_DISK_CHECK) { ASSERT_TRUE(bfound); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); uint64_t size; db_->Size(size); @@ -938,7 +938,7 @@ TEST_F(DBTest2, ARHIVE_DISK_CHECK) { milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); std::this_thread::sleep_for(std::chrono::microseconds(1)); } @@ -950,16 +950,16 @@ TEST_F(DBTest2, ARHIVE_DISK_CHECK) { } TEST_F(DBTest2, DELETE_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); bool has_collection = false; - db_->HasCollection(TABLE_NAME, has_collection); + db_->HasCollection(COLLECTION_NAME, has_collection); ASSERT_TRUE(has_collection); uint64_t size; @@ -970,34 +970,34 @@ TEST_F(DBTest2, DELETE_TEST) { BuildVectors(nb, 0, xb); milvus::engine::IDNumbers vector_ids; - stat = db_->InsertVectors(TABLE_NAME, "", xb); + stat = db_->InsertVectors(COLLECTION_NAME, "", xb); milvus::engine::CollectionIndex index; - stat = db_->CreateIndex(TABLE_NAME, index); + stat = db_->CreateIndex(COLLECTION_NAME, index); // create partition, drop collection will drop partition recursively - stat = db_->CreatePartition(TABLE_NAME, "part0", "0"); + stat = db_->CreatePartition(COLLECTION_NAME, "part0", "0"); ASSERT_TRUE(stat.ok()); // fail drop collection fiu_init(0); FIU_ENABLE_FIU("DBImpl.DropCollectionRecursively.failed"); - stat = db_->DropCollection(TABLE_NAME); + stat = db_->DropCollection(COLLECTION_NAME); ASSERT_FALSE(stat.ok()); fiu_disable("DBImpl.DropCollectionRecursively.failed"); - stat = db_->DropCollection(TABLE_NAME); + stat = db_->DropCollection(COLLECTION_NAME); std::this_thread::sleep_for(std::chrono::seconds(2)); ASSERT_TRUE(stat.ok()); - db_->HasCollection(TABLE_NAME, has_collection); + db_->HasCollection(COLLECTION_NAME, has_collection); ASSERT_FALSE(has_collection); } -TEST_F(DBTest2, SHOW_TABLE_INFO_TEST) { - std::string collection_name = TABLE_NAME; - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); - auto stat = db_->CreateCollection(table_schema); +TEST_F(DBTest2, SHOW_COLLECTION_INFO_TEST) { + std::string collection_name = COLLECTION_NAME; + milvus::engine::meta::CollectionSchema collection_schema = BuildCollectionSchema(); + auto stat = db_->CreateCollection(collection_schema); uint64_t nb = VECTOR_COUNT; milvus::engine::VectorsData xb; @@ -1046,7 +1046,7 @@ TEST_F(DBTest2, SHOW_TABLE_INFO_TEST) { } TEST_F(DBTestWAL, DB_INSERT_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); @@ -1075,7 +1075,7 @@ TEST_F(DBTestWAL, DB_INSERT_TEST) { } TEST_F(DBTestWAL, DB_STOP_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); @@ -1107,7 +1107,7 @@ TEST_F(DBTestWAL, DB_STOP_TEST) { } TEST_F(DBTestWALRecovery, RECOVERY_WITH_NO_ERROR) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); @@ -1156,7 +1156,7 @@ TEST_F(DBTestWALRecovery, RECOVERY_WITH_NO_ERROR) { } TEST_F(DBTestWALRecovery_Error, RECOVERY_WITH_INVALID_LOG_FILE) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); @@ -1178,19 +1178,19 @@ TEST_F(DBTestWALRecovery_Error, RECOVERY_WITH_INVALID_LOG_FILE) { ASSERT_ANY_THROW(db_ = milvus::engine::DBFactory::Build(options)); } -TEST_F(DBTest2, FLUSH_NON_EXISTING_TABLE) { - auto status = db_->Flush("non_existing_table"); +TEST_F(DBTest2, FLUSH_NON_EXISTING_COLLECTION) { + auto status = db_->Flush("non_existing"); ASSERT_FALSE(status.ok()); } -TEST_F(DBTest2, GET_VECTOR_NON_EXISTING_TABLE) { +TEST_F(DBTest2, GET_VECTOR_NON_EXISTING_COLLECTION) { milvus::engine::VectorsData vector; - auto status = db_->GetVectorByID("non_existing_table", 0, vector); + auto status = db_->GetVectorByID("non_existing", 0, vector); ASSERT_FALSE(status.ok()); } TEST_F(DBTest2, GET_VECTOR_BY_ID_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); @@ -1209,41 +1209,41 @@ TEST_F(DBTest2, GET_VECTOR_BY_ID_TEST) { db_->Flush(collection_info.collection_id_); milvus::engine::VectorsData vector_data; - stat = db_->GetVectorByID(TABLE_NAME, qxb.id_array_[0], vector_data); + stat = db_->GetVectorByID(COLLECTION_NAME, qxb.id_array_[0], vector_data); ASSERT_TRUE(stat.ok()); ASSERT_EQ(vector_data.vector_count_, 1); - ASSERT_EQ(vector_data.float_data_.size(), TABLE_DIM); + ASSERT_EQ(vector_data.float_data_.size(), COLLECTION_DIM); - for (int64_t i = 0; i < TABLE_DIM; i++) { + for (int64_t i = 0; i < COLLECTION_DIM; i++) { ASSERT_FLOAT_EQ(vector_data.float_data_[i], qxb.float_data_[i]); } } TEST_F(DBTest2, GET_VECTOR_IDS_TEST) { - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); - auto stat = db_->CreateCollection(table_schema); + milvus::engine::meta::CollectionSchema collection_schema = BuildCollectionSchema(); + auto stat = db_->CreateCollection(collection_schema); ASSERT_TRUE(stat.ok()); uint64_t BATCH_COUNT = 1000; milvus::engine::VectorsData vector_1; BuildVectors(BATCH_COUNT, 0, vector_1); - stat = db_->InsertVectors(TABLE_NAME, "", vector_1); + stat = db_->InsertVectors(COLLECTION_NAME, "", vector_1); ASSERT_TRUE(stat.ok()); std::string partition_tag = "part_tag"; - stat = db_->CreatePartition(TABLE_NAME, "", partition_tag); + stat = db_->CreatePartition(COLLECTION_NAME, "", partition_tag); ASSERT_TRUE(stat.ok()); milvus::engine::VectorsData vector_2; BuildVectors(BATCH_COUNT, 1, vector_2); - stat = db_->InsertVectors(TABLE_NAME, partition_tag, vector_2); + stat = db_->InsertVectors(COLLECTION_NAME, partition_tag, vector_2); ASSERT_TRUE(stat.ok()); db_->Flush(); milvus::engine::CollectionInfo collection_info; - stat = db_->GetCollectionInfo(TABLE_NAME, collection_info); + stat = db_->GetCollectionInfo(COLLECTION_NAME, collection_info); ASSERT_TRUE(stat.ok()); ASSERT_EQ(collection_info.partitions_stat_.size(), 2UL); @@ -1251,25 +1251,25 @@ TEST_F(DBTest2, GET_VECTOR_IDS_TEST) { std::string partition_segment = collection_info.partitions_stat_[1].segments_stat_[0].name_; milvus::engine::IDNumbers vector_ids; - stat = db_->GetVectorIDs(TABLE_NAME, default_segment, vector_ids); + stat = db_->GetVectorIDs(COLLECTION_NAME, default_segment, vector_ids); ASSERT_TRUE(stat.ok()); ASSERT_EQ(vector_ids.size(), BATCH_COUNT); - stat = db_->GetVectorIDs(TABLE_NAME, partition_segment, vector_ids); + stat = db_->GetVectorIDs(COLLECTION_NAME, partition_segment, vector_ids); ASSERT_TRUE(stat.ok()); ASSERT_EQ(vector_ids.size(), BATCH_COUNT); milvus::engine::IDNumbers ids_to_delete{0, 100, 999, 1000, 1500, 1888, 1999}; - stat = db_->DeleteVectors(TABLE_NAME, ids_to_delete); + stat = db_->DeleteVectors(COLLECTION_NAME, ids_to_delete); ASSERT_TRUE(stat.ok()); db_->Flush(); - stat = db_->GetVectorIDs(TABLE_NAME, default_segment, vector_ids); + stat = db_->GetVectorIDs(COLLECTION_NAME, default_segment, vector_ids); ASSERT_TRUE(stat.ok()); ASSERT_EQ(vector_ids.size(), BATCH_COUNT - 3); - stat = db_->GetVectorIDs(TABLE_NAME, partition_segment, vector_ids); + stat = db_->GetVectorIDs(COLLECTION_NAME, partition_segment, vector_ids); ASSERT_TRUE(stat.ok()); // ASSERT_EQ(vector_ids.size(), BATCH_COUNT - 4); } @@ -1279,8 +1279,8 @@ TEST_F(DBTest2, INSERT_DUPLICATE_ID) { options.wal_enable_ = false; db_ = milvus::engine::DBFactory::Build(options); - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); - auto stat = db_->CreateCollection(table_schema); + milvus::engine::meta::CollectionSchema collection_schema = BuildCollectionSchema(); + auto stat = db_->CreateCollection(collection_schema); ASSERT_TRUE(stat.ok()); uint64_t size = 20; @@ -1291,16 +1291,16 @@ TEST_F(DBTest2, INSERT_DUPLICATE_ID) { vector.id_array_.emplace_back(0); } - stat = db_->InsertVectors(TABLE_NAME, "", vector); + stat = db_->InsertVectors(COLLECTION_NAME, "", vector); ASSERT_TRUE(stat.ok()); - stat = db_->Flush(TABLE_NAME); + stat = db_->Flush(COLLECTION_NAME); ASSERT_TRUE(stat.ok()); } /* TEST_F(DBTest2, SEARCH_WITH_DIFFERENT_INDEX) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); // collection_info.index_file_size_ = 1 * milvus::engine::M; auto stat = db_->CreateCollection(collection_info); @@ -1310,7 +1310,7 @@ TEST_F(DBTest2, SEARCH_WITH_DIFFERENT_INDEX) { milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); stat = db_->Flush(); ASSERT_TRUE(stat.ok()); } diff --git a/core/unittest/db/test_db_mysql.cpp b/core/unittest/db/test_db_mysql.cpp index cff19ce1b5..32671170d3 100644 --- a/core/unittest/db/test_db_mysql.cpp +++ b/core/unittest/db/test_db_mysql.cpp @@ -24,16 +24,16 @@ namespace { -static const char* TABLE_NAME = "test_group"; -static constexpr int64_t TABLE_DIM = 256; +static const char* COLLECTION_NAME = "test_group"; +static constexpr int64_t COLLECTION_DIM = 256; static constexpr int64_t VECTOR_COUNT = 25000; static constexpr int64_t INSERT_LOOP = 1000; milvus::engine::meta::CollectionSchema -BuildTableSchema() { +BuildCollectionSchema() { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = TABLE_NAME; + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = COLLECTION_NAME; collection_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; return collection_info; } @@ -42,11 +42,11 @@ void BuildVectors(uint64_t n, uint64_t batch_index, milvus::engine::VectorsData& vectors) { vectors.vector_count_ = n; vectors.float_data_.clear(); - vectors.float_data_.resize(n * TABLE_DIM); + vectors.float_data_.resize(n * COLLECTION_DIM); float* data = vectors.float_data_.data(); for (uint64_t i = 0; i < n; i++) { - for (int64_t j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); - data[TABLE_DIM * i] += i / 2000.; + for (int64_t j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); + data[COLLECTION_DIM * i] += i / 2000.; vectors.id_array_.push_back(n * batch_index + i); } @@ -55,14 +55,14 @@ BuildVectors(uint64_t n, uint64_t batch_index, milvus::engine::VectorsData& vect } // namespace TEST_F(MySqlDBTest, DB_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); uint64_t qb = 5; milvus::engine::VectorsData qxb; @@ -91,7 +91,7 @@ TEST_F(MySqlDBTest, DB_TEST) { START_TIMER; std::vector tags; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, qxb, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, qxb, result_ids, result_distances); ss << "Search " << j << " With Size " << count / milvus::engine::M << " M"; STOP_TIMER(ss.str()); @@ -114,14 +114,14 @@ TEST_F(MySqlDBTest, DB_TEST) { for (auto i = 0; i < loop; ++i) { if (i == 40) { - db_->InsertVectors(TABLE_NAME, "", qxb); + db_->InsertVectors(COLLECTION_NAME, "", qxb); ASSERT_EQ(qxb.id_array_.size(), qb); } else { uint64_t nb = 50; milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_EQ(xb.id_array_.size(), nb); } @@ -134,20 +134,20 @@ TEST_F(MySqlDBTest, DB_TEST) { search.join(); uint64_t count; - stat = db_->GetCollectionRowCount(TABLE_NAME, count); + stat = db_->GetCollectionRowCount(COLLECTION_NAME, count); ASSERT_TRUE(stat.ok()); ASSERT_GT(count, 0); } TEST_F(MySqlDBTest, SEARCH_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); // prepare raw data size_t nb = VECTOR_COUNT; @@ -155,21 +155,21 @@ TEST_F(MySqlDBTest, SEARCH_TEST) { size_t k = 5; milvus::engine::VectorsData xb, xq; xb.vector_count_ = nb; - xb.float_data_.resize(nb * TABLE_DIM); + xb.float_data_.resize(nb * COLLECTION_DIM); xq.vector_count_ = nq; - xq.float_data_.resize(nq * TABLE_DIM); + xq.float_data_.resize(nq * COLLECTION_DIM); xb.id_array_.resize(nb); std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution<> dis_xt(-1.0, 1.0); - for (size_t i = 0; i < nb * TABLE_DIM; i++) { + for (size_t i = 0; i < nb * COLLECTION_DIM; i++) { xb.float_data_[i] = dis_xt(gen); if (i < nb) { xb.id_array_[i] = i; } } - for (size_t i = 0; i < nq * TABLE_DIM; i++) { + for (size_t i = 0; i < nq * COLLECTION_DIM; i++) { xq.float_data_[i] = dis_xt(gen); } @@ -180,7 +180,7 @@ TEST_F(MySqlDBTest, SEARCH_TEST) { std::vector dis(k * nq); // insert data - stat = db_->InsertVectors(TABLE_NAME, "", xb); + stat = db_->InsertVectors(COLLECTION_NAME, "", xb); ASSERT_TRUE(stat.ok()); // sleep(2); // wait until build index finish @@ -191,12 +191,12 @@ TEST_F(MySqlDBTest, SEARCH_TEST) { milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; milvus::json json_params = {{"nprobe", 10}}; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, k, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, k, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); } TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); std::vector table_schema_array; @@ -204,7 +204,7 @@ TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) { ASSERT_TRUE(stat.ok()); bool bfound = false; for (auto& schema : table_schema_array) { - if (schema.collection_id_ == TABLE_NAME) { + if (schema.collection_id_ == COLLECTION_NAME) { bfound = true; break; } @@ -212,21 +212,21 @@ TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) { ASSERT_TRUE(bfound); fiu_init(0); - FIU_ENABLE_FIU("MySQLMetaImpl.AllTable.null_connection"); + FIU_ENABLE_FIU("MySQLMetaImpl.AllCollection.null_connection"); stat = db_->AllCollections(table_schema_array); ASSERT_FALSE(stat.ok()); - FIU_ENABLE_FIU("MySQLMetaImpl.AllTable.throw_exception"); + FIU_ENABLE_FIU("MySQLMetaImpl.AllCollection.throw_exception"); stat = db_->AllCollections(table_schema_array); ASSERT_FALSE(stat.ok()); - fiu_disable("MySQLMetaImpl.AllTable.null_connection"); - fiu_disable("MySQLMetaImpl.AllTable.throw_exception"); + fiu_disable("MySQLMetaImpl.AllCollection.null_connection"); + fiu_disable("MySQLMetaImpl.AllCollection.throw_exception"); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); milvus::engine::IDNumbers vector_ids; milvus::engine::IDNumbers target_ids; @@ -240,7 +240,7 @@ TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) { for (auto i = 0; i < loop; ++i) { milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); std::this_thread::sleep_for(std::chrono::microseconds(1)); } @@ -263,17 +263,17 @@ TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) { } TEST_F(MySqlDBTest, DELETE_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); // std::cout << stat.ToString() << std::endl; milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = TABLE_NAME; + collection_info_get.collection_id_ = COLLECTION_NAME; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); bool has_collection = false; - db_->HasCollection(TABLE_NAME, has_collection); + db_->HasCollection(COLLECTION_NAME, has_collection); ASSERT_TRUE(has_collection); milvus::engine::IDNumbers vector_ids; @@ -287,32 +287,32 @@ TEST_F(MySqlDBTest, DELETE_TEST) { for (auto i = 0; i < loop; ++i) { milvus::engine::VectorsData xb; BuildVectors(nb, i, xb); - db_->InsertVectors(TABLE_NAME, "", xb); + db_->InsertVectors(COLLECTION_NAME, "", xb); std::this_thread::sleep_for(std::chrono::microseconds(1)); } stat = db_->Flush(); ASSERT_TRUE(stat.ok()); - stat = db_->DropCollection(TABLE_NAME); + stat = db_->DropCollection(COLLECTION_NAME); //// std::cout << "5 sec start" << std::endl; // std::this_thread::sleep_for(std::chrono::seconds(5)); //// std::cout << "5 sec finish" << std::endl; ASSERT_TRUE(stat.ok()); // - db_->HasCollection(TABLE_NAME, has_collection); + db_->HasCollection(COLLECTION_NAME, has_collection); ASSERT_FALSE(has_collection); } TEST_F(MySqlDBTest, PARTITION_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); // create partition and insert data const int64_t PARTITION_COUNT = 5; const int64_t INSERT_BATCH = 2000; - std::string collection_name = TABLE_NAME; + std::string collection_name = COLLECTION_NAME; for (int64_t i = 0; i < PARTITION_COUNT; i++) { std::string partition_tag = std::to_string(i); std::string partition_name = collection_name + "_" + partition_tag; @@ -366,7 +366,7 @@ TEST_F(MySqlDBTest, PARTITION_TEST) { ASSERT_TRUE(stat.ok()); uint64_t row_count = 0; - stat = db_->GetCollectionRowCount(TABLE_NAME, row_count); + stat = db_->GetCollectionRowCount(COLLECTION_NAME, row_count); ASSERT_TRUE(stat.ok()); ASSERT_EQ(row_count, INSERT_BATCH * PARTITION_COUNT); } @@ -383,7 +383,7 @@ TEST_F(MySqlDBTest, PARTITION_TEST) { milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; milvus::json json_params = {{"nprobe", nprobe}}; - stat = db_->Query(dummy_context_, TABLE_NAME, tags, topk, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, topk, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids.size() / topk, nq); @@ -391,7 +391,7 @@ TEST_F(MySqlDBTest, PARTITION_TEST) { tags.clear(); result_ids.clear(); result_distances.clear(); - stat = db_->Query(dummy_context_, TABLE_NAME, tags, topk, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, topk, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids.size() / topk, nq); @@ -399,7 +399,7 @@ TEST_F(MySqlDBTest, PARTITION_TEST) { tags.push_back("\\d"); result_ids.clear(); result_distances.clear(); - stat = db_->Query(dummy_context_, TABLE_NAME, tags, topk, json_params, xq, result_ids, result_distances); + stat = db_->Query(dummy_context_, COLLECTION_NAME, tags, topk, json_params, xq, result_ids, result_distances); ASSERT_TRUE(stat.ok()); ASSERT_EQ(result_ids.size() / topk, nq); } @@ -459,13 +459,13 @@ TEST_F(MySqlDBTest, PARTITION_TEST) { ASSERT_TRUE(stat.ok()); stat = db_->CreatePartition(collection_name, collection_name + "_1", "1"); - FIU_ENABLE_FIU("MySQLMetaImpl.DeleteTableFiles.null_connection"); + FIU_ENABLE_FIU("MySQLMetaImpl.DeleteCollectionFiles.null_connection"); stat = db_->DropPartition(collection_name + "_1"); - fiu_disable("MySQLMetaImpl.DeleteTableFiles.null_connection"); + fiu_disable("MySQLMetaImpl.DeleteCollectionFiles.null_connection"); - FIU_ENABLE_FIU("MySQLMetaImpl.DeleteTableFiles.throw_exception"); + FIU_ENABLE_FIU("MySQLMetaImpl.DeleteCollectionFiles.throw_exception"); stat = db_->DropPartition(collection_name + "_1"); - fiu_disable("MySQLMetaImpl.DeleteTableFiles.throw_exception"); + fiu_disable("MySQLMetaImpl.DeleteCollectionFiles.throw_exception"); } { diff --git a/core/unittest/db/test_delete.cpp b/core/unittest/db/test_delete.cpp index 8253ef8ffd..dd4368ac2e 100644 --- a/core/unittest/db/test_delete.cpp +++ b/core/unittest/db/test_delete.cpp @@ -31,10 +31,10 @@ namespace { -static constexpr int64_t TABLE_DIM = 256; +static constexpr int64_t COLLECTION_DIM = 256; std::string -GetTableName() { +GetCollectionName() { auto now = std::chrono::system_clock::now(); auto micros = std::chrono::duration_cast(now.time_since_epoch()).count(); static std::string collection_name = std::to_string(micros); @@ -42,10 +42,10 @@ GetTableName() { } milvus::engine::meta::CollectionSchema -BuildTableSchema() { +BuildCollectionSchema() { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = GetTableName(); + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = GetCollectionName(); collection_info.metric_type_ = (int32_t)milvus::engine::MetricType::L2; collection_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; return collection_info; @@ -55,23 +55,23 @@ void BuildVectors(uint64_t n, milvus::engine::VectorsData& vectors) { vectors.vector_count_ = n; vectors.float_data_.clear(); - vectors.float_data_.resize(n * TABLE_DIM); + vectors.float_data_.resize(n * COLLECTION_DIM); float* data = vectors.float_data_.data(); for (int i = 0; i < n; i++) { - for (int j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); + for (int j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); } } } // namespace TEST_F(DeleteTest, delete_in_mem) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -94,8 +94,8 @@ TEST_F(DeleteTest, delete_in_mem) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -133,14 +133,14 @@ TEST_F(DeleteTest, delete_in_mem) { } TEST_F(DeleteTest, delete_on_disk) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -163,8 +163,8 @@ TEST_F(DeleteTest, delete_on_disk) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -202,14 +202,14 @@ TEST_F(DeleteTest, delete_on_disk) { } TEST_F(DeleteTest, delete_multiple_times) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -232,8 +232,8 @@ TEST_F(DeleteTest, delete_multiple_times) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -265,7 +265,7 @@ TEST_F(DeleteTest, delete_multiple_times) { } TEST_F(DeleteTest, delete_before_create_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); collection_info.engine_type_ = (int32_t)milvus::engine::EngineType::FAISS_IVFFLAT; auto stat = db_->CreateCollection(collection_info); @@ -273,7 +273,7 @@ TEST_F(DeleteTest, delete_before_create_index) { collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 10000; milvus::engine::VectorsData xb; @@ -299,8 +299,8 @@ TEST_F(DeleteTest, delete_before_create_index) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -341,7 +341,7 @@ TEST_F(DeleteTest, delete_before_create_index) { } TEST_F(DeleteTest, delete_with_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); collection_info.engine_type_ = (int32_t)milvus::engine::EngineType::FAISS_IVFFLAT; auto stat = db_->CreateCollection(collection_info); @@ -349,7 +349,7 @@ TEST_F(DeleteTest, delete_with_index) { collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 10000; milvus::engine::VectorsData xb; @@ -372,8 +372,8 @@ TEST_F(DeleteTest, delete_with_index) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -418,14 +418,14 @@ TEST_F(DeleteTest, delete_with_index) { } TEST_F(DeleteTest, delete_multiple_times_with_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -448,8 +448,8 @@ TEST_F(DeleteTest, delete_multiple_times_with_index) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -496,14 +496,14 @@ TEST_F(DeleteTest, delete_multiple_times_with_index) { } TEST_F(DeleteTest, delete_single_vector) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 1; milvus::engine::VectorsData xb; @@ -543,14 +543,14 @@ TEST_F(DeleteTest, delete_single_vector) { } TEST_F(DeleteTest, delete_add_create_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 3000; milvus::engine::VectorsData xb; @@ -595,7 +595,7 @@ TEST_F(DeleteTest, delete_add_create_index) { milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; milvus::engine::VectorsData qb = xb; - qb.float_data_.resize(TABLE_DIM); + qb.float_data_.resize(COLLECTION_DIM); qb.vector_count_ = 1; qb.id_array_.clear(); stat = db_->Query(dummy_context_, @@ -613,14 +613,14 @@ TEST_F(DeleteTest, delete_add_create_index) { } TEST_F(DeleteTest, delete_add_auto_flush) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 3000; milvus::engine::VectorsData xb; @@ -667,7 +667,7 @@ TEST_F(DeleteTest, delete_add_auto_flush) { milvus::engine::ResultIds result_ids; milvus::engine::ResultDistances result_distances; milvus::engine::VectorsData qb = xb; - qb.float_data_.resize(TABLE_DIM); + qb.float_data_.resize(COLLECTION_DIM); qb.vector_count_ = 1; qb.id_array_.clear(); stat = db_->Query(dummy_context_, @@ -686,14 +686,14 @@ TEST_F(DeleteTest, delete_add_auto_flush) { } TEST_F(CompactTest, compact_basic) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100; milvus::engine::VectorsData xb; @@ -739,7 +739,7 @@ TEST_F(CompactTest, compact_basic) { } TEST_F(CompactTest, compact_with_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); collection_info.index_file_size_ = milvus::engine::ONE_KB; collection_info.engine_type_ = (int32_t)milvus::engine::EngineType::FAISS_IVFSQ8; auto stat = db_->CreateCollection(collection_info); @@ -748,7 +748,7 @@ TEST_F(CompactTest, compact_with_index) { collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 3000; milvus::engine::VectorsData xb; @@ -772,8 +772,8 @@ TEST_F(CompactTest, compact_with_index) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } diff --git a/core/unittest/db/test_mem.cpp b/core/unittest/db/test_mem.cpp index eaa9718585..2e81d80e3d 100644 --- a/core/unittest/db/test_mem.cpp +++ b/core/unittest/db/test_mem.cpp @@ -33,10 +33,10 @@ namespace { -static constexpr int64_t TABLE_DIM = 256; +static constexpr int64_t COLLECTION_DIM = 256; std::string -GetTableName() { +GetCollectionName() { auto now = std::chrono::system_clock::now(); auto micros = std::chrono::duration_cast(now.time_since_epoch()).count(); static std::string collection_name = std::to_string(micros); @@ -44,10 +44,10 @@ GetTableName() { } milvus::engine::meta::CollectionSchema -BuildTableSchema() { +BuildCollectionSchema() { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = GetTableName(); + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = GetCollectionName(); collection_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP; return collection_info; } @@ -56,21 +56,21 @@ void BuildVectors(uint64_t n, milvus::engine::VectorsData& vectors) { vectors.vector_count_ = n; vectors.float_data_.clear(); - vectors.float_data_.resize(n * TABLE_DIM); + vectors.float_data_.resize(n * COLLECTION_DIM); float* data = vectors.float_data_.data(); for (int i = 0; i < n; i++) { - for (int j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); + for (int j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); } } } // namespace TEST_F(MemManagerTest, VECTOR_SOURCE_TEST) { - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); + milvus::engine::meta::CollectionSchema table_schema = BuildCollectionSchema(); auto status = impl_->CreateCollection(table_schema); ASSERT_TRUE(status.ok()); milvus::engine::meta::SegmentSchema table_file_schema; - table_file_schema.collection_id_ = GetTableName(); + table_file_schema.collection_id_ = GetCollectionName(); status = impl_->CreateCollectionFile(table_file_schema); ASSERT_TRUE(status.ok()); @@ -113,11 +113,11 @@ TEST_F(MemManagerTest, MEM_TABLE_FILE_TEST) { auto options = GetOptions(); fiu_init(0); - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); + milvus::engine::meta::CollectionSchema table_schema = BuildCollectionSchema(); auto status = impl_->CreateCollection(table_schema); ASSERT_TRUE(status.ok()); - milvus::engine::MemTableFile mem_table_file(GetTableName(), impl_, options); + milvus::engine::MemTableFile mem_table_file(GetCollectionName(), impl_, options); int64_t n_100 = 100; milvus::engine::VectorsData vectors_100; @@ -130,7 +130,7 @@ TEST_F(MemManagerTest, MEM_TABLE_FILE_TEST) { // std::cout << mem_table_file.GetCurrentMem() << " " << mem_table_file.GetMemLeft() << std::endl; - size_t singleVectorMem = sizeof(float) * TABLE_DIM; + size_t singleVectorMem = sizeof(float) * COLLECTION_DIM; ASSERT_EQ(mem_table_file.GetCurrentMem(), n_100 * singleVectorMem); int64_t n_max = milvus::engine::MAX_TABLE_FILE_MEM / singleVectorMem; @@ -152,7 +152,7 @@ TEST_F(MemManagerTest, MEM_TABLE_FILE_TEST) { { //test fail create collection file FIU_ENABLE_FIU("SqliteMetaImpl.CreateCollectionFile.throw_exception"); - milvus::engine::MemTableFile mem_table_file_1(GetTableName(), impl_, options); + milvus::engine::MemTableFile mem_table_file_1(GetCollectionName(), impl_, options); fiu_disable("SqliteMetaImpl.CreateCollectionFile.throw_exception"); status = mem_table_file_1.Add(source); @@ -162,7 +162,7 @@ TEST_F(MemManagerTest, MEM_TABLE_FILE_TEST) { { options.insert_cache_immediately_ = true; - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); + milvus::engine::meta::CollectionSchema table_schema = BuildCollectionSchema(); table_schema.collection_id_ = "faiss_pq"; table_schema.engine_type_ = (int)milvus::engine::EngineType::FAISS_PQ; auto status = impl_->CreateCollection(table_schema); @@ -176,7 +176,7 @@ TEST_F(MemManagerTest, MEM_TABLE_FILE_TEST) { TEST_F(MemManagerTest, MEM_TABLE_TEST) { auto options = GetOptions(); - milvus::engine::meta::CollectionSchema table_schema = BuildTableSchema(); + milvus::engine::meta::CollectionSchema table_schema = BuildCollectionSchema(); auto status = impl_->CreateCollection(table_schema); ASSERT_TRUE(status.ok()); @@ -185,7 +185,7 @@ TEST_F(MemManagerTest, MEM_TABLE_TEST) { BuildVectors(n_100, vectors_100); milvus::engine::VectorSourcePtr source_100 = std::make_shared(vectors_100); - milvus::engine::MemTable mem_table(GetTableName(), impl_, options); + milvus::engine::MemTable mem_table(GetCollectionName(), impl_, options); status = mem_table.Add(source_100); ASSERT_TRUE(status.ok()); @@ -193,7 +193,7 @@ TEST_F(MemManagerTest, MEM_TABLE_TEST) { milvus::engine::MemTableFilePtr mem_table_file; mem_table.GetCurrentMemTableFile(mem_table_file); - size_t singleVectorMem = sizeof(float) * TABLE_DIM; + size_t singleVectorMem = sizeof(float) * COLLECTION_DIM; ASSERT_EQ(mem_table_file->GetCurrentMem(), n_100 * singleVectorMem); int64_t n_max = milvus::engine::MAX_TABLE_FILE_MEM / singleVectorMem; @@ -245,14 +245,14 @@ TEST_F(MemManagerTest, MEM_TABLE_TEST) { } TEST_F(MemManagerTest2, SERIAL_INSERT_SEARCH_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = GetTableName(); + collection_info_get.collection_id_ = GetCollectionName(); stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -262,7 +262,7 @@ TEST_F(MemManagerTest2, SERIAL_INSERT_SEARCH_TEST) { xb.id_array_.push_back(i); } - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); ASSERT_TRUE(stat.ok()); // std::this_thread::sleep_for(std::chrono::seconds(3)); // ensure raw data write to disk @@ -279,8 +279,8 @@ TEST_F(MemManagerTest2, SERIAL_INSERT_SEARCH_TEST) { int64_t index = dis(gen); milvus::engine::VectorsData search; search.vector_count_ = 1; - for (int64_t j = 0; j < TABLE_DIM; j++) { - search.float_data_.push_back(xb.float_data_[index * TABLE_DIM + j]); + for (int64_t j = 0; j < COLLECTION_DIM; j++) { + search.float_data_.push_back(xb.float_data_[index * COLLECTION_DIM + j]); } search_vectors.insert(std::make_pair(xb.id_array_[index], search)); } @@ -295,21 +295,28 @@ TEST_F(MemManagerTest2, SERIAL_INSERT_SEARCH_TEST) { milvus::engine::ResultDistances result_distances; stat = - db_->Query(dummy_context_, GetTableName(), tags, topk, json_params, search, result_ids, result_distances); + db_->Query(dummy_context_, + GetCollectionName(), + tags, + topk, + json_params, + search, + result_ids, + result_distances); ASSERT_EQ(result_ids[0], pair.first); ASSERT_LT(result_distances[0], 1e-4); } } TEST_F(MemManagerTest2, INSERT_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = GetTableName(); + collection_info_get.collection_id_ = GetCollectionName(); stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); auto start_time = METRICS_NOW_TIME; @@ -319,7 +326,7 @@ TEST_F(MemManagerTest2, INSERT_TEST) { milvus::engine::VectorsData xb; BuildVectors(nb, xb); milvus::engine::IDNumbers vector_ids; - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); ASSERT_TRUE(stat.ok()); } auto end_time = METRICS_NOW_TIME; @@ -329,18 +336,18 @@ TEST_F(MemManagerTest2, INSERT_TEST) { TEST_F(MemManagerTest2, INSERT_BINARY_TEST) { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = GetTableName(); + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = GetCollectionName(); collection_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_BIN_IDMAP; collection_info.metric_type_ = (int32_t)milvus::engine::MetricType::JACCARD; auto stat = db_->CreateCollection(collection_info); ASSERT_TRUE(stat.ok()); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = GetTableName(); + collection_info_get.collection_id_ = GetCollectionName(); stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int insert_loop = 10; for (int k = 0; k < insert_loop; ++k) { @@ -348,29 +355,30 @@ TEST_F(MemManagerTest2, INSERT_BINARY_TEST) { int64_t nb = 10000; vectors.vector_count_ = nb; vectors.binary_data_.clear(); - vectors.binary_data_.resize(nb * TABLE_DIM); + vectors.binary_data_.resize(nb * COLLECTION_DIM); uint8_t* data = vectors.binary_data_.data(); std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> distribution{0, std::numeric_limits::max()}; for (int i = 0; i < nb; i++) { - for (int j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = distribution(gen); + for (int j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = distribution(gen); } milvus::engine::IDNumbers vector_ids; - stat = db_->InsertVectors(GetTableName(), "", vectors); + stat = db_->InsertVectors(GetCollectionName(), "", vectors); ASSERT_TRUE(stat.ok()); } } -// TEST_F(MemManagerTest2, CONCURRENT_INSERT_SEARCH_TEST) { -// milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + +//TEST_F(MemManagerTest2, CONCURRENT_INSERT_SEARCH_TEST) { +// milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); // auto stat = db_->CreateCollection(collection_info); // // milvus::engine::meta::CollectionSchema collection_info_get; -// collection_info_get.collection_id_ = GetTableName(); +// collection_info_get.collection_id_ = GetCollectionName(); // stat = db_->DescribeCollection(collection_info_get); // ASSERT_TRUE(stat.ok()); -// ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); +// ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); // // int64_t nb = 40960; // milvus::engine::VectorsData xb; @@ -401,7 +409,14 @@ TEST_F(MemManagerTest2, INSERT_BINARY_TEST) { // // std::vector tags; // stat = -// db_->Query(dummy_context_, GetTableName(), tags, k, json_params, qxb, result_ids, result_distances); +// db_->Query(dummy_context_, +// GetCollectionName(), +// tags, +// k, +// json_params, +// qxb, +// result_ids, +// result_distances); // ss << "Search " << j << " With Size " << count / milvus::engine::M << " M"; // STOP_TIMER(ss.str()); // @@ -425,11 +440,11 @@ TEST_F(MemManagerTest2, INSERT_BINARY_TEST) { // for (auto i = 0; i < loop; ++i) { // if (i == 0) { // qxb.id_array_.clear(); -// db_->InsertVectors(GetTableName(), "", qxb); +// db_->InsertVectors(GetCollectionName(), "", qxb); // ASSERT_EQ(qxb.id_array_.size(), qb); // } else { // xb.id_array_.clear(); -// db_->InsertVectors(GetTableName(), "", xb); +// db_->InsertVectors(GetCollectionName(), "", xb); // ASSERT_EQ(xb.id_array_.size(), nb); // } // std::this_thread::sleep_for(std::chrono::microseconds(1)); @@ -439,14 +454,14 @@ TEST_F(MemManagerTest2, INSERT_BINARY_TEST) { //} TEST_F(MemManagerTest2, VECTOR_IDS_TEST) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; - collection_info_get.collection_id_ = GetTableName(); + collection_info_get.collection_id_ = GetCollectionName(); stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -457,7 +472,7 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) { xb.id_array_[i] = i; } - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); ASSERT_EQ(xb.id_array_[0], 0); ASSERT_TRUE(stat.ok()); @@ -468,7 +483,7 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) { for (auto i = 0; i < nb; i++) { xb.id_array_[i] = i + nb; } - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); ASSERT_EQ(xb.id_array_[0], nb); ASSERT_TRUE(stat.ok()); @@ -479,14 +494,14 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) { for (auto i = 0; i < nb; i++) { xb.id_array_[i] = i + nb / 2; } - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); ASSERT_EQ(xb.id_array_[0], nb / 2); ASSERT_TRUE(stat.ok()); nb = 65536; // 128M BuildVectors(nb, xb); xb.id_array_.clear(); - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); ASSERT_TRUE(stat.ok()); nb = 100; @@ -496,7 +511,7 @@ TEST_F(MemManagerTest2, VECTOR_IDS_TEST) { for (auto i = 0; i < nb; i++) { xb.id_array_[i] = i + nb; } - stat = db_->InsertVectors(GetTableName(), "", xb); + stat = db_->InsertVectors(GetCollectionName(), "", xb); for (auto i = 0; i < nb; i++) { ASSERT_EQ(xb.id_array_[i], i + nb); } diff --git a/core/unittest/db/test_meta.cpp b/core/unittest/db/test_meta.cpp index b239067f5c..ca13d62904 100644 --- a/core/unittest/db/test_meta.cpp +++ b/core/unittest/db/test_meta.cpp @@ -24,7 +24,7 @@ #include #include "src/db/OngoingFileChecker.h" -TEST_F(MetaTest, TABLE_TEST) { +TEST_F(MetaTest, COLLECTION_TEST) { auto collection_id = "meta_test_table"; milvus::engine::meta::CollectionSchema collection; @@ -143,22 +143,22 @@ TEST_F(MetaTest, FALID_TEST) { fiu_disable("SqliteMetaImpl.CreateCollectionFile.throw_exception"); } { - FIU_ENABLE_FIU("SqliteMetaImpl.DeleteTableFiles.throw_exception"); - status = impl_->DeleteTableFiles(collection.collection_id_); + FIU_ENABLE_FIU("SqliteMetaImpl.DeleteCollectionFiles.throw_exception"); + status = impl_->DeleteCollectionFiles(collection.collection_id_); ASSERT_FALSE(status.ok()); - fiu_disable("SqliteMetaImpl.DeleteTableFiles.throw_exception"); + fiu_disable("SqliteMetaImpl.DeleteCollectionFiles.throw_exception"); } { milvus::engine::meta::SegmentsSchema schemas; std::vector ids; - status = impl_->GetTableFiles("notexist", ids, schemas); + status = impl_->GetCollectionFiles("notexist", ids, schemas); ASSERT_FALSE(status.ok()); - FIU_ENABLE_FIU("SqliteMetaImpl.GetTableFiles.throw_exception"); - status = impl_->GetTableFiles(collection_id, ids, schemas); + FIU_ENABLE_FIU("SqliteMetaImpl.GetCollectionFiles.throw_exception"); + status = impl_->GetCollectionFiles(collection_id, ids, schemas); ASSERT_FALSE(status.ok()); ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED); - fiu_disable("SqliteMetaImpl.GetTableFiles.throw_exception"); + fiu_disable("SqliteMetaImpl.GetCollectionFiles.throw_exception"); } { FIU_ENABLE_FIU("SqliteMetaImpl.UpdateCollectionFlag.throw_exception"); @@ -278,10 +278,10 @@ TEST_F(MetaTest, FALID_TEST) { impl_->UpdateCollectionFile(file); milvus::engine::meta::SegmentsSchema files; - FIU_ENABLE_FIU("SqliteMetaImpl_FilesToIndex_TableNotFound"); + FIU_ENABLE_FIU("SqliteMetaImpl_FilesToIndex_CollectionNotFound"); status = impl_->FilesToIndex(files); ASSERT_EQ(status.code(), milvus::DB_NOT_FOUND); - fiu_disable("SqliteMetaImpl_FilesToIndex_TableNotFound"); + fiu_disable("SqliteMetaImpl_FilesToIndex_CollectionNotFound"); FIU_ENABLE_FIU("SqliteMetaImpl.FilesToIndex.throw_exception"); status = impl_->FilesToIndex(files); @@ -336,24 +336,24 @@ TEST_F(MetaTest, FALID_TEST) { ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED); fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveFile_FailCommited"); - FIU_ENABLE_FIU("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTable_Failcommited"); + FIU_ENABLE_FIU("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollection_Failcommited"); status = impl_->CleanUpFilesWithTTL(1); ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED); - fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTable_Failcommited"); + fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollection_Failcommited"); - FIU_ENABLE_FIU("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTable_ThrowException"); + FIU_ENABLE_FIU("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollection_ThrowException"); status = impl_->CleanUpFilesWithTTL(1); ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED); - fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTable_ThrowException"); + fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollection_ThrowException"); - FIU_ENABLE_FIU("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTableFolder_ThrowException"); + FIU_ENABLE_FIU("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollectionFolder_ThrowException"); status = impl_->CleanUpFilesWithTTL(1); ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED); - fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveTableFolder_ThrowException"); + fiu_disable("SqliteMetaImpl.CleanUpFilesWithTTL.RemoveCollectionFolder_ThrowException"); } } -TEST_F(MetaTest, TABLE_FILE_TEST) { +TEST_F(MetaTest, COLLECTION_FILE_TEST) { auto collection_id = "meta_test_table"; milvus::engine::meta::CollectionSchema collection; @@ -382,7 +382,7 @@ TEST_F(MetaTest, TABLE_FILE_TEST) { ASSERT_EQ(table_file.file_type_, new_file_type); } -TEST_F(MetaTest, TABLE_FILE_ROW_COUNT_TEST) { +TEST_F(MetaTest, COLLECTION_FILE_ROW_COUNT_TEST) { auto collection_id = "row_count_test_table"; milvus::engine::meta::CollectionSchema collection; @@ -411,7 +411,7 @@ TEST_F(MetaTest, TABLE_FILE_ROW_COUNT_TEST) { std::vector ids = {table_file.id_}; milvus::engine::meta::SegmentsSchema schemas; - status = impl_->GetTableFiles(collection_id, ids, schemas); + status = impl_->GetCollectionFiles(collection_id, ids, schemas); ASSERT_EQ(schemas.size(), 1UL); ASSERT_EQ(table_file.row_count_, schemas[0].row_count_); ASSERT_EQ(table_file.file_id_, schemas[0].file_id_); @@ -471,7 +471,7 @@ TEST_F(MetaTest, ARCHIVE_TEST_DAYS) { int i = 0; milvus::engine::meta::SegmentsSchema files_get; - status = impl.GetTableFiles(table_file.collection_id_, ids, files_get); + status = impl.GetCollectionFiles(table_file.collection_id_, ids, files_get); ASSERT_TRUE(status.ok()); for (auto& file : files_get) { @@ -527,7 +527,7 @@ TEST_F(MetaTest, ARCHIVE_TEST_DISK) { int i = 0; milvus::engine::meta::SegmentsSchema files_get; - status = impl.GetTableFiles(table_file.collection_id_, ids, files_get); + status = impl.GetCollectionFiles(table_file.collection_id_, ids, files_get); ASSERT_TRUE(status.ok()); for (auto& file : files_get) { @@ -540,7 +540,7 @@ TEST_F(MetaTest, ARCHIVE_TEST_DISK) { impl.DropAll(); } -TEST_F(MetaTest, TABLE_FILES_TEST) { +TEST_F(MetaTest, COLLECTION_FILES_TEST) { auto collection_id = "meta_test_group"; milvus::engine::meta::CollectionSchema collection; @@ -656,7 +656,7 @@ TEST_F(MetaTest, TABLE_FILES_TEST) { to_index_files_cnt + index_files_cnt; ASSERT_EQ(table_files.size(), total_cnt); - status = impl_->DeleteTableFiles(collection_id); + status = impl_->DeleteCollectionFiles(collection_id); ASSERT_TRUE(status.ok()); status = impl_->CreateCollectionFile(table_file); @@ -733,7 +733,7 @@ TEST_F(MetaTest, LSN_TEST) { collection.collection_id_ = collection_id; auto status = impl_->CreateCollection(collection); - status = impl_->UpdateTableFlushLSN(collection_id, lsn); + status = impl_->UpdateCollectionFlushLSN(collection_id, lsn); ASSERT_TRUE(status.ok()); uint64_t temp_lsb = 0; diff --git a/core/unittest/db/test_meta_mysql.cpp b/core/unittest/db/test_meta_mysql.cpp index 14ea83793f..a3fd02adc6 100644 --- a/core/unittest/db/test_meta_mysql.cpp +++ b/core/unittest/db/test_meta_mysql.cpp @@ -26,9 +26,9 @@ #include const char* FAILED_CONNECT_SQL_SERVER = "Failed to connect to meta server(mysql)"; -const char* TABLE_ALREADY_EXISTS = "Collection already exists and it is in delete state, please wait a second"; +const char* COLLECTION_ALREADY_EXISTS = "Collection already exists and it is in delete state, please wait a second"; -TEST_F(MySqlMetaTest, TABLE_TEST) { +TEST_F(MySqlMetaTest, COLLECTION_TEST) { auto collection_id = "meta_test_table"; fiu_init(0); @@ -70,11 +70,11 @@ TEST_F(MySqlMetaTest, TABLE_TEST) { //ensure collection exists stat = impl_->CreateCollection(collection); - FIU_ENABLE_FIU("MySQLMetaImpl.CreateCollectionTable.schema_TO_DELETE"); + FIU_ENABLE_FIU("MySQLMetaImpl.CreateCollection.schema_TO_DELETE"); stat = impl_->CreateCollection(collection); ASSERT_FALSE(stat.ok()); - ASSERT_EQ(stat.message(), TABLE_ALREADY_EXISTS); - fiu_disable("MySQLMetaImpl.CreateCollectionTable.schema_TO_DELETE"); + ASSERT_EQ(stat.message(), COLLECTION_ALREADY_EXISTS); + fiu_disable("MySQLMetaImpl.CreateCollection.schema_TO_DELETE"); FIU_ENABLE_FIU("MySQLMetaImpl.DescribeCollection.null_connection"); stat = impl_->DescribeCollection(collection); @@ -122,7 +122,7 @@ TEST_F(MySqlMetaTest, TABLE_TEST) { ASSERT_TRUE(status.ok()); } -TEST_F(MySqlMetaTest, TABLE_FILE_TEST) { +TEST_F(MySqlMetaTest, COLLECTION_FILE_TEST) { auto collection_id = "meta_test_table"; fiu_init(0); @@ -232,21 +232,21 @@ TEST_F(MySqlMetaTest, TABLE_FILE_TEST) { std::vector ids = {table_file.id_}; milvus::engine::meta::SegmentsSchema files; - status = impl_->GetTableFiles(table_file.collection_id_, ids, files); + status = impl_->GetCollectionFiles(table_file.collection_id_, ids, files); ASSERT_EQ(files.size(), 0UL); - FIU_ENABLE_FIU("MySQLMetaImpl.GetTableFiles.null_connection"); - status = impl_->GetTableFiles(table_file.collection_id_, ids, files); + FIU_ENABLE_FIU("MySQLMetaImpl.GetCollectionFiles.null_connection"); + status = impl_->GetCollectionFiles(table_file.collection_id_, ids, files); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.GetTableFiles.null_connection"); + fiu_disable("MySQLMetaImpl.GetCollectionFiles.null_connection"); - FIU_ENABLE_FIU("MySQLMetaImpl.GetTableFiles.throw_exception"); - status = impl_->GetTableFiles(table_file.collection_id_, ids, files); + FIU_ENABLE_FIU("MySQLMetaImpl.GetCollectionFiles.throw_exception"); + status = impl_->GetCollectionFiles(table_file.collection_id_, ids, files); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.GetTableFiles.throw_exception"); + fiu_disable("MySQLMetaImpl.GetCollectionFiles.throw_exception"); ids.clear(); - status = impl_->GetTableFiles(table_file.collection_id_, ids, files); + status = impl_->GetCollectionFiles(table_file.collection_id_, ids, files); ASSERT_TRUE(status.ok()); table_file.collection_id_ = collection.collection_id_; @@ -278,7 +278,7 @@ TEST_F(MySqlMetaTest, TABLE_FILE_TEST) { ASSERT_TRUE(status.ok()); } -TEST_F(MySqlMetaTest, TABLE_FILE_ROW_COUNT_TEST) { +TEST_F(MySqlMetaTest, COLLECTION_FILE_ROW_COUNT_TEST) { auto collection_id = "row_count_test_table"; milvus::engine::meta::CollectionSchema collection; @@ -307,7 +307,7 @@ TEST_F(MySqlMetaTest, TABLE_FILE_ROW_COUNT_TEST) { std::vector ids = {table_file.id_}; milvus::engine::meta::SegmentsSchema schemas; - status = impl_->GetTableFiles(collection_id, ids, schemas); + status = impl_->GetCollectionFiles(collection_id, ids, schemas); ASSERT_EQ(schemas.size(), 1UL); ASSERT_EQ(table_file.row_count_, schemas[0].row_count_); ASSERT_EQ(table_file.file_id_, schemas[0].file_id_); @@ -372,7 +372,7 @@ TEST_F(MySqlMetaTest, ARCHIVE_TEST_DAYS) { int i = 0; milvus::engine::meta::SegmentsSchema files_get; - status = impl.GetTableFiles(table_file.collection_id_, ids, files_get); + status = impl.GetCollectionFiles(table_file.collection_id_, ids, files_get); ASSERT_TRUE(status.ok()); for (auto& file : files_get) { @@ -464,7 +464,7 @@ TEST_F(MySqlMetaTest, ARCHIVE_TEST_DISK) { int i = 0; milvus::engine::meta::SegmentsSchema files_get; - status = impl.GetTableFiles(table_file.collection_id_, ids, files_get); + status = impl.GetCollectionFiles(table_file.collection_id_, ids, files_get); ASSERT_TRUE(status.ok()); for (auto& file : files_get) { @@ -505,14 +505,14 @@ TEST_F(MySqlMetaTest, INVALID_INITILIZE_TEST) { fiu_disable("MySQLMetaImpl.Initialize.is_thread_aware"); } { - FIU_ENABLE_FIU("MySQLMetaImpl.Initialize.fail_create_table_scheme"); + FIU_ENABLE_FIU("MySQLMetaImpl.Initialize.fail_create_collection_scheme"); ASSERT_ANY_THROW(milvus::engine::meta::MySQLMetaImpl impl(GetOptions().meta_, GetOptions().mode_)); - fiu_disable("MySQLMetaImpl.Initialize.fail_create_table_scheme"); + fiu_disable("MySQLMetaImpl.Initialize.fail_create_collection_scheme"); } { - FIU_ENABLE_FIU("MySQLMetaImpl.Initialize.fail_create_table_files"); + FIU_ENABLE_FIU("MySQLMetaImpl.Initialize.fail_create_collection_files"); ASSERT_ANY_THROW(milvus::engine::meta::MySQLMetaImpl impl(GetOptions().meta_, GetOptions().mode_)); - fiu_disable("MySQLMetaImpl.Initialize.fail_create_table_files"); + fiu_disable("MySQLMetaImpl.Initialize.fail_create_collection_files"); } { FIU_ENABLE_FIU("MySQLConnectionPool.create.throw_exception"); @@ -526,7 +526,7 @@ TEST_F(MySqlMetaTest, INVALID_INITILIZE_TEST) { } } -TEST_F(MySqlMetaTest, TABLE_FILES_TEST) { +TEST_F(MySqlMetaTest, COLLECTION_FILES_TEST) { auto collection_id = "meta_test_group"; fiu_init(0); @@ -687,17 +687,17 @@ TEST_F(MySqlMetaTest, TABLE_FILES_TEST) { to_index_files_cnt + index_files_cnt; ASSERT_EQ(table_files.size(), total_cnt); - FIU_ENABLE_FIU("MySQLMetaImpl.DeleteTableFiles.null_connection"); - status = impl_->DeleteTableFiles(collection_id); + FIU_ENABLE_FIU("MySQLMetaImpl.DeleteCollectionFiles.null_connection"); + status = impl_->DeleteCollectionFiles(collection_id); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.DeleteTableFiles.null_connection"); + fiu_disable("MySQLMetaImpl.DeleteCollectionFiles.null_connection"); - FIU_ENABLE_FIU("MySQLMetaImpl.DeleteTableFiles.throw_exception"); - status = impl_->DeleteTableFiles(collection_id); + FIU_ENABLE_FIU("MySQLMetaImpl.DeleteCollectionFiles.throw_exception"); + status = impl_->DeleteCollectionFiles(collection_id); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.DeleteTableFiles.throw_exception"); + fiu_disable("MySQLMetaImpl.DeleteCollectionFiles.throw_exception"); - status = impl_->DeleteTableFiles(collection_id); + status = impl_->DeleteCollectionFiles(collection_id); ASSERT_TRUE(status.ok()); status = impl_->DropCollection(collection_id); @@ -716,25 +716,25 @@ TEST_F(MySqlMetaTest, TABLE_FILES_TEST) { ASSERT_FALSE(status.ok()); fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RomoveToDeleteFiles_ThrowException"); - FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteTables_NUllConnection"); + FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteCollections_NUllConnection"); status = impl_->CleanUpFilesWithTTL(0UL); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteTables_NUllConnection"); + fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteCollections_NUllConnection"); - FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteTables_ThrowException"); + FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteCollections_ThrowException"); status = impl_->CleanUpFilesWithTTL(0UL); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteTables_ThrowException"); + fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveToDeleteCollections_ThrowException"); - FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedTableFolder_NUllConnection"); + FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedCollectionFolder_NUllConnection"); status = impl_->CleanUpFilesWithTTL(0UL); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedTableFolder_NUllConnection"); + fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedCollectionFolder_NUllConnection"); - FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedTableFolder_ThrowException"); + FIU_ENABLE_FIU("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedCollectionFolder_ThrowException"); status = impl_->CleanUpFilesWithTTL(0UL); ASSERT_FALSE(status.ok()); - fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedTableFolder_ThrowException"); + fiu_disable("MySQLMetaImpl.CleanUpFilesWithTTL.RemoveDeletedCollectionFolder_ThrowException"); } TEST_F(MySqlMetaTest, INDEX_TEST) { diff --git a/core/unittest/db/test_misc.cpp b/core/unittest/db/test_misc.cpp index 5ffb4f7a84..7d9450f6cf 100644 --- a/core/unittest/db/test_misc.cpp +++ b/core/unittest/db/test_misc.cpp @@ -90,21 +90,21 @@ TEST(DBMiscTest, UTILS_TEST) { options.slave_paths_.push_back("/tmp/milvus_test/slave_1"); options.slave_paths_.push_back("/tmp/milvus_test/slave_2"); - const std::string TABLE_NAME = "test_tbl"; + const std::string COLLECTION_NAME = "test_tbl"; fiu_init(0); milvus::Status status; FIU_ENABLE_FIU("CommonUtil.CreateDirectory.create_parent_fail"); - status = milvus::engine::utils::CreateCollectionPath(options, TABLE_NAME); + status = milvus::engine::utils::CreateCollectionPath(options, COLLECTION_NAME); ASSERT_FALSE(status.ok()); fiu_disable("CommonUtil.CreateDirectory.create_parent_fail"); FIU_ENABLE_FIU("CreateCollectionPath.creat_slave_path"); - status = milvus::engine::utils::CreateCollectionPath(options, TABLE_NAME); + status = milvus::engine::utils::CreateCollectionPath(options, COLLECTION_NAME); ASSERT_FALSE(status.ok()); fiu_disable("CreateCollectionPath.creat_slave_path"); - status = milvus::engine::utils::CreateCollectionPath(options, TABLE_NAME); + status = milvus::engine::utils::CreateCollectionPath(options, COLLECTION_NAME); ASSERT_TRUE(status.ok()); ASSERT_TRUE(boost::filesystem::exists(options.path_)); for (auto& path : options.slave_paths_) { @@ -112,26 +112,26 @@ TEST(DBMiscTest, UTILS_TEST) { } // options.slave_paths.push_back("/"); - // status = engine::utils::CreateCollectionPath(options, TABLE_NAME); + // status = engine::utils::CreateCollectionPath(options, COLLECTION_NAME); // ASSERT_FALSE(status.ok()); // // options.path = "/"; - // status = engine::utils::CreateCollectionPath(options, TABLE_NAME); + // status = engine::utils::CreateCollectionPath(options, COLLECTION_NAME); // ASSERT_FALSE(status.ok()); milvus::engine::meta::SegmentSchema file; file.id_ = 50; - file.collection_id_ = TABLE_NAME; + file.collection_id_ = COLLECTION_NAME; file.file_type_ = 3; file.date_ = 155000; - status = milvus::engine::utils::GetTableFilePath(options, file); + status = milvus::engine::utils::GetCollectionFilePath(options, file); ASSERT_TRUE(status.ok()); ASSERT_FALSE(file.location_.empty()); - status = milvus::engine::utils::DeleteTablePath(options, TABLE_NAME); + status = milvus::engine::utils::DeleteCollectionPath(options, COLLECTION_NAME); ASSERT_TRUE(status.ok()); - status = milvus::engine::utils::DeleteTableFilePath(options, file); + status = milvus::engine::utils::DeleteCollectionFilePath(options, file); ASSERT_TRUE(status.ok()); status = milvus::engine::utils::CreateCollectionFilePath(options, file); @@ -142,20 +142,20 @@ TEST(DBMiscTest, UTILS_TEST) { ASSERT_FALSE(status.ok()); fiu_disable("CreateCollectionFilePath.fail_create"); - status = milvus::engine::utils::GetTableFilePath(options, file); + status = milvus::engine::utils::GetCollectionFilePath(options, file); ASSERT_FALSE(file.location_.empty()); FIU_ENABLE_FIU("CommonUtil.CreateDirectory.create_parent_fail"); - status = milvus::engine::utils::GetTableFilePath(options, file); + status = milvus::engine::utils::GetCollectionFilePath(options, file); ASSERT_FALSE(file.location_.empty()); fiu_disable("CommonUtil.CreateDirectory.create_parent_fail"); - FIU_ENABLE_FIU("GetTableFilePath.enable_s3"); - status = milvus::engine::utils::GetTableFilePath(options, file); + FIU_ENABLE_FIU("GetCollectionFilePath.enable_s3"); + status = milvus::engine::utils::GetCollectionFilePath(options, file); ASSERT_FALSE(file.location_.empty()); - fiu_disable("GetTableFilePath.enable_s3"); + fiu_disable("GetCollectionFilePath.enable_s3"); - status = milvus::engine::utils::DeleteTableFilePath(options, file); + status = milvus::engine::utils::DeleteCollectionFilePath(options, file); ASSERT_TRUE(status.ok()); diff --git a/core/unittest/db/test_search_by_id.cpp b/core/unittest/db/test_search_by_id.cpp index ada27feb6c..530ba7f389 100644 --- a/core/unittest/db/test_search_by_id.cpp +++ b/core/unittest/db/test_search_by_id.cpp @@ -31,10 +31,10 @@ namespace { -static constexpr int64_t TABLE_DIM = 256; +static constexpr int64_t COLLECTION_DIM = 256; std::string -GetTableName() { +GetCollectionName() { auto now = std::chrono::system_clock::now(); auto micros = std::chrono::duration_cast(now.time_since_epoch()).count(); static std::string collection_name = std::to_string(micros); @@ -42,10 +42,10 @@ GetTableName() { } milvus::engine::meta::CollectionSchema -BuildTableSchema() { +BuildCollectionSchema() { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = GetTableName(); + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = GetCollectionName(); collection_info.metric_type_ = (int32_t)milvus::engine::MetricType::L2; collection_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFFLAT; return collection_info; @@ -55,23 +55,23 @@ void BuildVectors(uint64_t n, milvus::engine::VectorsData& vectors) { vectors.vector_count_ = n; vectors.float_data_.clear(); - vectors.float_data_.resize(n * TABLE_DIM); + vectors.float_data_.resize(n * COLLECTION_DIM); float* data = vectors.float_data_.data(); for (int i = 0; i < n; i++) { - for (int j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); + for (int j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); } } } // namespace TEST_F(SearchByIdTest, basic) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -116,14 +116,14 @@ TEST_F(SearchByIdTest, basic) { } TEST_F(SearchByIdTest, with_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 10000; milvus::engine::VectorsData xb; @@ -174,14 +174,14 @@ TEST_F(SearchByIdTest, with_index) { } TEST_F(SearchByIdTest, with_delete) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -235,14 +235,14 @@ TEST_F(SearchByIdTest, with_delete) { } TEST_F(GetVectorByIdTest, basic) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -292,14 +292,14 @@ TEST_F(GetVectorByIdTest, basic) { } TEST_F(GetVectorByIdTest, with_index) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 10000; milvus::engine::VectorsData xb; @@ -354,14 +354,14 @@ TEST_F(GetVectorByIdTest, with_index) { } TEST_F(GetVectorByIdTest, with_delete) { - milvus::engine::meta::CollectionSchema collection_info = BuildTableSchema(); + milvus::engine::meta::CollectionSchema collection_info = BuildCollectionSchema(); auto stat = db_->CreateCollection(collection_info); milvus::engine::meta::CollectionSchema collection_info_get; collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int64_t nb = 100000; milvus::engine::VectorsData xb; @@ -414,8 +414,8 @@ TEST_F(GetVectorByIdTest, with_delete) { TEST_F(SearchByIdTest, BINARY) { milvus::engine::meta::CollectionSchema collection_info; - collection_info.dimension_ = TABLE_DIM; - collection_info.collection_id_ = GetTableName(); + collection_info.dimension_ = COLLECTION_DIM; + collection_info.collection_id_ = GetCollectionName(); collection_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_BIN_IDMAP; collection_info.metric_type_ = (int32_t)milvus::engine::MetricType::JACCARD; auto stat = db_->CreateCollection(collection_info); @@ -425,7 +425,7 @@ TEST_F(SearchByIdTest, BINARY) { collection_info_get.collection_id_ = collection_info.collection_id_; stat = db_->DescribeCollection(collection_info_get); ASSERT_TRUE(stat.ok()); - ASSERT_EQ(collection_info_get.dimension_, TABLE_DIM); + ASSERT_EQ(collection_info_get.dimension_, COLLECTION_DIM); int insert_loop = 10; int64_t nb = 1000; @@ -434,7 +434,7 @@ TEST_F(SearchByIdTest, BINARY) { milvus::engine::VectorsData vectors; vectors.vector_count_ = nb; vectors.binary_data_.clear(); - vectors.binary_data_.resize(nb * TABLE_DIM); + vectors.binary_data_.resize(nb * COLLECTION_DIM); uint8_t* data = vectors.binary_data_.data(); vectors.id_array_.clear(); @@ -442,8 +442,8 @@ TEST_F(SearchByIdTest, BINARY) { std::mt19937 gen(rd()); std::uniform_int_distribution<> distribution{0, std::numeric_limits::max()}; for (int i = 0; i < nb; i++) { - for (int j = 0; j < TABLE_DIM; j++) { - data[TABLE_DIM * i + j] = distribution(gen); + for (int j = 0; j < COLLECTION_DIM; j++) { + data[COLLECTION_DIM * i + j] = distribution(gen); } vectors.id_array_.emplace_back(k * nb + i); } diff --git a/core/unittest/db/test_wal.cpp b/core/unittest/db/test_wal.cpp index e736ccdd64..17f0903fd5 100644 --- a/core/unittest/db/test_wal.cpp +++ b/core/unittest/db/test_wal.cpp @@ -639,7 +639,7 @@ TEST(WalTest, MANAGER_TEST) { ASSERT_TRUE(record.collection_id.empty()); } -TEST(WalTest, MANAGER_SAME_NAME_TABLE) { +TEST(WalTest, MANAGER_SAME_NAME_COLLECTION) { MakeEmptyTestPath(); milvus::engine::DBMetaOptions opt = {WAL_GTEST_PATH}; diff --git a/core/unittest/metrics/test_metrics.cpp b/core/unittest/metrics/test_metrics.cpp index 9483250bce..304b33e193 100644 --- a/core/unittest/metrics/test_metrics.cpp +++ b/core/unittest/metrics/test_metrics.cpp @@ -26,17 +26,17 @@ #include "metrics/Metrics.h" namespace { -static constexpr int64_t TABLE_DIM = 256; +static constexpr int64_t COLLECTION_DIM = 256; void BuildVectors(uint64_t n, milvus::engine::VectorsData& vectors) { vectors.vector_count_ = n; vectors.float_data_.clear(); - vectors.float_data_.resize(n * TABLE_DIM); + vectors.float_data_.resize(n * COLLECTION_DIM); float* data = vectors.float_data_.data(); for (uint64_t i = 0; i < n; i++) { - for (int64_t j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48(); - data[TABLE_DIM * i] += i / 2000.; + for (int64_t j = 0; j < COLLECTION_DIM; j++) data[COLLECTION_DIM * i + j] = drand48(); + data[COLLECTION_DIM * i] += i / 2000.; } } } // namespace diff --git a/core/unittest/server/test_rpc.cpp b/core/unittest/server/test_rpc.cpp index d1be557715..b362b2eaab 100644 --- a/core/unittest/server/test_rpc.cpp +++ b/core/unittest/server/test_rpc.cpp @@ -36,8 +36,8 @@ namespace { -static const char* TABLE_NAME = "test_grpc"; -static constexpr int64_t TABLE_DIM = 256; +static const char* COLLECTION_NAME = "test_grpc"; +static constexpr int64_t COLLECTION_DIM = 256; static constexpr int64_t INDEX_FILE_SIZE = 1024; static constexpr int64_t VECTOR_COUNT = 1000; static constexpr int64_t INSERT_LOOP = 10; @@ -114,15 +114,15 @@ class RpcHandlerTest : public testing::Test { dummy_context->SetTraceContext(trace_context); ::grpc::ServerContext context; handler->SetContext(&context, dummy_context); - ::milvus::grpc::TableSchema request; + ::milvus::grpc::CollectionSchema request; ::milvus::grpc::Status status; - request.set_table_name(TABLE_NAME); - request.set_dimension(TABLE_DIM); + request.set_collection_name(COLLECTION_NAME); + request.set_dimension(COLLECTION_DIM); request.set_index_file_size(INDEX_FILE_SIZE); request.set_metric_type(1); handler->SetContext(&context, dummy_context); handler->random_id(); - ::grpc::Status grpc_status = handler->CreateTable(&context, &request, &status); + ::grpc::Status grpc_status = handler->CreateCollection(&context, &request, &status); } void @@ -148,8 +148,8 @@ BuildVectors(int64_t from, int64_t to, std::vector>& vector_r vector_record_array.clear(); for (int64_t k = from; k < to; k++) { std::vector record; - record.resize(TABLE_DIM); - for (int64_t i = 0; i < TABLE_DIM; i++) { + record.resize(COLLECTION_DIM); + for (int64_t i = 0; i < COLLECTION_DIM; i++) { record[i] = (float)(i + k); } @@ -166,8 +166,8 @@ BuildBinVectors(int64_t from, int64_t to, std::vector>& vec vector_record_array.clear(); for (int64_t k = from; k < to; k++) { std::vector record; - record.resize(TABLE_DIM / 8); - for (int64_t i = 0; i < TABLE_DIM / 8; i++) { + record.resize(COLLECTION_DIM / 8); + for (int64_t i = 0; i < COLLECTION_DIM / 8; i++) { record[i] = (i + k) % 256; } @@ -196,11 +196,11 @@ TEST_F(RpcHandlerTest, HAS_COLLECTION_TEST) { ::grpc::ServerContext context; handler->SetContext(&context, dummy_context); handler->RegisterRequestHandler(milvus::server::RequestHandler()); - ::milvus::grpc::TableName request; + ::milvus::grpc::CollectionName request; ::milvus::grpc::BoolReply reply; - ::grpc::Status status = handler->HasTable(&context, &request, &reply); - request.set_table_name(TABLE_NAME); - status = handler->HasTable(&context, &request, &reply); + ::grpc::Status status = handler->HasCollection(&context, &request, &reply); + request.set_collection_name(COLLECTION_NAME); + status = handler->HasCollection(&context, &request, &reply); ASSERT_TRUE(status.error_code() == ::grpc::Status::OK.error_code()); int error_code = reply.status().error_code(); ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS); @@ -208,7 +208,7 @@ TEST_F(RpcHandlerTest, HAS_COLLECTION_TEST) { fiu_init(0); fiu_enable("HasCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); - handler->HasTable(&context, &request, &reply); + handler->HasCollection(&context, &request, &reply); ASSERT_NE(reply.status().error_code(), ::milvus::grpc::ErrorCode::SUCCESS); fiu_disable("HasCollectionRequest.OnExecute.throw_std_exception"); } @@ -220,10 +220,10 @@ TEST_F(RpcHandlerTest, INDEX_TEST) { ::milvus::grpc::IndexParam request; ::milvus::grpc::Status response; ::grpc::Status grpc_status = handler->CreateIndex(&context, &request, &response); - request.set_table_name("test1"); + request.set_collection_name("test1"); handler->CreateIndex(&context, &request, &response); - request.set_table_name(TABLE_NAME); + request.set_collection_name(COLLECTION_NAME); handler->CreateIndex(&context, &request, &response); request.set_index_type(1); @@ -261,12 +261,12 @@ TEST_F(RpcHandlerTest, INDEX_TEST) { fiu_disable("CreateIndexRequest.OnExecute.ip_meteric"); #endif - ::milvus::grpc::TableName collection_name; + ::milvus::grpc::CollectionName collection_name; ::milvus::grpc::IndexParam index_param; handler->DescribeIndex(&context, &collection_name, &index_param); - collection_name.set_table_name("test4"); + collection_name.set_collection_name("test4"); handler->DescribeIndex(&context, &collection_name, &index_param); - collection_name.set_table_name(TABLE_NAME); + collection_name.set_collection_name(COLLECTION_NAME); handler->DescribeIndex(&context, &collection_name, &index_param); fiu_init(0); @@ -277,15 +277,15 @@ TEST_F(RpcHandlerTest, INDEX_TEST) { ::milvus::grpc::Status status; collection_name.Clear(); handler->DropIndex(&context, &collection_name, &status); - collection_name.set_table_name("test5"); + collection_name.set_collection_name("test5"); handler->DropIndex(&context, &collection_name, &status); - collection_name.set_table_name(TABLE_NAME); + collection_name.set_collection_name(COLLECTION_NAME); fiu_init(0); - fiu_enable("DropIndexRequest.OnExecute.table_not_exist", 1, NULL, 0); + fiu_enable("DropIndexRequest.OnExecute.collection_not_exist", 1, NULL, 0); handler->DropIndex(&context, &collection_name, &status); - fiu_disable("DropIndexRequest.OnExecute.table_not_exist"); + fiu_disable("DropIndexRequest.OnExecute.collection_not_exist"); fiu_enable("DropIndexRequest.OnExecute.drop_index_fail", 1, NULL, 0); handler->DropIndex(&context, &collection_name, &status); @@ -305,7 +305,7 @@ TEST_F(RpcHandlerTest, INSERT_TEST) { ::milvus::grpc::InsertParam request; ::milvus::grpc::Status response; - request.set_table_name(TABLE_NAME); + request.set_collection_name(COLLECTION_NAME); std::vector> record_array; BuildVectors(0, VECTOR_COUNT, record_array); ::milvus::grpc::VectorIds vector_ids; @@ -326,10 +326,10 @@ TEST_F(RpcHandlerTest, INSERT_TEST) { ASSERT_NE(vector_ids.vector_id_array_size(), VECTOR_COUNT); fiu_disable("InsertRequest.OnExecute.db_not_found"); - fiu_enable("InsertRequest.OnExecute.describe_table_fail", 1, NULL, 0); + fiu_enable("InsertRequest.OnExecute.describe_collection_fail", 1, NULL, 0); handler->Insert(&context, &request, &vector_ids); ASSERT_NE(vector_ids.vector_id_array_size(), VECTOR_COUNT); - fiu_disable("InsertRequest.OnExecute.describe_table_fail"); + fiu_disable("InsertRequest.OnExecute.describe_collection_fail"); fiu_enable("InsertRequest.OnExecute.illegal_vector_id", 1, NULL, 0); handler->Insert(&context, &request, &vector_ids); @@ -360,7 +360,7 @@ TEST_F(RpcHandlerTest, INSERT_TEST) { fiu_disable("InsertRequest.OnExecute.invalid_ids_size"); // insert vectors with wrong dim - std::vector record_wrong_dim(TABLE_DIM - 1, 0.5f); + std::vector record_wrong_dim(COLLECTION_DIM - 1, 0.5f); ::milvus::grpc::RowRecord* grpc_record = request.add_row_record_array(); CopyRowRecord(grpc_record, record_wrong_dim); handler->Insert(&context, &request, &vector_ids); @@ -380,11 +380,11 @@ TEST_F(RpcHandlerTest, SEARCH_TEST) { handler->Search(&context, &request, &response); // test collection not exist - request.set_table_name("test3"); + request.set_collection_name("test3"); handler->Search(&context, &request, &response); // test invalid topk - request.set_table_name(TABLE_NAME); + request.set_collection_name(COLLECTION_NAME); handler->Search(&context, &request, &response); // test invalid nprobe @@ -406,14 +406,14 @@ TEST_F(RpcHandlerTest, SEARCH_TEST) { CopyRowRecord(grpc_record, record); } // insert vectors - insert_param.set_table_name(TABLE_NAME); + insert_param.set_collection_name(COLLECTION_NAME); ::milvus::grpc::VectorIds vector_ids; handler->Insert(&context, &insert_param, &vector_ids); // flush ::milvus::grpc::Status grpc_status; ::milvus::grpc::FlushParam flush_param; - flush_param.add_table_name_array(TABLE_NAME); + flush_param.add_collection_name_array(COLLECTION_NAME); handler->Flush(&context, &flush_param, &grpc_status); // search @@ -438,15 +438,15 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_TEST) { handler->SetContext(&context, dummy_context); handler->RegisterRequestHandler(milvus::server::RequestHandler()); - // create table - std::string table_name = "combine"; - ::milvus::grpc::TableSchema tableschema; - tableschema.set_table_name(table_name); - tableschema.set_dimension(TABLE_DIM); - tableschema.set_index_file_size(INDEX_FILE_SIZE); - tableschema.set_metric_type(1); // L2 metric + // create collection + std::string collection_name = "combine"; + ::milvus::grpc::CollectionSchema collection_schema; + collection_schema.set_collection_name(collection_name); + collection_schema.set_dimension(COLLECTION_DIM); + collection_schema.set_index_file_size(INDEX_FILE_SIZE); + collection_schema.set_metric_type(1); // L2 metric ::milvus::grpc::Status status; - handler->CreateTable(&context, &tableschema, &status); + handler->CreateCollection(&context, &collection_schema, &status); ASSERT_EQ(status.error_code(), 0); // insert vectors @@ -460,14 +460,14 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_TEST) { insert_param.add_row_id_array(++vec_id); } - insert_param.set_table_name(table_name); + insert_param.set_collection_name(collection_name); ::milvus::grpc::VectorIds vector_ids; handler->Insert(&context, &insert_param, &vector_ids); // flush ::milvus::grpc::Status grpc_status; ::milvus::grpc::FlushParam flush_param; - flush_param.add_table_name_array(table_name); + flush_param.add_collection_name_array(collection_name); handler->Flush(&context, &flush_param, &grpc_status); // multi thread search requests will be combined @@ -478,7 +478,7 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_TEST) { std::vector request_array; for (int i = 0; i < QUERY_COUNT; i++) { RequestPtr request = std::make_shared<::milvus::grpc::SearchParam>(); - request->set_table_name(table_name); + request->set_collection_name(collection_name); request->set_topk(TOPK); milvus::grpc::KeyValuePair* kv = request->add_extra_params(); kv->set_key(milvus::server::grpc::EXTRA_PARAM_KEY); @@ -540,15 +540,15 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_BINARY_TEST) { handler->SetContext(&context, dummy_context); handler->RegisterRequestHandler(milvus::server::RequestHandler()); - // create table - std::string table_name = "combine_bin"; - ::milvus::grpc::TableSchema tableschema; - tableschema.set_table_name(table_name); - tableschema.set_dimension(TABLE_DIM); - tableschema.set_index_file_size(INDEX_FILE_SIZE); - tableschema.set_metric_type(5); // tanimoto metric + // create collection + std::string collection_name = "combine_bin"; + ::milvus::grpc::CollectionSchema collection_schema; + collection_schema.set_collection_name(collection_name); + collection_schema.set_dimension(COLLECTION_DIM); + collection_schema.set_index_file_size(INDEX_FILE_SIZE); + collection_schema.set_metric_type(5); // tanimoto metric ::milvus::grpc::Status status; - handler->CreateTable(&context, &tableschema, &status); + handler->CreateCollection(&context, &collection_schema, &status); ASSERT_EQ(status.error_code(), 0); // insert vectors @@ -562,14 +562,14 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_BINARY_TEST) { insert_param.add_row_id_array(++vec_id); } - insert_param.set_table_name(table_name); + insert_param.set_collection_name(collection_name); ::milvus::grpc::VectorIds vector_ids; handler->Insert(&context, &insert_param, &vector_ids); // flush ::milvus::grpc::Status grpc_status; ::milvus::grpc::FlushParam flush_param; - flush_param.add_table_name_array(table_name); + flush_param.add_collection_name_array(collection_name); handler->Flush(&context, &flush_param, &grpc_status); // multi thread search requests will be combined @@ -580,7 +580,7 @@ TEST_F(RpcHandlerTest, COMBINE_SEARCH_BINARY_TEST) { std::vector request_array; for (int i = 0; i < QUERY_COUNT; i++) { RequestPtr request = std::make_shared<::milvus::grpc::SearchParam>(); - request->set_table_name(table_name); + request->set_collection_name(collection_name); request->set_topk(TOPK); milvus::grpc::KeyValuePair* kv = request->add_extra_params(); kv->set_key(milvus::server::grpc::EXTRA_PARAM_KEY); @@ -640,46 +640,50 @@ TEST_F(RpcHandlerTest, TABLES_TEST) { ::grpc::ServerContext context; handler->SetContext(&context, dummy_context); handler->RegisterRequestHandler(milvus::server::RequestHandler()); - ::milvus::grpc::TableSchema tableschema; - ::milvus::grpc::Status response; - std::string tablename = "tbl"; - // create collection test - // test null input - handler->CreateTable(&context, nullptr, &response); - // test invalid collection name - handler->CreateTable(&context, &tableschema, &response); - // test invalid collection dimension - tableschema.set_table_name(tablename); - handler->CreateTable(&context, &tableschema, &response); - // test invalid index file size - tableschema.set_dimension(TABLE_DIM); - // handler->CreateTable(&context, &tableschema, &response); - // test invalid index metric type - tableschema.set_index_file_size(INDEX_FILE_SIZE); - handler->CreateTable(&context, &tableschema, &response); - // test collection already exist - tableschema.set_metric_type(1); - handler->CreateTable(&context, &tableschema, &response); + ::milvus::grpc::Status response; + std::string collection_name = "tbl"; + { + ::milvus::grpc::CollectionSchema collection_schema; + // create collection test + // test null input + handler->CreateCollection(&context, nullptr, &response); + // test invalid collection name + handler->CreateCollection(&context, &collection_schema, &response); + // test invalid collection dimension + collection_schema.set_collection_name(collection_name); + handler->CreateCollection(&context, &collection_schema, &response); + // test invalid index file size + collection_schema.set_dimension(COLLECTION_DIM); + // handler->CreateCollection(&context, &collection_schema, &response); + // test invalid index metric type + collection_schema.set_index_file_size(INDEX_FILE_SIZE); + handler->CreateCollection(&context, &collection_schema, &response); + // test collection already exist + collection_schema.set_metric_type(1); + handler->CreateCollection(&context, &collection_schema, &response); + } // describe collection test // test invalid collection name - ::milvus::grpc::TableName collection_name; - ::milvus::grpc::TableSchema table_schema; - handler->DescribeTable(&context, &collection_name, &table_schema); + ::milvus::grpc::CollectionName grpc_collection_name; + { + ::milvus::grpc::CollectionSchema collection_schema; + handler->DescribeCollection(&context, &grpc_collection_name, &collection_schema); - collection_name.set_table_name(TABLE_NAME); - ::grpc::Status status = handler->DescribeTable(&context, &collection_name, &table_schema); - ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); + grpc_collection_name.set_collection_name(COLLECTION_NAME); + ::grpc::Status status = handler->DescribeCollection(&context, &grpc_collection_name, &collection_schema); + ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); - fiu_init(0); - fiu_enable("DescribeCollectionRequest.OnExecute.describe_table_fail", 1, NULL, 0); - handler->DescribeTable(&context, &collection_name, &table_schema); - fiu_disable("DescribeCollectionRequest.OnExecute.describe_table_fail"); + fiu_init(0); + fiu_enable("DescribeCollectionRequest.OnExecute.describe_collection_fail", 1, NULL, 0); + handler->DescribeCollection(&context, &grpc_collection_name, &collection_schema); + fiu_disable("DescribeCollectionRequest.OnExecute.describe_collection_fail"); - fiu_enable("DescribeCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); - handler->DescribeTable(&context, &collection_name, &table_schema); - fiu_disable("DescribeCollectionRequest.OnExecute.throw_std_exception"); + fiu_enable("DescribeCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); + handler->DescribeCollection(&context, &grpc_collection_name, &collection_schema); + fiu_disable("DescribeCollectionRequest.OnExecute.throw_std_exception"); + } ::milvus::grpc::InsertParam request; std::vector> record_array; @@ -691,7 +695,7 @@ TEST_F(RpcHandlerTest, TABLES_TEST) { // Insert vectors // test invalid collection name handler->Insert(&context, &request, &vector_ids); - request.set_table_name(tablename); + request.set_collection_name(collection_name); // test empty row record handler->Insert(&context, &request, &vector_ids); @@ -716,164 +720,178 @@ TEST_F(RpcHandlerTest, TABLES_TEST) { } handler->Insert(&context, &request, &vector_ids); - // show tables - ::milvus::grpc::Command cmd; - ::milvus::grpc::TableNameList table_name_list; - status = handler->ShowTables(&context, &cmd, &table_name_list); - ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); + // show collections + { + ::milvus::grpc::Command cmd; + ::milvus::grpc::CollectionNameList collection_name_list; + auto status = handler->ShowCollections(&context, &cmd, &collection_name_list); + ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); - // show collection info - ::milvus::grpc::TableInfo collection_info; - status = handler->ShowTableInfo(&context, &collection_name, &collection_info); - ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); + // show collection info + ::milvus::grpc::CollectionInfo collection_info; + status = handler->ShowCollectionInfo(&context, &grpc_collection_name, &collection_info); + ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); - fiu_init(0); - fiu_enable("ShowCollectionsRequest.OnExecute.show_tables_fail", 1, NULL, 0); - handler->ShowTables(&context, &cmd, &table_name_list); - fiu_disable("ShowCollectionsRequest.OnExecute.show_tables_fail"); + fiu_init(0); + fiu_enable("ShowCollectionsRequest.OnExecute.show_collections_fail", 1, NULL, 0); + handler->ShowCollections(&context, &cmd, &collection_name_list); + fiu_disable("ShowCollectionsRequest.OnExecute.show_collections_fail"); + } // Count Collection - ::milvus::grpc::TableRowCount count; - collection_name.Clear(); - status = handler->CountTable(&context, &collection_name, &count); - collection_name.set_table_name(tablename); - status = handler->CountTable(&context, &collection_name, &count); - ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); - // ASSERT_EQ(count.table_row_count(), vector_ids.vector_id_array_size()); - fiu_init(0); - fiu_enable("CountCollectionRequest.OnExecute.db_not_found", 1, NULL, 0); - status = handler->CountTable(&context, &collection_name, &count); - fiu_disable("CountCollectionRequest.OnExecute.db_not_found"); + { + ::milvus::grpc::CollectionRowCount count; + grpc_collection_name.Clear(); + auto status = handler->CountCollection(&context, &grpc_collection_name, &count); + grpc_collection_name.set_collection_name(collection_name); + status = handler->CountCollection(&context, &grpc_collection_name, &count); + ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); + // ASSERT_EQ(count.collection_row_count(), vector_ids.vector_id_array_size()); + fiu_init(0); + fiu_enable("CountCollectionRequest.OnExecute.db_not_found", 1, NULL, 0); + status = handler->CountCollection(&context, &grpc_collection_name, &count); + fiu_disable("CountCollectionRequest.OnExecute.db_not_found"); - fiu_enable("CountCollectionRequest.OnExecute.status_error", 1, NULL, 0); - status = handler->CountTable(&context, &collection_name, &count); - fiu_disable("CountCollectionRequest.OnExecute.status_error"); + fiu_enable("CountCollectionRequest.OnExecute.status_error", 1, NULL, 0); + status = handler->CountCollection(&context, &grpc_collection_name, &count); + fiu_disable("CountCollectionRequest.OnExecute.status_error"); - fiu_enable("CountCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); - status = handler->CountTable(&context, &collection_name, &count); - fiu_disable("CountCollectionRequest.OnExecute.throw_std_exception"); + fiu_enable("CountCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); + status = handler->CountCollection(&context, &grpc_collection_name, &count); + fiu_disable("CountCollectionRequest.OnExecute.throw_std_exception"); + } // Preload Collection - collection_name.Clear(); - status = handler->PreloadTable(&context, &collection_name, &response); - collection_name.set_table_name(TABLE_NAME); - status = handler->PreloadTable(&context, &collection_name, &response); - ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); + { + ::milvus::grpc::CollectionSchema collection_schema; - fiu_enable("PreloadCollectionRequest.OnExecute.preload_table_fail", 1, NULL, 0); - handler->PreloadTable(&context, &collection_name, &response); - fiu_disable("PreloadCollectionRequest.OnExecute.preload_table_fail"); + grpc_collection_name.Clear(); + auto status = handler->PreloadCollection(&context, &grpc_collection_name, &response); + grpc_collection_name.set_collection_name(COLLECTION_NAME); + status = handler->PreloadCollection(&context, &grpc_collection_name, &response); + ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code()); - fiu_enable("PreloadCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); - handler->PreloadTable(&context, &collection_name, &response); - fiu_disable("PreloadCollectionRequest.OnExecute.throw_std_exception"); + fiu_enable("PreloadCollectionRequest.OnExecute.preload_collection_fail", 1, NULL, 0); + handler->PreloadCollection(&context, &grpc_collection_name, &response); + fiu_disable("PreloadCollectionRequest.OnExecute.preload_collection_fail"); - fiu_init(0); - fiu_enable("CreateCollectionRequest.OnExecute.invalid_index_file_size", 1, NULL, 0); - tableschema.set_table_name(tablename); - handler->CreateTable(&context, &tableschema, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("CreateCollectionRequest.OnExecute.invalid_index_file_size"); + fiu_enable("PreloadCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); + handler->PreloadCollection(&context, &grpc_collection_name, &response); + fiu_disable("PreloadCollectionRequest.OnExecute.throw_std_exception"); - fiu_enable("CreateCollectionRequest.OnExecute.db_already_exist", 1, NULL, 0); - tableschema.set_table_name(tablename); - handler->CreateTable(&context, &tableschema, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("CreateCollectionRequest.OnExecute.db_already_exist"); + fiu_init(0); + fiu_enable("CreateCollectionRequest.OnExecute.invalid_index_file_size", 1, NULL, 0); + collection_schema.set_collection_name(collection_name); + handler->CreateCollection(&context, &collection_schema, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("CreateCollectionRequest.OnExecute.invalid_index_file_size"); - fiu_enable("CreateCollectionRequest.OnExecute.create_table_fail", 1, NULL, 0); - tableschema.set_table_name(tablename); - handler->CreateTable(&context, &tableschema, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("CreateCollectionRequest.OnExecute.create_table_fail"); + fiu_enable("CreateCollectionRequest.OnExecute.db_already_exist", 1, NULL, 0); + collection_schema.set_collection_name(collection_name); + handler->CreateCollection(&context, &collection_schema, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("CreateCollectionRequest.OnExecute.db_already_exist"); - fiu_enable("CreateCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); - tableschema.set_table_name(tablename); - handler->CreateTable(&context, &tableschema, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("CreateCollectionRequest.OnExecute.throw_std_exception"); + fiu_enable("CreateCollectionRequest.OnExecute.create_collection_fail", 1, NULL, 0); + collection_schema.set_collection_name(collection_name); + handler->CreateCollection(&context, &collection_schema, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("CreateCollectionRequest.OnExecute.create_collection_fail"); + + fiu_enable("CreateCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); + collection_schema.set_collection_name(collection_name); + handler->CreateCollection(&context, &collection_schema, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("CreateCollectionRequest.OnExecute.throw_std_exception"); + } // Drop collection - collection_name.set_table_name(""); - // test invalid collection name - ::grpc::Status grpc_status = handler->DropTable(&context, &collection_name, &response); - collection_name.set_table_name(tablename); + { + ::milvus::grpc::CollectionSchema collection_schema; + collection_schema.set_dimension(128); + collection_schema.set_index_file_size(1024); + collection_schema.set_metric_type(1); + grpc_collection_name.set_collection_name(""); + // test invalid collection name + ::grpc::Status grpc_status = handler->DropCollection(&context, &grpc_collection_name, &response); + grpc_collection_name.set_collection_name(collection_name); - fiu_enable("DropCollectionRequest.OnExecute.db_not_found", 1, NULL, 0); - handler->DropTable(&context, &collection_name, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("DropCollectionRequest.OnExecute.db_not_found"); + fiu_enable("DropCollectionRequest.OnExecute.db_not_found", 1, NULL, 0); + handler->DropCollection(&context, &grpc_collection_name, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("DropCollectionRequest.OnExecute.db_not_found"); - fiu_enable("DropCollectionRequest.OnExecute.describe_table_fail", 1, NULL, 0); - handler->DropTable(&context, &collection_name, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("DropCollectionRequest.OnExecute.describe_table_fail"); + fiu_enable("DropCollectionRequest.OnExecute.describe_collection_fail", 1, NULL, 0); + handler->DropCollection(&context, &grpc_collection_name, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("DropCollectionRequest.OnExecute.describe_collection_fail"); - fiu_enable("DropCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); - handler->DropTable(&context, &collection_name, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("DropCollectionRequest.OnExecute.throw_std_exception"); + fiu_enable("DropCollectionRequest.OnExecute.throw_std_exception", 1, NULL, 0); + handler->DropCollection(&context, &grpc_collection_name, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("DropCollectionRequest.OnExecute.throw_std_exception"); - grpc_status = handler->DropTable(&context, &collection_name, &response); - ASSERT_EQ(grpc_status.error_code(), ::grpc::Status::OK.error_code()); - int error_code = response.error_code(); - ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS); + grpc_status = handler->DropCollection(&context, &grpc_collection_name, &response); + ASSERT_EQ(grpc_status.error_code(), ::grpc::Status::OK.error_code()); + int error_code = response.error_code(); + ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS); - tableschema.set_table_name(collection_name.table_name()); - handler->DropTable(&context, &collection_name, &response); - sleep(1); - handler->CreateTable(&context, &tableschema, &response); - ASSERT_EQ(response.error_code(), ::grpc::Status::OK.error_code()); + collection_schema.set_collection_name(grpc_collection_name.collection_name()); + handler->DropCollection(&context, &grpc_collection_name, &response); + sleep(1); + handler->CreateCollection(&context, &collection_schema, &response); + ASSERT_EQ(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_enable("DropCollectionRequest.OnExecute.drop_table_fail", 1, NULL, 0); - handler->DropTable(&context, &collection_name, &response); - ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("DropCollectionRequest.OnExecute.drop_table_fail"); + fiu_enable("DropCollectionRequest.OnExecute.drop_collection_fail", 1, NULL, 0); + handler->DropCollection(&context, &grpc_collection_name, &response); + ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); + fiu_disable("DropCollectionRequest.OnExecute.drop_collection_fail"); - handler->DropTable(&context, &collection_name, &response); + handler->DropCollection(&context, &grpc_collection_name, &response); + } } TEST_F(RpcHandlerTest, PARTITION_TEST) { ::grpc::ServerContext context; handler->SetContext(&context, dummy_context); handler->RegisterRequestHandler(milvus::server::RequestHandler()); - ::milvus::grpc::TableSchema table_schema; + ::milvus::grpc::CollectionSchema collection_schema; ::milvus::grpc::Status response; - std::string str_table_name = "tbl_partition"; - table_schema.set_table_name(str_table_name); - table_schema.set_dimension(TABLE_DIM); - table_schema.set_index_file_size(INDEX_FILE_SIZE); - table_schema.set_metric_type(1); - handler->CreateTable(&context, &table_schema, &response); + std::string str_collection_name = "tbl_partition"; + collection_schema.set_collection_name(str_collection_name); + collection_schema.set_dimension(COLLECTION_DIM); + collection_schema.set_index_file_size(INDEX_FILE_SIZE); + collection_schema.set_metric_type(1); + handler->CreateCollection(&context, &collection_schema, &response); ::milvus::grpc::PartitionParam partition_param; - partition_param.set_table_name(str_table_name); + partition_param.set_collection_name(str_collection_name); std::string partition_tag = "0"; partition_param.set_tag(partition_tag); handler->CreatePartition(&context, &partition_param, &response); ASSERT_EQ(response.error_code(), ::grpc::Status::OK.error_code()); - ::milvus::grpc::TableName collection_name; - collection_name.set_table_name(str_table_name); + ::milvus::grpc::CollectionName collection_name; + collection_name.set_collection_name(str_collection_name); ::milvus::grpc::PartitionList partition_list; handler->ShowPartitions(&context, &collection_name, &partition_list); ASSERT_EQ(response.error_code(), ::grpc::Status::OK.error_code()); ASSERT_EQ(partition_list.partition_tag_array_size(), 2); fiu_init(0); - fiu_enable("ShowPartitionsRequest.OnExecute.invalid_table_name", 1, NULL, 0); + fiu_enable("ShowPartitionsRequest.OnExecute.invalid_collection_name", 1, NULL, 0); handler->ShowPartitions(&context, &collection_name, &partition_list); - fiu_disable("ShowPartitionsRequest.OnExecute.invalid_table_name"); + fiu_disable("ShowPartitionsRequest.OnExecute.invalid_collection_name"); fiu_enable("ShowPartitionsRequest.OnExecute.show_partition_fail", 1, NULL, 0); handler->ShowPartitions(&context, &collection_name, &partition_list); fiu_disable("ShowPartitionsRequest.OnExecute.show_partition_fail"); fiu_init(0); - fiu_enable("CreatePartitionRequest.OnExecute.invalid_table_name", 1, NULL, 0); + fiu_enable("CreatePartitionRequest.OnExecute.invalid_collection_name", 1, NULL, 0); handler->CreatePartition(&context, &partition_param, &response); ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("CreatePartitionRequest.OnExecute.invalid_table_name"); + fiu_disable("CreatePartitionRequest.OnExecute.invalid_collection_name"); fiu_enable("CreatePartitionRequest.OnExecute.invalid_partition_name", 1, NULL, 0); handler->CreatePartition(&context, &partition_param, &response); @@ -901,13 +919,13 @@ TEST_F(RpcHandlerTest, PARTITION_TEST) { fiu_disable("CreatePartitionRequest.OnExecute.throw_std_exception"); ::milvus::grpc::PartitionParam partition_parm; - partition_parm.set_table_name(str_table_name); + partition_parm.set_collection_name(str_collection_name); partition_parm.set_tag(partition_tag); - fiu_enable("DropPartitionRequest.OnExecute.invalid_table_name", 1, NULL, 0); + fiu_enable("DropPartitionRequest.OnExecute.invalid_collection_name", 1, NULL, 0); handler->DropPartition(&context, &partition_parm, &response); ASSERT_NE(response.error_code(), ::grpc::Status::OK.error_code()); - fiu_disable("DropPartitionRequest.OnExecute.invalid_table_name"); + fiu_disable("DropPartitionRequest.OnExecute.invalid_collection_name"); handler->DropPartition(&context, &partition_parm, &response); ASSERT_EQ(response.error_code(), ::grpc::Status::OK.error_code()); diff --git a/core/unittest/server/test_util.cpp b/core/unittest/server/test_util.cpp index 9d65668518..2d81c83105 100644 --- a/core/unittest/server/test_util.cpp +++ b/core/unittest/server/test_util.cpp @@ -319,18 +319,18 @@ TEST(UtilTest, STATUS_TEST) { ASSERT_EQ(status_move.ToString(), status_ref.ToString()); } -TEST(ValidationUtilTest, VALIDATE_TABLENAME_TEST) { +TEST(ValidationUtilTest, VALIDATE_COLLECTION_NAME_TEST) { std::string collection_name = "Normal123_"; auto status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); ASSERT_TRUE(status.ok()); collection_name = "12sds"; status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); collection_name = ""; status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); collection_name = "_asdasd"; status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); @@ -338,23 +338,23 @@ TEST(ValidationUtilTest, VALIDATE_TABLENAME_TEST) { collection_name = "!@#!@"; status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); collection_name = "_!@#!@"; status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); collection_name = "中文"; status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); collection_name = std::string(10000, 'a'); status = milvus::server::ValidationUtil::ValidateCollectionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); collection_name = ""; status = milvus::server::ValidationUtil::ValidatePartitionName(collection_name); - ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME); + ASSERT_EQ(status.code(), milvus::SERVER_INVALID_COLLECTION_NAME); } TEST(ValidationUtilTest, VALIDATE_DIMENSION_TEST) { diff --git a/core/unittest/server/test_web.cpp b/core/unittest/server/test_web.cpp index a9f58e8848..3061e22597 100644 --- a/core/unittest/server/test_web.cpp +++ b/core/unittest/server/test_web.cpp @@ -43,8 +43,8 @@ #include "version.h" -static const char* TABLE_NAME = "test_web"; -static constexpr int64_t TABLE_DIM = 256; +static const char* COLLECTION_NAME = "test_web"; +static constexpr int64_t COLLECTION_DIM = 256; static constexpr int64_t INDEX_FILE_SIZE = 1024; static constexpr int64_t VECTOR_COUNT = 1000; static constexpr int64_t INSERT_LOOP = 10; @@ -255,11 +255,11 @@ class WebHandlerTest : public testing::Test { TEST_F(WebHandlerTest, TABLE) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); auto collection_dto = milvus::server::web::TableRequestDto::createShared(); collection_dto->collection_name = collection_name; - collection_dto->dimension = TABLE_DIM + 100000; + collection_dto->dimension = COLLECTION_DIM + 100000; collection_dto->index_file_size = INDEX_FILE_SIZE; collection_dto->metric_type = "L2"; @@ -268,7 +268,7 @@ TEST_F(WebHandlerTest, TABLE) { ASSERT_EQ(StatusCode::ILLEGAL_DIMENSION, status_dto->code->getValue()); // invalid index file size - collection_dto->dimension = TABLE_DIM; + collection_dto->dimension = COLLECTION_DIM; collection_dto->index_file_size = -1; status_dto = handler->CreateTable(collection_dto); ASSERT_EQ(StatusCode::ILLEGAL_ARGUMENT, status_dto->code->getValue()); @@ -291,12 +291,12 @@ TEST_F(WebHandlerTest, TABLE) { // drop collection which not exists. status_dto = handler->DropTable(collection_name + "57575yfhfdhfhdh436gdsgpppdgsgv3233"); - ASSERT_EQ(StatusCode::TABLE_NOT_EXISTS, status_dto->code->getValue()); + ASSERT_EQ(StatusCode::COLLECTION_NOT_EXISTS, status_dto->code->getValue()); } TEST_F(WebHandlerTest, HAS_COLLECTION_TEST) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 10, 10, "L2"); @@ -306,10 +306,10 @@ TEST_F(WebHandlerTest, HAS_COLLECTION_TEST) { ASSERT_EQ(0, status_dto->code->getValue()); } -TEST_F(WebHandlerTest, GET_TABLE) { +TEST_F(WebHandlerTest, GET_COLLECTION) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 10, 10, "L2"); milvus::server::web::OQueryParams query_params; @@ -326,7 +326,7 @@ TEST_F(WebHandlerTest, GET_TABLE) { TEST_F(WebHandlerTest, INSERT_COUNT) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 16, 10, "L2"); nlohmann::json body_json; @@ -351,7 +351,7 @@ TEST_F(WebHandlerTest, INSERT_COUNT) { TEST_F(WebHandlerTest, INDEX) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 16, 10, "L2"); nlohmann::json index_json; @@ -386,7 +386,7 @@ TEST_F(WebHandlerTest, INDEX) { TEST_F(WebHandlerTest, PARTITION) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 16, 10, "L2"); auto partition_dto = milvus::server::web::PartitionRequestDto::createShared(); @@ -418,17 +418,17 @@ TEST_F(WebHandlerTest, PARTITION) { TEST_F(WebHandlerTest, SEARCH) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); - GenTable(collection_name->std_str(), TABLE_DIM, 10, "L2"); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); + GenTable(collection_name->std_str(), COLLECTION_DIM, 10, "L2"); nlohmann::json insert_json; - insert_json["vectors"] = RandomRecordsJson(TABLE_DIM, 1000); + insert_json["vectors"] = RandomRecordsJson(COLLECTION_DIM, 1000); auto ids_dto = milvus::server::web::VectorIdsDto::createShared(); auto status_dto = handler->Insert(collection_name, insert_json.dump().c_str(), ids_dto); ASSERT_EQ(milvus::server::web::SUCCESS, status_dto->code->getValue()); nlohmann::json search_pram_json; - search_pram_json["vectors"] = RandomRecordsJson(TABLE_DIM, 10); + search_pram_json["vectors"] = RandomRecordsJson(COLLECTION_DIM, 10); search_pram_json["topk"] = 1; search_pram_json["params"] = nlohmann::json::parse("{\"nprobe\": 10}"); @@ -459,7 +459,7 @@ TEST_F(WebHandlerTest, SYSTEM_INFO) { TEST_F(WebHandlerTest, FLUSH) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 16, 10, "L2"); nlohmann::json body_json; @@ -478,7 +478,7 @@ TEST_F(WebHandlerTest, FLUSH) { TEST_F(WebHandlerTest, COMPACT) { handler->RegisterRequestHandler(milvus::server::RequestHandler()); - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(collection_name->std_str(), 16, 10, "L2"); nlohmann::json body_json; @@ -600,7 +600,7 @@ static const char* CONTROLLER_TEST_VALID_CONFIG_STR = ""; } // namespace -static const char* CONTROLLER_TEST_TABLE_NAME = "controller_unit_test"; +static const char* CONTROLLER_TEST_COLLECTION_NAME = "controller_unit_test"; static const char* CONTROLLER_TEST_CONFIG_DIR = "/tmp/milvus_web_controller_test/"; static const char* CONTROLLER_TEST_CONFIG_FILE = "config.yaml"; @@ -937,7 +937,7 @@ TEST_F(WebControllerTest, OPTIONS) { ASSERT_EQ(OStatus::CODE_204.code, response->getStatusCode()); } -TEST_F(WebControllerTest, CREATE_TABLE) { +TEST_F(WebControllerTest, CREATE_COLLECTION) { auto collection_dto = milvus::server::web::TableRequestDto::createShared(); auto response = client_ptr->createTable(collection_dto, conncetion_ptr); ASSERT_EQ(OStatus::CODE_400.code, response->getStatusCode()); @@ -967,7 +967,7 @@ TEST_F(WebControllerTest, CREATE_TABLE) { ASSERT_EQ(OStatus::CODE_400.code, response->getStatusCode()); } -TEST_F(WebControllerTest, GET_TABLE_META) { +TEST_F(WebControllerTest, GET_COLLECTION_META) { OString collection_name = "web_test_create_collection" + OString(RandomName().c_str()); GenTable(client_ptr, conncetion_ptr, collection_name, 10, 10, "L2"); @@ -987,14 +987,14 @@ TEST_F(WebControllerTest, GET_TABLE_META) { response = client_ptr->getTable(collection_name, "", conncetion_ptr); ASSERT_EQ(OStatus::CODE_400.code, response->getStatusCode()); auto status_sto = response->readBodyToDto(object_mapper.get()); - ASSERT_EQ(milvus::server::web::StatusCode::ILLEGAL_TABLE_NAME, status_sto->code->getValue()); + ASSERT_EQ(milvus::server::web::StatusCode::ILLEGAL_COLLECTION_NAME, status_sto->code->getValue()); collection_name = "test_collection_not_found_000000000111010101002020203020aaaaa3030435"; response = client_ptr->getTable(collection_name, "", conncetion_ptr); ASSERT_EQ(OStatus::CODE_404.code, response->getStatusCode()); } -TEST_F(WebControllerTest, GET_TABLE_STAT) { +TEST_F(WebControllerTest, GET_COLLECTION_STAT) { OString collection_name = "web_test_get_collection_stat" + OString(RandomName().c_str()); GenTable(client_ptr, conncetion_ptr, collection_name, 128, 5, "L2"); @@ -1025,7 +1025,7 @@ TEST_F(WebControllerTest, GET_TABLE_STAT) { ASSERT_TRUE(seg0_stat.contains("size")); } -TEST_F(WebControllerTest, SHOW_TABLES) { +TEST_F(WebControllerTest, SHOW_COLLECTIONS) { // test query collection limit 1 auto response = client_ptr->showTables("1", "1", conncetion_ptr); ASSERT_EQ(OStatus::CODE_200.code, response->getStatusCode()); @@ -1053,7 +1053,7 @@ TEST_F(WebControllerTest, SHOW_TABLES) { ASSERT_EQ(OStatus::CODE_400.code, response->getStatusCode()); } -TEST_F(WebControllerTest, DROP_TABLE) { +TEST_F(WebControllerTest, DROP_COLLECTION) { auto collection_name = "collection_drop_test" + OString(RandomName().c_str()); GenTable(client_ptr, conncetion_ptr, collection_name, 128, 100, "L2"); sleep(1); @@ -1065,7 +1065,7 @@ TEST_F(WebControllerTest, DROP_TABLE) { response = client_ptr->dropTable(collection_name, conncetion_ptr); ASSERT_EQ(OStatus::CODE_404.code, response->getStatusCode()); auto error_dto = response->readBodyToDto(object_mapper.get()); - ASSERT_EQ(milvus::server::web::StatusCode::TABLE_NOT_EXISTS, error_dto->code->getValue()); + ASSERT_EQ(milvus::server::web::StatusCode::COLLECTION_NOT_EXISTS, error_dto->code->getValue()); } TEST_F(WebControllerTest, INSERT) { @@ -1202,7 +1202,7 @@ TEST_F(WebControllerTest, INDEX) { response = client_ptr->getIndex(collection_name + "dfaedXXXdfdfet4t343aa4", conncetion_ptr); ASSERT_EQ(OStatus::CODE_404.code, response->getStatusCode()); auto error_dto = response->readBodyToDto(object_mapper.get()); - ASSERT_EQ(milvus::server::web::StatusCode::TABLE_NOT_EXISTS, error_dto->code->getValue()); + ASSERT_EQ(milvus::server::web::StatusCode::COLLECTION_NOT_EXISTS, error_dto->code->getValue()); } TEST_F(WebControllerTest, PARTITION) { @@ -1229,7 +1229,7 @@ TEST_F(WebControllerTest, PARTITION) { response = client_ptr->createPartition(collection_name + "afafanotgitdiexists", par_param); ASSERT_EQ(OStatus::CODE_404.code, response->getStatusCode()); error_dto = response->readBodyToDto(object_mapper.get()); - ASSERT_EQ(milvus::server::web::StatusCode::TABLE_NOT_EXISTS, error_dto->code); + ASSERT_EQ(milvus::server::web::StatusCode::COLLECTION_NOT_EXISTS, error_dto->code); // insert 200 vectors into collection with tag = 'tag01' auto status = InsertData(client_ptr, conncetion_ptr, collection_name, 64, 200, "tag01"); @@ -1255,7 +1255,7 @@ TEST_F(WebControllerTest, PARTITION) { response = client_ptr->showPartitions(collection_name + "dfafaefaluanqibazao990099", "0", "10", conncetion_ptr); ASSERT_EQ(OStatus::CODE_404.code, response->getStatusCode()); error_dto = response->readBodyToDto(object_mapper.get()); - ASSERT_EQ(milvus::server::web::StatusCode::TABLE_NOT_EXISTS, error_dto->code->getValue()); + ASSERT_EQ(milvus::server::web::StatusCode::COLLECTION_NOT_EXISTS, error_dto->code->getValue()); response = client_ptr->dropPartition(collection_name, "{\"partition_tag\": \"tag01\"}", conncetion_ptr); ASSERT_EQ(OStatus::CODE_204.code, response->getStatusCode()); @@ -1428,7 +1428,7 @@ TEST_F(WebControllerTest, SEARCH) { response = client_ptr->vectorsOp(collection_name + "999piyanning", search_json.dump().c_str(), conncetion_ptr); ASSERT_EQ(OStatus::CODE_404.code, response->getStatusCode()); error_dto = response->readBodyToDto(object_mapper.get()); - ASSERT_EQ(milvus::server::web::StatusCode::TABLE_NOT_EXISTS, error_dto->code->getValue()); + ASSERT_EQ(milvus::server::web::StatusCode::COLLECTION_NOT_EXISTS, error_dto->code->getValue()); } TEST_F(WebControllerTest, SEARCH_BIN) { @@ -1794,7 +1794,7 @@ TEST_F(WebControllerTest, DEVICES_CONFIG) { } TEST_F(WebControllerTest, FLUSH) { - auto collection_name = milvus::server::web::OString(TABLE_NAME) + RandomName().c_str(); + auto collection_name = milvus::server::web::OString(COLLECTION_NAME) + RandomName().c_str(); GenTable(client_ptr, conncetion_ptr, collection_name, 16, 10, "L2"); auto status = InsertData(client_ptr, conncetion_ptr, collection_name, 16, 1000); diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc index 3c127bcb18..2276765803 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.cc @@ -20,13 +20,13 @@ namespace milvus { namespace grpc { static const char* MilvusService_method_names[] = { - "/milvus.grpc.MilvusService/CreateTable", - "/milvus.grpc.MilvusService/HasTable", - "/milvus.grpc.MilvusService/DescribeTable", - "/milvus.grpc.MilvusService/CountTable", - "/milvus.grpc.MilvusService/ShowTables", - "/milvus.grpc.MilvusService/ShowTableInfo", - "/milvus.grpc.MilvusService/DropTable", + "/milvus.grpc.MilvusService/CreateCollection", + "/milvus.grpc.MilvusService/HasCollection", + "/milvus.grpc.MilvusService/DescribeCollection", + "/milvus.grpc.MilvusService/CountCollection", + "/milvus.grpc.MilvusService/ShowCollections", + "/milvus.grpc.MilvusService/ShowCollectionInfo", + "/milvus.grpc.MilvusService/DropCollection", "/milvus.grpc.MilvusService/CreateIndex", "/milvus.grpc.MilvusService/DescribeIndex", "/milvus.grpc.MilvusService/DropIndex", @@ -41,7 +41,7 @@ static const char* MilvusService_method_names[] = { "/milvus.grpc.MilvusService/SearchInFiles", "/milvus.grpc.MilvusService/Cmd", "/milvus.grpc.MilvusService/DeleteByID", - "/milvus.grpc.MilvusService/PreloadTable", + "/milvus.grpc.MilvusService/PreloadCollection", "/milvus.grpc.MilvusService/Flush", "/milvus.grpc.MilvusService/Compact", }; @@ -53,13 +53,13 @@ std::unique_ptr< MilvusService::Stub> MilvusService::NewStub(const std::shared_p } MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) - : channel_(channel), rpcmethod_CreateTable_(MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_HasTable_(MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DescribeTable_(MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_CountTable_(MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowTables_(MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_ShowTableInfo_(MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_DropTable_(MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + : channel_(channel), rpcmethod_CreateCollection_(MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_HasCollection_(MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DescribeCollection_(MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_CountCollection_(MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowCollections_(MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_ShowCollectionInfo_(MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_DropCollection_(MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_CreateIndex_(MilvusService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DescribeIndex_(MilvusService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DropIndex_(MilvusService_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) @@ -74,205 +74,205 @@ MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& chan , rpcmethod_SearchInFiles_(MilvusService_method_names[18], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Cmd_(MilvusService_method_names[19], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_DeleteByID_(MilvusService_method_names[20], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) - , rpcmethod_PreloadTable_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_PreloadCollection_(MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Flush_(MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) , rpcmethod_Compact_(MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) {} -::grpc::Status MilvusService::Stub::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateTable_, context, request, response); +::grpc::Status MilvusService::Stub::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasTable_, context, request, response); +::grpc::Status MilvusService::Stub::HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeTable_, context, request, response); +::grpc::Status MilvusService::Stub::DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionSchema* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableSchema>::Create(channel_.get(), cq, rpcmethod_DescribeTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* MilvusService::Stub::AsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionSchema>::Create(channel_.get(), cq, rpcmethod_DescribeCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableSchema>::Create(channel_.get(), cq, rpcmethod_DescribeTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* MilvusService::Stub::PrepareAsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionSchema>::Create(channel_.get(), cq, rpcmethod_DescribeCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountTable_, context, request, response); +::grpc::Status MilvusService::Stub::CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::AsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* MilvusService::Stub::PrepareAsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionRowCount>::Create(channel_.get(), cq, rpcmethod_CountCollection_, context, request, false); } -::grpc::Status MilvusService::Stub::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowTables_, context, request, response); +::grpc::Status MilvusService::Stub::ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::CollectionNameList* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowCollections_, context, request, response); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollections_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* MilvusService::Stub::AsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionNameList>::Create(channel_.get(), cq, rpcmethod_ShowCollections_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* MilvusService::Stub::PrepareAsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionNameList>::Create(channel_.get(), cq, rpcmethod_ShowCollections_, context, request, false); } -::grpc::Status MilvusService::Stub::ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableInfo* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowTableInfo_, context, request, response); +::grpc::Status MilvusService::Stub::ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowCollectionInfo_, context, request, response); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTableInfo_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowCollectionInfo_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* MilvusService::Stub::AsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableInfo>::Create(channel_.get(), cq, rpcmethod_ShowTableInfo_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::AsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowCollectionInfo_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* MilvusService::Stub::PrepareAsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableInfo>::Create(channel_.get(), cq, rpcmethod_ShowTableInfo_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* MilvusService::Stub::PrepareAsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::CollectionInfo>::Create(channel_.get(), cq, rpcmethod_ShowCollectionInfo_, context, request, false); } -::grpc::Status MilvusService::Stub::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropTable_, context, request, response); +::grpc::Status MilvusService::Stub::DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropCollection_, context, request, false); } ::grpc::Status MilvusService::Stub::CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) { @@ -303,11 +303,11 @@ void MilvusService::Stub::experimental_async::CreateIndex(::grpc::ClientContext* return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateIndex_, context, request, false); } -::grpc::Status MilvusService::Stub::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) { +::grpc::Status MilvusService::Stub::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::IndexParam* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeIndex_, context, request, response); } -void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function f) { +void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, std::move(f)); } @@ -315,7 +315,7 @@ void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContex ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, reactor); } @@ -323,19 +323,19 @@ void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContex ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::IndexParam>::Create(channel_.get(), cq, rpcmethod_DescribeIndex_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::IndexParam>::Create(channel_.get(), cq, rpcmethod_DescribeIndex_, context, request, false); } -::grpc::Status MilvusService::Stub::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Stub::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropIndex_, context, request, response); } -void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { +void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, std::move(f)); } @@ -343,7 +343,7 @@ void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* c ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, reactor); } @@ -351,11 +351,11 @@ void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* c ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropIndex_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropIndex_, context, request, false); } @@ -387,11 +387,11 @@ void MilvusService::Stub::experimental_async::CreatePartition(::grpc::ClientCont return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreatePartition_, context, request, false); } -::grpc::Status MilvusService::Stub::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::PartitionList* response) { +::grpc::Status MilvusService::Stub::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::PartitionList* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowPartitions_, context, request, response); } -void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, std::function f) { +void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, std::move(f)); } @@ -399,7 +399,7 @@ void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientConte ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, reactor); } @@ -407,11 +407,11 @@ void MilvusService::Stub::experimental_async::ShowPartitions(::grpc::ClientConte ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowPartitions_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::PartitionList>::Create(channel_.get(), cq, rpcmethod_ShowPartitions_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* MilvusService::Stub::PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::PartitionList>::Create(channel_.get(), cq, rpcmethod_ShowPartitions_, context, request, false); } @@ -667,32 +667,32 @@ void MilvusService::Stub::experimental_async::DeleteByID(::grpc::ClientContext* return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteByID_, context, request, false); } -::grpc::Status MilvusService::Stub::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { - return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadTable_, context, request, response); +::grpc::Status MilvusService::Stub::PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadCollection_, context, request, response); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { - ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, std::move(f)); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function f) { + ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, reactor); } -void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { - ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, reactor); +void MilvusService::Stub::experimental_async::PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { + ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadCollection_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadTable_, context, request, true); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadCollection_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadTable_, context, request, false); +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadCollection_, context, request, false); } ::grpc::Status MilvusService::Stub::Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) { @@ -723,11 +723,11 @@ void MilvusService::Stub::experimental_async::Flush(::grpc::ClientContext* conte return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Flush_, context, request, false); } -::grpc::Status MilvusService::Stub::Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Stub::Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) { return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Compact_, context, request, response); } -void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function f) { +void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function f) { ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, std::move(f)); } @@ -735,7 +735,7 @@ void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* con ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, std::move(f)); } -void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { +void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) { ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, reactor); } @@ -743,11 +743,11 @@ void MilvusService::Stub::experimental_async::Compact(::grpc::ClientContext* con ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Compact_, context, request, response, reactor); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Compact_, context, request, true); } -::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { +::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_Compact_, context, request, false); } @@ -755,38 +755,38 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableSchema, ::milvus::grpc::Status>( - std::mem_fn(&MilvusService::Service::CreateTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::CreateCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>( - std::mem_fn(&MilvusService::Service::HasTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( + std::mem_fn(&MilvusService::Service::HasCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>( - std::mem_fn(&MilvusService::Service::DescribeTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>( + std::mem_fn(&MilvusService::Service::DescribeCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>( - std::mem_fn(&MilvusService::Service::CountTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( + std::mem_fn(&MilvusService::Service::CountCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::TableNameList>( - std::mem_fn(&MilvusService::Service::ShowTables), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>( + std::mem_fn(&MilvusService::Service::ShowCollections), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>( - std::mem_fn(&MilvusService::Service::ShowTableInfo), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( + std::mem_fn(&MilvusService::Service::ShowCollectionInfo), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( - std::mem_fn(&MilvusService::Service::DropTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::DropCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, @@ -795,12 +795,12 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>( std::mem_fn(&MilvusService::Service::DescribeIndex), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::DropIndex), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[10], @@ -810,7 +810,7 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>( std::mem_fn(&MilvusService::Service::ShowPartitions), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[12], @@ -860,8 +860,8 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[21], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( - std::mem_fn(&MilvusService::Service::PreloadTable), this))); + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( + std::mem_fn(&MilvusService::Service::PreloadCollection), this))); AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[22], ::grpc::internal::RpcMethod::NORMAL_RPC, @@ -870,56 +870,56 @@ MilvusService::Service::Service() { AddMethod(new ::grpc::internal::RpcServiceMethod( MilvusService_method_names[23], ::grpc::internal::RpcMethod::NORMAL_RPC, - new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( std::mem_fn(&MilvusService::Service::Compact), this))); } MilvusService::Service::~Service() { } -::grpc::Status MilvusService::Service::CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::CreateCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) { +::grpc::Status MilvusService::Service::HasCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) { +::grpc::Status MilvusService::Service::DescribeCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) { +::grpc::Status MilvusService::Service::CountCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) { +::grpc::Status MilvusService::Service::ShowCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::ShowTableInfo(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response) { +::grpc::Status MilvusService::Service::ShowCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::DropCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; @@ -933,14 +933,14 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) { +::grpc::Status MilvusService::Service::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response) { (void) context; (void) request; (void) response; return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; @@ -954,7 +954,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response) { +::grpc::Status MilvusService::Service::ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response) { (void) context; (void) request; (void) response; @@ -1024,7 +1024,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; @@ -1038,7 +1038,7 @@ MilvusService::Service::~Service() { return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } -::grpc::Status MilvusService::Service::Compact(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) { +::grpc::Status MilvusService::Service::Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response) { (void) context; (void) request; (void) response; diff --git a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h index 511445f4df..c9f00d5e92 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.grpc.pb.h @@ -48,98 +48,98 @@ class MilvusService final { public: virtual ~StubInterface() {} // * - // @brief This method is used to create table + // @brief This method is used to create collection // - // @param TableSchema, use to provide table information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status - virtual ::grpc::Status CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateTableRaw(context, request, cq)); + virtual ::grpc::Status CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateCollectionRaw(context, request, cq)); } // * - // @brief This method is used to test table existence. + // @brief This method is used to test collection existence. // - // @param TableName, table name is going to be tested. + // @param CollectionName, collection name is going to be tested. // // @return BoolReply - virtual ::grpc::Status HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasTableRaw(context, request, cq)); + virtual ::grpc::Status HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasCollectionRaw(context, request, cq)); } // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableSchema - virtual ::grpc::Status DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>> AsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>>(AsyncDescribeTableRaw(context, request, cq)); + // @return CollectionSchema + virtual ::grpc::Status DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionSchema* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>> AsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>>(AsyncDescribeCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>> PrepareAsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>>(PrepareAsyncDescribeTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>> PrepareAsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>>(PrepareAsyncDescribeCollectionRaw(context, request, cq)); } // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableRowCount - virtual ::grpc::Status CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>> AsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>>(AsyncCountTableRaw(context, request, cq)); + // @return CollectionRowCount + virtual ::grpc::Status CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> AsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(AsyncCountCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountCollectionRaw(context, request, cq)); } // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // - // @return TableNameList - virtual ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq)); + // @return CollectionNameList + virtual ::grpc::Status ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::CollectionNameList* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>> AsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>>(AsyncShowCollectionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>> PrepareAsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>>(PrepareAsyncShowCollectionsRaw(context, request, cq)); } // * - // @brief This method is used to get table detail information. + // @brief This method is used to get collection detail information. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableInfo - virtual ::grpc::Status ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableInfo* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>> AsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>>(AsyncShowTableInfoRaw(context, request, cq)); + // @return CollectionInfo + virtual ::grpc::Status ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> AsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(AsyncShowCollectionInfoRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>> PrepareAsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>>(PrepareAsyncShowTableInfoRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowCollectionInfoRaw(context, request, cq)); } // * - // @brief This method is used to delete table. + // @brief This method is used to delete collection. // - // @param TableName, table name is going to be deleted. + // @param CollectionName, collection name is going to be deleted. // - // @return TableNameList - virtual ::grpc::Status DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropTableRaw(context, request, cq)); + // @return CollectionNameList + virtual ::grpc::Status DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropCollectionRaw(context, request, cq)); } // * - // @brief This method is used to build index by table in sync mode. + // @brief This method is used to build index by collection in sync mode. // // @param IndexParam, index paramters. // @@ -154,27 +154,27 @@ class MilvusService final { // * // @brief This method is used to describe index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return IndexParam - virtual ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::IndexParam* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>>(AsyncDescribeIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>>(PrepareAsyncDescribeIndexRaw(context, request, cq)); } // * // @brief This method is used to drop index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropIndexRaw(context, request, cq)); } // * @@ -193,14 +193,14 @@ class MilvusService final { // * // @brief This method is used to show partition information // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return PartitionList - virtual ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::PartitionList* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::PartitionList* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>>(AsyncShowPartitionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>>(PrepareAsyncShowPartitionsRaw(context, request, cq)); } // * @@ -217,7 +217,7 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropPartitionRaw(context, request, cq)); } // * - // @brief This method is used to add vector array to table. + // @brief This method is used to add vector array to collection. // // @param InsertParam, insert parameters. // @@ -245,7 +245,7 @@ class MilvusService final { // * // @brief This method is used to get vector ids from a segment // - // @param GetVectorIDsParam, target table and segment + // @param GetVectorIDsParam, target collection and segment // // @return VectorIds virtual ::grpc::Status GetVectorIDs(::grpc::ClientContext* context, const ::milvus::grpc::GetVectorIDsParam& request, ::milvus::grpc::VectorIds* response) = 0; @@ -256,7 +256,7 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>>(PrepareAsyncGetVectorIDsRaw(context, request, cq)); } // * - // @brief This method is used to query vector in table. + // @brief This method is used to query vector in collection. // // @param SearchParam, search parameters. // @@ -321,17 +321,17 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDeleteByIDRaw(context, request, cq)); } // * - // @brief This method is used to preload table + // @brief This method is used to preload collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadTableRaw(context, request, cq)); + virtual ::grpc::Status PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } // * // @brief This method is used to flush buffer into storage. @@ -347,93 +347,93 @@ class MilvusService final { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncFlushRaw(context, request, cq)); } // * - // @brief This method is used to compact table + // @brief This method is used to compact collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0; - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + virtual ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCompactRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } class experimental_async_interface { public: virtual ~experimental_async_interface() {} // * - // @brief This method is used to create table + // @brief This method is used to create collection // - // @param TableSchema, use to provide table information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status - virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to test table existence. + // @brief This method is used to test collection existence. // - // @param TableName, table name is going to be tested. + // @param CollectionName, collection name is going to be tested. // // @return BoolReply - virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function) = 0; - virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) = 0; - virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableSchema - virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function) = 0; - virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function) = 0; - virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionSchema + virtual void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, std::function) = 0; + virtual void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, std::function) = 0; + virtual void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableRowCount - virtual void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function) = 0; - virtual void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function) = 0; - virtual void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionRowCount + virtual void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) = 0; + virtual void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // - // @return TableNameList - virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function) = 0; - virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function) = 0; - virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionNameList + virtual void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, std::function) = 0; + virtual void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, std::function) = 0; + virtual void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to get table detail information. + // @brief This method is used to get collection detail information. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableInfo - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, std::function) = 0; - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, std::function) = 0; - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionInfo + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) = 0; + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to delete table. + // @brief This method is used to delete collection. // - // @param TableName, table name is going to be deleted. + // @param CollectionName, collection name is going to be deleted. // - // @return TableNameList - virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + // @return CollectionNameList + virtual void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to build index by table in sync mode. + // @brief This method is used to build index by collection in sync mode. // // @param IndexParam, index paramters. // @@ -445,22 +445,22 @@ class MilvusService final { // * // @brief This method is used to describe index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return IndexParam - virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function) = 0; + virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, std::function) = 0; virtual void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function) = 0; - virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to drop index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; virtual void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to create partition @@ -475,12 +475,12 @@ class MilvusService final { // * // @brief This method is used to show partition information // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return PartitionList - virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, std::function) = 0; + virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, std::function) = 0; virtual void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, std::function) = 0; - virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to drop partition @@ -493,7 +493,7 @@ class MilvusService final { virtual void DropPartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DropPartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to add vector array to table. + // @brief This method is used to add vector array to collection. // // @param InsertParam, insert parameters. // @@ -515,7 +515,7 @@ class MilvusService final { // * // @brief This method is used to get vector ids from a segment // - // @param GetVectorIDsParam, target table and segment + // @param GetVectorIDsParam, target collection and segment // // @return VectorIds virtual void GetVectorIDs(::grpc::ClientContext* context, const ::milvus::grpc::GetVectorIDsParam* request, ::milvus::grpc::VectorIds* response, std::function) = 0; @@ -523,7 +523,7 @@ class MilvusService final { virtual void GetVectorIDs(::grpc::ClientContext* context, const ::milvus::grpc::GetVectorIDsParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void GetVectorIDs(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to query vector in table. + // @brief This method is used to query vector in collection. // // @param SearchParam, search parameters. // @@ -573,15 +573,15 @@ class MilvusService final { virtual void DeleteByID(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void DeleteByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to preload table + // @brief This method is used to preload collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; - virtual void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * // @brief This method is used to flush buffer into storage. // @@ -593,42 +593,42 @@ class MilvusService final { virtual void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; // * - // @brief This method is used to compact table + // @brief This method is used to compact collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) = 0; + virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) = 0; virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) = 0; - virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; + virtual void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; virtual void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0; }; virtual class experimental_async_interface* experimental_async() { return nullptr; } private: - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>* AsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableInfo>* PrepareAsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>* AsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionSchema>* PrepareAsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* AsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>* AsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionNameList>* PrepareAsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* AsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) = 0; @@ -647,64 +647,64 @@ class MilvusService final { virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; - virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) = 0; }; class Stub final : public StubInterface { public: Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); - ::grpc::Status CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateTableRaw(context, request, cq)); + ::grpc::Status CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateCollectionRaw(context, request, cq)); } - ::grpc::Status HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasTableRaw(context, request, cq)); + ::grpc::Status HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::BoolReply* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasCollectionRaw(context, request, cq)); } - ::grpc::Status DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>> AsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>>(AsyncDescribeTableRaw(context, request, cq)); + ::grpc::Status DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionSchema* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>> AsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>>(AsyncDescribeCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>> PrepareAsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>>(PrepareAsyncDescribeTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>> PrepareAsyncDescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>>(PrepareAsyncDescribeCollectionRaw(context, request, cq)); } - ::grpc::Status CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> AsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(AsyncCountTableRaw(context, request, cq)); + ::grpc::Status CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionRowCount* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> AsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(AsyncCountCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>> PrepareAsyncCountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>>(PrepareAsyncCountCollectionRaw(context, request, cq)); } - ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq)); + ::grpc::Status ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::CollectionNameList* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>> AsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>>(AsyncShowCollectionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>> PrepareAsyncShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>>(PrepareAsyncShowCollectionsRaw(context, request, cq)); } - ::grpc::Status ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableInfo* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>> AsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>>(AsyncShowTableInfoRaw(context, request, cq)); + ::grpc::Status ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::CollectionInfo* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> AsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(AsyncShowCollectionInfoRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>> PrepareAsyncShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>>(PrepareAsyncShowTableInfoRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>> PrepareAsyncShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>>(PrepareAsyncShowCollectionInfoRaw(context, request, cq)); } - ::grpc::Status DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropTableRaw(context, request, cq)); + ::grpc::Status DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropCollectionRaw(context, request, cq)); } ::grpc::Status CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) { @@ -713,18 +713,18 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateIndexRaw(context, request, cq)); } - ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::IndexParam* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>>(AsyncDescribeIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>>(PrepareAsyncDescribeIndexRaw(context, request, cq)); } - ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropIndexRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropIndexRaw(context, request, cq)); } ::grpc::Status CreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::milvus::grpc::Status* response) override; @@ -734,11 +734,11 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreatePartitionRaw(context, request, cq)); } - ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::PartitionList* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::PartitionList* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> AsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>>(AsyncShowPartitionsRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>> PrepareAsyncShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>>(PrepareAsyncShowPartitionsRaw(context, request, cq)); } ::grpc::Status DropPartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::milvus::grpc::Status* response) override; @@ -804,12 +804,12 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDeleteByID(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDeleteByIDRaw(context, request, cq)); } - ::grpc::Status PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadTableRaw(context, request, cq)); + ::grpc::Status PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadCollectionRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { - return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadTableRaw(context, request, cq)); + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadCollectionRaw(context, request, cq)); } ::grpc::Status Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::milvus::grpc::Status* response) override; std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncFlush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) { @@ -818,63 +818,63 @@ class MilvusService final { std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncFlush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncFlushRaw(context, request, cq)); } - ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override; - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + ::grpc::Status Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::milvus::grpc::Status* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCompactRaw(context, request, cq)); } - std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) { + std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCompact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) { return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCompactRaw(context, request, cq)); } class experimental_async final : public StubInterface::experimental_async_interface { public: - void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function) override; - void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function) override; - void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) override; - void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function) override; - void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function) override; - void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function) override; - void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function) override; - void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function) override; - void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function) override; - void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, std::function) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, std::function) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowTableInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; - void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, std::function) override; + void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void CreateCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CreateCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function) override; + void HasCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void HasCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, std::function) override; + void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, std::function) override; + void DescribeCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, std::function) override; + void CountCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void CountCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, std::function) override; + void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, std::function) override; + void ShowCollections(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollections(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, std::function) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowCollectionInfo(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void DropCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, std::function) override; void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function) override; + void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, std::function) override; void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function) override; - void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; + void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, std::function) override; void CreatePartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void CreatePartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void CreatePartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, std::function) override; + void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, std::function) override; void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, std::function) override; - void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void ShowPartitions(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void ShowPartitions(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DropPartition(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response, std::function) override; void DropPartition(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; @@ -912,17 +912,17 @@ class MilvusService final { void DeleteByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void DeleteByID(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void DeleteByID(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; - void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; + void PreloadCollection(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void PreloadCollection(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; void Flush(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Flush(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; - void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function) override; + void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, std::function) override; void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function) override; - void Compact(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; + void Compact(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; void Compact(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override; private: friend class Stub; @@ -935,30 +935,30 @@ class MilvusService final { private: std::shared_ptr< ::grpc::ChannelInterface> channel_; class experimental_async async_stub_{this}; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* AsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableInfo>* PrepareAsyncShowTableInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionSchema& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* AsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionSchema>* PrepareAsyncDescribeCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* AsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionRowCount>* PrepareAsyncCountCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* AsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionNameList>* PrepareAsyncShowCollectionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* AsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::CollectionInfo>* PrepareAsyncShowCollectionInfoRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreatePartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* AsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::PartitionList>* PrepareAsyncShowPartitionsRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropPartitionRaw(::grpc::ClientContext* context, const ::milvus::grpc::PartitionParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) override; @@ -977,19 +977,19 @@ class MilvusService final { ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteByIDRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByIDParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadCollectionRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncFlushRaw(::grpc::ClientContext* context, const ::milvus::grpc::FlushParam& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override; - const ::grpc::internal::RpcMethod rpcmethod_CreateTable_; - const ::grpc::internal::RpcMethod rpcmethod_HasTable_; - const ::grpc::internal::RpcMethod rpcmethod_DescribeTable_; - const ::grpc::internal::RpcMethod rpcmethod_CountTable_; - const ::grpc::internal::RpcMethod rpcmethod_ShowTables_; - const ::grpc::internal::RpcMethod rpcmethod_ShowTableInfo_; - const ::grpc::internal::RpcMethod rpcmethod_DropTable_; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCompactRaw(::grpc::ClientContext* context, const ::milvus::grpc::CollectionName& request, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_CreateCollection_; + const ::grpc::internal::RpcMethod rpcmethod_HasCollection_; + const ::grpc::internal::RpcMethod rpcmethod_DescribeCollection_; + const ::grpc::internal::RpcMethod rpcmethod_CountCollection_; + const ::grpc::internal::RpcMethod rpcmethod_ShowCollections_; + const ::grpc::internal::RpcMethod rpcmethod_ShowCollectionInfo_; + const ::grpc::internal::RpcMethod rpcmethod_DropCollection_; const ::grpc::internal::RpcMethod rpcmethod_CreateIndex_; const ::grpc::internal::RpcMethod rpcmethod_DescribeIndex_; const ::grpc::internal::RpcMethod rpcmethod_DropIndex_; @@ -1004,7 +1004,7 @@ class MilvusService final { const ::grpc::internal::RpcMethod rpcmethod_SearchInFiles_; const ::grpc::internal::RpcMethod rpcmethod_Cmd_; const ::grpc::internal::RpcMethod rpcmethod_DeleteByID_; - const ::grpc::internal::RpcMethod rpcmethod_PreloadTable_; + const ::grpc::internal::RpcMethod rpcmethod_PreloadCollection_; const ::grpc::internal::RpcMethod rpcmethod_Flush_; const ::grpc::internal::RpcMethod rpcmethod_Compact_; }; @@ -1015,56 +1015,56 @@ class MilvusService final { Service(); virtual ~Service(); // * - // @brief This method is used to create table + // @brief This method is used to create collection // - // @param TableSchema, use to provide table information to be created. + // @param CollectionSchema, use to provide collection information to be created. // // @return Status - virtual ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status CreateCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to test table existence. + // @brief This method is used to test collection existence. // - // @param TableName, table name is going to be tested. + // @param CollectionName, collection name is going to be tested. // // @return BoolReply - virtual ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response); + virtual ::grpc::Status HasCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response); // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableSchema - virtual ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response); + // @return CollectionSchema + virtual ::grpc::Status DescribeCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionSchema* response); // * - // @brief This method is used to get table schema. + // @brief This method is used to get collection schema. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableRowCount - virtual ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response); + // @return CollectionRowCount + virtual ::grpc::Status CountCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionRowCount* response); // * - // @brief This method is used to list all tables. + // @brief This method is used to list all collections. // // @param Command, dummy parameter. // - // @return TableNameList - virtual ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response); + // @return CollectionNameList + virtual ::grpc::Status ShowCollections(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::CollectionNameList* response); // * - // @brief This method is used to get table detail information. + // @brief This method is used to get collection detail information. // - // @param TableName, target table name. + // @param CollectionName, target collection name. // - // @return TableInfo - virtual ::grpc::Status ShowTableInfo(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableInfo* response); + // @return CollectionInfo + virtual ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::CollectionInfo* response); // * - // @brief This method is used to delete table. + // @brief This method is used to delete collection. // - // @param TableName, table name is going to be deleted. + // @param CollectionName, collection name is going to be deleted. // - // @return TableNameList - virtual ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + // @return CollectionNameList + virtual ::grpc::Status DropCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to build index by table in sync mode. + // @brief This method is used to build index by collection in sync mode. // // @param IndexParam, index paramters. // @@ -1073,17 +1073,17 @@ class MilvusService final { // * // @brief This method is used to describe index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return IndexParam - virtual ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response); + virtual ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response); // * // @brief This method is used to drop index // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * // @brief This method is used to create partition // @@ -1094,10 +1094,10 @@ class MilvusService final { // * // @brief This method is used to show partition information // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return PartitionList - virtual ::grpc::Status ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::PartitionList* response); + virtual ::grpc::Status ShowPartitions(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response); // * // @brief This method is used to drop partition // @@ -1106,7 +1106,7 @@ class MilvusService final { // @return Status virtual ::grpc::Status DropPartition(::grpc::ServerContext* context, const ::milvus::grpc::PartitionParam* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to add vector array to table. + // @brief This method is used to add vector array to collection. // // @param InsertParam, insert parameters. // @@ -1122,12 +1122,12 @@ class MilvusService final { // * // @brief This method is used to get vector ids from a segment // - // @param GetVectorIDsParam, target table and segment + // @param GetVectorIDsParam, target collection and segment // // @return VectorIds virtual ::grpc::Status GetVectorIDs(::grpc::ServerContext* context, const ::milvus::grpc::GetVectorIDsParam* request, ::milvus::grpc::VectorIds* response); // * - // @brief This method is used to query vector in table. + // @brief This method is used to query vector in collection. // // @param SearchParam, search parameters. // @@ -1162,12 +1162,12 @@ class MilvusService final { // @return status virtual ::grpc::Status DeleteByID(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByIDParam* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to preload table + // @brief This method is used to preload collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status PreloadCollection(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); // * // @brief This method is used to flush buffer into storage. // @@ -1176,150 +1176,150 @@ class MilvusService final { // @return Status virtual ::grpc::Status Flush(::grpc::ServerContext* context, const ::milvus::grpc::FlushParam* request, ::milvus::grpc::Status* response); // * - // @brief This method is used to compact table + // @brief This method is used to compact collection // - // @param TableName, target table name. + // @param CollectionName, target collection name. // // @return Status - virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response); + virtual ::grpc::Status Compact(::grpc::ServerContext* context, const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response); }; template - class WithAsyncMethod_CreateTable : public BaseClass { + class WithAsyncMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_CreateTable() { + WithAsyncMethod_CreateCollection() { ::grpc::Service::MarkMethodAsync(0); } - ~WithAsyncMethod_CreateTable() override { + ~WithAsyncMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCreateTable(::grpc::ServerContext* context, ::milvus::grpc::TableSchema* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCreateCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionSchema* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_HasTable : public BaseClass { + class WithAsyncMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_HasTable() { + WithAsyncMethod_HasCollection() { ::grpc::Service::MarkMethodAsync(1); } - ~WithAsyncMethod_HasTable() override { + ~WithAsyncMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestHasTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestHasCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_DescribeTable : public BaseClass { + class WithAsyncMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_DescribeTable() { + WithAsyncMethod_DescribeCollection() { ::grpc::Service::MarkMethodAsync(2); } - ~WithAsyncMethod_DescribeTable() override { + ~WithAsyncMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDescribeTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableSchema>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDescribeCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionSchema>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_CountTable : public BaseClass { + class WithAsyncMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_CountTable() { + WithAsyncMethod_CountCollection() { ::grpc::Service::MarkMethodAsync(3); } - ~WithAsyncMethod_CountTable() override { + ~WithAsyncMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCountTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCountCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_ShowTables : public BaseClass { + class WithAsyncMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_ShowTables() { + WithAsyncMethod_ShowCollections() { ::grpc::Service::MarkMethodAsync(4); } - ~WithAsyncMethod_ShowTables() override { + ~WithAsyncMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTables(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableNameList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollections(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionNameList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_ShowTableInfo : public BaseClass { + class WithAsyncMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_ShowTableInfo() { + WithAsyncMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodAsync(5); } - ~WithAsyncMethod_ShowTableInfo() override { + ~WithAsyncMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTableInfo(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollectionInfo(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::CollectionInfo>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithAsyncMethod_DropTable : public BaseClass { + class WithAsyncMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_DropTable() { + WithAsyncMethod_DropCollection() { ::grpc::Service::MarkMethodAsync(6); } - ~WithAsyncMethod_DropTable() override { + ~WithAsyncMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDropTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDropCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1355,11 +1355,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDescribeIndex(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::IndexParam>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDescribeIndex(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::IndexParam>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1375,11 +1375,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDropIndex(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDropIndex(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1415,11 +1415,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowPartitions(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::PartitionList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowPartitions(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::PartitionList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1604,22 +1604,22 @@ class MilvusService final { } }; template - class WithAsyncMethod_PreloadTable : public BaseClass { + class WithAsyncMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithAsyncMethod_PreloadTable() { + WithAsyncMethod_PreloadCollection() { ::grpc::Service::MarkMethodAsync(21); } - ~WithAsyncMethod_PreloadTable() override { + ~WithAsyncMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPreloadTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestPreloadCollection(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(21, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -1655,231 +1655,231 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCompact(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCompact(::grpc::ServerContext* context, ::milvus::grpc::CollectionName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(23, context, request, response, new_call_cq, notification_cq, tag); } }; - typedef WithAsyncMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > AsyncService; + typedef WithAsyncMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > AsyncService; template - class ExperimentalWithCallbackMethod_CreateTable : public BaseClass { + class ExperimentalWithCallbackMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_CreateTable() { + ExperimentalWithCallbackMethod_CreateCollection() { ::grpc::Service::experimental().MarkMethodCallback(0, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableSchema* request, + const ::milvus::grpc::CollectionSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->CreateTable(context, request, response, controller); + return this->CreateCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_CreateTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>*>( + void SetMessageAllocatorFor_CreateCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(0)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_CreateTable() override { + ~ExperimentalWithCallbackMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_HasTable : public BaseClass { + class ExperimentalWithCallbackMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_HasTable() { + ExperimentalWithCallbackMethod_HasCollection() { ::grpc::Service::experimental().MarkMethodCallback(1, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->HasTable(context, request, response, controller); + return this->HasCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_HasTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>*>( + void SetMessageAllocatorFor_HasCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>*>( ::grpc::Service::experimental().GetHandler(1)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_HasTable() override { + ~ExperimentalWithCallbackMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_DescribeTable : public BaseClass { + class ExperimentalWithCallbackMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_DescribeTable() { + ExperimentalWithCallbackMethod_DescribeCollection() { ::grpc::Service::experimental().MarkMethodCallback(2, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableSchema* response, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionSchema* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->DescribeTable(context, request, response, controller); + return this->DescribeCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_DescribeTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>*>( + void SetMessageAllocatorFor_DescribeCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>*>( ::grpc::Service::experimental().GetHandler(2)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_DescribeTable() override { + ~ExperimentalWithCallbackMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_CountTable : public BaseClass { + class ExperimentalWithCallbackMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_CountTable() { + ExperimentalWithCallbackMethod_CountCollection() { ::grpc::Service::experimental().MarkMethodCallback(3, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableRowCount* response, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionRowCount* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->CountTable(context, request, response, controller); + return this->CountCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_CountTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>*>( + void SetMessageAllocatorFor_CountCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>*>( ::grpc::Service::experimental().GetHandler(3)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_CountTable() override { + ~ExperimentalWithCallbackMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_ShowTables : public BaseClass { + class ExperimentalWithCallbackMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_ShowTables() { + ExperimentalWithCallbackMethod_ShowCollections() { ::grpc::Service::experimental().MarkMethodCallback(4, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>( [this](::grpc::ServerContext* context, const ::milvus::grpc::Command* request, - ::milvus::grpc::TableNameList* response, + ::milvus::grpc::CollectionNameList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->ShowTables(context, request, response, controller); + return this->ShowCollections(context, request, response, controller); })); } - void SetMessageAllocatorFor_ShowTables( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>*>( + void SetMessageAllocatorFor_ShowCollections( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>*>( ::grpc::Service::experimental().GetHandler(4)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_ShowTables() override { + ~ExperimentalWithCallbackMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_ShowTableInfo : public BaseClass { + class ExperimentalWithCallbackMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_ShowTableInfo() { + ExperimentalWithCallbackMethod_ShowCollectionInfo() { ::grpc::Service::experimental().MarkMethodCallback(5, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, - ::milvus::grpc::TableInfo* response, + const ::milvus::grpc::CollectionName* request, + ::milvus::grpc::CollectionInfo* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->ShowTableInfo(context, request, response, controller); + return this->ShowCollectionInfo(context, request, response, controller); })); } - void SetMessageAllocatorFor_ShowTableInfo( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>*>( + void SetMessageAllocatorFor_ShowCollectionInfo( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>*>( ::grpc::Service::experimental().GetHandler(5)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_ShowTableInfo() override { + ~ExperimentalWithCallbackMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_DropTable : public BaseClass { + class ExperimentalWithCallbackMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_DropTable() { + ExperimentalWithCallbackMethod_DropCollection() { ::grpc::Service::experimental().MarkMethodCallback(6, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->DropTable(context, request, response, controller); + return this->DropCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_DropTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + void SetMessageAllocatorFor_DropCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(6)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_DropTable() override { + ~ExperimentalWithCallbackMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_CreateIndex : public BaseClass { @@ -1919,17 +1919,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_DescribeIndex() { ::grpc::Service::experimental().MarkMethodCallback(8, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->DescribeIndex(context, request, response, controller); })); } void SetMessageAllocatorFor_DescribeIndex( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>*>( ::grpc::Service::experimental().GetHandler(8)) ->SetMessageAllocator(allocator); } @@ -1937,11 +1937,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_DropIndex : public BaseClass { @@ -1950,17 +1950,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_DropIndex() { ::grpc::Service::experimental().MarkMethodCallback(9, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->DropIndex(context, request, response, controller); })); } void SetMessageAllocatorFor_DropIndex( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(9)) ->SetMessageAllocator(allocator); } @@ -1968,11 +1968,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_CreatePartition : public BaseClass { @@ -2012,17 +2012,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_ShowPartitions() { ::grpc::Service::experimental().MarkMethodCallback(11, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::PartitionList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->ShowPartitions(context, request, response, controller); })); } void SetMessageAllocatorFor_ShowPartitions( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>*>( ::grpc::Service::experimental().GetHandler(11)) ->SetMessageAllocator(allocator); } @@ -2030,11 +2030,11 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_DropPartition : public BaseClass { @@ -2316,35 +2316,35 @@ class MilvusService final { virtual void DeleteByID(::grpc::ServerContext* /*context*/, const ::milvus::grpc::DeleteByIDParam* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithCallbackMethod_PreloadTable : public BaseClass { + class ExperimentalWithCallbackMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithCallbackMethod_PreloadTable() { + ExperimentalWithCallbackMethod_PreloadCollection() { ::grpc::Service::experimental().MarkMethodCallback(21, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - return this->PreloadTable(context, request, response, controller); + return this->PreloadCollection(context, request, response, controller); })); } - void SetMessageAllocatorFor_PreloadTable( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + void SetMessageAllocatorFor_PreloadCollection( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(21)) ->SetMessageAllocator(allocator); } - ~ExperimentalWithCallbackMethod_PreloadTable() override { + ~ExperimentalWithCallbackMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithCallbackMethod_Flush : public BaseClass { @@ -2384,17 +2384,17 @@ class MilvusService final { public: ExperimentalWithCallbackMethod_Compact() { ::grpc::Service::experimental().MarkMethodCallback(23, - new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>( + new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>( [this](::grpc::ServerContext* context, - const ::milvus::grpc::TableName* request, + const ::milvus::grpc::CollectionName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { return this->Compact(context, request, response, controller); })); } void SetMessageAllocatorFor_Compact( - ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) { - static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>( + ::grpc::experimental::MessageAllocator< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>* allocator) { + static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>*>( ::grpc::Service::experimental().GetHandler(23)) ->SetMessageAllocator(allocator); } @@ -2402,128 +2402,128 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; - typedef ExperimentalWithCallbackMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; + typedef ExperimentalWithCallbackMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > ExperimentalCallbackService; template - class WithGenericMethod_CreateTable : public BaseClass { + class WithGenericMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_CreateTable() { + WithGenericMethod_CreateCollection() { ::grpc::Service::MarkMethodGeneric(0); } - ~WithGenericMethod_CreateTable() override { + ~WithGenericMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_HasTable : public BaseClass { + class WithGenericMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_HasTable() { + WithGenericMethod_HasCollection() { ::grpc::Service::MarkMethodGeneric(1); } - ~WithGenericMethod_HasTable() override { + ~WithGenericMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_DescribeTable : public BaseClass { + class WithGenericMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_DescribeTable() { + WithGenericMethod_DescribeCollection() { ::grpc::Service::MarkMethodGeneric(2); } - ~WithGenericMethod_DescribeTable() override { + ~WithGenericMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_CountTable : public BaseClass { + class WithGenericMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_CountTable() { + WithGenericMethod_CountCollection() { ::grpc::Service::MarkMethodGeneric(3); } - ~WithGenericMethod_CountTable() override { + ~WithGenericMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_ShowTables : public BaseClass { + class WithGenericMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_ShowTables() { + WithGenericMethod_ShowCollections() { ::grpc::Service::MarkMethodGeneric(4); } - ~WithGenericMethod_ShowTables() override { + ~WithGenericMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_ShowTableInfo : public BaseClass { + class WithGenericMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_ShowTableInfo() { + WithGenericMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodGeneric(5); } - ~WithGenericMethod_ShowTableInfo() override { + ~WithGenericMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithGenericMethod_DropTable : public BaseClass { + class WithGenericMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_DropTable() { + WithGenericMethod_DropCollection() { ::grpc::Service::MarkMethodGeneric(6); } - ~WithGenericMethod_DropTable() override { + ~WithGenericMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2557,7 +2557,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2574,7 +2574,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2608,7 +2608,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2767,18 +2767,18 @@ class MilvusService final { } }; template - class WithGenericMethod_PreloadTable : public BaseClass { + class WithGenericMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithGenericMethod_PreloadTable() { + WithGenericMethod_PreloadCollection() { ::grpc::Service::MarkMethodGeneric(21); } - ~WithGenericMethod_PreloadTable() override { + ~WithGenericMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -2812,148 +2812,148 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } }; template - class WithRawMethod_CreateTable : public BaseClass { + class WithRawMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_CreateTable() { + WithRawMethod_CreateCollection() { ::grpc::Service::MarkMethodRaw(0); } - ~WithRawMethod_CreateTable() override { + ~WithRawMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCreateTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCreateCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_HasTable : public BaseClass { + class WithRawMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_HasTable() { + WithRawMethod_HasCollection() { ::grpc::Service::MarkMethodRaw(1); } - ~WithRawMethod_HasTable() override { + ~WithRawMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestHasTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestHasCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_DescribeTable : public BaseClass { + class WithRawMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_DescribeTable() { + WithRawMethod_DescribeCollection() { ::grpc::Service::MarkMethodRaw(2); } - ~WithRawMethod_DescribeTable() override { + ~WithRawMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDescribeTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDescribeCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_CountTable : public BaseClass { + class WithRawMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_CountTable() { + WithRawMethod_CountCollection() { ::grpc::Service::MarkMethodRaw(3); } - ~WithRawMethod_CountTable() override { + ~WithRawMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestCountTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestCountCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_ShowTables : public BaseClass { + class WithRawMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_ShowTables() { + WithRawMethod_ShowCollections() { ::grpc::Service::MarkMethodRaw(4); } - ~WithRawMethod_ShowTables() override { + ~WithRawMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTables(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollections(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_ShowTableInfo : public BaseClass { + class WithRawMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_ShowTableInfo() { + WithRawMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodRaw(5); } - ~WithRawMethod_ShowTableInfo() override { + ~WithRawMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestShowTableInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestShowCollectionInfo(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag); } }; template - class WithRawMethod_DropTable : public BaseClass { + class WithRawMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_DropTable() { + WithRawMethod_DropCollection() { ::grpc::Service::MarkMethodRaw(6); } - ~WithRawMethod_DropTable() override { + ~WithRawMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestDropTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestDropCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -2989,7 +2989,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3009,7 +3009,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3049,7 +3049,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3238,22 +3238,22 @@ class MilvusService final { } }; template - class WithRawMethod_PreloadTable : public BaseClass { + class WithRawMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithRawMethod_PreloadTable() { + WithRawMethod_PreloadCollection() { ::grpc::Service::MarkMethodRaw(21); } - ~WithRawMethod_PreloadTable() override { + ~WithRawMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - void RequestPreloadTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + void RequestPreloadCollection(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { ::grpc::Service::RequestAsyncUnary(21, context, request, response, new_call_cq, notification_cq, tag); } }; @@ -3289,7 +3289,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3298,179 +3298,179 @@ class MilvusService final { } }; template - class ExperimentalWithRawCallbackMethod_CreateTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_CreateTable() { + ExperimentalWithRawCallbackMethod_CreateCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(0, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->CreateTable(context, request, response, controller); + this->CreateCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_CreateTable() override { + ~ExperimentalWithRawCallbackMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CreateTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CreateCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_HasTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_HasTable() { + ExperimentalWithRawCallbackMethod_HasCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(1, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->HasTable(context, request, response, controller); + this->HasCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_HasTable() override { + ~ExperimentalWithRawCallbackMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void HasTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void HasCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_DescribeTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_DescribeTable() { + ExperimentalWithRawCallbackMethod_DescribeCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(2, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->DescribeTable(context, request, response, controller); + this->DescribeCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_DescribeTable() override { + ~ExperimentalWithRawCallbackMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DescribeTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DescribeCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_CountTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_CountTable() { + ExperimentalWithRawCallbackMethod_CountCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(3, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->CountTable(context, request, response, controller); + this->CountCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_CountTable() override { + ~ExperimentalWithRawCallbackMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void CountTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void CountCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_ShowTables : public BaseClass { + class ExperimentalWithRawCallbackMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_ShowTables() { + ExperimentalWithRawCallbackMethod_ShowCollections() { ::grpc::Service::experimental().MarkMethodRawCallback(4, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->ShowTables(context, request, response, controller); + this->ShowCollections(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_ShowTables() override { + ~ExperimentalWithRawCallbackMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTables(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollections(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_ShowTableInfo : public BaseClass { + class ExperimentalWithRawCallbackMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_ShowTableInfo() { + ExperimentalWithRawCallbackMethod_ShowCollectionInfo() { ::grpc::Service::experimental().MarkMethodRawCallback(5, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->ShowTableInfo(context, request, response, controller); + this->ShowCollectionInfo(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_ShowTableInfo() override { + ~ExperimentalWithRawCallbackMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void ShowTableInfo(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_DropTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_DropTable() { + ExperimentalWithRawCallbackMethod_DropCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(6, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->DropTable(context, request, response, controller); + this->DropCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_DropTable() override { + ~ExperimentalWithRawCallbackMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void DropTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void DropCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithRawCallbackMethod_CreateIndex : public BaseClass { @@ -3516,7 +3516,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3541,7 +3541,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3591,7 +3591,7 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } @@ -3823,29 +3823,29 @@ class MilvusService final { virtual void DeleteByID(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class ExperimentalWithRawCallbackMethod_PreloadTable : public BaseClass { + class ExperimentalWithRawCallbackMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - ExperimentalWithRawCallbackMethod_PreloadTable() { + ExperimentalWithRawCallbackMethod_PreloadCollection() { ::grpc::Service::experimental().MarkMethodRawCallback(21, new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>( [this](::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { - this->PreloadTable(context, request, response, controller); + this->PreloadCollection(context, request, response, controller); })); } - ~ExperimentalWithRawCallbackMethod_PreloadTable() override { + ~ExperimentalWithRawCallbackMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } - virtual void PreloadTable(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } + virtual void PreloadCollection(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template class ExperimentalWithRawCallbackMethod_Flush : public BaseClass { @@ -3891,151 +3891,151 @@ class MilvusService final { BaseClassMustBeDerivedFromService(this); } // disable synchronous version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } virtual void Compact(::grpc::ServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); } }; template - class WithStreamedUnaryMethod_CreateTable : public BaseClass { + class WithStreamedUnaryMethod_CreateCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_CreateTable() { + WithStreamedUnaryMethod_CreateCollection() { ::grpc::Service::MarkMethodStreamed(0, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateTable::StreamedCreateTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionSchema, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateCollection::StreamedCreateCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_CreateTable() override { + ~WithStreamedUnaryMethod_CreateCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status CreateTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status CreateCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionSchema* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedCreateTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableSchema,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedCreateCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionSchema,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_HasTable : public BaseClass { + class WithStreamedUnaryMethod_HasCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_HasTable() { + WithStreamedUnaryMethod_HasCollection() { ::grpc::Service::MarkMethodStreamed(1, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasTable::StreamedHasTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasCollection::StreamedHasCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_HasTable() override { + ~WithStreamedUnaryMethod_HasCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status HasTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { + ::grpc::Status HasCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::BoolReply* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedHasTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedHasCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_DescribeTable : public BaseClass { + class WithStreamedUnaryMethod_DescribeCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_DescribeTable() { + WithStreamedUnaryMethod_DescribeCollection() { ::grpc::Service::MarkMethodStreamed(2, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>(std::bind(&WithStreamedUnaryMethod_DescribeTable::StreamedDescribeTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionSchema>(std::bind(&WithStreamedUnaryMethod_DescribeCollection::StreamedDescribeCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_DescribeTable() override { + ~WithStreamedUnaryMethod_DescribeCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DescribeTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableSchema* /*response*/) override { + ::grpc::Status DescribeCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionSchema* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDescribeTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableSchema>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDescribeCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionSchema>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_CountTable : public BaseClass { + class WithStreamedUnaryMethod_CountCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_CountTable() { + WithStreamedUnaryMethod_CountCollection() { ::grpc::Service::MarkMethodStreamed(3, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>(std::bind(&WithStreamedUnaryMethod_CountTable::StreamedCountTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionRowCount>(std::bind(&WithStreamedUnaryMethod_CountCollection::StreamedCountCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_CountTable() override { + ~WithStreamedUnaryMethod_CountCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status CountTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableRowCount* /*response*/) override { + ::grpc::Status CountCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionRowCount* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedCountTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableRowCount>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedCountCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionRowCount>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_ShowTables : public BaseClass { + class WithStreamedUnaryMethod_ShowCollections : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_ShowTables() { + WithStreamedUnaryMethod_ShowCollections() { ::grpc::Service::MarkMethodStreamed(4, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(std::bind(&WithStreamedUnaryMethod_ShowTables::StreamedShowTables, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::CollectionNameList>(std::bind(&WithStreamedUnaryMethod_ShowCollections::StreamedShowCollections, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_ShowTables() override { + ~WithStreamedUnaryMethod_ShowCollections() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status ShowTables(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::TableNameList* /*response*/) override { + ::grpc::Status ShowCollections(::grpc::ServerContext* /*context*/, const ::milvus::grpc::Command* /*request*/, ::milvus::grpc::CollectionNameList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedShowTables(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::TableNameList>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedShowCollections(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::CollectionNameList>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_ShowTableInfo : public BaseClass { + class WithStreamedUnaryMethod_ShowCollectionInfo : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_ShowTableInfo() { + WithStreamedUnaryMethod_ShowCollectionInfo() { ::grpc::Service::MarkMethodStreamed(5, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableInfo>(std::bind(&WithStreamedUnaryMethod_ShowTableInfo::StreamedShowTableInfo, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::CollectionInfo>(std::bind(&WithStreamedUnaryMethod_ShowCollectionInfo::StreamedShowCollectionInfo, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_ShowTableInfo() override { + ~WithStreamedUnaryMethod_ShowCollectionInfo() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status ShowTableInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::TableInfo* /*response*/) override { + ::grpc::Status ShowCollectionInfo(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::CollectionInfo* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedShowTableInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableInfo>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedShowCollectionInfo(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::CollectionInfo>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_DropTable : public BaseClass { + class WithStreamedUnaryMethod_DropCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_DropTable() { + WithStreamedUnaryMethod_DropCollection() { ::grpc::Service::MarkMethodStreamed(6, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropTable::StreamedDropTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropCollection::StreamedDropCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_DropTable() override { + ~WithStreamedUnaryMethod_DropCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DropTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDropTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDropCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CreateIndex : public BaseClass { @@ -4064,18 +4064,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_DescribeIndex() { ::grpc::Service::MarkMethodStreamed(8, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>(std::bind(&WithStreamedUnaryMethod_DescribeIndex::StreamedDescribeIndex, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::IndexParam>(std::bind(&WithStreamedUnaryMethod_DescribeIndex::StreamedDescribeIndex, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DescribeIndex() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { + ::grpc::Status DescribeIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::IndexParam* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDescribeIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::IndexParam>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDescribeIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::IndexParam>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_DropIndex : public BaseClass { @@ -4084,18 +4084,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_DropIndex() { ::grpc::Service::MarkMethodStreamed(9, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropIndex::StreamedDropIndex, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropIndex::StreamedDropIndex, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_DropIndex() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status DropIndex(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedDropIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedDropIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_CreatePartition : public BaseClass { @@ -4124,18 +4124,18 @@ class MilvusService final { public: WithStreamedUnaryMethod_ShowPartitions() { ::grpc::Service::MarkMethodStreamed(11, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::PartitionList>(std::bind(&WithStreamedUnaryMethod_ShowPartitions::StreamedShowPartitions, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::PartitionList>(std::bind(&WithStreamedUnaryMethod_ShowPartitions::StreamedShowPartitions, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_ShowPartitions() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { + ::grpc::Status ShowPartitions(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::PartitionList* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedShowPartitions(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::PartitionList>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedShowPartitions(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::PartitionList>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_DropPartition : public BaseClass { @@ -4318,24 +4318,24 @@ class MilvusService final { virtual ::grpc::Status StreamedDeleteByID(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::DeleteByIDParam,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template - class WithStreamedUnaryMethod_PreloadTable : public BaseClass { + class WithStreamedUnaryMethod_PreloadCollection : public BaseClass { private: void BaseClassMustBeDerivedFromService(const Service* /*service*/) {} public: - WithStreamedUnaryMethod_PreloadTable() { + WithStreamedUnaryMethod_PreloadCollection() { ::grpc::Service::MarkMethodStreamed(21, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadTable::StreamedPreloadTable, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadCollection::StreamedPreloadCollection, this, std::placeholders::_1, std::placeholders::_2))); } - ~WithStreamedUnaryMethod_PreloadTable() override { + ~WithStreamedUnaryMethod_PreloadCollection() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status PreloadTable(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status PreloadCollection(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedPreloadTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedPreloadCollection(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; template class WithStreamedUnaryMethod_Flush : public BaseClass { @@ -4364,22 +4364,22 @@ class MilvusService final { public: WithStreamedUnaryMethod_Compact() { ::grpc::Service::MarkMethodStreamed(23, - new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Compact::StreamedCompact, this, std::placeholders::_1, std::placeholders::_2))); + new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::CollectionName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_Compact::StreamedCompact, this, std::placeholders::_1, std::placeholders::_2))); } ~WithStreamedUnaryMethod_Compact() override { BaseClassMustBeDerivedFromService(this); } // disable regular version of this method - ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::TableName* /*request*/, ::milvus::grpc::Status* /*response*/) override { + ::grpc::Status Compact(::grpc::ServerContext* /*context*/, const ::milvus::grpc::CollectionName* /*request*/, ::milvus::grpc::Status* /*response*/) override { abort(); return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); } // replace default version of method with streamed unary - virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0; + virtual ::grpc::Status StreamedCompact(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::CollectionName,::milvus::grpc::Status>* server_unary_streamer) = 0; }; - typedef WithStreamedUnaryMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedUnaryService; typedef Service SplitStreamedService; - typedef WithStreamedUnaryMethod_CreateTable > > > > > > > > > > > > > > > > > > > > > > > StreamedService; + typedef WithStreamedUnaryMethod_CreateCollection > > > > > > > > > > > > > > > > > > > > > > > StreamedService; }; } // namespace grpc diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.cc b/sdk/grpc-gen/gen-milvus/milvus.pb.cc index 3886e57da1..ed3d048ff6 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.cc +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.cc @@ -27,18 +27,18 @@ class KeyValuePairDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _KeyValuePair_default_instance_; -class TableNameDefaultTypeInternal { +class CollectionNameDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableName_default_instance_; -class TableNameListDefaultTypeInternal { + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionName_default_instance_; +class CollectionNameListDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableNameList_default_instance_; -class TableSchemaDefaultTypeInternal { + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionNameList_default_instance_; +class CollectionSchemaDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableSchema_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionSchema_default_instance_; class PartitionParamDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -83,10 +83,10 @@ class BoolReplyDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _BoolReply_default_instance_; -class TableRowCountDefaultTypeInternal { +class CollectionRowCountDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableRowCount_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionRowCount_default_instance_; class CommandDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -111,10 +111,10 @@ class PartitionStatDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; } _PartitionStat_default_instance_; -class TableInfoDefaultTypeInternal { +class CollectionInfoDefaultTypeInternal { public: - ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; -} _TableInfo_default_instance_; + ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; +} _CollectionInfo_default_instance_; class VectorIdentityDefaultTypeInternal { public: ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed _instance; @@ -144,6 +144,82 @@ static void InitDefaultsscc_info_BoolReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BoolReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; +static void InitDefaultsscc_info_CollectionInfo_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionInfo_default_instance_; + new (ptr) ::milvus::grpc::CollectionInfo(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionInfo::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_CollectionInfo_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_CollectionInfo_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_PartitionStat_milvus_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionName_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionName_default_instance_; + new (ptr) ::milvus::grpc::CollectionName(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionName::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CollectionName_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_CollectionName_milvus_2eproto}, {}}; + +static void InitDefaultsscc_info_CollectionNameList_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionNameList_default_instance_; + new (ptr) ::milvus::grpc::CollectionNameList(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionNameList::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionNameList_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionNameList_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionRowCount_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionRowCount_default_instance_; + new (ptr) ::milvus::grpc::CollectionRowCount(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionRowCount::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CollectionRowCount_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_CollectionRowCount_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base,}}; + +static void InitDefaultsscc_info_CollectionSchema_milvus_2eproto() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + + { + void* ptr = &::milvus::grpc::_CollectionSchema_default_instance_; + new (ptr) ::milvus::grpc::CollectionSchema(); + ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); + } + ::milvus::grpc::CollectionSchema::InitAsDefaultInstance(); +} + +::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_CollectionSchema_milvus_2eproto = + {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_CollectionSchema_milvus_2eproto}, { + &scc_info_Status_status_2eproto.base, + &scc_info_KeyValuePair_milvus_2eproto.base,}}; + static void InitDefaultsscc_info_Command_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -379,82 +455,6 @@ static void InitDefaultsscc_info_StringReply_milvus_2eproto() { {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringReply_milvus_2eproto}, { &scc_info_Status_status_2eproto.base,}}; -static void InitDefaultsscc_info_TableInfo_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableInfo_default_instance_; - new (ptr) ::milvus::grpc::TableInfo(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableInfo::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TableInfo_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TableInfo_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base, - &scc_info_PartitionStat_milvus_2eproto.base,}}; - -static void InitDefaultsscc_info_TableName_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableName_default_instance_; - new (ptr) ::milvus::grpc::TableName(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableName::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TableName_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TableName_milvus_2eproto}, {}}; - -static void InitDefaultsscc_info_TableNameList_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableNameList_default_instance_; - new (ptr) ::milvus::grpc::TableNameList(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableNameList::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableNameList_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableNameList_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base,}}; - -static void InitDefaultsscc_info_TableRowCount_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableRowCount_default_instance_; - new (ptr) ::milvus::grpc::TableRowCount(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableRowCount::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableRowCount_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableRowCount_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base,}}; - -static void InitDefaultsscc_info_TableSchema_milvus_2eproto() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - - { - void* ptr = &::milvus::grpc::_TableSchema_default_instance_; - new (ptr) ::milvus::grpc::TableSchema(); - ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); - } - ::milvus::grpc::TableSchema::InitAsDefaultInstance(); -} - -::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TableSchema_milvus_2eproto = - {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TableSchema_milvus_2eproto}, { - &scc_info_Status_status_2eproto.base, - &scc_info_KeyValuePair_milvus_2eproto.base,}}; - static void InitDefaultsscc_info_TopKQueryResult_milvus_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; @@ -528,35 +528,35 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, key_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::KeyValuePair, value_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionName, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionName, collection_name_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, table_names_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionNameList, collection_names_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, table_name_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, dimension_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, index_file_size_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, metric_type_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, extra_params_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, collection_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, dimension_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, index_file_size_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, metric_type_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionSchema, extra_params_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionParam, tag_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionList, _internal_metadata_), @@ -577,7 +577,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, row_record_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, row_id_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, partition_tag_), @@ -594,7 +594,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, partition_tag_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, query_record_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, topk_), @@ -611,7 +611,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, partition_tag_array_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, id_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchByIDParam, topk_), @@ -640,12 +640,12 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, status_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, bool_reply_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, table_row_count_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionRowCount, collection_row_count_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::Command, _internal_metadata_), ~0u, // no _extensions_ @@ -658,7 +658,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, index_type_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, extra_params_), ~0u, // no _has_bits_ @@ -666,13 +666,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::FlushParam, table_name_array_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::FlushParam, collection_name_array_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByIDParam, id_array_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::SegmentStat, _internal_metadata_), @@ -692,19 +692,19 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionStat, total_row_count_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::PartitionStat, segments_stat_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, status_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, total_row_count_), - PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableInfo, partitions_stat_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, status_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, total_row_count_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::CollectionInfo, partitions_stat_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIdentity, id_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorData, _internal_metadata_), @@ -718,14 +718,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROT ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, table_name_), + PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, collection_name_), PROTOBUF_FIELD_OFFSET(::milvus::grpc::GetVectorIDsParam, segment_name_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::milvus::grpc::KeyValuePair)}, - { 7, -1, sizeof(::milvus::grpc::TableName)}, - { 13, -1, sizeof(::milvus::grpc::TableNameList)}, - { 20, -1, sizeof(::milvus::grpc::TableSchema)}, + { 7, -1, sizeof(::milvus::grpc::CollectionName)}, + { 13, -1, sizeof(::milvus::grpc::CollectionNameList)}, + { 20, -1, sizeof(::milvus::grpc::CollectionSchema)}, { 31, -1, sizeof(::milvus::grpc::PartitionParam)}, { 38, -1, sizeof(::milvus::grpc::PartitionList)}, { 45, -1, sizeof(::milvus::grpc::RowRecord)}, @@ -737,14 +737,14 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 96, -1, sizeof(::milvus::grpc::TopKQueryResult)}, { 105, -1, sizeof(::milvus::grpc::StringReply)}, { 112, -1, sizeof(::milvus::grpc::BoolReply)}, - { 119, -1, sizeof(::milvus::grpc::TableRowCount)}, + { 119, -1, sizeof(::milvus::grpc::CollectionRowCount)}, { 126, -1, sizeof(::milvus::grpc::Command)}, { 132, -1, sizeof(::milvus::grpc::IndexParam)}, { 141, -1, sizeof(::milvus::grpc::FlushParam)}, { 147, -1, sizeof(::milvus::grpc::DeleteByIDParam)}, { 154, -1, sizeof(::milvus::grpc::SegmentStat)}, { 163, -1, sizeof(::milvus::grpc::PartitionStat)}, - { 171, -1, sizeof(::milvus::grpc::TableInfo)}, + { 171, -1, sizeof(::milvus::grpc::CollectionInfo)}, { 179, -1, sizeof(::milvus::grpc::VectorIdentity)}, { 186, -1, sizeof(::milvus::grpc::VectorData)}, { 193, -1, sizeof(::milvus::grpc::GetVectorIDsParam)}, @@ -752,9 +752,9 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::milvus::grpc::_KeyValuePair_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableName_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableNameList_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableSchema_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionName_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionNameList_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionSchema_default_instance_), reinterpret_cast(&::milvus::grpc::_PartitionParam_default_instance_), reinterpret_cast(&::milvus::grpc::_PartitionList_default_instance_), reinterpret_cast(&::milvus::grpc::_RowRecord_default_instance_), @@ -766,14 +766,14 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::milvus::grpc::_TopKQueryResult_default_instance_), reinterpret_cast(&::milvus::grpc::_StringReply_default_instance_), reinterpret_cast(&::milvus::grpc::_BoolReply_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableRowCount_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionRowCount_default_instance_), reinterpret_cast(&::milvus::grpc::_Command_default_instance_), reinterpret_cast(&::milvus::grpc::_IndexParam_default_instance_), reinterpret_cast(&::milvus::grpc::_FlushParam_default_instance_), reinterpret_cast(&::milvus::grpc::_DeleteByIDParam_default_instance_), reinterpret_cast(&::milvus::grpc::_SegmentStat_default_instance_), reinterpret_cast(&::milvus::grpc::_PartitionStat_default_instance_), - reinterpret_cast(&::milvus::grpc::_TableInfo_default_instance_), + reinterpret_cast(&::milvus::grpc::_CollectionInfo_default_instance_), reinterpret_cast(&::milvus::grpc::_VectorIdentity_default_instance_), reinterpret_cast(&::milvus::grpc::_VectorData_default_instance_), reinterpret_cast(&::milvus::grpc::_GetVectorIDsParam_default_instance_), @@ -782,110 +782,120 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\014milvus.proto\022\013milvus.grpc\032\014status.prot" "o\"*\n\014KeyValuePair\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030" - "\002 \001(\t\"\037\n\tTableName\022\022\n\ntable_name\030\001 \001(\t\"I" - "\n\rTableNameList\022#\n\006status\030\001 \001(\0132\023.milvus" - ".grpc.Status\022\023\n\013table_names\030\002 \003(\t\"\270\001\n\013Ta" - "bleSchema\022#\n\006status\030\001 \001(\0132\023.milvus.grpc." - "Status\022\022\n\ntable_name\030\002 \001(\t\022\021\n\tdimension\030" - "\003 \001(\003\022\027\n\017index_file_size\030\004 \001(\003\022\023\n\013metric" - "_type\030\005 \001(\005\022/\n\014extra_params\030\006 \003(\0132\031.milv" - "us.grpc.KeyValuePair\"1\n\016PartitionParam\022\022" - "\n\ntable_name\030\001 \001(\t\022\013\n\003tag\030\002 \001(\t\"Q\n\rParti" - "tionList\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.S" - "tatus\022\033\n\023partition_tag_array\030\002 \003(\t\"4\n\tRo" - "wRecord\022\022\n\nfloat_data\030\001 \003(\002\022\023\n\013binary_da" - "ta\030\002 \001(\014\"\261\001\n\013InsertParam\022\022\n\ntable_name\030\001" + "\002 \001(\t\")\n\016CollectionName\022\027\n\017collection_na" + "me\030\001 \001(\t\"S\n\022CollectionNameList\022#\n\006status" + "\030\001 \001(\0132\023.milvus.grpc.Status\022\030\n\020collectio" + "n_names\030\002 \003(\t\"\302\001\n\020CollectionSchema\022#\n\006st" + "atus\030\001 \001(\0132\023.milvus.grpc.Status\022\027\n\017colle" + "ction_name\030\002 \001(\t\022\021\n\tdimension\030\003 \001(\003\022\027\n\017i" + "ndex_file_size\030\004 \001(\003\022\023\n\013metric_type\030\005 \001(" + "\005\022/\n\014extra_params\030\006 \003(\0132\031.milvus.grpc.Ke" + "yValuePair\"6\n\016PartitionParam\022\027\n\017collecti" + "on_name\030\001 \001(\t\022\013\n\003tag\030\002 \001(\t\"Q\n\rPartitionL" + "ist\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\033\n\023partition_tag_array\030\002 \003(\t\"4\n\tRowReco" + "rd\022\022\n\nfloat_data\030\001 \003(\002\022\023\n\013binary_data\030\002 " + "\001(\014\"\266\001\n\013InsertParam\022\027\n\017collection_name\030\001" " \001(\t\0220\n\020row_record_array\030\002 \003(\0132\026.milvus." "grpc.RowRecord\022\024\n\014row_id_array\030\003 \003(\003\022\025\n\r" "partition_tag\030\004 \001(\t\022/\n\014extra_params\030\005 \003(" "\0132\031.milvus.grpc.KeyValuePair\"I\n\tVectorId" "s\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\027" - "\n\017vector_id_array\030\002 \003(\003\"\261\001\n\013SearchParam\022" - "\022\n\ntable_name\030\001 \001(\t\022\033\n\023partition_tag_arr" - "ay\030\002 \003(\t\0222\n\022query_record_array\030\003 \003(\0132\026.m" - "ilvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022/\n\014ex" - "tra_params\030\005 \003(\0132\031.milvus.grpc.KeyValueP" - "air\"[\n\022SearchInFilesParam\022\025\n\rfile_id_arr" - "ay\030\001 \003(\t\022.\n\014search_param\030\002 \001(\0132\030.milvus." - "grpc.SearchParam\"\215\001\n\017SearchByIDParam\022\022\n\n" - "table_name\030\001 \001(\t\022\033\n\023partition_tag_array\030" - "\002 \003(\t\022\n\n\002id\030\003 \001(\003\022\014\n\004topk\030\004 \001(\003\022/\n\014extra" - "_params\030\005 \003(\0132\031.milvus.grpc.KeyValuePair" - "\"g\n\017TopKQueryResult\022#\n\006status\030\001 \001(\0132\023.mi" - "lvus.grpc.Status\022\017\n\007row_num\030\002 \001(\003\022\013\n\003ids" - "\030\003 \003(\003\022\021\n\tdistances\030\004 \003(\002\"H\n\013StringReply" - "\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\024\n" - "\014string_reply\030\002 \001(\t\"D\n\tBoolReply\022#\n\006stat" - "us\030\001 \001(\0132\023.milvus.grpc.Status\022\022\n\nbool_re" - "ply\030\002 \001(\010\"M\n\rTableRowCount\022#\n\006status\030\001 \001" - "(\0132\023.milvus.grpc.Status\022\027\n\017table_row_cou" - "nt\030\002 \001(\003\"\026\n\007Command\022\013\n\003cmd\030\001 \001(\t\"\212\001\n\nInd" - "exParam\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St" - "atus\022\022\n\ntable_name\030\002 \001(\t\022\022\n\nindex_type\030\003" - " \001(\005\022/\n\014extra_params\030\004 \003(\0132\031.milvus.grpc" - ".KeyValuePair\"&\n\nFlushParam\022\030\n\020table_nam" - "e_array\030\001 \003(\t\"7\n\017DeleteByIDParam\022\022\n\ntabl" - "e_name\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"]\n\013Segmen" - "tStat\022\024\n\014segment_name\030\001 \001(\t\022\021\n\trow_count" - "\030\002 \001(\003\022\022\n\nindex_name\030\003 \001(\t\022\021\n\tdata_size\030" - "\004 \001(\003\"f\n\rPartitionStat\022\013\n\003tag\030\001 \001(\t\022\027\n\017t" - "otal_row_count\030\002 \001(\003\022/\n\rsegments_stat\030\003 " - "\003(\0132\030.milvus.grpc.SegmentStat\"~\n\tTableIn" - "fo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" - "\027\n\017total_row_count\030\002 \001(\003\0223\n\017partitions_s" - "tat\030\003 \003(\0132\032.milvus.grpc.PartitionStat\"0\n" - "\016VectorIdentity\022\022\n\ntable_name\030\001 \001(\t\022\n\n\002i" - "d\030\002 \001(\003\"^\n\nVectorData\022#\n\006status\030\001 \001(\0132\023." - "milvus.grpc.Status\022+\n\013vector_data\030\002 \001(\0132" - "\026.milvus.grpc.RowRecord\"=\n\021GetVectorIDsP" - "aram\022\022\n\ntable_name\030\001 \001(\t\022\024\n\014segment_name" - "\030\002 \001(\t2\313\014\n\rMilvusService\022>\n\013CreateTable\022" - "\030.milvus.grpc.TableSchema\032\023.milvus.grpc." - "Status\"\000\022<\n\010HasTable\022\026.milvus.grpc.Table" - "Name\032\026.milvus.grpc.BoolReply\"\000\022C\n\rDescri" - "beTable\022\026.milvus.grpc.TableName\032\030.milvus" - ".grpc.TableSchema\"\000\022B\n\nCountTable\022\026.milv" - "us.grpc.TableName\032\032.milvus.grpc.TableRow" - "Count\"\000\022@\n\nShowTables\022\024.milvus.grpc.Comm" - "and\032\032.milvus.grpc.TableNameList\"\000\022A\n\rSho" - "wTableInfo\022\026.milvus.grpc.TableName\032\026.mil" - "vus.grpc.TableInfo\"\000\022:\n\tDropTable\022\026.milv" - "us.grpc.TableName\032\023.milvus.grpc.Status\"\000" - "\022=\n\013CreateIndex\022\027.milvus.grpc.IndexParam" - "\032\023.milvus.grpc.Status\"\000\022B\n\rDescribeIndex" - "\022\026.milvus.grpc.TableName\032\027.milvus.grpc.I" - "ndexParam\"\000\022:\n\tDropIndex\022\026.milvus.grpc.T" - "ableName\032\023.milvus.grpc.Status\"\000\022E\n\017Creat" - "ePartition\022\033.milvus.grpc.PartitionParam\032" - "\023.milvus.grpc.Status\"\000\022F\n\016ShowPartitions" - "\022\026.milvus.grpc.TableName\032\032.milvus.grpc.P" - "artitionList\"\000\022C\n\rDropPartition\022\033.milvus" - ".grpc.PartitionParam\032\023.milvus.grpc.Statu" - "s\"\000\022<\n\006Insert\022\030.milvus.grpc.InsertParam\032" - "\026.milvus.grpc.VectorIds\"\000\022G\n\rGetVectorBy" - "ID\022\033.milvus.grpc.VectorIdentity\032\027.milvus" - ".grpc.VectorData\"\000\022H\n\014GetVectorIDs\022\036.mil" - "vus.grpc.GetVectorIDsParam\032\026.milvus.grpc" - ".VectorIds\"\000\022B\n\006Search\022\030.milvus.grpc.Sea" - "rchParam\032\034.milvus.grpc.TopKQueryResult\"\000" - "\022J\n\nSearchByID\022\034.milvus.grpc.SearchByIDP" - "aram\032\034.milvus.grpc.TopKQueryResult\"\000\022P\n\r" - "SearchInFiles\022\037.milvus.grpc.SearchInFile" - "sParam\032\034.milvus.grpc.TopKQueryResult\"\000\0227" - "\n\003Cmd\022\024.milvus.grpc.Command\032\030.milvus.grp" - "c.StringReply\"\000\022A\n\nDeleteByID\022\034.milvus.g" - "rpc.DeleteByIDParam\032\023.milvus.grpc.Status" - "\"\000\022=\n\014PreloadTable\022\026.milvus.grpc.TableNa" - "me\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022\027.mil" - "vus.grpc.FlushParam\032\023.milvus.grpc.Status" - "\"\000\0228\n\007Compact\022\026.milvus.grpc.TableName\032\023." - "milvus.grpc.Status\"\000b\006proto3" + "\n\017vector_id_array\030\002 \003(\003\"\266\001\n\013SearchParam\022" + "\027\n\017collection_name\030\001 \001(\t\022\033\n\023partition_ta" + "g_array\030\002 \003(\t\0222\n\022query_record_array\030\003 \003(" + "\0132\026.milvus.grpc.RowRecord\022\014\n\004topk\030\004 \001(\003\022" + "/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.KeyV" + "aluePair\"[\n\022SearchInFilesParam\022\025\n\rfile_i" + "d_array\030\001 \003(\t\022.\n\014search_param\030\002 \001(\0132\030.mi" + "lvus.grpc.SearchParam\"\222\001\n\017SearchByIDPara" + "m\022\027\n\017collection_name\030\001 \001(\t\022\033\n\023partition_" + "tag_array\030\002 \003(\t\022\n\n\002id\030\003 \001(\003\022\014\n\004topk\030\004 \001(" + "\003\022/\n\014extra_params\030\005 \003(\0132\031.milvus.grpc.Ke" + "yValuePair\"g\n\017TopKQueryResult\022#\n\006status\030" + "\001 \001(\0132\023.milvus.grpc.Status\022\017\n\007row_num\030\002 " + "\001(\003\022\013\n\003ids\030\003 \003(\003\022\021\n\tdistances\030\004 \003(\002\"H\n\013S" + "tringReply\022#\n\006status\030\001 \001(\0132\023.milvus.grpc" + ".Status\022\024\n\014string_reply\030\002 \001(\t\"D\n\tBoolRep" + "ly\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022" + "\022\n\nbool_reply\030\002 \001(\010\"W\n\022CollectionRowCoun" + "t\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status\022\034" + "\n\024collection_row_count\030\002 \001(\003\"\026\n\007Command\022" + "\013\n\003cmd\030\001 \001(\t\"\217\001\n\nIndexParam\022#\n\006status\030\001 " + "\001(\0132\023.milvus.grpc.Status\022\027\n\017collection_n" + "ame\030\002 \001(\t\022\022\n\nindex_type\030\003 \001(\005\022/\n\014extra_p" + "arams\030\004 \003(\0132\031.milvus.grpc.KeyValuePair\"+" + "\n\nFlushParam\022\035\n\025collection_name_array\030\001 " + "\003(\t\"<\n\017DeleteByIDParam\022\027\n\017collection_nam" + "e\030\001 \001(\t\022\020\n\010id_array\030\002 \003(\003\"]\n\013SegmentStat" + "\022\024\n\014segment_name\030\001 \001(\t\022\021\n\trow_count\030\002 \001(" + "\003\022\022\n\nindex_name\030\003 \001(\t\022\021\n\tdata_size\030\004 \001(\003" + "\"f\n\rPartitionStat\022\013\n\003tag\030\001 \001(\t\022\027\n\017total_" + "row_count\030\002 \001(\003\022/\n\rsegments_stat\030\003 \003(\0132\030" + ".milvus.grpc.SegmentStat\"\203\001\n\016CollectionI" + "nfo\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Status" + "\022\027\n\017total_row_count\030\002 \001(\003\0223\n\017partitions_" + "stat\030\003 \003(\0132\032.milvus.grpc.PartitionStat\"5" + "\n\016VectorIdentity\022\027\n\017collection_name\030\001 \001(" + "\t\022\n\n\002id\030\002 \001(\003\"^\n\nVectorData\022#\n\006status\030\001 " + "\001(\0132\023.milvus.grpc.Status\022+\n\013vector_data\030" + "\002 \001(\0132\026.milvus.grpc.RowRecord\"B\n\021GetVect" + "orIDsParam\022\027\n\017collection_name\030\001 \001(\t\022\024\n\014s" + "egment_name\030\002 \001(\t2\276\r\n\rMilvusService\022H\n\020C" + "reateCollection\022\035.milvus.grpc.Collection" + "Schema\032\023.milvus.grpc.Status\"\000\022F\n\rHasColl" + "ection\022\033.milvus.grpc.CollectionName\032\026.mi" + "lvus.grpc.BoolReply\"\000\022R\n\022DescribeCollect" + "ion\022\033.milvus.grpc.CollectionName\032\035.milvu" + "s.grpc.CollectionSchema\"\000\022Q\n\017CountCollec" + "tion\022\033.milvus.grpc.CollectionName\032\037.milv" + "us.grpc.CollectionRowCount\"\000\022J\n\017ShowColl" + "ections\022\024.milvus.grpc.Command\032\037.milvus.g" + "rpc.CollectionNameList\"\000\022P\n\022ShowCollecti" + "onInfo\022\033.milvus.grpc.CollectionName\032\033.mi" + "lvus.grpc.CollectionInfo\"\000\022D\n\016DropCollec" + "tion\022\033.milvus.grpc.CollectionName\032\023.milv" + "us.grpc.Status\"\000\022=\n\013CreateIndex\022\027.milvus" + ".grpc.IndexParam\032\023.milvus.grpc.Status\"\000\022" + "G\n\rDescribeIndex\022\033.milvus.grpc.Collectio" + "nName\032\027.milvus.grpc.IndexParam\"\000\022\?\n\tDrop" + "Index\022\033.milvus.grpc.CollectionName\032\023.mil" + "vus.grpc.Status\"\000\022E\n\017CreatePartition\022\033.m" + "ilvus.grpc.PartitionParam\032\023.milvus.grpc." + "Status\"\000\022K\n\016ShowPartitions\022\033.milvus.grpc" + ".CollectionName\032\032.milvus.grpc.PartitionL" + "ist\"\000\022C\n\rDropPartition\022\033.milvus.grpc.Par" + "titionParam\032\023.milvus.grpc.Status\"\000\022<\n\006In" + "sert\022\030.milvus.grpc.InsertParam\032\026.milvus." + "grpc.VectorIds\"\000\022G\n\rGetVectorByID\022\033.milv" + "us.grpc.VectorIdentity\032\027.milvus.grpc.Vec" + "torData\"\000\022H\n\014GetVectorIDs\022\036.milvus.grpc." + "GetVectorIDsParam\032\026.milvus.grpc.VectorId" + "s\"\000\022B\n\006Search\022\030.milvus.grpc.SearchParam\032" + "\034.milvus.grpc.TopKQueryResult\"\000\022J\n\nSearc" + "hByID\022\034.milvus.grpc.SearchByIDParam\032\034.mi" + "lvus.grpc.TopKQueryResult\"\000\022P\n\rSearchInF" + "iles\022\037.milvus.grpc.SearchInFilesParam\032\034." + "milvus.grpc.TopKQueryResult\"\000\0227\n\003Cmd\022\024.m" + "ilvus.grpc.Command\032\030.milvus.grpc.StringR" + "eply\"\000\022A\n\nDeleteByID\022\034.milvus.grpc.Delet" + "eByIDParam\032\023.milvus.grpc.Status\"\000\022G\n\021Pre" + "loadCollection\022\033.milvus.grpc.CollectionN" + "ame\032\023.milvus.grpc.Status\"\000\0227\n\005Flush\022\027.mi" + "lvus.grpc.FlushParam\032\023.milvus.grpc.Statu" + "s\"\000\022=\n\007Compact\022\033.milvus.grpc.CollectionN" + "ame\032\023.milvus.grpc.Status\"\000b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = { &::descriptor_table_status_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[26] = { &scc_info_BoolReply_milvus_2eproto.base, + &scc_info_CollectionInfo_milvus_2eproto.base, + &scc_info_CollectionName_milvus_2eproto.base, + &scc_info_CollectionNameList_milvus_2eproto.base, + &scc_info_CollectionRowCount_milvus_2eproto.base, + &scc_info_CollectionSchema_milvus_2eproto.base, &scc_info_Command_milvus_2eproto.base, &scc_info_DeleteByIDParam_milvus_2eproto.base, &scc_info_FlushParam_milvus_2eproto.base, @@ -902,11 +912,6 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil &scc_info_SearchParam_milvus_2eproto.base, &scc_info_SegmentStat_milvus_2eproto.base, &scc_info_StringReply_milvus_2eproto.base, - &scc_info_TableInfo_milvus_2eproto.base, - &scc_info_TableName_milvus_2eproto.base, - &scc_info_TableNameList_milvus_2eproto.base, - &scc_info_TableRowCount_milvus_2eproto.base, - &scc_info_TableSchema_milvus_2eproto.base, &scc_info_TopKQueryResult_milvus_2eproto.base, &scc_info_VectorData_milvus_2eproto.base, &scc_info_VectorIdentity_milvus_2eproto.base, @@ -915,7 +920,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_mil static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once; static bool descriptor_table_milvus_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = { - &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 3988, + &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 4194, &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 26, 1, schemas, file_default_instances, TableStruct_milvus_2eproto::offsets, file_level_metadata_milvus_2eproto, 26, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto, @@ -1260,73 +1265,73 @@ void KeyValuePair::InternalSwap(KeyValuePair* other) { // =================================================================== -void TableName::InitAsDefaultInstance() { +void CollectionName::InitAsDefaultInstance() { } -class TableName::_Internal { +class CollectionName::_Internal { public: }; -TableName::TableName() +CollectionName::CollectionName() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableName) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionName) } -TableName::TableName(const TableName& from) +CollectionName::CollectionName(const CollectionName& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableName) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionName) } -void TableName::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableName_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionName::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionName_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -TableName::~TableName() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableName) +CollectionName::~CollectionName() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionName) SharedDtor(); } -void TableName::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionName::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void TableName::SetCachedSize(int size) const { +void CollectionName::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableName& TableName::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableName_milvus_2eproto.base); +const CollectionName& CollectionName::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionName_milvus_2eproto.base); return *internal_default_instance(); } -void TableName::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableName) +void CollectionName::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableName.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.CollectionName.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -1350,25 +1355,25 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableName::MergePartialFromCodedStream( +bool CollectionName::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableName) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionName) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.TableName.table_name")); + "milvus.grpc.CollectionName.collection_name")); } else { goto handle_unusual; } @@ -1387,65 +1392,65 @@ bool TableName::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableName) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionName) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableName) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionName) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableName::SerializeWithCachedSizes( +void CollectionName::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableName.table_name"); + "milvus.grpc.CollectionName.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionName) } -::PROTOBUF_NAMESPACE_ID::uint8* TableName::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionName::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableName.table_name"); + "milvus.grpc.CollectionName.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableName) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionName) return target; } -size_t TableName::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableName) +size_t CollectionName::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionName) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -1457,11 +1462,11 @@ size_t TableName::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -1469,133 +1474,133 @@ size_t TableName::ByteSizeLong() const { return total_size; } -void TableName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableName) +void CollectionName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionName) GOOGLE_DCHECK_NE(&from, this); - const TableName* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionName* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableName) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionName) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableName) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionName) MergeFrom(*source); } } -void TableName::MergeFrom(const TableName& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableName) +void CollectionName::MergeFrom(const CollectionName& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionName) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } } -void TableName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableName) +void CollectionName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionName) if (&from == this) return; Clear(); MergeFrom(from); } -void TableName::CopyFrom(const TableName& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableName) +void CollectionName::CopyFrom(const CollectionName& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionName) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableName::IsInitialized() const { +bool CollectionName::IsInitialized() const { return true; } -void TableName::InternalSwap(TableName* other) { +void CollectionName::InternalSwap(CollectionName* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); } -::PROTOBUF_NAMESPACE_ID::Metadata TableName::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionName::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== -void TableNameList::InitAsDefaultInstance() { - ::milvus::grpc::_TableNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionNameList::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableNameList::_Internal { +class CollectionNameList::_Internal { public: - static const ::milvus::grpc::Status& status(const TableNameList* msg); + static const ::milvus::grpc::Status& status(const CollectionNameList* msg); }; const ::milvus::grpc::Status& -TableNameList::_Internal::status(const TableNameList* msg) { +CollectionNameList::_Internal::status(const CollectionNameList* msg) { return *msg->status_; } -void TableNameList::clear_status() { +void CollectionNameList::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableNameList::TableNameList() +CollectionNameList::CollectionNameList() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableNameList) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionNameList) } -TableNameList::TableNameList(const TableNameList& from) +CollectionNameList::CollectionNameList(const CollectionNameList& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - table_names_(from.table_names_) { + collection_names_(from.collection_names_) { _internal_metadata_.MergeFrom(from._internal_metadata_); if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); } else { status_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableNameList) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionNameList) } -void TableNameList::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableNameList_milvus_2eproto.base); +void CollectionNameList::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionNameList_milvus_2eproto.base); status_ = nullptr; } -TableNameList::~TableNameList() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableNameList) +CollectionNameList::~CollectionNameList() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionNameList) SharedDtor(); } -void TableNameList::SharedDtor() { +void CollectionNameList::SharedDtor() { if (this != internal_default_instance()) delete status_; } -void TableNameList::SetCachedSize(int size) const { +void CollectionNameList::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableNameList& TableNameList::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableNameList_milvus_2eproto.base); +const CollectionNameList& CollectionNameList::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionNameList_milvus_2eproto.base); return *internal_default_instance(); } -void TableNameList::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableNameList) +void CollectionNameList::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_names_.Clear(); + collection_names_.Clear(); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } @@ -1604,7 +1609,7 @@ void TableNameList::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -1618,13 +1623,13 @@ const char* TableNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ CHK_(ptr); } else goto handle_unusual; continue; - // repeated string table_names = 2; + // repeated string collection_names = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; do { ptr += 1; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_table_names(), ptr, ctx, "milvus.grpc.TableNameList.table_names"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_names(), ptr, ctx, "milvus.grpc.CollectionNameList.collection_names"); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18); @@ -1650,11 +1655,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableNameList::MergePartialFromCodedStream( +bool CollectionNameList::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableNameList) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionNameList) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -1671,16 +1676,16 @@ bool TableNameList::MergePartialFromCodedStream( break; } - // repeated string table_names = 2; + // repeated string collection_names = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->add_table_names())); + input, this->add_collection_names())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_names(this->table_names_size() - 1).data(), - static_cast(this->table_names(this->table_names_size() - 1).length()), + this->collection_names(this->collection_names_size() - 1).data(), + static_cast(this->collection_names(this->collection_names_size() - 1).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.TableNameList.table_names")); + "milvus.grpc.CollectionNameList.collection_names")); } else { goto handle_unusual; } @@ -1699,18 +1704,18 @@ bool TableNameList::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableNameList) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionNameList) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableNameList) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionNameList) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableNameList::SerializeWithCachedSizes( +void CollectionNameList::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1720,26 +1725,26 @@ void TableNameList::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // repeated string table_names = 2; - for (int i = 0, n = this->table_names_size(); i < n; i++) { + // repeated string collection_names = 2; + for (int i = 0, n = this->collection_names_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_names(i).data(), static_cast(this->table_names(i).length()), + this->collection_names(i).data(), static_cast(this->collection_names(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableNameList.table_names"); + "milvus.grpc.CollectionNameList.collection_names"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( - 2, this->table_names(i), output); + 2, this->collection_names(i), output); } if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionNameList) } -::PROTOBUF_NAMESPACE_ID::uint8* TableNameList::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionNameList::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1750,26 +1755,26 @@ void TableNameList::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // repeated string table_names = 2; - for (int i = 0, n = this->table_names_size(); i < n; i++) { + // repeated string collection_names = 2; + for (int i = 0, n = this->collection_names_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_names(i).data(), static_cast(this->table_names(i).length()), + this->collection_names(i).data(), static_cast(this->collection_names(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableNameList.table_names"); + "milvus.grpc.CollectionNameList.collection_names"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - WriteStringToArray(2, this->table_names(i), target); + WriteStringToArray(2, this->collection_names(i), target); } if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableNameList) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionNameList) return target; } -size_t TableNameList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableNameList) +size_t CollectionNameList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionNameList) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -1781,12 +1786,12 @@ size_t TableNameList::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated string table_names = 2; + // repeated string collection_names = 2; total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->table_names_size()); - for (int i = 0, n = this->table_names_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_names_size()); + for (int i = 0, n = this->collection_names_size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_names(i)); + this->collection_names(i)); } // .milvus.grpc.Status status = 1; @@ -1801,98 +1806,98 @@ size_t TableNameList::ByteSizeLong() const { return total_size; } -void TableNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableNameList) +void CollectionNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionNameList) GOOGLE_DCHECK_NE(&from, this); - const TableNameList* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionNameList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableNameList) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionNameList) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableNameList) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionNameList) MergeFrom(*source); } } -void TableNameList::MergeFrom(const TableNameList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableNameList) +void CollectionNameList::MergeFrom(const CollectionNameList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionNameList) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - table_names_.MergeFrom(from.table_names_); + collection_names_.MergeFrom(from.collection_names_); if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } } -void TableNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableNameList) +void CollectionNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionNameList) if (&from == this) return; Clear(); MergeFrom(from); } -void TableNameList::CopyFrom(const TableNameList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableNameList) +void CollectionNameList::CopyFrom(const CollectionNameList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionNameList) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableNameList::IsInitialized() const { +bool CollectionNameList::IsInitialized() const { return true; } -void TableNameList::InternalSwap(TableNameList* other) { +void CollectionNameList::InternalSwap(CollectionNameList* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_names_.InternalSwap(CastToBase(&other->table_names_)); + collection_names_.InternalSwap(CastToBase(&other->collection_names_)); swap(status_, other->status_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableNameList::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionNameList::GetMetadata() const { return GetMetadataStatic(); } // =================================================================== -void TableSchema::InitAsDefaultInstance() { - ::milvus::grpc::_TableSchema_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionSchema::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionSchema_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableSchema::_Internal { +class CollectionSchema::_Internal { public: - static const ::milvus::grpc::Status& status(const TableSchema* msg); + static const ::milvus::grpc::Status& status(const CollectionSchema* msg); }; const ::milvus::grpc::Status& -TableSchema::_Internal::status(const TableSchema* msg) { +CollectionSchema::_Internal::status(const CollectionSchema* msg) { return *msg->status_; } -void TableSchema::clear_status() { +void CollectionSchema::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableSchema::TableSchema() +CollectionSchema::CollectionSchema() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableSchema) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionSchema) } -TableSchema::TableSchema(const TableSchema& from) +CollectionSchema::CollectionSchema(const CollectionSchema& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); @@ -1902,44 +1907,44 @@ TableSchema::TableSchema(const TableSchema& from) ::memcpy(&dimension_, &from.dimension_, static_cast(reinterpret_cast(&metric_type_) - reinterpret_cast(&dimension_)) + sizeof(metric_type_)); - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableSchema) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionSchema) } -void TableSchema::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableSchema_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionSchema::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionSchema_milvus_2eproto.base); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&status_, 0, static_cast( reinterpret_cast(&metric_type_) - reinterpret_cast(&status_)) + sizeof(metric_type_)); } -TableSchema::~TableSchema() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableSchema) +CollectionSchema::~CollectionSchema() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionSchema) SharedDtor(); } -void TableSchema::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void CollectionSchema::SharedDtor() { + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete status_; } -void TableSchema::SetCachedSize(int size) const { +void CollectionSchema::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableSchema& TableSchema::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableSchema_milvus_2eproto.base); +const CollectionSchema& CollectionSchema::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionSchema_milvus_2eproto.base); return *internal_default_instance(); } -void TableSchema::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableSchema) +void CollectionSchema::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } @@ -1951,7 +1956,7 @@ void TableSchema::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -1965,10 +1970,10 @@ const char* TableSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); } else goto handle_unusual; continue; - // string table_name = 2; + // string collection_name = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableSchema.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.CollectionSchema.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -2025,11 +2030,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableSchema::MergePartialFromCodedStream( +bool CollectionSchema::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableSchema) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionSchema) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -2046,15 +2051,15 @@ bool TableSchema::MergePartialFromCodedStream( break; } - // string table_name = 2; + // string collection_name = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.TableSchema.table_name")); + "milvus.grpc.CollectionSchema.collection_name")); } else { goto handle_unusual; } @@ -2123,18 +2128,18 @@ bool TableSchema::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableSchema) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionSchema) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableSchema) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionSchema) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableSchema::SerializeWithCachedSizes( +void CollectionSchema::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2144,14 +2149,14 @@ void TableSchema::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableSchema.table_name"); + "milvus.grpc.CollectionSchema.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->table_name(), output); + 2, this->collection_name(), output); } // int64 dimension = 3; @@ -2182,12 +2187,12 @@ void TableSchema::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionSchema) } -::PROTOBUF_NAMESPACE_ID::uint8* TableSchema::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionSchema::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2198,15 +2203,15 @@ void TableSchema::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.TableSchema.table_name"); + "milvus.grpc.CollectionSchema.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 2, this->table_name(), target); + 2, this->collection_name(), target); } // int64 dimension = 3; @@ -2236,12 +2241,12 @@ void TableSchema::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableSchema) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionSchema) return target; } -size_t TableSchema::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableSchema) +size_t CollectionSchema::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionSchema) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -2264,11 +2269,11 @@ size_t TableSchema::ByteSizeLong() const { } } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // .milvus.grpc.Status status = 1; @@ -2304,32 +2309,32 @@ size_t TableSchema::ByteSizeLong() const { return total_size; } -void TableSchema::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableSchema) +void CollectionSchema::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionSchema) GOOGLE_DCHECK_NE(&from, this); - const TableSchema* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionSchema* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableSchema) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionSchema) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableSchema) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionSchema) MergeFrom(*source); } } -void TableSchema::MergeFrom(const TableSchema& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableSchema) +void CollectionSchema::MergeFrom(const CollectionSchema& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionSchema) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); @@ -2345,29 +2350,29 @@ void TableSchema::MergeFrom(const TableSchema& from) { } } -void TableSchema::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableSchema) +void CollectionSchema::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionSchema) if (&from == this) return; Clear(); MergeFrom(from); } -void TableSchema::CopyFrom(const TableSchema& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableSchema) +void CollectionSchema::CopyFrom(const CollectionSchema& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionSchema) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableSchema::IsInitialized() const { +bool CollectionSchema::IsInitialized() const { return true; } -void TableSchema::InternalSwap(TableSchema* other) { +void CollectionSchema::InternalSwap(CollectionSchema* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(status_, other->status_); swap(dimension_, other->dimension_); @@ -2375,7 +2380,7 @@ void TableSchema::InternalSwap(TableSchema* other) { swap(metric_type_, other->metric_type_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableSchema::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionSchema::GetMetadata() const { return GetMetadataStatic(); } @@ -2397,9 +2402,9 @@ PartitionParam::PartitionParam(const PartitionParam& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from.tag().empty()) { @@ -2410,7 +2415,7 @@ PartitionParam::PartitionParam(const PartitionParam& from) void PartitionParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PartitionParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -2420,7 +2425,7 @@ PartitionParam::~PartitionParam() { } void PartitionParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -2439,7 +2444,7 @@ void PartitionParam::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -2452,10 +2457,10 @@ const char* PartitionParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.PartitionParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.PartitionParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -2496,15 +2501,15 @@ bool PartitionParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.PartitionParam.table_name")); + "milvus.grpc.PartitionParam.collection_name")); } else { goto handle_unusual; } @@ -2553,14 +2558,14 @@ void PartitionParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.PartitionParam.table_name"); + "milvus.grpc.PartitionParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // string tag = 2; @@ -2586,15 +2591,15 @@ void PartitionParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.PartitionParam.table_name"); + "milvus.grpc.PartitionParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // string tag = 2; @@ -2629,11 +2634,11 @@ size_t PartitionParam::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // string tag = 2; @@ -2670,9 +2675,9 @@ void PartitionParam::MergeFrom(const PartitionParam& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.tag().size() > 0) { @@ -2701,7 +2706,7 @@ bool PartitionParam::IsInitialized() const { void PartitionParam::InternalSwap(PartitionParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); tag_.Swap(&other->tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); @@ -3388,9 +3393,9 @@ InsertParam::InsertParam(const InsertParam& from) row_id_array_(from.row_id_array_), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from.partition_tag().empty()) { @@ -3401,7 +3406,7 @@ InsertParam::InsertParam(const InsertParam& from) void InsertParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_InsertParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -3411,7 +3416,7 @@ InsertParam::~InsertParam() { } void InsertParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -3433,7 +3438,7 @@ void InsertParam::Clear() { row_record_array_.Clear(); row_id_array_.Clear(); extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -3446,10 +3451,10 @@ const char* InsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.InsertParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.InsertParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -3524,15 +3529,15 @@ bool InsertParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.InsertParam.table_name")); + "milvus.grpc.InsertParam.collection_name")); } else { goto handle_unusual; } @@ -3619,14 +3624,14 @@ void InsertParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.InsertParam.table_name"); + "milvus.grpc.InsertParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -3681,15 +3686,15 @@ void InsertParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.InsertParam.table_name"); + "milvus.grpc.InsertParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -3790,11 +3795,11 @@ size_t InsertParam::ByteSizeLong() const { } } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // string partition_tag = 4; @@ -3834,9 +3839,9 @@ void InsertParam::MergeFrom(const InsertParam& from) { row_record_array_.MergeFrom(from.row_record_array_); row_id_array_.MergeFrom(from.row_id_array_); extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.partition_tag().size() > 0) { @@ -3868,7 +3873,7 @@ void InsertParam::InternalSwap(InsertParam* other) { CastToBase(&row_record_array_)->InternalSwap(CastToBase(&other->row_record_array_)); row_id_array_.InternalSwap(&other->row_id_array_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); partition_tag_.Swap(&other->partition_tag_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); @@ -4240,9 +4245,9 @@ SearchParam::SearchParam(const SearchParam& from) query_record_array_(from.query_record_array_), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } topk_ = from.topk_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchParam) @@ -4250,7 +4255,7 @@ SearchParam::SearchParam(const SearchParam& from) void SearchParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); topk_ = PROTOBUF_LONGLONG(0); } @@ -4260,7 +4265,7 @@ SearchParam::~SearchParam() { } void SearchParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SearchParam::SetCachedSize(int size) const { @@ -4281,7 +4286,7 @@ void SearchParam::Clear() { partition_tag_array_.Clear(); query_record_array_.Clear(); extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); topk_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -4294,10 +4299,10 @@ const char* SearchParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.SearchParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -4374,15 +4379,15 @@ bool SearchParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.SearchParam.table_name")); + "milvus.grpc.SearchParam.collection_name")); } else { goto handle_unusual; } @@ -4467,14 +4472,14 @@ void SearchParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchParam.table_name"); + "milvus.grpc.SearchParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated string partition_tag_array = 2; @@ -4523,15 +4528,15 @@ void SearchParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchParam.table_name"); + "milvus.grpc.SearchParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated string partition_tag_array = 2; @@ -4616,11 +4621,11 @@ size_t SearchParam::ByteSizeLong() const { } } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // int64 topk = 4; @@ -4660,9 +4665,9 @@ void SearchParam::MergeFrom(const SearchParam& from) { partition_tag_array_.MergeFrom(from.partition_tag_array_); query_record_array_.MergeFrom(from.query_record_array_); extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.topk() != 0) { set_topk(from.topk()); @@ -4693,7 +4698,7 @@ void SearchParam::InternalSwap(SearchParam* other) { partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); CastToBase(&query_record_array_)->InternalSwap(CastToBase(&other->query_record_array_)); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(topk_, other->topk_); } @@ -5048,9 +5053,9 @@ SearchByIDParam::SearchByIDParam(const SearchByIDParam& from) partition_tag_array_(from.partition_tag_array_), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } ::memcpy(&id_, &from.id_, static_cast(reinterpret_cast(&topk_) - @@ -5060,7 +5065,7 @@ SearchByIDParam::SearchByIDParam(const SearchByIDParam& from) void SearchByIDParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchByIDParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&id_, 0, static_cast( reinterpret_cast(&topk_) - reinterpret_cast(&id_)) + sizeof(topk_)); @@ -5072,7 +5077,7 @@ SearchByIDParam::~SearchByIDParam() { } void SearchByIDParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SearchByIDParam::SetCachedSize(int size) const { @@ -5092,7 +5097,7 @@ void SearchByIDParam::Clear() { partition_tag_array_.Clear(); extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&id_, 0, static_cast( reinterpret_cast(&topk_) - reinterpret_cast(&id_)) + sizeof(topk_)); @@ -5107,10 +5112,10 @@ const char* SearchByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.SearchByIDParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.SearchByIDParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -5182,15 +5187,15 @@ bool SearchByIDParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.SearchByIDParam.table_name")); + "milvus.grpc.SearchByIDParam.collection_name")); } else { goto handle_unusual; } @@ -5277,14 +5282,14 @@ void SearchByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchByIDParam.table_name"); + "milvus.grpc.SearchByIDParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated string partition_tag_array = 2; @@ -5329,15 +5334,15 @@ void SearchByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.SearchByIDParam.table_name"); + "milvus.grpc.SearchByIDParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated string partition_tag_array = 2; @@ -5408,11 +5413,11 @@ size_t SearchByIDParam::ByteSizeLong() const { } } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // int64 id = 3; @@ -5458,9 +5463,9 @@ void SearchByIDParam::MergeFrom(const SearchByIDParam& from) { partition_tag_array_.MergeFrom(from.partition_tag_array_); extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.id() != 0) { set_id(from.id()); @@ -5493,7 +5498,7 @@ void SearchByIDParam::InternalSwap(SearchByIDParam* other) { _internal_metadata_.Swap(&other->_internal_metadata_); partition_tag_array_.InternalSwap(CastToBase(&other->partition_tag_array_)); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(id_, other->id_); swap(topk_, other->topk_); @@ -6609,31 +6614,31 @@ void BoolReply::InternalSwap(BoolReply* other) { // =================================================================== -void TableRowCount::InitAsDefaultInstance() { - ::milvus::grpc::_TableRowCount_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionRowCount::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionRowCount_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableRowCount::_Internal { +class CollectionRowCount::_Internal { public: - static const ::milvus::grpc::Status& status(const TableRowCount* msg); + static const ::milvus::grpc::Status& status(const CollectionRowCount* msg); }; const ::milvus::grpc::Status& -TableRowCount::_Internal::status(const TableRowCount* msg) { +CollectionRowCount::_Internal::status(const CollectionRowCount* msg) { return *msg->status_; } -void TableRowCount::clear_status() { +void CollectionRowCount::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableRowCount::TableRowCount() +CollectionRowCount::CollectionRowCount() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionRowCount) } -TableRowCount::TableRowCount(const TableRowCount& from) +CollectionRowCount::CollectionRowCount(const CollectionRowCount& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -6642,37 +6647,37 @@ TableRowCount::TableRowCount(const TableRowCount& from) } else { status_ = nullptr; } - table_row_count_ = from.table_row_count_; - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableRowCount) + collection_row_count_ = from.collection_row_count_; + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionRowCount) } -void TableRowCount::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableRowCount_milvus_2eproto.base); +void CollectionRowCount::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionRowCount_milvus_2eproto.base); ::memset(&status_, 0, static_cast( - reinterpret_cast(&table_row_count_) - - reinterpret_cast(&status_)) + sizeof(table_row_count_)); + reinterpret_cast(&collection_row_count_) - + reinterpret_cast(&status_)) + sizeof(collection_row_count_)); } -TableRowCount::~TableRowCount() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableRowCount) +CollectionRowCount::~CollectionRowCount() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionRowCount) SharedDtor(); } -void TableRowCount::SharedDtor() { +void CollectionRowCount::SharedDtor() { if (this != internal_default_instance()) delete status_; } -void TableRowCount::SetCachedSize(int size) const { +void CollectionRowCount::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableRowCount& TableRowCount::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableRowCount_milvus_2eproto.base); +const CollectionRowCount& CollectionRowCount::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionRowCount_milvus_2eproto.base); return *internal_default_instance(); } -void TableRowCount::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableRowCount) +void CollectionRowCount::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6681,12 +6686,12 @@ void TableRowCount::Clear() { delete status_; } status_ = nullptr; - table_row_count_ = PROTOBUF_LONGLONG(0); + collection_row_count_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -6700,10 +6705,10 @@ const char* TableRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ CHK_(ptr); } else goto handle_unusual; continue; - // int64 table_row_count = 2; + // int64 collection_row_count = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - table_row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); + collection_row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6727,11 +6732,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableRowCount::MergePartialFromCodedStream( +bool CollectionRowCount::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionRowCount) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -6748,13 +6753,13 @@ bool TableRowCount::MergePartialFromCodedStream( break; } - // int64 table_row_count = 2; + // int64 collection_row_count = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) { DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive< ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>( - input, &table_row_count_))); + input, &collection_row_count_))); } else { goto handle_unusual; } @@ -6773,18 +6778,18 @@ bool TableRowCount::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionRowCount) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionRowCount) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableRowCount::SerializeWithCachedSizes( +void CollectionRowCount::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -6794,21 +6799,21 @@ void TableRowCount::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // int64 table_row_count = 2; - if (this->table_row_count() != 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->table_row_count(), output); + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->collection_row_count(), output); } if (_internal_metadata_.have_unknown_fields()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionRowCount) } -::PROTOBUF_NAMESPACE_ID::uint8* TableRowCount::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionRowCount::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -6819,21 +6824,21 @@ void TableRowCount::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // int64 table_row_count = 2; - if (this->table_row_count() != 0) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->table_row_count(), target); + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->collection_row_count(), target); } if (_internal_metadata_.have_unknown_fields()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionRowCount) return target; } -size_t TableRowCount::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableRowCount) +size_t CollectionRowCount::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionRowCount) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -6852,11 +6857,11 @@ size_t TableRowCount::ByteSizeLong() const { *status_); } - // int64 table_row_count = 2; - if (this->table_row_count() != 0) { + // int64 collection_row_count = 2; + if (this->collection_row_count() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->table_row_count()); + this->collection_row_count()); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -6864,23 +6869,23 @@ size_t TableRowCount::ByteSizeLong() const { return total_size; } -void TableRowCount::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionRowCount) GOOGLE_DCHECK_NE(&from, this); - const TableRowCount* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionRowCount* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionRowCount) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionRowCount) MergeFrom(*source); } } -void TableRowCount::MergeFrom(const TableRowCount& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::MergeFrom(const CollectionRowCount& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionRowCount) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6889,37 +6894,37 @@ void TableRowCount::MergeFrom(const TableRowCount& from) { if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); } - if (from.table_row_count() != 0) { - set_table_row_count(from.table_row_count()); + if (from.collection_row_count() != 0) { + set_collection_row_count(from.collection_row_count()); } } -void TableRowCount::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionRowCount) if (&from == this) return; Clear(); MergeFrom(from); } -void TableRowCount::CopyFrom(const TableRowCount& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableRowCount) +void CollectionRowCount::CopyFrom(const CollectionRowCount& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionRowCount) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableRowCount::IsInitialized() const { +bool CollectionRowCount::IsInitialized() const { return true; } -void TableRowCount::InternalSwap(TableRowCount* other) { +void CollectionRowCount::InternalSwap(CollectionRowCount* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); swap(status_, other->status_); - swap(table_row_count_, other->table_row_count_); + swap(collection_row_count_, other->collection_row_count_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableRowCount::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionRowCount::GetMetadata() const { return GetMetadataStatic(); } @@ -7224,9 +7229,9 @@ IndexParam::IndexParam(const IndexParam& from) _internal_metadata_(nullptr), extra_params_(from.extra_params_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { status_ = new ::milvus::grpc::Status(*from.status_); @@ -7239,7 +7244,7 @@ IndexParam::IndexParam(const IndexParam& from) void IndexParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_IndexParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(&status_, 0, static_cast( reinterpret_cast(&index_type_) - reinterpret_cast(&status_)) + sizeof(index_type_)); @@ -7251,7 +7256,7 @@ IndexParam::~IndexParam() { } void IndexParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete status_; } @@ -7271,7 +7276,7 @@ void IndexParam::Clear() { (void) cached_has_bits; extra_params_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } @@ -7295,10 +7300,10 @@ const char* IndexParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: CHK_(ptr); } else goto handle_unusual; continue; - // string table_name = 2; + // string collection_name = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.IndexParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.IndexParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -7362,15 +7367,15 @@ bool IndexParam::MergePartialFromCodedStream( break; } - // string table_name = 2; + // string collection_name = 2; case 2: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.IndexParam.table_name")); + "milvus.grpc.IndexParam.collection_name")); } else { goto handle_unusual; } @@ -7434,14 +7439,14 @@ void IndexParam::SerializeWithCachedSizes( 1, _Internal::status(this), output); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.IndexParam.table_name"); + "milvus.grpc.IndexParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->table_name(), output); + 2, this->collection_name(), output); } // int32 index_type = 3; @@ -7478,15 +7483,15 @@ void IndexParam::SerializeWithCachedSizes( 1, _Internal::status(this), target); } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.IndexParam.table_name"); + "milvus.grpc.IndexParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 2, this->table_name(), target); + 2, this->collection_name(), target); } // int32 index_type = 3; @@ -7534,11 +7539,11 @@ size_t IndexParam::ByteSizeLong() const { } } - // string table_name = 2; - if (this->table_name().size() > 0) { + // string collection_name = 2; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // .milvus.grpc.Status status = 1; @@ -7583,9 +7588,9 @@ void IndexParam::MergeFrom(const IndexParam& from) { (void) cached_has_bits; extra_params_.MergeFrom(from.extra_params_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.has_status()) { mutable_status()->::milvus::grpc::Status::MergeFrom(from.status()); @@ -7617,7 +7622,7 @@ void IndexParam::InternalSwap(IndexParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&extra_params_)->InternalSwap(CastToBase(&other->extra_params_)); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(status_, other->status_); swap(index_type_, other->index_type_); @@ -7644,7 +7649,7 @@ FlushParam::FlushParam() FlushParam::FlushParam(const FlushParam& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), - table_name_array_(from.table_name_array_) { + collection_name_array_(from.collection_name_array_) { _internal_metadata_.MergeFrom(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:milvus.grpc.FlushParam) } @@ -7676,7 +7681,7 @@ void FlushParam::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_array_.Clear(); + collection_name_array_.Clear(); _internal_metadata_.Clear(); } @@ -7688,13 +7693,13 @@ const char* FlushParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // repeated string table_name_array = 1; + // repeated string collection_name_array = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; do { ptr += 1; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_table_name_array(), ptr, ctx, "milvus.grpc.FlushParam.table_name_array"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_collection_name_array(), ptr, ctx, "milvus.grpc.FlushParam.collection_name_array"); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10); @@ -7730,16 +7735,16 @@ bool FlushParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // repeated string table_name_array = 1; + // repeated string collection_name_array = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->add_table_name_array())); + input, this->add_collection_name_array())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name_array(this->table_name_array_size() - 1).data(), - static_cast(this->table_name_array(this->table_name_array_size() - 1).length()), + this->collection_name_array(this->collection_name_array_size() - 1).data(), + static_cast(this->collection_name_array(this->collection_name_array_size() - 1).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.FlushParam.table_name_array")); + "milvus.grpc.FlushParam.collection_name_array")); } else { goto handle_unusual; } @@ -7773,14 +7778,14 @@ void FlushParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated string table_name_array = 1; - for (int i = 0, n = this->table_name_array_size(); i < n; i++) { + // repeated string collection_name_array = 1; + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name_array(i).data(), static_cast(this->table_name_array(i).length()), + this->collection_name_array(i).data(), static_cast(this->collection_name_array(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.FlushParam.table_name_array"); + "milvus.grpc.FlushParam.collection_name_array"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString( - 1, this->table_name_array(i), output); + 1, this->collection_name_array(i), output); } if (_internal_metadata_.have_unknown_fields()) { @@ -7796,14 +7801,14 @@ void FlushParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated string table_name_array = 1; - for (int i = 0, n = this->table_name_array_size(); i < n; i++) { + // repeated string collection_name_array = 1; + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name_array(i).data(), static_cast(this->table_name_array(i).length()), + this->collection_name_array(i).data(), static_cast(this->collection_name_array(i).length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.FlushParam.table_name_array"); + "milvus.grpc.FlushParam.collection_name_array"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - WriteStringToArray(1, this->table_name_array(i), target); + WriteStringToArray(1, this->collection_name_array(i), target); } if (_internal_metadata_.have_unknown_fields()) { @@ -7827,12 +7832,12 @@ size_t FlushParam::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated string table_name_array = 1; + // repeated string collection_name_array = 1; total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->table_name_array_size()); - for (int i = 0, n = this->table_name_array_size(); i < n; i++) { + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->collection_name_array_size()); + for (int i = 0, n = this->collection_name_array_size(); i < n; i++) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name_array(i)); + this->collection_name_array(i)); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -7862,7 +7867,7 @@ void FlushParam::MergeFrom(const FlushParam& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - table_name_array_.MergeFrom(from.table_name_array_); + collection_name_array_.MergeFrom(from.collection_name_array_); } void FlushParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -7886,7 +7891,7 @@ bool FlushParam::IsInitialized() const { void FlushParam::InternalSwap(FlushParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_array_.InternalSwap(CastToBase(&other->table_name_array_)); + collection_name_array_.InternalSwap(CastToBase(&other->collection_name_array_)); } ::PROTOBUF_NAMESPACE_ID::Metadata FlushParam::GetMetadata() const { @@ -7912,16 +7917,16 @@ DeleteByIDParam::DeleteByIDParam(const DeleteByIDParam& from) _internal_metadata_(nullptr), id_array_(from.id_array_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } // @@protoc_insertion_point(copy_constructor:milvus.grpc.DeleteByIDParam) } void DeleteByIDParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DeleteByIDParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } DeleteByIDParam::~DeleteByIDParam() { @@ -7930,7 +7935,7 @@ DeleteByIDParam::~DeleteByIDParam() { } void DeleteByIDParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void DeleteByIDParam::SetCachedSize(int size) const { @@ -7949,7 +7954,7 @@ void DeleteByIDParam::Clear() { (void) cached_has_bits; id_array_.Clear(); - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -7961,10 +7966,10 @@ const char* DeleteByIDParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.DeleteByIDParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.DeleteByIDParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -8008,15 +8013,15 @@ bool DeleteByIDParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.DeleteByIDParam.table_name")); + "milvus.grpc.DeleteByIDParam.collection_name")); } else { goto handle_unusual; } @@ -8066,14 +8071,14 @@ void DeleteByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.DeleteByIDParam.table_name"); + "milvus.grpc.DeleteByIDParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // repeated int64 id_array = 2; @@ -8100,15 +8105,15 @@ void DeleteByIDParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.DeleteByIDParam.table_name"); + "milvus.grpc.DeleteByIDParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // repeated int64 id_array = 2; @@ -8160,11 +8165,11 @@ size_t DeleteByIDParam::ByteSizeLong() const { total_size += data_size; } - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); @@ -8195,9 +8200,9 @@ void DeleteByIDParam::MergeFrom(const DeleteByIDParam& from) { (void) cached_has_bits; id_array_.MergeFrom(from.id_array_); - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } } @@ -8223,7 +8228,7 @@ void DeleteByIDParam::InternalSwap(DeleteByIDParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); id_array_.InternalSwap(&other->id_array_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); } @@ -9025,31 +9030,31 @@ void PartitionStat::InternalSwap(PartitionStat* other) { // =================================================================== -void TableInfo::InitAsDefaultInstance() { - ::milvus::grpc::_TableInfo_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( +void CollectionInfo::InitAsDefaultInstance() { + ::milvus::grpc::_CollectionInfo_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>( ::milvus::grpc::Status::internal_default_instance()); } -class TableInfo::_Internal { +class CollectionInfo::_Internal { public: - static const ::milvus::grpc::Status& status(const TableInfo* msg); + static const ::milvus::grpc::Status& status(const CollectionInfo* msg); }; const ::milvus::grpc::Status& -TableInfo::_Internal::status(const TableInfo* msg) { +CollectionInfo::_Internal::status(const CollectionInfo* msg) { return *msg->status_; } -void TableInfo::clear_status() { +void CollectionInfo::clear_status() { if (GetArenaNoVirtual() == nullptr && status_ != nullptr) { delete status_; } status_ = nullptr; } -TableInfo::TableInfo() +CollectionInfo::CollectionInfo() : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { SharedCtor(); - // @@protoc_insertion_point(constructor:milvus.grpc.TableInfo) + // @@protoc_insertion_point(constructor:milvus.grpc.CollectionInfo) } -TableInfo::TableInfo(const TableInfo& from) +CollectionInfo::CollectionInfo(const CollectionInfo& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr), partitions_stat_(from.partitions_stat_) { @@ -9060,36 +9065,36 @@ TableInfo::TableInfo(const TableInfo& from) status_ = nullptr; } total_row_count_ = from.total_row_count_; - // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableInfo) + // @@protoc_insertion_point(copy_constructor:milvus.grpc.CollectionInfo) } -void TableInfo::SharedCtor() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableInfo_milvus_2eproto.base); +void CollectionInfo::SharedCtor() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CollectionInfo_milvus_2eproto.base); ::memset(&status_, 0, static_cast( reinterpret_cast(&total_row_count_) - reinterpret_cast(&status_)) + sizeof(total_row_count_)); } -TableInfo::~TableInfo() { - // @@protoc_insertion_point(destructor:milvus.grpc.TableInfo) +CollectionInfo::~CollectionInfo() { + // @@protoc_insertion_point(destructor:milvus.grpc.CollectionInfo) SharedDtor(); } -void TableInfo::SharedDtor() { +void CollectionInfo::SharedDtor() { if (this != internal_default_instance()) delete status_; } -void TableInfo::SetCachedSize(int size) const { +void CollectionInfo::SetCachedSize(int size) const { _cached_size_.Set(size); } -const TableInfo& TableInfo::default_instance() { - ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableInfo_milvus_2eproto.base); +const CollectionInfo& CollectionInfo::default_instance() { + ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CollectionInfo_milvus_2eproto.base); return *internal_default_instance(); } -void TableInfo::Clear() { -// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableInfo) +void CollectionInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9104,7 +9109,7 @@ void TableInfo::Clear() { } #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -const char* TableInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* CollectionInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; @@ -9157,11 +9162,11 @@ failure: #undef CHK_ } #else // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -bool TableInfo::MergePartialFromCodedStream( +bool CollectionInfo::MergePartialFromCodedStream( ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) { #define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure ::PROTOBUF_NAMESPACE_ID::uint32 tag; - // @@protoc_insertion_point(parse_start:milvus.grpc.TableInfo) + // @@protoc_insertion_point(parse_start:milvus.grpc.CollectionInfo) for (;;) { ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); tag = p.first; @@ -9214,18 +9219,18 @@ bool TableInfo::MergePartialFromCodedStream( } } success: - // @@protoc_insertion_point(parse_success:milvus.grpc.TableInfo) + // @@protoc_insertion_point(parse_success:milvus.grpc.CollectionInfo) return true; failure: - // @@protoc_insertion_point(parse_failure:milvus.grpc.TableInfo) + // @@protoc_insertion_point(parse_failure:milvus.grpc.CollectionInfo) return false; #undef DO_ } #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER -void TableInfo::SerializeWithCachedSizes( +void CollectionInfo::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_start:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -9253,12 +9258,12 @@ void TableInfo::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields( _internal_metadata_.unknown_fields(), output); } - // @@protoc_insertion_point(serialize_end:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_end:milvus.grpc.CollectionInfo) } -::PROTOBUF_NAMESPACE_ID::uint8* TableInfo::InternalSerializeWithCachedSizesToArray( +::PROTOBUF_NAMESPACE_ID::uint8* CollectionInfo::InternalSerializeWithCachedSizesToArray( ::PROTOBUF_NAMESPACE_ID::uint8* target) const { - // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -9286,12 +9291,12 @@ void TableInfo::SerializeWithCachedSizes( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields(), target); } - // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableInfo) + // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.CollectionInfo) return target; } -size_t TableInfo::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableInfo) +size_t CollectionInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.CollectionInfo) size_t total_size = 0; if (_internal_metadata_.have_unknown_fields()) { @@ -9333,23 +9338,23 @@ size_t TableInfo::ByteSizeLong() const { return total_size; } -void TableInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableInfo) +void CollectionInfo::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.CollectionInfo) GOOGLE_DCHECK_NE(&from, this); - const TableInfo* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const CollectionInfo* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableInfo) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.CollectionInfo) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableInfo) + // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.CollectionInfo) MergeFrom(*source); } } -void TableInfo::MergeFrom(const TableInfo& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableInfo) +void CollectionInfo::MergeFrom(const CollectionInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.CollectionInfo) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -9364,25 +9369,25 @@ void TableInfo::MergeFrom(const TableInfo& from) { } } -void TableInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableInfo) +void CollectionInfo::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.CollectionInfo) if (&from == this) return; Clear(); MergeFrom(from); } -void TableInfo::CopyFrom(const TableInfo& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableInfo) +void CollectionInfo::CopyFrom(const CollectionInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.CollectionInfo) if (&from == this) return; Clear(); MergeFrom(from); } -bool TableInfo::IsInitialized() const { +bool CollectionInfo::IsInitialized() const { return true; } -void TableInfo::InternalSwap(TableInfo* other) { +void CollectionInfo::InternalSwap(CollectionInfo* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); CastToBase(&partitions_stat_)->InternalSwap(CastToBase(&other->partitions_stat_)); @@ -9390,7 +9395,7 @@ void TableInfo::InternalSwap(TableInfo* other) { swap(total_row_count_, other->total_row_count_); } -::PROTOBUF_NAMESPACE_ID::Metadata TableInfo::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata CollectionInfo::GetMetadata() const { return GetMetadataStatic(); } @@ -9412,9 +9417,9 @@ VectorIdentity::VectorIdentity(const VectorIdentity& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } id_ = from.id_; // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorIdentity) @@ -9422,7 +9427,7 @@ VectorIdentity::VectorIdentity(const VectorIdentity& from) void VectorIdentity::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorIdentity_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); id_ = PROTOBUF_LONGLONG(0); } @@ -9432,7 +9437,7 @@ VectorIdentity::~VectorIdentity() { } void VectorIdentity::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void VectorIdentity::SetCachedSize(int size) const { @@ -9450,7 +9455,7 @@ void VectorIdentity::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); id_ = PROTOBUF_LONGLONG(0); _internal_metadata_.Clear(); } @@ -9463,10 +9468,10 @@ const char* VectorIdentity::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.VectorIdentity.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.VectorIdentity.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -9507,15 +9512,15 @@ bool VectorIdentity::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.VectorIdentity.table_name")); + "milvus.grpc.VectorIdentity.collection_name")); } else { goto handle_unusual; } @@ -9562,14 +9567,14 @@ void VectorIdentity::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.VectorIdentity.table_name"); + "milvus.grpc.VectorIdentity.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // int64 id = 2; @@ -9590,15 +9595,15 @@ void VectorIdentity::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.VectorIdentity.table_name"); + "milvus.grpc.VectorIdentity.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // int64 id = 2; @@ -9627,11 +9632,11 @@ size_t VectorIdentity::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // int64 id = 2; @@ -9668,9 +9673,9 @@ void VectorIdentity::MergeFrom(const VectorIdentity& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.id() != 0) { set_id(from.id()); @@ -9698,7 +9703,7 @@ bool VectorIdentity::IsInitialized() const { void VectorIdentity::InternalSwap(VectorIdentity* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); swap(id_, other->id_); } @@ -10058,9 +10063,9 @@ GetVectorIDsParam::GetVectorIDsParam(const GetVectorIDsParam& from) : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) { _internal_metadata_.MergeFrom(from._internal_metadata_); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from.table_name().empty()) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from.collection_name().empty()) { + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (!from.segment_name().empty()) { @@ -10071,7 +10076,7 @@ GetVectorIDsParam::GetVectorIDsParam(const GetVectorIDsParam& from) void GetVectorIDsParam::SharedCtor() { ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GetVectorIDsParam_milvus_2eproto.base); - table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); segment_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -10081,7 +10086,7 @@ GetVectorIDsParam::~GetVectorIDsParam() { } void GetVectorIDsParam::SharedDtor() { - table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); segment_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -10100,7 +10105,7 @@ void GetVectorIDsParam::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); segment_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); _internal_metadata_.Clear(); } @@ -10113,10 +10118,10 @@ const char* GetVectorIDsParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); CHK_(ptr); switch (tag >> 3) { - // string table_name = 1; + // string collection_name = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.GetVectorIDsParam.table_name"); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_collection_name(), ptr, ctx, "milvus.grpc.GetVectorIDsParam.collection_name"); CHK_(ptr); } else goto handle_unusual; continue; @@ -10157,15 +10162,15 @@ bool GetVectorIDsParam::MergePartialFromCodedStream( tag = p.first; if (!p.second) goto handle_unusual; switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string table_name = 1; + // string collection_name = 1; case 1: { if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) { DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString( - input, this->mutable_table_name())); + input, this->mutable_collection_name())); DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, - "milvus.grpc.GetVectorIDsParam.table_name")); + "milvus.grpc.GetVectorIDsParam.collection_name")); } else { goto handle_unusual; } @@ -10214,14 +10219,14 @@ void GetVectorIDsParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.GetVectorIDsParam.table_name"); + "milvus.grpc.GetVectorIDsParam.collection_name"); ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->table_name(), output); + 1, this->collection_name(), output); } // string segment_name = 2; @@ -10247,15 +10252,15 @@ void GetVectorIDsParam::SerializeWithCachedSizes( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->table_name().data(), static_cast(this->table_name().length()), + this->collection_name().data(), static_cast(this->collection_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "milvus.grpc.GetVectorIDsParam.table_name"); + "milvus.grpc.GetVectorIDsParam.collection_name"); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray( - 1, this->table_name(), target); + 1, this->collection_name(), target); } // string segment_name = 2; @@ -10290,11 +10295,11 @@ size_t GetVectorIDsParam::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string table_name = 1; - if (this->table_name().size() > 0) { + // string collection_name = 1; + if (this->collection_name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->table_name()); + this->collection_name()); } // string segment_name = 2; @@ -10331,9 +10336,9 @@ void GetVectorIDsParam::MergeFrom(const GetVectorIDsParam& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.table_name().size() > 0) { + if (from.collection_name().size() > 0) { - table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_); + collection_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.collection_name_); } if (from.segment_name().size() > 0) { @@ -10362,7 +10367,7 @@ bool GetVectorIDsParam::IsInitialized() const { void GetVectorIDsParam::InternalSwap(GetVectorIDsParam* other) { using std::swap; _internal_metadata_.Swap(&other->_internal_metadata_); - table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.Swap(&other->collection_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); segment_name_.Swap(&other->segment_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual()); @@ -10380,14 +10385,14 @@ PROTOBUF_NAMESPACE_OPEN template<> PROTOBUF_NOINLINE ::milvus::grpc::KeyValuePair* Arena::CreateMaybeMessage< ::milvus::grpc::KeyValuePair >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::KeyValuePair >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableName* Arena::CreateMaybeMessage< ::milvus::grpc::TableName >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableName >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionName >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionName >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage< ::milvus::grpc::TableNameList >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableNameList >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionNameList >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionNameList >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage< ::milvus::grpc::TableSchema >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableSchema >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionSchema* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionSchema >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionSchema >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::PartitionParam* Arena::CreateMaybeMessage< ::milvus::grpc::PartitionParam >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::PartitionParam >(arena); @@ -10422,8 +10427,8 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::StringReply* Arena::CreateMaybeMess template<> PROTOBUF_NOINLINE ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage< ::milvus::grpc::BoolReply >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::BoolReply >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage< ::milvus::grpc::TableRowCount >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableRowCount >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionRowCount >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionRowCount >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::Command* Arena::CreateMaybeMessage< ::milvus::grpc::Command >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::Command >(arena); @@ -10443,8 +10448,8 @@ template<> PROTOBUF_NOINLINE ::milvus::grpc::SegmentStat* Arena::CreateMaybeMess template<> PROTOBUF_NOINLINE ::milvus::grpc::PartitionStat* Arena::CreateMaybeMessage< ::milvus::grpc::PartitionStat >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::PartitionStat >(arena); } -template<> PROTOBUF_NOINLINE ::milvus::grpc::TableInfo* Arena::CreateMaybeMessage< ::milvus::grpc::TableInfo >(Arena* arena) { - return Arena::CreateInternal< ::milvus::grpc::TableInfo >(arena); +template<> PROTOBUF_NOINLINE ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage< ::milvus::grpc::CollectionInfo >(Arena* arena) { + return Arena::CreateInternal< ::milvus::grpc::CollectionInfo >(arena); } template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorIdentity* Arena::CreateMaybeMessage< ::milvus::grpc::VectorIdentity >(Arena* arena) { return Arena::CreateInternal< ::milvus::grpc::VectorIdentity >(arena); diff --git a/sdk/grpc-gen/gen-milvus/milvus.pb.h b/sdk/grpc-gen/gen-milvus/milvus.pb.h index 4528f278e1..88113f73f7 100644 --- a/sdk/grpc-gen/gen-milvus/milvus.pb.h +++ b/sdk/grpc-gen/gen-milvus/milvus.pb.h @@ -60,6 +60,21 @@ namespace grpc { class BoolReply; class BoolReplyDefaultTypeInternal; extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_; +class CollectionInfo; +class CollectionInfoDefaultTypeInternal; +extern CollectionInfoDefaultTypeInternal _CollectionInfo_default_instance_; +class CollectionName; +class CollectionNameDefaultTypeInternal; +extern CollectionNameDefaultTypeInternal _CollectionName_default_instance_; +class CollectionNameList; +class CollectionNameListDefaultTypeInternal; +extern CollectionNameListDefaultTypeInternal _CollectionNameList_default_instance_; +class CollectionRowCount; +class CollectionRowCountDefaultTypeInternal; +extern CollectionRowCountDefaultTypeInternal _CollectionRowCount_default_instance_; +class CollectionSchema; +class CollectionSchemaDefaultTypeInternal; +extern CollectionSchemaDefaultTypeInternal _CollectionSchema_default_instance_; class Command; class CommandDefaultTypeInternal; extern CommandDefaultTypeInternal _Command_default_instance_; @@ -108,21 +123,6 @@ extern SegmentStatDefaultTypeInternal _SegmentStat_default_instance_; class StringReply; class StringReplyDefaultTypeInternal; extern StringReplyDefaultTypeInternal _StringReply_default_instance_; -class TableInfo; -class TableInfoDefaultTypeInternal; -extern TableInfoDefaultTypeInternal _TableInfo_default_instance_; -class TableName; -class TableNameDefaultTypeInternal; -extern TableNameDefaultTypeInternal _TableName_default_instance_; -class TableNameList; -class TableNameListDefaultTypeInternal; -extern TableNameListDefaultTypeInternal _TableNameList_default_instance_; -class TableRowCount; -class TableRowCountDefaultTypeInternal; -extern TableRowCountDefaultTypeInternal _TableRowCount_default_instance_; -class TableSchema; -class TableSchemaDefaultTypeInternal; -extern TableSchemaDefaultTypeInternal _TableSchema_default_instance_; class TopKQueryResult; class TopKQueryResultDefaultTypeInternal; extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_; @@ -139,6 +139,11 @@ extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_; } // namespace milvus PROTOBUF_NAMESPACE_OPEN template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*); +template<> ::milvus::grpc::CollectionInfo* Arena::CreateMaybeMessage<::milvus::grpc::CollectionInfo>(Arena*); +template<> ::milvus::grpc::CollectionName* Arena::CreateMaybeMessage<::milvus::grpc::CollectionName>(Arena*); +template<> ::milvus::grpc::CollectionNameList* Arena::CreateMaybeMessage<::milvus::grpc::CollectionNameList>(Arena*); +template<> ::milvus::grpc::CollectionRowCount* Arena::CreateMaybeMessage<::milvus::grpc::CollectionRowCount>(Arena*); +template<> ::milvus::grpc::CollectionSchema* Arena::CreateMaybeMessage<::milvus::grpc::CollectionSchema>(Arena*); template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*); template<> ::milvus::grpc::DeleteByIDParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByIDParam>(Arena*); template<> ::milvus::grpc::FlushParam* Arena::CreateMaybeMessage<::milvus::grpc::FlushParam>(Arena*); @@ -155,11 +160,6 @@ template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvu template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*); template<> ::milvus::grpc::SegmentStat* Arena::CreateMaybeMessage<::milvus::grpc::SegmentStat>(Arena*); template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*); -template<> ::milvus::grpc::TableInfo* Arena::CreateMaybeMessage<::milvus::grpc::TableInfo>(Arena*); -template<> ::milvus::grpc::TableName* Arena::CreateMaybeMessage<::milvus::grpc::TableName>(Arena*); -template<> ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage<::milvus::grpc::TableNameList>(Arena*); -template<> ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage<::milvus::grpc::TableRowCount>(Arena*); -template<> ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage<::milvus::grpc::TableSchema>(Arena*); template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*); template<> ::milvus::grpc::VectorData* Arena::CreateMaybeMessage<::milvus::grpc::VectorData>(Arena*); template<> ::milvus::grpc::VectorIdentity* Arena::CreateMaybeMessage<::milvus::grpc::VectorIdentity>(Arena*); @@ -320,23 +320,23 @@ class KeyValuePair : }; // ------------------------------------------------------------------- -class TableName : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableName) */ { +class CollectionName : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionName) */ { public: - TableName(); - virtual ~TableName(); + CollectionName(); + virtual ~CollectionName(); - TableName(const TableName& from); - TableName(TableName&& from) noexcept - : TableName() { + CollectionName(const CollectionName& from); + CollectionName(CollectionName&& from) noexcept + : CollectionName() { *this = ::std::move(from); } - inline TableName& operator=(const TableName& from) { + inline CollectionName& operator=(const CollectionName& from) { CopyFrom(from); return *this; } - inline TableName& operator=(TableName&& from) noexcept { + inline CollectionName& operator=(CollectionName&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -354,37 +354,37 @@ class TableName : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableName& default_instance(); + static const CollectionName& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableName* internal_default_instance() { - return reinterpret_cast( - &_TableName_default_instance_); + static inline const CollectionName* internal_default_instance() { + return reinterpret_cast( + &_CollectionName_default_instance_); } static constexpr int kIndexInFileMessages = 1; - friend void swap(TableName& a, TableName& b) { + friend void swap(CollectionName& a, CollectionName& b) { a.Swap(&b); } - inline void Swap(TableName* other) { + inline void Swap(CollectionName* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableName* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionName* New() const final { + return CreateMaybeMessage(nullptr); } - TableName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableName& from); - void MergeFrom(const TableName& from); + void CopyFrom(const CollectionName& from); + void MergeFrom(const CollectionName& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -405,10 +405,10 @@ class TableName : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableName* other); + void InternalSwap(CollectionName* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableName"; + return "milvus.grpc.CollectionName"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -433,47 +433,47 @@ class TableName : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableName) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionName) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; // ------------------------------------------------------------------- -class TableNameList : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableNameList) */ { +class CollectionNameList : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionNameList) */ { public: - TableNameList(); - virtual ~TableNameList(); + CollectionNameList(); + virtual ~CollectionNameList(); - TableNameList(const TableNameList& from); - TableNameList(TableNameList&& from) noexcept - : TableNameList() { + CollectionNameList(const CollectionNameList& from); + CollectionNameList(CollectionNameList&& from) noexcept + : CollectionNameList() { *this = ::std::move(from); } - inline TableNameList& operator=(const TableNameList& from) { + inline CollectionNameList& operator=(const CollectionNameList& from) { CopyFrom(from); return *this; } - inline TableNameList& operator=(TableNameList&& from) noexcept { + inline CollectionNameList& operator=(CollectionNameList&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -491,37 +491,37 @@ class TableNameList : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableNameList& default_instance(); + static const CollectionNameList& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableNameList* internal_default_instance() { - return reinterpret_cast( - &_TableNameList_default_instance_); + static inline const CollectionNameList* internal_default_instance() { + return reinterpret_cast( + &_CollectionNameList_default_instance_); } static constexpr int kIndexInFileMessages = 2; - friend void swap(TableNameList& a, TableNameList& b) { + friend void swap(CollectionNameList& a, CollectionNameList& b) { a.Swap(&b); } - inline void Swap(TableNameList* other) { + inline void Swap(CollectionNameList* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableNameList* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionNameList* New() const final { + return CreateMaybeMessage(nullptr); } - TableNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableNameList& from); - void MergeFrom(const TableNameList& from); + void CopyFrom(const CollectionNameList& from); + void MergeFrom(const CollectionNameList& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -542,10 +542,10 @@ class TableNameList : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableNameList* other); + void InternalSwap(CollectionNameList* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableNameList"; + return "milvus.grpc.CollectionNameList"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -570,25 +570,25 @@ class TableNameList : // accessors ------------------------------------------------------- enum : int { - kTableNamesFieldNumber = 2, + kCollectionNamesFieldNumber = 2, kStatusFieldNumber = 1, }; - // repeated string table_names = 2; - int table_names_size() const; - void clear_table_names(); - const std::string& table_names(int index) const; - std::string* mutable_table_names(int index); - void set_table_names(int index, const std::string& value); - void set_table_names(int index, std::string&& value); - void set_table_names(int index, const char* value); - void set_table_names(int index, const char* value, size_t size); - std::string* add_table_names(); - void add_table_names(const std::string& value); - void add_table_names(std::string&& value); - void add_table_names(const char* value); - void add_table_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& table_names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_table_names(); + // repeated string collection_names = 2; + int collection_names_size() const; + void clear_collection_names(); + const std::string& collection_names(int index) const; + std::string* mutable_collection_names(int index); + void set_collection_names(int index, const std::string& value); + void set_collection_names(int index, std::string&& value); + void set_collection_names(int index, const char* value); + void set_collection_names(int index, const char* value, size_t size); + std::string* add_collection_names(); + void add_collection_names(const std::string& value); + void add_collection_names(std::string&& value); + void add_collection_names(const char* value); + void add_collection_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collection_names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collection_names(); // .milvus.grpc.Status status = 1; bool has_status() const; @@ -598,35 +598,35 @@ class TableNameList : ::milvus::grpc::Status* mutable_status(); void set_allocated_status(::milvus::grpc::Status* status); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableNameList) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionNameList) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField table_names_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collection_names_; ::milvus::grpc::Status* status_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; // ------------------------------------------------------------------- -class TableSchema : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableSchema) */ { +class CollectionSchema : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionSchema) */ { public: - TableSchema(); - virtual ~TableSchema(); + CollectionSchema(); + virtual ~CollectionSchema(); - TableSchema(const TableSchema& from); - TableSchema(TableSchema&& from) noexcept - : TableSchema() { + CollectionSchema(const CollectionSchema& from); + CollectionSchema(CollectionSchema&& from) noexcept + : CollectionSchema() { *this = ::std::move(from); } - inline TableSchema& operator=(const TableSchema& from) { + inline CollectionSchema& operator=(const CollectionSchema& from) { CopyFrom(from); return *this; } - inline TableSchema& operator=(TableSchema&& from) noexcept { + inline CollectionSchema& operator=(CollectionSchema&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -644,37 +644,37 @@ class TableSchema : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableSchema& default_instance(); + static const CollectionSchema& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableSchema* internal_default_instance() { - return reinterpret_cast( - &_TableSchema_default_instance_); + static inline const CollectionSchema* internal_default_instance() { + return reinterpret_cast( + &_CollectionSchema_default_instance_); } static constexpr int kIndexInFileMessages = 3; - friend void swap(TableSchema& a, TableSchema& b) { + friend void swap(CollectionSchema& a, CollectionSchema& b) { a.Swap(&b); } - inline void Swap(TableSchema* other) { + inline void Swap(CollectionSchema* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableSchema* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionSchema* New() const final { + return CreateMaybeMessage(nullptr); } - TableSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableSchema& from); - void MergeFrom(const TableSchema& from); + void CopyFrom(const CollectionSchema& from); + void MergeFrom(const CollectionSchema& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -695,10 +695,10 @@ class TableSchema : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableSchema* other); + void InternalSwap(CollectionSchema* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableSchema"; + return "milvus.grpc.CollectionSchema"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -724,7 +724,7 @@ class TableSchema : enum : int { kExtraParamsFieldNumber = 6, - kTableNameFieldNumber = 2, + kCollectionNameFieldNumber = 2, kStatusFieldNumber = 1, kDimensionFieldNumber = 3, kIndexFileSizeFieldNumber = 4, @@ -741,16 +741,16 @@ class TableSchema : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 2; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // .milvus.grpc.Status status = 1; bool has_status() const; @@ -775,13 +775,13 @@ class TableSchema : ::PROTOBUF_NAMESPACE_ID::int32 metric_type() const; void set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableSchema) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionSchema) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::milvus::grpc::Status* status_; ::PROTOBUF_NAMESPACE_ID::int64 dimension_; ::PROTOBUF_NAMESPACE_ID::int64 index_file_size_; @@ -904,19 +904,19 @@ class PartitionParam : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kTagFieldNumber = 2, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // string tag = 2; void clear_tag(); @@ -934,7 +934,7 @@ class PartitionParam : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -1361,7 +1361,7 @@ class InsertParam : kRowRecordArrayFieldNumber = 2, kRowIdArrayFieldNumber = 3, kExtraParamsFieldNumber = 5, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kPartitionTagFieldNumber = 4, }; // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -1397,16 +1397,16 @@ class InsertParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // string partition_tag = 4; void clear_partition_tag(); @@ -1428,7 +1428,7 @@ class InsertParam : ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > row_id_array_; mutable std::atomic _row_id_array_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -1699,7 +1699,7 @@ class SearchParam : kPartitionTagArrayFieldNumber = 2, kQueryRecordArrayFieldNumber = 3, kExtraParamsFieldNumber = 5, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kTopkFieldNumber = 4, }; // repeated string partition_tag_array = 2; @@ -1741,16 +1741,16 @@ class SearchParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // int64 topk = 4; void clear_topk(); @@ -1765,7 +1765,7 @@ class SearchParam : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > query_record_array_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::int64 topk_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -2040,7 +2040,7 @@ class SearchByIDParam : enum : int { kPartitionTagArrayFieldNumber = 2, kExtraParamsFieldNumber = 5, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kIdFieldNumber = 3, kTopkFieldNumber = 4, }; @@ -2072,16 +2072,16 @@ class SearchByIDParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // int64 id = 3; void clear_id(); @@ -2100,7 +2100,7 @@ class SearchByIDParam : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField partition_tag_array_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::int64 id_; ::PROTOBUF_NAMESPACE_ID::int64 topk_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -2565,23 +2565,23 @@ class BoolReply : }; // ------------------------------------------------------------------- -class TableRowCount : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableRowCount) */ { +class CollectionRowCount : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionRowCount) */ { public: - TableRowCount(); - virtual ~TableRowCount(); + CollectionRowCount(); + virtual ~CollectionRowCount(); - TableRowCount(const TableRowCount& from); - TableRowCount(TableRowCount&& from) noexcept - : TableRowCount() { + CollectionRowCount(const CollectionRowCount& from); + CollectionRowCount(CollectionRowCount&& from) noexcept + : CollectionRowCount() { *this = ::std::move(from); } - inline TableRowCount& operator=(const TableRowCount& from) { + inline CollectionRowCount& operator=(const CollectionRowCount& from) { CopyFrom(from); return *this; } - inline TableRowCount& operator=(TableRowCount&& from) noexcept { + inline CollectionRowCount& operator=(CollectionRowCount&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -2599,37 +2599,37 @@ class TableRowCount : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableRowCount& default_instance(); + static const CollectionRowCount& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableRowCount* internal_default_instance() { - return reinterpret_cast( - &_TableRowCount_default_instance_); + static inline const CollectionRowCount* internal_default_instance() { + return reinterpret_cast( + &_CollectionRowCount_default_instance_); } static constexpr int kIndexInFileMessages = 15; - friend void swap(TableRowCount& a, TableRowCount& b) { + friend void swap(CollectionRowCount& a, CollectionRowCount& b) { a.Swap(&b); } - inline void Swap(TableRowCount* other) { + inline void Swap(CollectionRowCount* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableRowCount* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionRowCount* New() const final { + return CreateMaybeMessage(nullptr); } - TableRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableRowCount& from); - void MergeFrom(const TableRowCount& from); + void CopyFrom(const CollectionRowCount& from); + void MergeFrom(const CollectionRowCount& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -2650,10 +2650,10 @@ class TableRowCount : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableRowCount* other); + void InternalSwap(CollectionRowCount* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableRowCount"; + return "milvus.grpc.CollectionRowCount"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -2679,7 +2679,7 @@ class TableRowCount : enum : int { kStatusFieldNumber = 1, - kTableRowCountFieldNumber = 2, + kCollectionRowCountFieldNumber = 2, }; // .milvus.grpc.Status status = 1; bool has_status() const; @@ -2689,18 +2689,18 @@ class TableRowCount : ::milvus::grpc::Status* mutable_status(); void set_allocated_status(::milvus::grpc::Status* status); - // int64 table_row_count = 2; - void clear_table_row_count(); - ::PROTOBUF_NAMESPACE_ID::int64 table_row_count() const; - void set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); + // int64 collection_row_count = 2; + void clear_collection_row_count(); + ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count() const; + void set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableRowCount) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionRowCount) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::milvus::grpc::Status* status_; - ::PROTOBUF_NAMESPACE_ID::int64 table_row_count_; + ::PROTOBUF_NAMESPACE_ID::int64 collection_row_count_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -2957,7 +2957,7 @@ class IndexParam : enum : int { kExtraParamsFieldNumber = 4, - kTableNameFieldNumber = 2, + kCollectionNameFieldNumber = 2, kStatusFieldNumber = 1, kIndexTypeFieldNumber = 3, }; @@ -2972,16 +2972,16 @@ class IndexParam : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& extra_params() const; - // string table_name = 2; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 2; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // .milvus.grpc.Status status = 1; bool has_status() const; @@ -3002,7 +3002,7 @@ class IndexParam : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair > extra_params_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::milvus::grpc::Status* status_; ::PROTOBUF_NAMESPACE_ID::int32 index_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -3123,31 +3123,31 @@ class FlushParam : // accessors ------------------------------------------------------- enum : int { - kTableNameArrayFieldNumber = 1, + kCollectionNameArrayFieldNumber = 1, }; - // repeated string table_name_array = 1; - int table_name_array_size() const; - void clear_table_name_array(); - const std::string& table_name_array(int index) const; - std::string* mutable_table_name_array(int index); - void set_table_name_array(int index, const std::string& value); - void set_table_name_array(int index, std::string&& value); - void set_table_name_array(int index, const char* value); - void set_table_name_array(int index, const char* value, size_t size); - std::string* add_table_name_array(); - void add_table_name_array(const std::string& value); - void add_table_name_array(std::string&& value); - void add_table_name_array(const char* value); - void add_table_name_array(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& table_name_array() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_table_name_array(); + // repeated string collection_name_array = 1; + int collection_name_array_size() const; + void clear_collection_name_array(); + const std::string& collection_name_array(int index) const; + std::string* mutable_collection_name_array(int index); + void set_collection_name_array(int index, const std::string& value); + void set_collection_name_array(int index, std::string&& value); + void set_collection_name_array(int index, const char* value); + void set_collection_name_array(int index, const char* value, size_t size); + std::string* add_collection_name_array(); + void add_collection_name_array(const std::string& value); + void add_collection_name_array(std::string&& value); + void add_collection_name_array(const char* value); + void add_collection_name_array(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& collection_name_array() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_collection_name_array(); // @@protoc_insertion_point(class_scope:milvus.grpc.FlushParam) private: class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField table_name_array_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField collection_name_array_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -3267,7 +3267,7 @@ class DeleteByIDParam : enum : int { kIdArrayFieldNumber = 2, - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, }; // repeated int64 id_array = 2; int id_array_size() const; @@ -3280,16 +3280,16 @@ class DeleteByIDParam : ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >* mutable_id_array(); - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // @@protoc_insertion_point(class_scope:milvus.grpc.DeleteByIDParam) private: @@ -3298,7 +3298,7 @@ class DeleteByIDParam : ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > id_array_; mutable std::atomic _id_array_cached_byte_size_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; }; @@ -3625,23 +3625,23 @@ class PartitionStat : }; // ------------------------------------------------------------------- -class TableInfo : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableInfo) */ { +class CollectionInfo : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.CollectionInfo) */ { public: - TableInfo(); - virtual ~TableInfo(); + CollectionInfo(); + virtual ~CollectionInfo(); - TableInfo(const TableInfo& from); - TableInfo(TableInfo&& from) noexcept - : TableInfo() { + CollectionInfo(const CollectionInfo& from); + CollectionInfo(CollectionInfo&& from) noexcept + : CollectionInfo() { *this = ::std::move(from); } - inline TableInfo& operator=(const TableInfo& from) { + inline CollectionInfo& operator=(const CollectionInfo& from) { CopyFrom(from); return *this; } - inline TableInfo& operator=(TableInfo&& from) noexcept { + inline CollectionInfo& operator=(CollectionInfo&& from) noexcept { if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { if (this != &from) InternalSwap(&from); } else { @@ -3659,37 +3659,37 @@ class TableInfo : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return GetMetadataStatic().reflection; } - static const TableInfo& default_instance(); + static const CollectionInfo& default_instance(); static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TableInfo* internal_default_instance() { - return reinterpret_cast( - &_TableInfo_default_instance_); + static inline const CollectionInfo* internal_default_instance() { + return reinterpret_cast( + &_CollectionInfo_default_instance_); } static constexpr int kIndexInFileMessages = 22; - friend void swap(TableInfo& a, TableInfo& b) { + friend void swap(CollectionInfo& a, CollectionInfo& b) { a.Swap(&b); } - inline void Swap(TableInfo* other) { + inline void Swap(CollectionInfo* other) { if (other == this) return; InternalSwap(other); } // implements Message ---------------------------------------------- - inline TableInfo* New() const final { - return CreateMaybeMessage(nullptr); + inline CollectionInfo* New() const final { + return CreateMaybeMessage(nullptr); } - TableInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + CollectionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const TableInfo& from); - void MergeFrom(const TableInfo& from); + void CopyFrom(const CollectionInfo& from); + void MergeFrom(const CollectionInfo& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -3710,10 +3710,10 @@ class TableInfo : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(TableInfo* other); + void InternalSwap(CollectionInfo* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "milvus.grpc.TableInfo"; + return "milvus.grpc.CollectionInfo"; } private: inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const { @@ -3766,7 +3766,7 @@ class TableInfo : ::PROTOBUF_NAMESPACE_ID::int64 total_row_count() const; void set_total_row_count(::PROTOBUF_NAMESPACE_ID::int64 value); - // @@protoc_insertion_point(class_scope:milvus.grpc.TableInfo) + // @@protoc_insertion_point(class_scope:milvus.grpc.CollectionInfo) private: class _Internal; @@ -3892,19 +3892,19 @@ class VectorIdentity : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kIdFieldNumber = 2, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // int64 id = 2; void clear_id(); @@ -3916,7 +3916,7 @@ class VectorIdentity : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::int64 id_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -4180,19 +4180,19 @@ class GetVectorIDsParam : // accessors ------------------------------------------------------- enum : int { - kTableNameFieldNumber = 1, + kCollectionNameFieldNumber = 1, kSegmentNameFieldNumber = 2, }; - // string table_name = 1; - void clear_table_name(); - const std::string& table_name() const; - void set_table_name(const std::string& value); - void set_table_name(std::string&& value); - void set_table_name(const char* value); - void set_table_name(const char* value, size_t size); - std::string* mutable_table_name(); - std::string* release_table_name(); - void set_allocated_table_name(std::string* table_name); + // string collection_name = 1; + void clear_collection_name(); + const std::string& collection_name() const; + void set_collection_name(const std::string& value); + void set_collection_name(std::string&& value); + void set_collection_name(const char* value); + void set_collection_name(const char* value, size_t size); + std::string* mutable_collection_name(); + std::string* release_collection_name(); + void set_allocated_collection_name(std::string* collection_name); // string segment_name = 2; void clear_segment_name(); @@ -4210,7 +4210,7 @@ class GetVectorIDsParam : class _Internal; ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr segment_name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_milvus_2eproto; @@ -4330,90 +4330,90 @@ inline void KeyValuePair::set_allocated_value(std::string* value) { // ------------------------------------------------------------------- -// TableName +// CollectionName -// string table_name = 1; -inline void TableName::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void CollectionName::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& TableName::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableName.table_name) - return table_name_.GetNoArena(); +inline const std::string& CollectionName::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionName.collection_name) + return collection_name_.GetNoArena(); } -inline void TableName::set_table_name(const std::string& value) { +inline void CollectionName::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.TableName.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionName.collection_name) } -inline void TableName::set_table_name(std::string&& value) { +inline void CollectionName::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableName.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionName.collection_name) } -inline void TableName::set_table_name(const char* value) { +inline void CollectionName::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TableName.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionName.collection_name) } -inline void TableName::set_table_name(const char* value, size_t size) { +inline void CollectionName::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableName.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionName.collection_name) } -inline std::string* TableName::mutable_table_name() { +inline std::string* CollectionName::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableName.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionName.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* TableName::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableName.table_name) +inline std::string* CollectionName::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionName.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void TableName::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void CollectionName::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableName.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionName.collection_name) } // ------------------------------------------------------------------- -// TableNameList +// CollectionNameList // .milvus.grpc.Status status = 1; -inline bool TableNameList::has_status() const { +inline bool CollectionNameList::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableNameList::status() const { +inline const ::milvus::grpc::Status& CollectionNameList::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableNameList::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableNameList.status) +inline ::milvus::grpc::Status* CollectionNameList::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionNameList.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableNameList::mutable_status() { +inline ::milvus::grpc::Status* CollectionNameList::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.status) return status_; } -inline void TableNameList::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionNameList::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -4429,105 +4429,105 @@ inline void TableNameList::set_allocated_status(::milvus::grpc::Status* status) } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableNameList.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionNameList.status) } -// repeated string table_names = 2; -inline int TableNameList::table_names_size() const { - return table_names_.size(); +// repeated string collection_names = 2; +inline int CollectionNameList::collection_names_size() const { + return collection_names_.size(); } -inline void TableNameList::clear_table_names() { - table_names_.Clear(); +inline void CollectionNameList::clear_collection_names() { + collection_names_.Clear(); } -inline const std::string& TableNameList::table_names(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.table_names) - return table_names_.Get(index); +inline const std::string& CollectionNameList::collection_names(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Get(index); } -inline std::string* TableNameList::mutable_table_names(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.table_names) - return table_names_.Mutable(index); +inline std::string* CollectionNameList::mutable_collection_names(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Mutable(index); } -inline void TableNameList::set_table_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names) - table_names_.Mutable(index)->assign(value); +inline void CollectionNameList::set_collection_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names) + collection_names_.Mutable(index)->assign(value); } -inline void TableNameList::set_table_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names) - table_names_.Mutable(index)->assign(std::move(value)); +inline void CollectionNameList::set_collection_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionNameList.collection_names) + collection_names_.Mutable(index)->assign(std::move(value)); } -inline void TableNameList::set_table_names(int index, const char* value) { +inline void CollectionNameList::set_collection_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); - table_names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TableNameList.table_names) + collection_names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::set_table_names(int index, const char* value, size_t size) { - table_names_.Mutable(index)->assign( +inline void CollectionNameList::set_collection_names(int index, const char* value, size_t size) { + collection_names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableNameList.table_names) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionNameList.collection_names) } -inline std::string* TableNameList::add_table_names() { - // @@protoc_insertion_point(field_add_mutable:milvus.grpc.TableNameList.table_names) - return table_names_.Add(); +inline std::string* CollectionNameList::add_collection_names() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.CollectionNameList.collection_names) + return collection_names_.Add(); } -inline void TableNameList::add_table_names(const std::string& value) { - table_names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names) +inline void CollectionNameList::add_collection_names(const std::string& value) { + collection_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::add_table_names(std::string&& value) { - table_names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names) +inline void CollectionNameList::add_collection_names(std::string&& value) { + collection_names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::add_table_names(const char* value) { +inline void CollectionNameList::add_collection_names(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:milvus.grpc.TableNameList.table_names) + collection_names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.CollectionNameList.collection_names) } -inline void TableNameList::add_table_names(const char* value, size_t size) { - table_names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:milvus.grpc.TableNameList.table_names) +inline void CollectionNameList::add_collection_names(const char* value, size_t size) { + collection_names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.CollectionNameList.collection_names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -TableNameList::table_names() const { - // @@protoc_insertion_point(field_list:milvus.grpc.TableNameList.table_names) - return table_names_; +CollectionNameList::collection_names() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionNameList.collection_names) + return collection_names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -TableNameList::mutable_table_names() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableNameList.table_names) - return &table_names_; +CollectionNameList::mutable_collection_names() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionNameList.collection_names) + return &collection_names_; } // ------------------------------------------------------------------- -// TableSchema +// CollectionSchema // .milvus.grpc.Status status = 1; -inline bool TableSchema::has_status() const { +inline bool CollectionSchema::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableSchema::status() const { +inline const ::milvus::grpc::Status& CollectionSchema::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableSchema::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.status) +inline ::milvus::grpc::Status* CollectionSchema::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionSchema.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableSchema::mutable_status() { +inline ::milvus::grpc::Status* CollectionSchema::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionSchema.status) return status_; } -inline void TableSchema::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionSchema::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -4543,129 +4543,129 @@ inline void TableSchema::set_allocated_status(::milvus::grpc::Status* status) { } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionSchema.status) } -// string table_name = 2; -inline void TableSchema::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 2; +inline void CollectionSchema::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& TableSchema::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name) - return table_name_.GetNoArena(); +inline const std::string& CollectionSchema::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.collection_name) + return collection_name_.GetNoArena(); } -inline void TableSchema::set_table_name(const std::string& value) { +inline void CollectionSchema::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.collection_name) } -inline void TableSchema::set_table_name(std::string&& value) { +inline void CollectionSchema::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableSchema.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.CollectionSchema.collection_name) } -inline void TableSchema::set_table_name(const char* value) { +inline void CollectionSchema::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.TableSchema.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.CollectionSchema.collection_name) } -inline void TableSchema::set_table_name(const char* value, size_t size) { +inline void CollectionSchema::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableSchema.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.CollectionSchema.collection_name) } -inline std::string* TableSchema::mutable_table_name() { +inline std::string* CollectionSchema::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionSchema.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* TableSchema::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name) +inline std::string* CollectionSchema::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionSchema.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void TableSchema::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void CollectionSchema::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionSchema.collection_name) } // int64 dimension = 3; -inline void TableSchema::clear_dimension() { +inline void CollectionSchema::clear_dimension() { dimension_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::dimension() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.dimension) +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionSchema::dimension() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.dimension) return dimension_; } -inline void TableSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) { dimension_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.dimension) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.dimension) } // int64 index_file_size = 4; -inline void TableSchema::clear_index_file_size() { +inline void CollectionSchema::clear_index_file_size() { index_file_size_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::index_file_size() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.index_file_size) +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionSchema::index_file_size() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.index_file_size) return index_file_size_; } -inline void TableSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value) { index_file_size_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.index_file_size) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.index_file_size) } // int32 metric_type = 5; -inline void TableSchema::clear_metric_type() { +inline void CollectionSchema::clear_metric_type() { metric_type_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 TableSchema::metric_type() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.metric_type) +inline ::PROTOBUF_NAMESPACE_ID::int32 CollectionSchema::metric_type() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.metric_type) return metric_type_; } -inline void TableSchema::set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void CollectionSchema::set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value) { metric_type_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.metric_type) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionSchema.metric_type) } // repeated .milvus.grpc.KeyValuePair extra_params = 6; -inline int TableSchema::extra_params_size() const { +inline int CollectionSchema::extra_params_size() const { return extra_params_.size(); } -inline void TableSchema::clear_extra_params() { +inline void CollectionSchema::clear_extra_params() { extra_params_.Clear(); } -inline ::milvus::grpc::KeyValuePair* TableSchema::mutable_extra_params(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.extra_params) +inline ::milvus::grpc::KeyValuePair* CollectionSchema::mutable_extra_params(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionSchema.extra_params) return extra_params_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >* -TableSchema::mutable_extra_params() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableSchema.extra_params) +CollectionSchema::mutable_extra_params() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionSchema.extra_params) return &extra_params_; } -inline const ::milvus::grpc::KeyValuePair& TableSchema::extra_params(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.extra_params) +inline const ::milvus::grpc::KeyValuePair& CollectionSchema::extra_params(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionSchema.extra_params) return extra_params_.Get(index); } -inline ::milvus::grpc::KeyValuePair* TableSchema::add_extra_params() { - // @@protoc_insertion_point(field_add:milvus.grpc.TableSchema.extra_params) +inline ::milvus::grpc::KeyValuePair* CollectionSchema::add_extra_params() { + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionSchema.extra_params) return extra_params_.Add(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::KeyValuePair >& -TableSchema::extra_params() const { - // @@protoc_insertion_point(field_list:milvus.grpc.TableSchema.extra_params) +CollectionSchema::extra_params() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionSchema.extra_params) return extra_params_; } @@ -4673,55 +4673,55 @@ TableSchema::extra_params() const { // PartitionParam -// string table_name = 1; -inline void PartitionParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void PartitionParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& PartitionParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& PartitionParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.PartitionParam.collection_name) + return collection_name_.GetNoArena(); } -inline void PartitionParam::set_table_name(const std::string& value) { +inline void PartitionParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.PartitionParam.collection_name) } -inline void PartitionParam::set_table_name(std::string&& value) { +inline void PartitionParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.PartitionParam.collection_name) } -inline void PartitionParam::set_table_name(const char* value) { +inline void PartitionParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.PartitionParam.collection_name) } -inline void PartitionParam::set_table_name(const char* value, size_t size) { +inline void PartitionParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.PartitionParam.collection_name) } -inline std::string* PartitionParam::mutable_table_name() { +inline std::string* PartitionParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.PartitionParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* PartitionParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.table_name) +inline std::string* PartitionParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.PartitionParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void PartitionParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void PartitionParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.PartitionParam.collection_name) } // string tag = 2; @@ -4978,55 +4978,55 @@ inline void RowRecord::set_allocated_binary_data(std::string* binary_data) { // InsertParam -// string table_name = 1; -inline void InsertParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void InsertParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& InsertParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& InsertParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.collection_name) + return collection_name_.GetNoArena(); } -inline void InsertParam::set_table_name(const std::string& value) { +inline void InsertParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.collection_name) } -inline void InsertParam::set_table_name(std::string&& value) { +inline void InsertParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.collection_name) } -inline void InsertParam::set_table_name(const char* value) { +inline void InsertParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.collection_name) } -inline void InsertParam::set_table_name(const char* value, size_t size) { +inline void InsertParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.collection_name) } -inline std::string* InsertParam::mutable_table_name() { +inline std::string* InsertParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* InsertParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.table_name) +inline std::string* InsertParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void InsertParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void InsertParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.collection_name) } // repeated .milvus.grpc.RowRecord row_record_array = 2; @@ -5253,55 +5253,55 @@ VectorIds::mutable_vector_id_array() { // SearchParam -// string table_name = 1; -inline void SearchParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void SearchParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& SearchParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& SearchParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.collection_name) + return collection_name_.GetNoArena(); } -inline void SearchParam::set_table_name(const std::string& value) { +inline void SearchParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.collection_name) } -inline void SearchParam::set_table_name(std::string&& value) { +inline void SearchParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.collection_name) } -inline void SearchParam::set_table_name(const char* value) { +inline void SearchParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.collection_name) } -inline void SearchParam::set_table_name(const char* value, size_t size) { +inline void SearchParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.collection_name) } -inline std::string* SearchParam::mutable_table_name() { +inline std::string* SearchParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* SearchParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.table_name) +inline std::string* SearchParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void SearchParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void SearchParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.collection_name) } // repeated string partition_tag_array = 2; @@ -5567,55 +5567,55 @@ inline void SearchInFilesParam::set_allocated_search_param(::milvus::grpc::Searc // SearchByIDParam -// string table_name = 1; -inline void SearchByIDParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void SearchByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& SearchByIDParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.SearchByIDParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& SearchByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.SearchByIDParam.collection_name) + return collection_name_.GetNoArena(); } -inline void SearchByIDParam::set_table_name(const std::string& value) { +inline void SearchByIDParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.SearchByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.SearchByIDParam.collection_name) } -inline void SearchByIDParam::set_table_name(std::string&& value) { +inline void SearchByIDParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchByIDParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchByIDParam.collection_name) } -inline void SearchByIDParam::set_table_name(const char* value) { +inline void SearchByIDParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchByIDParam.collection_name) } -inline void SearchByIDParam::set_table_name(const char* value, size_t size) { +inline void SearchByIDParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchByIDParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchByIDParam.collection_name) } -inline std::string* SearchByIDParam::mutable_table_name() { +inline std::string* SearchByIDParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchByIDParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* SearchByIDParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.SearchByIDParam.table_name) +inline std::string* SearchByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.SearchByIDParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void SearchByIDParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void SearchByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchByIDParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchByIDParam.collection_name) } // repeated string partition_tag_array = 2; @@ -6029,35 +6029,35 @@ inline void BoolReply::set_bool_reply(bool value) { // ------------------------------------------------------------------- -// TableRowCount +// CollectionRowCount // .milvus.grpc.Status status = 1; -inline bool TableRowCount::has_status() const { +inline bool CollectionRowCount::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableRowCount::status() const { +inline const ::milvus::grpc::Status& CollectionRowCount::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableRowCount::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableRowCount.status) +inline ::milvus::grpc::Status* CollectionRowCount::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionRowCount.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableRowCount::mutable_status() { +inline ::milvus::grpc::Status* CollectionRowCount::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableRowCount.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionRowCount.status) return status_; } -inline void TableRowCount::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionRowCount::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -6073,21 +6073,21 @@ inline void TableRowCount::set_allocated_status(::milvus::grpc::Status* status) } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableRowCount.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionRowCount.status) } -// int64 table_row_count = 2; -inline void TableRowCount::clear_table_row_count() { - table_row_count_ = PROTOBUF_LONGLONG(0); +// int64 collection_row_count = 2; +inline void CollectionRowCount::clear_collection_row_count() { + collection_row_count_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableRowCount::table_row_count() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.table_row_count) - return table_row_count_; +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionRowCount::collection_row_count() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionRowCount.collection_row_count) + return collection_row_count_; } -inline void TableRowCount::set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionRowCount::set_collection_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { - table_row_count_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableRowCount.table_row_count) + collection_row_count_ = value; + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionRowCount.collection_row_count) } // ------------------------------------------------------------------- @@ -6194,55 +6194,55 @@ inline void IndexParam::set_allocated_status(::milvus::grpc::Status* status) { // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.status) } -// string table_name = 2; -inline void IndexParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 2; +inline void IndexParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& IndexParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& IndexParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.collection_name) + return collection_name_.GetNoArena(); } -inline void IndexParam::set_table_name(const std::string& value) { +inline void IndexParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.collection_name) } -inline void IndexParam::set_table_name(std::string&& value) { +inline void IndexParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.collection_name) } -inline void IndexParam::set_table_name(const char* value) { +inline void IndexParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.collection_name) } -inline void IndexParam::set_table_name(const char* value, size_t size) { +inline void IndexParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.collection_name) } -inline std::string* IndexParam::mutable_table_name() { +inline std::string* IndexParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* IndexParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.table_name) +inline std::string* IndexParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void IndexParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void IndexParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.collection_name) } // int32 index_type = 3; @@ -6293,124 +6293,124 @@ IndexParam::extra_params() const { // FlushParam -// repeated string table_name_array = 1; -inline int FlushParam::table_name_array_size() const { - return table_name_array_.size(); +// repeated string collection_name_array = 1; +inline int FlushParam::collection_name_array_size() const { + return collection_name_array_.size(); } -inline void FlushParam::clear_table_name_array() { - table_name_array_.Clear(); +inline void FlushParam::clear_collection_name_array() { + collection_name_array_.Clear(); } -inline const std::string& FlushParam::table_name_array(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.FlushParam.table_name_array) - return table_name_array_.Get(index); +inline const std::string& FlushParam::collection_name_array(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Get(index); } -inline std::string* FlushParam::mutable_table_name_array(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.FlushParam.table_name_array) - return table_name_array_.Mutable(index); +inline std::string* FlushParam::mutable_collection_name_array(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Mutable(index); } -inline void FlushParam::set_table_name_array(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.table_name_array) - table_name_array_.Mutable(index)->assign(value); +inline void FlushParam::set_collection_name_array(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array) + collection_name_array_.Mutable(index)->assign(value); } -inline void FlushParam::set_table_name_array(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.table_name_array) - table_name_array_.Mutable(index)->assign(std::move(value)); +inline void FlushParam::set_collection_name_array(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:milvus.grpc.FlushParam.collection_name_array) + collection_name_array_.Mutable(index)->assign(std::move(value)); } -inline void FlushParam::set_table_name_array(int index, const char* value) { +inline void FlushParam::set_collection_name_array(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_array_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:milvus.grpc.FlushParam.table_name_array) + collection_name_array_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::set_table_name_array(int index, const char* value, size_t size) { - table_name_array_.Mutable(index)->assign( +inline void FlushParam::set_collection_name_array(int index, const char* value, size_t size) { + collection_name_array_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FlushParam.table_name_array) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.FlushParam.collection_name_array) } -inline std::string* FlushParam::add_table_name_array() { - // @@protoc_insertion_point(field_add_mutable:milvus.grpc.FlushParam.table_name_array) - return table_name_array_.Add(); +inline std::string* FlushParam::add_collection_name_array() { + // @@protoc_insertion_point(field_add_mutable:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_.Add(); } -inline void FlushParam::add_table_name_array(const std::string& value) { - table_name_array_.Add()->assign(value); - // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.table_name_array) +inline void FlushParam::add_collection_name_array(const std::string& value) { + collection_name_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::add_table_name_array(std::string&& value) { - table_name_array_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.table_name_array) +inline void FlushParam::add_collection_name_array(std::string&& value) { + collection_name_array_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::add_table_name_array(const char* value) { +inline void FlushParam::add_collection_name_array(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_array_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:milvus.grpc.FlushParam.table_name_array) + collection_name_array_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:milvus.grpc.FlushParam.collection_name_array) } -inline void FlushParam::add_table_name_array(const char* value, size_t size) { - table_name_array_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:milvus.grpc.FlushParam.table_name_array) +inline void FlushParam::add_collection_name_array(const char* value, size_t size) { + collection_name_array_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:milvus.grpc.FlushParam.collection_name_array) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -FlushParam::table_name_array() const { - // @@protoc_insertion_point(field_list:milvus.grpc.FlushParam.table_name_array) - return table_name_array_; +FlushParam::collection_name_array() const { + // @@protoc_insertion_point(field_list:milvus.grpc.FlushParam.collection_name_array) + return collection_name_array_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -FlushParam::mutable_table_name_array() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FlushParam.table_name_array) - return &table_name_array_; +FlushParam::mutable_collection_name_array() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.FlushParam.collection_name_array) + return &collection_name_array_; } // ------------------------------------------------------------------- // DeleteByIDParam -// string table_name = 1; -inline void DeleteByIDParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void DeleteByIDParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& DeleteByIDParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& DeleteByIDParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByIDParam.collection_name) + return collection_name_.GetNoArena(); } -inline void DeleteByIDParam::set_table_name(const std::string& value) { +inline void DeleteByIDParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByIDParam.collection_name) } -inline void DeleteByIDParam::set_table_name(std::string&& value) { +inline void DeleteByIDParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByIDParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByIDParam.collection_name) } -inline void DeleteByIDParam::set_table_name(const char* value) { +inline void DeleteByIDParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.DeleteByIDParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.DeleteByIDParam.collection_name) } -inline void DeleteByIDParam::set_table_name(const char* value, size_t size) { +inline void DeleteByIDParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.DeleteByIDParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.DeleteByIDParam.collection_name) } -inline std::string* DeleteByIDParam::mutable_table_name() { +inline std::string* DeleteByIDParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByIDParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByIDParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* DeleteByIDParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByIDParam.table_name) +inline std::string* DeleteByIDParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByIDParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void DeleteByIDParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void DeleteByIDParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByIDParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByIDParam.collection_name) } // repeated int64 id_array = 2; @@ -6678,35 +6678,35 @@ PartitionStat::segments_stat() const { // ------------------------------------------------------------------- -// TableInfo +// CollectionInfo // .milvus.grpc.Status status = 1; -inline bool TableInfo::has_status() const { +inline bool CollectionInfo::has_status() const { return this != internal_default_instance() && status_ != nullptr; } -inline const ::milvus::grpc::Status& TableInfo::status() const { +inline const ::milvus::grpc::Status& CollectionInfo::status() const { const ::milvus::grpc::Status* p = status_; - // @@protoc_insertion_point(field_get:milvus.grpc.TableInfo.status) + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.status) return p != nullptr ? *p : *reinterpret_cast( &::milvus::grpc::_Status_default_instance_); } -inline ::milvus::grpc::Status* TableInfo::release_status() { - // @@protoc_insertion_point(field_release:milvus.grpc.TableInfo.status) +inline ::milvus::grpc::Status* CollectionInfo::release_status() { + // @@protoc_insertion_point(field_release:milvus.grpc.CollectionInfo.status) ::milvus::grpc::Status* temp = status_; status_ = nullptr; return temp; } -inline ::milvus::grpc::Status* TableInfo::mutable_status() { +inline ::milvus::grpc::Status* CollectionInfo::mutable_status() { if (status_ == nullptr) { auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual()); status_ = p; } - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableInfo.status) + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.status) return status_; } -inline void TableInfo::set_allocated_status(::milvus::grpc::Status* status) { +inline void CollectionInfo::set_allocated_status(::milvus::grpc::Status* status) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_); @@ -6722,50 +6722,50 @@ inline void TableInfo::set_allocated_status(::milvus::grpc::Status* status) { } status_ = status; - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableInfo.status) + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.CollectionInfo.status) } // int64 total_row_count = 2; -inline void TableInfo::clear_total_row_count() { +inline void CollectionInfo::clear_total_row_count() { total_row_count_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int64 TableInfo::total_row_count() const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableInfo.total_row_count) +inline ::PROTOBUF_NAMESPACE_ID::int64 CollectionInfo::total_row_count() const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.total_row_count) return total_row_count_; } -inline void TableInfo::set_total_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void CollectionInfo::set_total_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) { total_row_count_ = value; - // @@protoc_insertion_point(field_set:milvus.grpc.TableInfo.total_row_count) + // @@protoc_insertion_point(field_set:milvus.grpc.CollectionInfo.total_row_count) } // repeated .milvus.grpc.PartitionStat partitions_stat = 3; -inline int TableInfo::partitions_stat_size() const { +inline int CollectionInfo::partitions_stat_size() const { return partitions_stat_.size(); } -inline void TableInfo::clear_partitions_stat() { +inline void CollectionInfo::clear_partitions_stat() { partitions_stat_.Clear(); } -inline ::milvus::grpc::PartitionStat* TableInfo::mutable_partitions_stat(int index) { - // @@protoc_insertion_point(field_mutable:milvus.grpc.TableInfo.partitions_stat) +inline ::milvus::grpc::PartitionStat* CollectionInfo::mutable_partitions_stat(int index) { + // @@protoc_insertion_point(field_mutable:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionStat >* -TableInfo::mutable_partitions_stat() { - // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableInfo.partitions_stat) +CollectionInfo::mutable_partitions_stat() { + // @@protoc_insertion_point(field_mutable_list:milvus.grpc.CollectionInfo.partitions_stat) return &partitions_stat_; } -inline const ::milvus::grpc::PartitionStat& TableInfo::partitions_stat(int index) const { - // @@protoc_insertion_point(field_get:milvus.grpc.TableInfo.partitions_stat) +inline const ::milvus::grpc::PartitionStat& CollectionInfo::partitions_stat(int index) const { + // @@protoc_insertion_point(field_get:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_.Get(index); } -inline ::milvus::grpc::PartitionStat* TableInfo::add_partitions_stat() { - // @@protoc_insertion_point(field_add:milvus.grpc.TableInfo.partitions_stat) +inline ::milvus::grpc::PartitionStat* CollectionInfo::add_partitions_stat() { + // @@protoc_insertion_point(field_add:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_.Add(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::PartitionStat >& -TableInfo::partitions_stat() const { - // @@protoc_insertion_point(field_list:milvus.grpc.TableInfo.partitions_stat) +CollectionInfo::partitions_stat() const { + // @@protoc_insertion_point(field_list:milvus.grpc.CollectionInfo.partitions_stat) return partitions_stat_; } @@ -6773,55 +6773,55 @@ TableInfo::partitions_stat() const { // VectorIdentity -// string table_name = 1; -inline void VectorIdentity::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void VectorIdentity::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& VectorIdentity::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.VectorIdentity.table_name) - return table_name_.GetNoArena(); +inline const std::string& VectorIdentity::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.VectorIdentity.collection_name) + return collection_name_.GetNoArena(); } -inline void VectorIdentity::set_table_name(const std::string& value) { +inline void VectorIdentity::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.VectorIdentity.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.VectorIdentity.collection_name) } -inline void VectorIdentity::set_table_name(std::string&& value) { +inline void VectorIdentity::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorIdentity.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.VectorIdentity.collection_name) } -inline void VectorIdentity::set_table_name(const char* value) { +inline void VectorIdentity::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorIdentity.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.VectorIdentity.collection_name) } -inline void VectorIdentity::set_table_name(const char* value, size_t size) { +inline void VectorIdentity::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorIdentity.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.VectorIdentity.collection_name) } -inline std::string* VectorIdentity::mutable_table_name() { +inline std::string* VectorIdentity::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorIdentity.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorIdentity.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* VectorIdentity::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.VectorIdentity.table_name) +inline std::string* VectorIdentity::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.VectorIdentity.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void VectorIdentity::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void VectorIdentity::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorIdentity.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorIdentity.collection_name) } // int64 id = 2; @@ -6942,55 +6942,55 @@ inline void VectorData::set_allocated_vector_data(::milvus::grpc::RowRecord* vec // GetVectorIDsParam -// string table_name = 1; -inline void GetVectorIDsParam::clear_table_name() { - table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +// string collection_name = 1; +inline void GetVectorIDsParam::clear_collection_name() { + collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline const std::string& GetVectorIDsParam::table_name() const { - // @@protoc_insertion_point(field_get:milvus.grpc.GetVectorIDsParam.table_name) - return table_name_.GetNoArena(); +inline const std::string& GetVectorIDsParam::collection_name() const { + // @@protoc_insertion_point(field_get:milvus.grpc.GetVectorIDsParam.collection_name) + return collection_name_.GetNoArena(); } -inline void GetVectorIDsParam::set_table_name(const std::string& value) { +inline void GetVectorIDsParam::set_collection_name(const std::string& value) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:milvus.grpc.GetVectorIDsParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value); + // @@protoc_insertion_point(field_set:milvus.grpc.GetVectorIDsParam.collection_name) } -inline void GetVectorIDsParam::set_table_name(std::string&& value) { +inline void GetVectorIDsParam::set_collection_name(std::string&& value) { - table_name_.SetNoArena( + collection_name_.SetNoArena( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.GetVectorIDsParam.table_name) + // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.GetVectorIDsParam.collection_name) } -inline void GetVectorIDsParam::set_table_name(const char* value) { +inline void GetVectorIDsParam::set_collection_name(const char* value) { GOOGLE_DCHECK(value != nullptr); - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:milvus.grpc.GetVectorIDsParam.table_name) + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); + // @@protoc_insertion_point(field_set_char:milvus.grpc.GetVectorIDsParam.collection_name) } -inline void GetVectorIDsParam::set_table_name(const char* value, size_t size) { +inline void GetVectorIDsParam::set_collection_name(const char* value, size_t size) { - table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:milvus.grpc.GetVectorIDsParam.table_name) + // @@protoc_insertion_point(field_set_pointer:milvus.grpc.GetVectorIDsParam.collection_name) } -inline std::string* GetVectorIDsParam::mutable_table_name() { +inline std::string* GetVectorIDsParam::mutable_collection_name() { - // @@protoc_insertion_point(field_mutable:milvus.grpc.GetVectorIDsParam.table_name) - return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + // @@protoc_insertion_point(field_mutable:milvus.grpc.GetVectorIDsParam.collection_name) + return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline std::string* GetVectorIDsParam::release_table_name() { - // @@protoc_insertion_point(field_release:milvus.grpc.GetVectorIDsParam.table_name) +inline std::string* GetVectorIDsParam::release_collection_name() { + // @@protoc_insertion_point(field_release:milvus.grpc.GetVectorIDsParam.collection_name) - return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -inline void GetVectorIDsParam::set_allocated_table_name(std::string* table_name) { - if (table_name != nullptr) { +inline void GetVectorIDsParam::set_allocated_collection_name(std::string* collection_name) { + if (collection_name != nullptr) { } else { } - table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name); - // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetVectorIDsParam.table_name) + collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name); + // @@protoc_insertion_point(field_set_allocated:milvus.grpc.GetVectorIDsParam.collection_name) } // string segment_name = 2; diff --git a/sdk/grpc-gen/gen-status/status.pb.cc b/sdk/grpc-gen/gen-status/status.pb.cc index c36cd18a02..32aedec9d2 100644 --- a/sdk/grpc-gen/gen-status/status.pb.cc +++ b/sdk/grpc-gen/gen-status/status.pb.cc @@ -61,21 +61,21 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = const char descriptor_table_protodef_status_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\014status.proto\022\013milvus.grpc\"D\n\006Status\022*\n" "\nerror_code\030\001 \001(\0162\026.milvus.grpc.ErrorCod" - "e\022\016\n\006reason\030\002 \001(\t*\230\004\n\tErrorCode\022\013\n\007SUCCE" + "e\022\016\n\006reason\030\002 \001(\t*\242\004\n\tErrorCode\022\013\n\007SUCCE" "SS\020\000\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FA" - "ILED\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\024\n\020TABLE_N" - "OT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025\n\021ILL" - "EGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_TYPE\020\010" - "\022\026\n\022ILLEGAL_TABLE_NAME\020\t\022\020\n\014ILLEGAL_TOPK" - "\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021ILLEGAL_VEC" - "TOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RESULT\020\r\022\022\n\016F" - "ILE_NOT_FOUND\020\016\022\017\n\013META_FAILED\020\017\022\020\n\014CACH" - "E_FAILED\020\020\022\030\n\024CANNOT_CREATE_FOLDER\020\021\022\026\n\022" - "CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT_DELETE_FO" - "LDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024\022\025\n\021BUILD_" - "INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST\020\026\022\027\n\023ILLE" - "GAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_MEMORY\020\030b\006pr" - "oto3" + "ILED\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\031\n\025COLLECT" + "ION_NOT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\025" + "\n\021ILLEGAL_DIMENSION\020\007\022\026\n\022ILLEGAL_INDEX_T" + "YPE\020\010\022\033\n\027ILLEGAL_COLLECTION_NAME\020\t\022\020\n\014IL" + "LEGAL_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECORD\020\013\022\025\n\021I" + "LLEGAL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_SEARCH_RES" + "ULT\020\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013META_FAILED" + "\020\017\022\020\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_CREATE_FO" + "LDER\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022\030\n\024CANNOT" + "_DELETE_FOLDER\020\023\022\026\n\022CANNOT_DELETE_FILE\020\024" + "\022\025\n\021BUILD_INDEX_ERROR\020\025\022\021\n\rILLEGAL_NLIST" + "\020\026\022\027\n\023ILLEGAL_METRIC_TYPE\020\027\022\021\n\rOUT_OF_ME" + "MORY\020\030b\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_status_2eproto_deps[1] = { }; @@ -85,7 +85,7 @@ static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_sta static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_status_2eproto_once; static bool descriptor_table_status_2eproto_initialized = false; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto = { - &descriptor_table_status_2eproto_initialized, descriptor_table_protodef_status_2eproto, "status.proto", 644, + &descriptor_table_status_2eproto_initialized, descriptor_table_protodef_status_2eproto, "status.proto", 654, &descriptor_table_status_2eproto_once, descriptor_table_status_2eproto_sccs, descriptor_table_status_2eproto_deps, 1, 0, schemas, file_default_instances, TableStruct_status_2eproto::offsets, file_level_metadata_status_2eproto, 1, file_level_enum_descriptors_status_2eproto, file_level_service_descriptors_status_2eproto, diff --git a/sdk/grpc-gen/gen-status/status.pb.h b/sdk/grpc-gen/gen-status/status.pb.h index 346a61db69..94be8740cc 100644 --- a/sdk/grpc-gen/gen-status/status.pb.h +++ b/sdk/grpc-gen/gen-status/status.pb.h @@ -73,11 +73,11 @@ enum ErrorCode : int { UNEXPECTED_ERROR = 1, CONNECT_FAILED = 2, PERMISSION_DENIED = 3, - TABLE_NOT_EXISTS = 4, + COLLECTION_NOT_EXISTS = 4, ILLEGAL_ARGUMENT = 5, ILLEGAL_DIMENSION = 7, ILLEGAL_INDEX_TYPE = 8, - ILLEGAL_TABLE_NAME = 9, + ILLEGAL_COLLECTION_NAME = 9, ILLEGAL_TOPK = 10, ILLEGAL_ROWRECORD = 11, ILLEGAL_VECTOR_ID = 12, diff --git a/sdk/grpc/ClientProxy.cpp b/sdk/grpc/ClientProxy.cpp index ba3f20e598..1559f01ed6 100644 --- a/sdk/grpc/ClientProxy.cpp +++ b/sdk/grpc/ClientProxy.cpp @@ -36,7 +36,7 @@ ConstructSearchParam(const std::string& collection_name, int64_t topk, const std::string& extra_params, T& search_param) { - search_param.set_table_name(collection_name); + search_param.set_collection_name(collection_name); search_param.set_topk(topk); milvus::grpc::KeyValuePair* kv = search_param.add_extra_params(); kv->set_key(EXTRA_PARAM_KEY); @@ -181,13 +181,13 @@ ClientProxy::SetConfig(const std::string& node_name, const std::string& value) c Status ClientProxy::CreateCollection(const CollectionParam& param) { try { - ::milvus::grpc::TableSchema schema; - schema.set_table_name(param.collection_name); + ::milvus::grpc::CollectionSchema schema; + schema.set_collection_name(param.collection_name); schema.set_dimension(param.dimension); schema.set_index_file_size(param.index_file_size); schema.set_metric_type(static_cast(param.metric_type)); - return client_ptr_->CreateTable(schema); + return client_ptr_->CreateCollection(schema); } catch (std::exception& ex) { return Status(StatusCode::UnknownError, "Failed to create collection: " + std::string(ex.what())); } @@ -196,8 +196,8 @@ ClientProxy::CreateCollection(const CollectionParam& param) { bool ClientProxy::HasCollection(const std::string& collection_name) { Status status = Status::OK(); - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); bool result = client_ptr_->HasCollection(grpc_collection_name, status); return result; } @@ -205,9 +205,9 @@ ClientProxy::HasCollection(const std::string& collection_name) { Status ClientProxy::DropCollection(const std::string& collection_name) { try { - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); - return client_ptr_->DropTable(grpc_collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); + return client_ptr_->DropCollection(grpc_collection_name); } catch (std::exception& ex) { return Status(StatusCode::UnknownError, "Failed to drop collection: " + std::string(ex.what())); } @@ -217,7 +217,7 @@ Status ClientProxy::CreateIndex(const IndexParam& index_param) { try { ::milvus::grpc::IndexParam grpc_index_param; - grpc_index_param.set_table_name(index_param.collection_name); + grpc_index_param.set_collection_name(index_param.collection_name); grpc_index_param.set_index_type(static_cast(index_param.index_type)); milvus::grpc::KeyValuePair* kv = grpc_index_param.add_extra_params(); kv->set_key(EXTRA_PARAM_KEY); @@ -234,7 +234,7 @@ ClientProxy::Insert(const std::string& collection_name, const std::string& parti Status status = Status::OK(); try { ::milvus::grpc::InsertParam insert_param; - insert_param.set_table_name(collection_name); + insert_param.set_collection_name(collection_name); insert_param.set_partition_tag(partition_tag); for (auto& entity : entity_array) { @@ -266,7 +266,7 @@ Status ClientProxy::GetEntityByID(const std::string& collection_name, int64_t entity_id, Entity& entity_data) { try { ::milvus::grpc::VectorIdentity vector_identity; - vector_identity.set_table_name(collection_name); + vector_identity.set_collection_name(collection_name); vector_identity.set_id(entity_id); ::milvus::grpc::VectorData grpc_data; @@ -299,7 +299,7 @@ ClientProxy::GetIDsInSegment(const std::string& collection_name, const std::stri std::vector& id_array) { try { ::milvus::grpc::GetVectorIDsParam param; - param.set_table_name(collection_name); + param.set_collection_name(collection_name); param.set_segment_name(segment_name); ::milvus::grpc::VectorIds vector_ids; @@ -363,11 +363,11 @@ ClientProxy::Search(const std::string& collection_name, const std::vectorDescribeTable(collection_name, grpc_schema); + Status status = client_ptr_->DescribeCollection(collection_name, grpc_schema); - collection_param.collection_name = grpc_schema.table_name(); + collection_param.collection_name = grpc_schema.collection_name(); collection_param.dimension = grpc_schema.dimension(); collection_param.index_file_size = grpc_schema.index_file_size(); collection_param.metric_type = static_cast(grpc_schema.metric_type()); @@ -382,9 +382,9 @@ Status ClientProxy::CountCollection(const std::string& collection_name, int64_t& row_count) { try { Status status; - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); - row_count = client_ptr_->CountTable(grpc_collection_name, status); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); + row_count = client_ptr_->CountCollection(grpc_collection_name, status); return status; } catch (std::exception& ex) { return Status(StatusCode::UnknownError, "Failed to count collection: " + std::string(ex.what())); @@ -395,12 +395,12 @@ Status ClientProxy::ShowCollections(std::vector& collection_array) { try { Status status; - milvus::grpc::TableNameList collection_name_list; - status = client_ptr_->ShowTables(collection_name_list); + milvus::grpc::CollectionNameList collection_name_list; + status = client_ptr_->ShowCollections(collection_name_list); - collection_array.resize(collection_name_list.table_names_size()); - for (uint64_t i = 0; i < collection_name_list.table_names_size(); ++i) { - collection_array[i] = collection_name_list.table_names(i); + collection_array.resize(collection_name_list.collection_names_size()); + for (uint64_t i = 0; i < collection_name_list.collection_names_size(); ++i) { + collection_array[i] = collection_name_list.collection_names(i); } return status; } catch (std::exception& ex) { @@ -412,10 +412,10 @@ Status ClientProxy::ShowCollectionInfo(const std::string& collection_name, CollectionInfo& collection_info) { try { Status status; - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); - milvus::grpc::TableInfo grpc_collection_info; - status = client_ptr_->ShowTableInfo(grpc_collection_name, grpc_collection_info); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); + milvus::grpc::CollectionInfo grpc_collection_info; + status = client_ptr_->ShowCollectionInfo(grpc_collection_name, grpc_collection_info); // get native info collection_info.total_row_count = grpc_collection_info.total_row_count(); @@ -438,7 +438,7 @@ Status ClientProxy::DeleteByID(const std::string& collection_name, const std::vector& id_array) { try { ::milvus::grpc::DeleteByIDParam delete_by_id_param; - delete_by_id_param.set_table_name(collection_name); + delete_by_id_param.set_collection_name(collection_name); for (auto id : id_array) { delete_by_id_param.add_id_array(id); } @@ -452,9 +452,9 @@ ClientProxy::DeleteByID(const std::string& collection_name, const std::vectorPreloadTable(grpc_collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); + Status status = client_ptr_->PreloadCollection(grpc_collection_name); return status; } catch (std::exception& ex) { return Status(StatusCode::UnknownError, "Failed to preload collection: " + std::string(ex.what())); @@ -464,8 +464,8 @@ ClientProxy::PreloadCollection(const std::string& collection_name) const { Status ClientProxy::DescribeIndex(const std::string& collection_name, IndexParam& index_param) const { try { - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); ::milvus::grpc::IndexParam grpc_index_param; Status status = client_ptr_->DescribeIndex(grpc_collection_name, grpc_index_param); @@ -487,8 +487,8 @@ ClientProxy::DescribeIndex(const std::string& collection_name, IndexParam& index Status ClientProxy::DropIndex(const std::string& collection_name) const { try { - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); Status status = client_ptr_->DropIndex(grpc_collection_name); return status; } catch (std::exception& ex) { @@ -500,7 +500,7 @@ Status ClientProxy::CreatePartition(const PartitionParam& partition_param) { try { ::milvus::grpc::PartitionParam grpc_partition_param; - grpc_partition_param.set_table_name(partition_param.collection_name); + grpc_partition_param.set_collection_name(partition_param.collection_name); grpc_partition_param.set_tag(partition_param.partition_tag); Status status = client_ptr_->CreatePartition(grpc_partition_param); return status; @@ -512,8 +512,8 @@ ClientProxy::CreatePartition(const PartitionParam& partition_param) { Status ClientProxy::ShowPartitions(const std::string& collection_name, PartitionTagList& partition_tag_array) const { try { - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); ::milvus::grpc::PartitionList grpc_partition_list; Status status = client_ptr_->ShowPartitions(grpc_collection_name, grpc_partition_list); partition_tag_array.resize(grpc_partition_list.partition_tag_array_size()); @@ -530,7 +530,7 @@ Status ClientProxy::DropPartition(const PartitionParam& partition_param) { try { ::milvus::grpc::PartitionParam grpc_partition_param; - grpc_partition_param.set_table_name(partition_param.collection_name); + grpc_partition_param.set_collection_name(partition_param.collection_name); grpc_partition_param.set_tag(partition_param.partition_tag); Status status = client_ptr_->DropPartition(grpc_partition_param); return status; @@ -562,8 +562,8 @@ ClientProxy::Flush() { Status ClientProxy::CompactCollection(const std::string& collection_name) { try { - ::milvus::grpc::TableName grpc_collection_name; - grpc_collection_name.set_table_name(collection_name); + ::milvus::grpc::CollectionName grpc_collection_name; + grpc_collection_name.set_collection_name(collection_name); Status status = client_ptr_->Compact(grpc_collection_name); return status; } catch (std::exception& ex) { diff --git a/sdk/grpc/GrpcClient.cpp b/sdk/grpc/GrpcClient.cpp index bd4141f551..18216604bf 100644 --- a/sdk/grpc/GrpcClient.cpp +++ b/sdk/grpc/GrpcClient.cpp @@ -36,13 +36,13 @@ GrpcClient::GrpcClient(std::shared_ptr<::grpc::Channel>& channel) GrpcClient::~GrpcClient() = default; Status -GrpcClient::CreateTable(const ::milvus::grpc::TableSchema& table_schema) { +GrpcClient::CreateCollection(const ::milvus::grpc::CollectionSchema& collection_schema) { ClientContext context; grpc::Status response; - ::grpc::Status grpc_status = stub_->CreateTable(&context, table_schema, &response); + ::grpc::Status grpc_status = stub_->CreateCollection(&context, collection_schema, &response); if (!grpc_status.ok()) { - std::cerr << "CreateTable gRPC failed!" << std::endl; + std::cerr << "CreateCollection gRPC failed!" << std::endl; return Status(StatusCode::RPCFailed, grpc_status.error_message()); } @@ -54,10 +54,10 @@ GrpcClient::CreateTable(const ::milvus::grpc::TableSchema& table_schema) { } bool -GrpcClient::HasCollection(const ::milvus::grpc::TableName& collection_name, Status& status) { +GrpcClient::HasCollection(const ::milvus::grpc::CollectionName& collection_name, Status& status) { ClientContext context; ::milvus::grpc::BoolReply response; - ::grpc::Status grpc_status = stub_->HasTable(&context, collection_name, &response); + ::grpc::Status grpc_status = stub_->HasCollection(&context, collection_name, &response); if (!grpc_status.ok()) { std::cerr << "HasCollection gRPC failed!" << std::endl; @@ -72,13 +72,13 @@ GrpcClient::HasCollection(const ::milvus::grpc::TableName& collection_name, Stat } Status -GrpcClient::DropTable(const ::milvus::grpc::TableName& collection_name) { +GrpcClient::DropCollection(const ::milvus::grpc::CollectionName& collection_name) { ClientContext context; grpc::Status response; - ::grpc::Status grpc_status = stub_->DropTable(&context, collection_name, &response); + ::grpc::Status grpc_status = stub_->DropCollection(&context, collection_name, &response); if (!grpc_status.ok()) { - std::cerr << "DropTable gRPC failed!" << std::endl; + std::cerr << "DropCollection gRPC failed!" << std::endl; return Status(StatusCode::RPCFailed, grpc_status.error_message()); } if (response.error_code() != grpc::SUCCESS) { @@ -179,14 +179,14 @@ GrpcClient::Search( } Status -GrpcClient::DescribeTable(const std::string& collection_name, ::milvus::grpc::TableSchema& grpc_schema) { +GrpcClient::DescribeCollection(const std::string& collection_name, ::milvus::grpc::CollectionSchema& grpc_schema) { ClientContext context; - ::milvus::grpc::TableName grpc_tablename; - grpc_tablename.set_table_name(collection_name); - ::grpc::Status grpc_status = stub_->DescribeTable(&context, grpc_tablename, &grpc_schema); + ::milvus::grpc::CollectionName grpc_collectionname; + grpc_collectionname.set_collection_name(collection_name); + ::grpc::Status grpc_status = stub_->DescribeCollection(&context, grpc_collectionname, &grpc_schema); if (!grpc_status.ok()) { - std::cerr << "DescribeTable rpc failed!" << std::endl; + std::cerr << "DescribeCollection rpc failed!" << std::endl; std::cerr << grpc_status.error_message() << std::endl; return Status(StatusCode::RPCFailed, grpc_status.error_message()); } @@ -200,13 +200,13 @@ GrpcClient::DescribeTable(const std::string& collection_name, ::milvus::grpc::Ta } int64_t -GrpcClient::CountTable(grpc::TableName& collection_name, Status& status) { +GrpcClient::CountCollection(grpc::CollectionName& collection_name, Status& status) { ClientContext context; - ::milvus::grpc::TableRowCount response; - ::grpc::Status grpc_status = stub_->CountTable(&context, collection_name, &response); + ::milvus::grpc::CollectionRowCount response; + ::grpc::Status grpc_status = stub_->CountCollection(&context, collection_name, &response); if (!grpc_status.ok()) { - std::cerr << "CountTable rpc failed!" << std::endl; + std::cerr << "CountCollection rpc failed!" << std::endl; status = Status(StatusCode::RPCFailed, grpc_status.error_message()); return -1; } @@ -218,37 +218,37 @@ GrpcClient::CountTable(grpc::TableName& collection_name, Status& status) { } status = Status::OK(); - return response.table_row_count(); + return response.collection_row_count(); } Status -GrpcClient::ShowTables(milvus::grpc::TableNameList& table_name_list) { +GrpcClient::ShowCollections(milvus::grpc::CollectionNameList& collection_name_list) { ClientContext context; ::milvus::grpc::Command command; - ::grpc::Status grpc_status = stub_->ShowTables(&context, command, &table_name_list); + ::grpc::Status grpc_status = stub_->ShowCollections(&context, command, &collection_name_list); if (!grpc_status.ok()) { - std::cerr << "ShowTables gRPC failed!" << std::endl; + std::cerr << "ShowCollections gRPC failed!" << std::endl; std::cerr << grpc_status.error_message() << std::endl; return Status(StatusCode::RPCFailed, grpc_status.error_message()); } - if (table_name_list.status().error_code() != grpc::SUCCESS) { - std::cerr << table_name_list.status().reason() << std::endl; - return Status(StatusCode::ServerFailed, table_name_list.status().reason()); + if (collection_name_list.status().error_code() != grpc::SUCCESS) { + std::cerr << collection_name_list.status().reason() << std::endl; + return Status(StatusCode::ServerFailed, collection_name_list.status().reason()); } return Status::OK(); } Status -GrpcClient::ShowTableInfo(grpc::TableName& collection_name, grpc::TableInfo& collection_info) { +GrpcClient::ShowCollectionInfo(grpc::CollectionName& collection_name, grpc::CollectionInfo& collection_info) { ClientContext context; ::milvus::grpc::Command command; - ::grpc::Status grpc_status = stub_->ShowTableInfo(&context, collection_name, &collection_info); + ::grpc::Status grpc_status = stub_->ShowCollectionInfo(&context, collection_name, &collection_info); if (!grpc_status.ok()) { - std::cerr << "ShowTableInfo gRPC failed!" << std::endl; + std::cerr << "ShowCollectionInfo gRPC failed!" << std::endl; std::cerr << grpc_status.error_message() << std::endl; return Status(StatusCode::RPCFailed, grpc_status.error_message()); } @@ -284,13 +284,13 @@ GrpcClient::Cmd(const std::string& cmd, std::string& result) { } Status -GrpcClient::PreloadTable(milvus::grpc::TableName& collection_name) { +GrpcClient::PreloadCollection(milvus::grpc::CollectionName& collection_name) { ClientContext context; ::milvus::grpc::Status response; - ::grpc::Status grpc_status = stub_->PreloadTable(&context, collection_name, &response); + ::grpc::Status grpc_status = stub_->PreloadCollection(&context, collection_name, &response); if (!grpc_status.ok()) { - std::cerr << "PreloadTable gRPC failed!" << std::endl; + std::cerr << "PreloadCollection gRPC failed!" << std::endl; return Status(StatusCode::RPCFailed, grpc_status.error_message()); } @@ -320,7 +320,7 @@ GrpcClient::DeleteByID(grpc::DeleteByIDParam& delete_by_id_param) { } Status -GrpcClient::DescribeIndex(grpc::TableName& collection_name, grpc::IndexParam& index_param) { +GrpcClient::DescribeIndex(grpc::CollectionName& collection_name, grpc::IndexParam& index_param) { ClientContext context; ::grpc::Status grpc_status = stub_->DescribeIndex(&context, collection_name, &index_param); @@ -337,7 +337,7 @@ GrpcClient::DescribeIndex(grpc::TableName& collection_name, grpc::IndexParam& in } Status -GrpcClient::DropIndex(grpc::TableName& collection_name) { +GrpcClient::DropIndex(grpc::CollectionName& collection_name) { ClientContext context; ::milvus::grpc::Status response; ::grpc::Status grpc_status = stub_->DropIndex(&context, collection_name, &response); @@ -373,7 +373,7 @@ GrpcClient::CreatePartition(const grpc::PartitionParam& partition_param) { } Status -GrpcClient::ShowPartitions(const grpc::TableName& collection_name, grpc::PartitionList& partition_array) const { +GrpcClient::ShowPartitions(const grpc::CollectionName& collection_name, grpc::PartitionList& partition_array) const { ClientContext context; ::grpc::Status grpc_status = stub_->ShowPartitions(&context, collection_name, &partition_array); @@ -413,7 +413,7 @@ GrpcClient::Flush(const std::string& collection_name) { ::milvus::grpc::FlushParam param; if (!collection_name.empty()) { - param.add_table_name_array(collection_name); + param.add_collection_name_array(collection_name); } ::milvus::grpc::Status response; @@ -432,7 +432,7 @@ GrpcClient::Flush(const std::string& collection_name) { } Status -GrpcClient::Compact(milvus::grpc::TableName& collection_name) { +GrpcClient::Compact(milvus::grpc::CollectionName& collection_name) { ClientContext context; ::milvus::grpc::Status response; ::grpc::Status grpc_status = stub_->Compact(&context, collection_name, &response); diff --git a/sdk/grpc/GrpcClient.h b/sdk/grpc/GrpcClient.h index 838184cd69..7873144dae 100644 --- a/sdk/grpc/GrpcClient.h +++ b/sdk/grpc/GrpcClient.h @@ -36,13 +36,13 @@ class GrpcClient { virtual ~GrpcClient(); Status - CreateTable(const grpc::TableSchema& table_schema); + CreateCollection(const grpc::CollectionSchema& collection_schema); bool - HasCollection(const grpc::TableName& table_name, Status& status); + HasCollection(const grpc::CollectionName& collection_name, Status& status); Status - DropTable(const grpc::TableName& table_name); + DropCollection(const grpc::CollectionName& collection_name); Status CreateIndex(const grpc::IndexParam& index_param); @@ -60,16 +60,16 @@ class GrpcClient { Search(const grpc::SearchParam& search_param, ::milvus::grpc::TopKQueryResult& topk_query_result); Status - DescribeTable(const std::string& table_name, grpc::TableSchema& grpc_schema); + DescribeCollection(const std::string& collection_name, grpc::CollectionSchema& grpc_schema); int64_t - CountTable(grpc::TableName& table_name, Status& status); + CountCollection(grpc::CollectionName& collection_name, Status& status); Status - ShowTables(milvus::grpc::TableNameList& table_name_list); + ShowCollections(milvus::grpc::CollectionNameList& collection_name_list); Status - ShowTableInfo(grpc::TableName& table_name, grpc::TableInfo& collection_info); + ShowCollectionInfo(grpc::CollectionName& collection_name, grpc::CollectionInfo& collection_info); Status Cmd(const std::string& cmd, std::string& result); @@ -78,28 +78,28 @@ class GrpcClient { DeleteByID(grpc::DeleteByIDParam& delete_by_id_param); Status - PreloadTable(grpc::TableName& table_name); + PreloadCollection(grpc::CollectionName& collection_name); Status - DescribeIndex(grpc::TableName& table_name, grpc::IndexParam& index_param); + DescribeIndex(grpc::CollectionName& collection_name, grpc::IndexParam& index_param); Status - DropIndex(grpc::TableName& table_name); + DropIndex(grpc::CollectionName& collection_name); Status CreatePartition(const grpc::PartitionParam& partition_param); Status - ShowPartitions(const grpc::TableName& table_name, grpc::PartitionList& partition_array) const; + ShowPartitions(const grpc::CollectionName& collection_name, grpc::PartitionList& partition_array) const; Status DropPartition(const ::milvus::grpc::PartitionParam& partition_param); Status - Flush(const std::string& table_name); + Flush(const std::string& collection_name); Status - Compact(milvus::grpc::TableName& table_name); + Compact(milvus::grpc::CollectionName& collection_name); Status Disconnect();