mirror of
https://gitee.com/milvus-io/milvus.git
synced 2026-01-07 19:31:51 +08:00
1800 lines
56 KiB
C++
1800 lines
56 KiB
C++
/**
|
|
* Autogenerated by Thrift Compiler (0.12.0)
|
|
*
|
|
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
* @generated
|
|
*/
|
|
#ifndef MilvusService_H
|
|
#define MilvusService_H
|
|
|
|
#include <thrift/TDispatchProcessor.h>
|
|
#include <thrift/async/TConcurrentClientSyncInfo.h>
|
|
#include "milvus_types.h"
|
|
|
|
namespace milvus { namespace thrift {
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning( push )
|
|
#pragma warning (disable : 4250 ) //inheriting methods via dominance
|
|
#endif
|
|
|
|
class MilvusServiceIf {
|
|
public:
|
|
virtual ~MilvusServiceIf() {}
|
|
|
|
/**
|
|
* @brief Create table method
|
|
*
|
|
* This method is used to create table
|
|
*
|
|
* @param param, use to provide table information to be created.
|
|
*
|
|
*
|
|
* @param param
|
|
*/
|
|
virtual void CreateTable(const TableSchema& param) = 0;
|
|
|
|
/**
|
|
* @brief Test table existence method
|
|
*
|
|
* This method is used to test table existence.
|
|
*
|
|
* @param table_name, table name is going to be tested.
|
|
*
|
|
*
|
|
* @param table_name
|
|
*/
|
|
virtual bool HasTable(const std::string& table_name) = 0;
|
|
|
|
/**
|
|
* @brief Delete table method
|
|
*
|
|
* This method is used to delete table.
|
|
*
|
|
* @param table_name, table name is going to be deleted.
|
|
*
|
|
*
|
|
* @param table_name
|
|
*/
|
|
virtual void DeleteTable(const std::string& table_name) = 0;
|
|
|
|
/**
|
|
* @brief Build index by table method
|
|
*
|
|
* This method is used to build index by table in sync mode.
|
|
*
|
|
* @param table_name, table is going to be built index.
|
|
*
|
|
*
|
|
* @param table_name
|
|
*/
|
|
virtual void BuildIndex(const std::string& table_name) = 0;
|
|
|
|
/**
|
|
* @brief Add vector array to table
|
|
*
|
|
* This method is used to add vector array to table.
|
|
*
|
|
* @param table_name, table_name is inserted.
|
|
* @param record_array, vector array is inserted.
|
|
*
|
|
* @return vector id array
|
|
*
|
|
* @param table_name
|
|
* @param record_array
|
|
*/
|
|
virtual void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array) = 0;
|
|
|
|
/**
|
|
* @brief Query vector
|
|
*
|
|
* This method is used to query vector in table.
|
|
*
|
|
* @param table_name, table_name is queried.
|
|
* @param query_record_array, all vector are going to be queried.
|
|
* @param query_range_array, optional ranges for conditional search. If not specified, search whole table
|
|
* @param topk, how many similarity vectors will be searched.
|
|
*
|
|
* @return query result array.
|
|
*
|
|
* @param table_name
|
|
* @param query_record_array
|
|
* @param query_range_array
|
|
* @param topk
|
|
*/
|
|
virtual void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) = 0;
|
|
|
|
/**
|
|
* @brief Internal use query interface
|
|
*
|
|
* This method is used to query vector in specified files.
|
|
*
|
|
* @param file_id_array, specified files id array, queried.
|
|
* @param query_record_array, all vector are going to be queried.
|
|
* @param query_range_array, optional ranges for conditional search. If not specified, search whole table
|
|
* @param topk, how many similarity vectors will be searched.
|
|
*
|
|
* @return query result array.
|
|
*
|
|
* @param table_name
|
|
* @param file_id_array
|
|
* @param query_record_array
|
|
* @param query_range_array
|
|
* @param topk
|
|
*/
|
|
virtual void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) = 0;
|
|
|
|
/**
|
|
* @brief Get table schema
|
|
*
|
|
* This method is used to get table schema.
|
|
*
|
|
* @param table_name, target table name.
|
|
*
|
|
* @return table schema
|
|
*
|
|
* @param table_name
|
|
*/
|
|
virtual void DescribeTable(TableSchema& _return, const std::string& table_name) = 0;
|
|
|
|
/**
|
|
* @brief Get table row count
|
|
*
|
|
* This method is used to get table row count.
|
|
*
|
|
* @param table_name, target table name.
|
|
*
|
|
* @return table row count
|
|
*
|
|
* @param table_name
|
|
*/
|
|
virtual int64_t GetTableRowCount(const std::string& table_name) = 0;
|
|
|
|
/**
|
|
* @brief List all tables in database
|
|
*
|
|
* This method is used to list all tables.
|
|
*
|
|
*
|
|
* @return table names.
|
|
*/
|
|
virtual void ShowTables(std::vector<std::string> & _return) = 0;
|
|
|
|
/**
|
|
* @brief Give the server status
|
|
*
|
|
* This method is used to give the server status.
|
|
*
|
|
* @return Server status.
|
|
*
|
|
* @param cmd
|
|
*/
|
|
virtual void Ping(std::string& _return, const std::string& cmd) = 0;
|
|
};
|
|
|
|
class MilvusServiceIfFactory {
|
|
public:
|
|
typedef MilvusServiceIf Handler;
|
|
|
|
virtual ~MilvusServiceIfFactory() {}
|
|
|
|
virtual MilvusServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
|
|
virtual void releaseHandler(MilvusServiceIf* /* handler */) = 0;
|
|
};
|
|
|
|
class MilvusServiceIfSingletonFactory : virtual public MilvusServiceIfFactory {
|
|
public:
|
|
MilvusServiceIfSingletonFactory(const ::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf>& iface) : iface_(iface) {}
|
|
virtual ~MilvusServiceIfSingletonFactory() {}
|
|
|
|
virtual MilvusServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
|
|
return iface_.get();
|
|
}
|
|
virtual void releaseHandler(MilvusServiceIf* /* handler */) {}
|
|
|
|
protected:
|
|
::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface_;
|
|
};
|
|
|
|
class MilvusServiceNull : virtual public MilvusServiceIf {
|
|
public:
|
|
virtual ~MilvusServiceNull() {}
|
|
void CreateTable(const TableSchema& /* param */) {
|
|
return;
|
|
}
|
|
bool HasTable(const std::string& /* table_name */) {
|
|
bool _return = false;
|
|
return _return;
|
|
}
|
|
void DeleteTable(const std::string& /* table_name */) {
|
|
return;
|
|
}
|
|
void BuildIndex(const std::string& /* table_name */) {
|
|
return;
|
|
}
|
|
void AddVector(std::vector<int64_t> & /* _return */, const std::string& /* table_name */, const std::vector<RowRecord> & /* record_array */) {
|
|
return;
|
|
}
|
|
void SearchVector(std::vector<TopKQueryResult> & /* _return */, const std::string& /* table_name */, const std::vector<RowRecord> & /* query_record_array */, const std::vector<Range> & /* query_range_array */, const int64_t /* topk */) {
|
|
return;
|
|
}
|
|
void SearchVectorInFiles(std::vector<TopKQueryResult> & /* _return */, const std::string& /* table_name */, const std::vector<std::string> & /* file_id_array */, const std::vector<RowRecord> & /* query_record_array */, const std::vector<Range> & /* query_range_array */, const int64_t /* topk */) {
|
|
return;
|
|
}
|
|
void DescribeTable(TableSchema& /* _return */, const std::string& /* table_name */) {
|
|
return;
|
|
}
|
|
int64_t GetTableRowCount(const std::string& /* table_name */) {
|
|
int64_t _return = 0;
|
|
return _return;
|
|
}
|
|
void ShowTables(std::vector<std::string> & /* _return */) {
|
|
return;
|
|
}
|
|
void Ping(std::string& /* _return */, const std::string& /* cmd */) {
|
|
return;
|
|
}
|
|
};
|
|
|
|
typedef struct _MilvusService_CreateTable_args__isset {
|
|
_MilvusService_CreateTable_args__isset() : param(false) {}
|
|
bool param :1;
|
|
} _MilvusService_CreateTable_args__isset;
|
|
|
|
class MilvusService_CreateTable_args {
|
|
public:
|
|
|
|
MilvusService_CreateTable_args(const MilvusService_CreateTable_args&);
|
|
MilvusService_CreateTable_args& operator=(const MilvusService_CreateTable_args&);
|
|
MilvusService_CreateTable_args() {
|
|
}
|
|
|
|
virtual ~MilvusService_CreateTable_args() throw();
|
|
TableSchema param;
|
|
|
|
_MilvusService_CreateTable_args__isset __isset;
|
|
|
|
void __set_param(const TableSchema& val);
|
|
|
|
bool operator == (const MilvusService_CreateTable_args & rhs) const
|
|
{
|
|
if (!(param == rhs.param))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_CreateTable_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_CreateTable_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_CreateTable_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_CreateTable_pargs() throw();
|
|
const TableSchema* param;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_CreateTable_result__isset {
|
|
_MilvusService_CreateTable_result__isset() : e(false) {}
|
|
bool e :1;
|
|
} _MilvusService_CreateTable_result__isset;
|
|
|
|
class MilvusService_CreateTable_result {
|
|
public:
|
|
|
|
MilvusService_CreateTable_result(const MilvusService_CreateTable_result&);
|
|
MilvusService_CreateTable_result& operator=(const MilvusService_CreateTable_result&);
|
|
MilvusService_CreateTable_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_CreateTable_result() throw();
|
|
Exception e;
|
|
|
|
_MilvusService_CreateTable_result__isset __isset;
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_CreateTable_result & rhs) const
|
|
{
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_CreateTable_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_CreateTable_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_CreateTable_presult__isset {
|
|
_MilvusService_CreateTable_presult__isset() : e(false) {}
|
|
bool e :1;
|
|
} _MilvusService_CreateTable_presult__isset;
|
|
|
|
class MilvusService_CreateTable_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_CreateTable_presult() throw();
|
|
Exception e;
|
|
|
|
_MilvusService_CreateTable_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_HasTable_args__isset {
|
|
_MilvusService_HasTable_args__isset() : table_name(false) {}
|
|
bool table_name :1;
|
|
} _MilvusService_HasTable_args__isset;
|
|
|
|
class MilvusService_HasTable_args {
|
|
public:
|
|
|
|
MilvusService_HasTable_args(const MilvusService_HasTable_args&);
|
|
MilvusService_HasTable_args& operator=(const MilvusService_HasTable_args&);
|
|
MilvusService_HasTable_args() : table_name() {
|
|
}
|
|
|
|
virtual ~MilvusService_HasTable_args() throw();
|
|
std::string table_name;
|
|
|
|
_MilvusService_HasTable_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
bool operator == (const MilvusService_HasTable_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_HasTable_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_HasTable_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_HasTable_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_HasTable_pargs() throw();
|
|
const std::string* table_name;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_HasTable_result__isset {
|
|
_MilvusService_HasTable_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_HasTable_result__isset;
|
|
|
|
class MilvusService_HasTable_result {
|
|
public:
|
|
|
|
MilvusService_HasTable_result(const MilvusService_HasTable_result&);
|
|
MilvusService_HasTable_result& operator=(const MilvusService_HasTable_result&);
|
|
MilvusService_HasTable_result() : success(0) {
|
|
}
|
|
|
|
virtual ~MilvusService_HasTable_result() throw();
|
|
bool success;
|
|
Exception e;
|
|
|
|
_MilvusService_HasTable_result__isset __isset;
|
|
|
|
void __set_success(const bool val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_HasTable_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_HasTable_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_HasTable_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_HasTable_presult__isset {
|
|
_MilvusService_HasTable_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_HasTable_presult__isset;
|
|
|
|
class MilvusService_HasTable_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_HasTable_presult() throw();
|
|
bool* success;
|
|
Exception e;
|
|
|
|
_MilvusService_HasTable_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_DeleteTable_args__isset {
|
|
_MilvusService_DeleteTable_args__isset() : table_name(false) {}
|
|
bool table_name :1;
|
|
} _MilvusService_DeleteTable_args__isset;
|
|
|
|
class MilvusService_DeleteTable_args {
|
|
public:
|
|
|
|
MilvusService_DeleteTable_args(const MilvusService_DeleteTable_args&);
|
|
MilvusService_DeleteTable_args& operator=(const MilvusService_DeleteTable_args&);
|
|
MilvusService_DeleteTable_args() : table_name() {
|
|
}
|
|
|
|
virtual ~MilvusService_DeleteTable_args() throw();
|
|
std::string table_name;
|
|
|
|
_MilvusService_DeleteTable_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
bool operator == (const MilvusService_DeleteTable_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_DeleteTable_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_DeleteTable_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_DeleteTable_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_DeleteTable_pargs() throw();
|
|
const std::string* table_name;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_DeleteTable_result__isset {
|
|
_MilvusService_DeleteTable_result__isset() : e(false) {}
|
|
bool e :1;
|
|
} _MilvusService_DeleteTable_result__isset;
|
|
|
|
class MilvusService_DeleteTable_result {
|
|
public:
|
|
|
|
MilvusService_DeleteTable_result(const MilvusService_DeleteTable_result&);
|
|
MilvusService_DeleteTable_result& operator=(const MilvusService_DeleteTable_result&);
|
|
MilvusService_DeleteTable_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_DeleteTable_result() throw();
|
|
Exception e;
|
|
|
|
_MilvusService_DeleteTable_result__isset __isset;
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_DeleteTable_result & rhs) const
|
|
{
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_DeleteTable_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_DeleteTable_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_DeleteTable_presult__isset {
|
|
_MilvusService_DeleteTable_presult__isset() : e(false) {}
|
|
bool e :1;
|
|
} _MilvusService_DeleteTable_presult__isset;
|
|
|
|
class MilvusService_DeleteTable_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_DeleteTable_presult() throw();
|
|
Exception e;
|
|
|
|
_MilvusService_DeleteTable_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_BuildIndex_args__isset {
|
|
_MilvusService_BuildIndex_args__isset() : table_name(false) {}
|
|
bool table_name :1;
|
|
} _MilvusService_BuildIndex_args__isset;
|
|
|
|
class MilvusService_BuildIndex_args {
|
|
public:
|
|
|
|
MilvusService_BuildIndex_args(const MilvusService_BuildIndex_args&);
|
|
MilvusService_BuildIndex_args& operator=(const MilvusService_BuildIndex_args&);
|
|
MilvusService_BuildIndex_args() : table_name() {
|
|
}
|
|
|
|
virtual ~MilvusService_BuildIndex_args() throw();
|
|
std::string table_name;
|
|
|
|
_MilvusService_BuildIndex_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
bool operator == (const MilvusService_BuildIndex_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_BuildIndex_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_BuildIndex_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_BuildIndex_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_BuildIndex_pargs() throw();
|
|
const std::string* table_name;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_BuildIndex_result__isset {
|
|
_MilvusService_BuildIndex_result__isset() : e(false) {}
|
|
bool e :1;
|
|
} _MilvusService_BuildIndex_result__isset;
|
|
|
|
class MilvusService_BuildIndex_result {
|
|
public:
|
|
|
|
MilvusService_BuildIndex_result(const MilvusService_BuildIndex_result&);
|
|
MilvusService_BuildIndex_result& operator=(const MilvusService_BuildIndex_result&);
|
|
MilvusService_BuildIndex_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_BuildIndex_result() throw();
|
|
Exception e;
|
|
|
|
_MilvusService_BuildIndex_result__isset __isset;
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_BuildIndex_result & rhs) const
|
|
{
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_BuildIndex_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_BuildIndex_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_BuildIndex_presult__isset {
|
|
_MilvusService_BuildIndex_presult__isset() : e(false) {}
|
|
bool e :1;
|
|
} _MilvusService_BuildIndex_presult__isset;
|
|
|
|
class MilvusService_BuildIndex_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_BuildIndex_presult() throw();
|
|
Exception e;
|
|
|
|
_MilvusService_BuildIndex_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_AddVector_args__isset {
|
|
_MilvusService_AddVector_args__isset() : table_name(false), record_array(false) {}
|
|
bool table_name :1;
|
|
bool record_array :1;
|
|
} _MilvusService_AddVector_args__isset;
|
|
|
|
class MilvusService_AddVector_args {
|
|
public:
|
|
|
|
MilvusService_AddVector_args(const MilvusService_AddVector_args&);
|
|
MilvusService_AddVector_args& operator=(const MilvusService_AddVector_args&);
|
|
MilvusService_AddVector_args() : table_name() {
|
|
}
|
|
|
|
virtual ~MilvusService_AddVector_args() throw();
|
|
std::string table_name;
|
|
std::vector<RowRecord> record_array;
|
|
|
|
_MilvusService_AddVector_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
void __set_record_array(const std::vector<RowRecord> & val);
|
|
|
|
bool operator == (const MilvusService_AddVector_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
if (!(record_array == rhs.record_array))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_AddVector_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_AddVector_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_AddVector_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_AddVector_pargs() throw();
|
|
const std::string* table_name;
|
|
const std::vector<RowRecord> * record_array;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_AddVector_result__isset {
|
|
_MilvusService_AddVector_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_AddVector_result__isset;
|
|
|
|
class MilvusService_AddVector_result {
|
|
public:
|
|
|
|
MilvusService_AddVector_result(const MilvusService_AddVector_result&);
|
|
MilvusService_AddVector_result& operator=(const MilvusService_AddVector_result&);
|
|
MilvusService_AddVector_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_AddVector_result() throw();
|
|
std::vector<int64_t> success;
|
|
Exception e;
|
|
|
|
_MilvusService_AddVector_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<int64_t> & val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_AddVector_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_AddVector_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_AddVector_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_AddVector_presult__isset {
|
|
_MilvusService_AddVector_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_AddVector_presult__isset;
|
|
|
|
class MilvusService_AddVector_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_AddVector_presult() throw();
|
|
std::vector<int64_t> * success;
|
|
Exception e;
|
|
|
|
_MilvusService_AddVector_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_SearchVector_args__isset {
|
|
_MilvusService_SearchVector_args__isset() : table_name(false), query_record_array(false), query_range_array(false), topk(false) {}
|
|
bool table_name :1;
|
|
bool query_record_array :1;
|
|
bool query_range_array :1;
|
|
bool topk :1;
|
|
} _MilvusService_SearchVector_args__isset;
|
|
|
|
class MilvusService_SearchVector_args {
|
|
public:
|
|
|
|
MilvusService_SearchVector_args(const MilvusService_SearchVector_args&);
|
|
MilvusService_SearchVector_args& operator=(const MilvusService_SearchVector_args&);
|
|
MilvusService_SearchVector_args() : table_name(), topk(0) {
|
|
}
|
|
|
|
virtual ~MilvusService_SearchVector_args() throw();
|
|
std::string table_name;
|
|
std::vector<RowRecord> query_record_array;
|
|
std::vector<Range> query_range_array;
|
|
int64_t topk;
|
|
|
|
_MilvusService_SearchVector_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
void __set_query_record_array(const std::vector<RowRecord> & val);
|
|
|
|
void __set_query_range_array(const std::vector<Range> & val);
|
|
|
|
void __set_topk(const int64_t val);
|
|
|
|
bool operator == (const MilvusService_SearchVector_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
if (!(query_record_array == rhs.query_record_array))
|
|
return false;
|
|
if (!(query_range_array == rhs.query_range_array))
|
|
return false;
|
|
if (!(topk == rhs.topk))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_SearchVector_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_SearchVector_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_SearchVector_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_SearchVector_pargs() throw();
|
|
const std::string* table_name;
|
|
const std::vector<RowRecord> * query_record_array;
|
|
const std::vector<Range> * query_range_array;
|
|
const int64_t* topk;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_SearchVector_result__isset {
|
|
_MilvusService_SearchVector_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_SearchVector_result__isset;
|
|
|
|
class MilvusService_SearchVector_result {
|
|
public:
|
|
|
|
MilvusService_SearchVector_result(const MilvusService_SearchVector_result&);
|
|
MilvusService_SearchVector_result& operator=(const MilvusService_SearchVector_result&);
|
|
MilvusService_SearchVector_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_SearchVector_result() throw();
|
|
std::vector<TopKQueryResult> success;
|
|
Exception e;
|
|
|
|
_MilvusService_SearchVector_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<TopKQueryResult> & val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_SearchVector_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_SearchVector_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_SearchVector_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_SearchVector_presult__isset {
|
|
_MilvusService_SearchVector_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_SearchVector_presult__isset;
|
|
|
|
class MilvusService_SearchVector_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_SearchVector_presult() throw();
|
|
std::vector<TopKQueryResult> * success;
|
|
Exception e;
|
|
|
|
_MilvusService_SearchVector_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_SearchVectorInFiles_args__isset {
|
|
_MilvusService_SearchVectorInFiles_args__isset() : table_name(false), file_id_array(false), query_record_array(false), query_range_array(false), topk(false) {}
|
|
bool table_name :1;
|
|
bool file_id_array :1;
|
|
bool query_record_array :1;
|
|
bool query_range_array :1;
|
|
bool topk :1;
|
|
} _MilvusService_SearchVectorInFiles_args__isset;
|
|
|
|
class MilvusService_SearchVectorInFiles_args {
|
|
public:
|
|
|
|
MilvusService_SearchVectorInFiles_args(const MilvusService_SearchVectorInFiles_args&);
|
|
MilvusService_SearchVectorInFiles_args& operator=(const MilvusService_SearchVectorInFiles_args&);
|
|
MilvusService_SearchVectorInFiles_args() : table_name(), topk(0) {
|
|
}
|
|
|
|
virtual ~MilvusService_SearchVectorInFiles_args() throw();
|
|
std::string table_name;
|
|
std::vector<std::string> file_id_array;
|
|
std::vector<RowRecord> query_record_array;
|
|
std::vector<Range> query_range_array;
|
|
int64_t topk;
|
|
|
|
_MilvusService_SearchVectorInFiles_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
void __set_file_id_array(const std::vector<std::string> & val);
|
|
|
|
void __set_query_record_array(const std::vector<RowRecord> & val);
|
|
|
|
void __set_query_range_array(const std::vector<Range> & val);
|
|
|
|
void __set_topk(const int64_t val);
|
|
|
|
bool operator == (const MilvusService_SearchVectorInFiles_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
if (!(file_id_array == rhs.file_id_array))
|
|
return false;
|
|
if (!(query_record_array == rhs.query_record_array))
|
|
return false;
|
|
if (!(query_range_array == rhs.query_range_array))
|
|
return false;
|
|
if (!(topk == rhs.topk))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_SearchVectorInFiles_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_SearchVectorInFiles_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_SearchVectorInFiles_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_SearchVectorInFiles_pargs() throw();
|
|
const std::string* table_name;
|
|
const std::vector<std::string> * file_id_array;
|
|
const std::vector<RowRecord> * query_record_array;
|
|
const std::vector<Range> * query_range_array;
|
|
const int64_t* topk;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_SearchVectorInFiles_result__isset {
|
|
_MilvusService_SearchVectorInFiles_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_SearchVectorInFiles_result__isset;
|
|
|
|
class MilvusService_SearchVectorInFiles_result {
|
|
public:
|
|
|
|
MilvusService_SearchVectorInFiles_result(const MilvusService_SearchVectorInFiles_result&);
|
|
MilvusService_SearchVectorInFiles_result& operator=(const MilvusService_SearchVectorInFiles_result&);
|
|
MilvusService_SearchVectorInFiles_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_SearchVectorInFiles_result() throw();
|
|
std::vector<TopKQueryResult> success;
|
|
Exception e;
|
|
|
|
_MilvusService_SearchVectorInFiles_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<TopKQueryResult> & val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_SearchVectorInFiles_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_SearchVectorInFiles_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_SearchVectorInFiles_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_SearchVectorInFiles_presult__isset {
|
|
_MilvusService_SearchVectorInFiles_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_SearchVectorInFiles_presult__isset;
|
|
|
|
class MilvusService_SearchVectorInFiles_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_SearchVectorInFiles_presult() throw();
|
|
std::vector<TopKQueryResult> * success;
|
|
Exception e;
|
|
|
|
_MilvusService_SearchVectorInFiles_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_DescribeTable_args__isset {
|
|
_MilvusService_DescribeTable_args__isset() : table_name(false) {}
|
|
bool table_name :1;
|
|
} _MilvusService_DescribeTable_args__isset;
|
|
|
|
class MilvusService_DescribeTable_args {
|
|
public:
|
|
|
|
MilvusService_DescribeTable_args(const MilvusService_DescribeTable_args&);
|
|
MilvusService_DescribeTable_args& operator=(const MilvusService_DescribeTable_args&);
|
|
MilvusService_DescribeTable_args() : table_name() {
|
|
}
|
|
|
|
virtual ~MilvusService_DescribeTable_args() throw();
|
|
std::string table_name;
|
|
|
|
_MilvusService_DescribeTable_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
bool operator == (const MilvusService_DescribeTable_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_DescribeTable_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_DescribeTable_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_DescribeTable_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_DescribeTable_pargs() throw();
|
|
const std::string* table_name;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_DescribeTable_result__isset {
|
|
_MilvusService_DescribeTable_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_DescribeTable_result__isset;
|
|
|
|
class MilvusService_DescribeTable_result {
|
|
public:
|
|
|
|
MilvusService_DescribeTable_result(const MilvusService_DescribeTable_result&);
|
|
MilvusService_DescribeTable_result& operator=(const MilvusService_DescribeTable_result&);
|
|
MilvusService_DescribeTable_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_DescribeTable_result() throw();
|
|
TableSchema success;
|
|
Exception e;
|
|
|
|
_MilvusService_DescribeTable_result__isset __isset;
|
|
|
|
void __set_success(const TableSchema& val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_DescribeTable_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_DescribeTable_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_DescribeTable_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_DescribeTable_presult__isset {
|
|
_MilvusService_DescribeTable_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_DescribeTable_presult__isset;
|
|
|
|
class MilvusService_DescribeTable_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_DescribeTable_presult() throw();
|
|
TableSchema* success;
|
|
Exception e;
|
|
|
|
_MilvusService_DescribeTable_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_GetTableRowCount_args__isset {
|
|
_MilvusService_GetTableRowCount_args__isset() : table_name(false) {}
|
|
bool table_name :1;
|
|
} _MilvusService_GetTableRowCount_args__isset;
|
|
|
|
class MilvusService_GetTableRowCount_args {
|
|
public:
|
|
|
|
MilvusService_GetTableRowCount_args(const MilvusService_GetTableRowCount_args&);
|
|
MilvusService_GetTableRowCount_args& operator=(const MilvusService_GetTableRowCount_args&);
|
|
MilvusService_GetTableRowCount_args() : table_name() {
|
|
}
|
|
|
|
virtual ~MilvusService_GetTableRowCount_args() throw();
|
|
std::string table_name;
|
|
|
|
_MilvusService_GetTableRowCount_args__isset __isset;
|
|
|
|
void __set_table_name(const std::string& val);
|
|
|
|
bool operator == (const MilvusService_GetTableRowCount_args & rhs) const
|
|
{
|
|
if (!(table_name == rhs.table_name))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_GetTableRowCount_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_GetTableRowCount_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_GetTableRowCount_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_GetTableRowCount_pargs() throw();
|
|
const std::string* table_name;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_GetTableRowCount_result__isset {
|
|
_MilvusService_GetTableRowCount_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_GetTableRowCount_result__isset;
|
|
|
|
class MilvusService_GetTableRowCount_result {
|
|
public:
|
|
|
|
MilvusService_GetTableRowCount_result(const MilvusService_GetTableRowCount_result&);
|
|
MilvusService_GetTableRowCount_result& operator=(const MilvusService_GetTableRowCount_result&);
|
|
MilvusService_GetTableRowCount_result() : success(0) {
|
|
}
|
|
|
|
virtual ~MilvusService_GetTableRowCount_result() throw();
|
|
int64_t success;
|
|
Exception e;
|
|
|
|
_MilvusService_GetTableRowCount_result__isset __isset;
|
|
|
|
void __set_success(const int64_t val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_GetTableRowCount_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_GetTableRowCount_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_GetTableRowCount_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_GetTableRowCount_presult__isset {
|
|
_MilvusService_GetTableRowCount_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_GetTableRowCount_presult__isset;
|
|
|
|
class MilvusService_GetTableRowCount_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_GetTableRowCount_presult() throw();
|
|
int64_t* success;
|
|
Exception e;
|
|
|
|
_MilvusService_GetTableRowCount_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_ShowTables_args {
|
|
public:
|
|
|
|
MilvusService_ShowTables_args(const MilvusService_ShowTables_args&);
|
|
MilvusService_ShowTables_args& operator=(const MilvusService_ShowTables_args&);
|
|
MilvusService_ShowTables_args() {
|
|
}
|
|
|
|
virtual ~MilvusService_ShowTables_args() throw();
|
|
|
|
bool operator == (const MilvusService_ShowTables_args & /* rhs */) const
|
|
{
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_ShowTables_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_ShowTables_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_ShowTables_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_ShowTables_pargs() throw();
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_ShowTables_result__isset {
|
|
_MilvusService_ShowTables_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_ShowTables_result__isset;
|
|
|
|
class MilvusService_ShowTables_result {
|
|
public:
|
|
|
|
MilvusService_ShowTables_result(const MilvusService_ShowTables_result&);
|
|
MilvusService_ShowTables_result& operator=(const MilvusService_ShowTables_result&);
|
|
MilvusService_ShowTables_result() {
|
|
}
|
|
|
|
virtual ~MilvusService_ShowTables_result() throw();
|
|
std::vector<std::string> success;
|
|
Exception e;
|
|
|
|
_MilvusService_ShowTables_result__isset __isset;
|
|
|
|
void __set_success(const std::vector<std::string> & val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_ShowTables_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_ShowTables_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_ShowTables_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_ShowTables_presult__isset {
|
|
_MilvusService_ShowTables_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_ShowTables_presult__isset;
|
|
|
|
class MilvusService_ShowTables_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_ShowTables_presult() throw();
|
|
std::vector<std::string> * success;
|
|
Exception e;
|
|
|
|
_MilvusService_ShowTables_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_Ping_args__isset {
|
|
_MilvusService_Ping_args__isset() : cmd(false) {}
|
|
bool cmd :1;
|
|
} _MilvusService_Ping_args__isset;
|
|
|
|
class MilvusService_Ping_args {
|
|
public:
|
|
|
|
MilvusService_Ping_args(const MilvusService_Ping_args&);
|
|
MilvusService_Ping_args& operator=(const MilvusService_Ping_args&);
|
|
MilvusService_Ping_args() : cmd() {
|
|
}
|
|
|
|
virtual ~MilvusService_Ping_args() throw();
|
|
std::string cmd;
|
|
|
|
_MilvusService_Ping_args__isset __isset;
|
|
|
|
void __set_cmd(const std::string& val);
|
|
|
|
bool operator == (const MilvusService_Ping_args & rhs) const
|
|
{
|
|
if (!(cmd == rhs.cmd))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_Ping_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_Ping_args & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
|
|
class MilvusService_Ping_pargs {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_Ping_pargs() throw();
|
|
const std::string* cmd;
|
|
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_Ping_result__isset {
|
|
_MilvusService_Ping_result__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_Ping_result__isset;
|
|
|
|
class MilvusService_Ping_result {
|
|
public:
|
|
|
|
MilvusService_Ping_result(const MilvusService_Ping_result&);
|
|
MilvusService_Ping_result& operator=(const MilvusService_Ping_result&);
|
|
MilvusService_Ping_result() : success() {
|
|
}
|
|
|
|
virtual ~MilvusService_Ping_result() throw();
|
|
std::string success;
|
|
Exception e;
|
|
|
|
_MilvusService_Ping_result__isset __isset;
|
|
|
|
void __set_success(const std::string& val);
|
|
|
|
void __set_e(const Exception& val);
|
|
|
|
bool operator == (const MilvusService_Ping_result & rhs) const
|
|
{
|
|
if (!(success == rhs.success))
|
|
return false;
|
|
if (!(e == rhs.e))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const MilvusService_Ping_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const MilvusService_Ping_result & ) const;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
typedef struct _MilvusService_Ping_presult__isset {
|
|
_MilvusService_Ping_presult__isset() : success(false), e(false) {}
|
|
bool success :1;
|
|
bool e :1;
|
|
} _MilvusService_Ping_presult__isset;
|
|
|
|
class MilvusService_Ping_presult {
|
|
public:
|
|
|
|
|
|
virtual ~MilvusService_Ping_presult() throw();
|
|
std::string* success;
|
|
Exception e;
|
|
|
|
_MilvusService_Ping_presult__isset __isset;
|
|
|
|
uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
class MilvusServiceClient : virtual public MilvusServiceIf {
|
|
public:
|
|
MilvusServiceClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
|
|
setProtocol(prot);
|
|
}
|
|
MilvusServiceClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
|
|
setProtocol(iprot,oprot);
|
|
}
|
|
private:
|
|
void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
|
|
setProtocol(prot,prot);
|
|
}
|
|
void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
|
|
piprot_=iprot;
|
|
poprot_=oprot;
|
|
iprot_ = iprot.get();
|
|
oprot_ = oprot.get();
|
|
}
|
|
public:
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
|
|
return piprot_;
|
|
}
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
|
|
return poprot_;
|
|
}
|
|
void CreateTable(const TableSchema& param);
|
|
void send_CreateTable(const TableSchema& param);
|
|
void recv_CreateTable();
|
|
bool HasTable(const std::string& table_name);
|
|
void send_HasTable(const std::string& table_name);
|
|
bool recv_HasTable();
|
|
void DeleteTable(const std::string& table_name);
|
|
void send_DeleteTable(const std::string& table_name);
|
|
void recv_DeleteTable();
|
|
void BuildIndex(const std::string& table_name);
|
|
void send_BuildIndex(const std::string& table_name);
|
|
void recv_BuildIndex();
|
|
void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array);
|
|
void send_AddVector(const std::string& table_name, const std::vector<RowRecord> & record_array);
|
|
void recv_AddVector(std::vector<int64_t> & _return);
|
|
void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
void send_SearchVector(const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
void recv_SearchVector(std::vector<TopKQueryResult> & _return);
|
|
void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
void send_SearchVectorInFiles(const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
void recv_SearchVectorInFiles(std::vector<TopKQueryResult> & _return);
|
|
void DescribeTable(TableSchema& _return, const std::string& table_name);
|
|
void send_DescribeTable(const std::string& table_name);
|
|
void recv_DescribeTable(TableSchema& _return);
|
|
int64_t GetTableRowCount(const std::string& table_name);
|
|
void send_GetTableRowCount(const std::string& table_name);
|
|
int64_t recv_GetTableRowCount();
|
|
void ShowTables(std::vector<std::string> & _return);
|
|
void send_ShowTables();
|
|
void recv_ShowTables(std::vector<std::string> & _return);
|
|
void Ping(std::string& _return, const std::string& cmd);
|
|
void send_Ping(const std::string& cmd);
|
|
void recv_Ping(std::string& _return);
|
|
protected:
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
|
|
::apache::thrift::protocol::TProtocol* iprot_;
|
|
::apache::thrift::protocol::TProtocol* oprot_;
|
|
};
|
|
|
|
class MilvusServiceProcessor : public ::apache::thrift::TDispatchProcessor {
|
|
protected:
|
|
::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface_;
|
|
virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
|
|
private:
|
|
typedef void (MilvusServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
|
|
typedef std::map<std::string, ProcessFunction> ProcessMap;
|
|
ProcessMap processMap_;
|
|
void process_CreateTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_HasTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_DeleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_BuildIndex(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_AddVector(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_SearchVector(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_SearchVectorInFiles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_DescribeTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_GetTableRowCount(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_ShowTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
void process_Ping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
|
|
public:
|
|
MilvusServiceProcessor(::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface) :
|
|
iface_(iface) {
|
|
processMap_["CreateTable"] = &MilvusServiceProcessor::process_CreateTable;
|
|
processMap_["HasTable"] = &MilvusServiceProcessor::process_HasTable;
|
|
processMap_["DeleteTable"] = &MilvusServiceProcessor::process_DeleteTable;
|
|
processMap_["BuildIndex"] = &MilvusServiceProcessor::process_BuildIndex;
|
|
processMap_["AddVector"] = &MilvusServiceProcessor::process_AddVector;
|
|
processMap_["SearchVector"] = &MilvusServiceProcessor::process_SearchVector;
|
|
processMap_["SearchVectorInFiles"] = &MilvusServiceProcessor::process_SearchVectorInFiles;
|
|
processMap_["DescribeTable"] = &MilvusServiceProcessor::process_DescribeTable;
|
|
processMap_["GetTableRowCount"] = &MilvusServiceProcessor::process_GetTableRowCount;
|
|
processMap_["ShowTables"] = &MilvusServiceProcessor::process_ShowTables;
|
|
processMap_["Ping"] = &MilvusServiceProcessor::process_Ping;
|
|
}
|
|
|
|
virtual ~MilvusServiceProcessor() {}
|
|
};
|
|
|
|
class MilvusServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
|
|
public:
|
|
MilvusServiceProcessorFactory(const ::apache::thrift::stdcxx::shared_ptr< MilvusServiceIfFactory >& handlerFactory) :
|
|
handlerFactory_(handlerFactory) {}
|
|
|
|
::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
|
|
|
|
protected:
|
|
::apache::thrift::stdcxx::shared_ptr< MilvusServiceIfFactory > handlerFactory_;
|
|
};
|
|
|
|
class MilvusServiceMultiface : virtual public MilvusServiceIf {
|
|
public:
|
|
MilvusServiceMultiface(std::vector<apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> >& ifaces) : ifaces_(ifaces) {
|
|
}
|
|
virtual ~MilvusServiceMultiface() {}
|
|
protected:
|
|
std::vector<apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> > ifaces_;
|
|
MilvusServiceMultiface() {}
|
|
void add(::apache::thrift::stdcxx::shared_ptr<MilvusServiceIf> iface) {
|
|
ifaces_.push_back(iface);
|
|
}
|
|
public:
|
|
void CreateTable(const TableSchema& param) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->CreateTable(param);
|
|
}
|
|
ifaces_[i]->CreateTable(param);
|
|
}
|
|
|
|
bool HasTable(const std::string& table_name) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->HasTable(table_name);
|
|
}
|
|
return ifaces_[i]->HasTable(table_name);
|
|
}
|
|
|
|
void DeleteTable(const std::string& table_name) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->DeleteTable(table_name);
|
|
}
|
|
ifaces_[i]->DeleteTable(table_name);
|
|
}
|
|
|
|
void BuildIndex(const std::string& table_name) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->BuildIndex(table_name);
|
|
}
|
|
ifaces_[i]->BuildIndex(table_name);
|
|
}
|
|
|
|
void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->AddVector(_return, table_name, record_array);
|
|
}
|
|
ifaces_[i]->AddVector(_return, table_name, record_array);
|
|
return;
|
|
}
|
|
|
|
void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->SearchVector(_return, table_name, query_record_array, query_range_array, topk);
|
|
}
|
|
ifaces_[i]->SearchVector(_return, table_name, query_record_array, query_range_array, topk);
|
|
return;
|
|
}
|
|
|
|
void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->SearchVectorInFiles(_return, table_name, file_id_array, query_record_array, query_range_array, topk);
|
|
}
|
|
ifaces_[i]->SearchVectorInFiles(_return, table_name, file_id_array, query_record_array, query_range_array, topk);
|
|
return;
|
|
}
|
|
|
|
void DescribeTable(TableSchema& _return, const std::string& table_name) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->DescribeTable(_return, table_name);
|
|
}
|
|
ifaces_[i]->DescribeTable(_return, table_name);
|
|
return;
|
|
}
|
|
|
|
int64_t GetTableRowCount(const std::string& table_name) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->GetTableRowCount(table_name);
|
|
}
|
|
return ifaces_[i]->GetTableRowCount(table_name);
|
|
}
|
|
|
|
void ShowTables(std::vector<std::string> & _return) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->ShowTables(_return);
|
|
}
|
|
ifaces_[i]->ShowTables(_return);
|
|
return;
|
|
}
|
|
|
|
void Ping(std::string& _return, const std::string& cmd) {
|
|
size_t sz = ifaces_.size();
|
|
size_t i = 0;
|
|
for (; i < (sz - 1); ++i) {
|
|
ifaces_[i]->Ping(_return, cmd);
|
|
}
|
|
ifaces_[i]->Ping(_return, cmd);
|
|
return;
|
|
}
|
|
|
|
};
|
|
|
|
// The 'concurrent' client is a thread safe client that correctly handles
|
|
// out of order responses. It is slower than the regular client, so should
|
|
// only be used when you need to share a connection among multiple threads
|
|
class MilvusServiceConcurrentClient : virtual public MilvusServiceIf {
|
|
public:
|
|
MilvusServiceConcurrentClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
|
|
setProtocol(prot);
|
|
}
|
|
MilvusServiceConcurrentClient(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
|
|
setProtocol(iprot,oprot);
|
|
}
|
|
private:
|
|
void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
|
|
setProtocol(prot,prot);
|
|
}
|
|
void setProtocol(apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
|
|
piprot_=iprot;
|
|
poprot_=oprot;
|
|
iprot_ = iprot.get();
|
|
oprot_ = oprot.get();
|
|
}
|
|
public:
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
|
|
return piprot_;
|
|
}
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
|
|
return poprot_;
|
|
}
|
|
void CreateTable(const TableSchema& param);
|
|
int32_t send_CreateTable(const TableSchema& param);
|
|
void recv_CreateTable(const int32_t seqid);
|
|
bool HasTable(const std::string& table_name);
|
|
int32_t send_HasTable(const std::string& table_name);
|
|
bool recv_HasTable(const int32_t seqid);
|
|
void DeleteTable(const std::string& table_name);
|
|
int32_t send_DeleteTable(const std::string& table_name);
|
|
void recv_DeleteTable(const int32_t seqid);
|
|
void BuildIndex(const std::string& table_name);
|
|
int32_t send_BuildIndex(const std::string& table_name);
|
|
void recv_BuildIndex(const int32_t seqid);
|
|
void AddVector(std::vector<int64_t> & _return, const std::string& table_name, const std::vector<RowRecord> & record_array);
|
|
int32_t send_AddVector(const std::string& table_name, const std::vector<RowRecord> & record_array);
|
|
void recv_AddVector(std::vector<int64_t> & _return, const int32_t seqid);
|
|
void SearchVector(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
int32_t send_SearchVector(const std::string& table_name, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
void recv_SearchVector(std::vector<TopKQueryResult> & _return, const int32_t seqid);
|
|
void SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
int32_t send_SearchVectorInFiles(const std::string& table_name, const std::vector<std::string> & file_id_array, const std::vector<RowRecord> & query_record_array, const std::vector<Range> & query_range_array, const int64_t topk);
|
|
void recv_SearchVectorInFiles(std::vector<TopKQueryResult> & _return, const int32_t seqid);
|
|
void DescribeTable(TableSchema& _return, const std::string& table_name);
|
|
int32_t send_DescribeTable(const std::string& table_name);
|
|
void recv_DescribeTable(TableSchema& _return, const int32_t seqid);
|
|
int64_t GetTableRowCount(const std::string& table_name);
|
|
int32_t send_GetTableRowCount(const std::string& table_name);
|
|
int64_t recv_GetTableRowCount(const int32_t seqid);
|
|
void ShowTables(std::vector<std::string> & _return);
|
|
int32_t send_ShowTables();
|
|
void recv_ShowTables(std::vector<std::string> & _return, const int32_t seqid);
|
|
void Ping(std::string& _return, const std::string& cmd);
|
|
int32_t send_Ping(const std::string& cmd);
|
|
void recv_Ping(std::string& _return, const int32_t seqid);
|
|
protected:
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
|
|
apache::thrift::stdcxx::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
|
|
::apache::thrift::protocol::TProtocol* iprot_;
|
|
::apache::thrift::protocol::TProtocol* oprot_;
|
|
::apache::thrift::async::TConcurrentClientSyncInfo sync_;
|
|
};
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning( pop )
|
|
#endif
|
|
|
|
}} // namespace
|
|
|
|
#endif
|