You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ga...@apache.org on 2018/01/18 17:56:28 UTC
[68/70] [abbrv] hive git commit: HIVE-17990 Add Thrift and DB storage
for Schema Registry objects
http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
index 42bc929..5b380ad 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
@@ -205,6 +205,20 @@ class ThriftHiveMetastoreIf : virtual public ::facebook::fb303::FacebookService
virtual void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) = 0;
virtual void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) = 0;
virtual void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) = 0;
+ virtual void create_ischema(const ISchema& schema) = 0;
+ virtual void alter_ischema(const std::string& schemaName, const ISchema& newSchema) = 0;
+ virtual void get_ischema(ISchema& _return, const std::string& schemaName) = 0;
+ virtual void drop_ischema(const std::string& schemaName) = 0;
+ virtual void add_schema_version(const SchemaVersion& schemaVersion) = 0;
+ virtual void get_schema_version(SchemaVersion& _return, const std::string& schemaName, const int32_t version) = 0;
+ virtual void get_schema_latest_version(SchemaVersion& _return, const std::string& schemaName) = 0;
+ virtual void get_schema_all_versions(std::vector<SchemaVersion> & _return, const std::string& schemaName) = 0;
+ virtual void drop_schema_version(const std::string& schemaName, const int32_t version) = 0;
+ virtual void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) = 0;
+ virtual void map_schema_version_to_serde(const std::string& schemaName, const int32_t version, const std::string& serdeName) = 0;
+ virtual void set_schema_version_state(const std::string& schemaName, const int32_t version, const SchemaVersionState::type state) = 0;
+ virtual void add_serde(const SerDeInfo& serde) = 0;
+ virtual void get_serde(SerDeInfo& _return, const std::string& serdeName) = 0;
};
class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory {
@@ -811,6 +825,48 @@ class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual p
void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& /* _return */, const WMCreateOrDropTriggerToPoolMappingRequest& /* request */) {
return;
}
+ void create_ischema(const ISchema& /* schema */) {
+ return;
+ }
+ void alter_ischema(const std::string& /* schemaName */, const ISchema& /* newSchema */) {
+ return;
+ }
+ void get_ischema(ISchema& /* _return */, const std::string& /* schemaName */) {
+ return;
+ }
+ void drop_ischema(const std::string& /* schemaName */) {
+ return;
+ }
+ void add_schema_version(const SchemaVersion& /* schemaVersion */) {
+ return;
+ }
+ void get_schema_version(SchemaVersion& /* _return */, const std::string& /* schemaName */, const int32_t /* version */) {
+ return;
+ }
+ void get_schema_latest_version(SchemaVersion& /* _return */, const std::string& /* schemaName */) {
+ return;
+ }
+ void get_schema_all_versions(std::vector<SchemaVersion> & /* _return */, const std::string& /* schemaName */) {
+ return;
+ }
+ void drop_schema_version(const std::string& /* schemaName */, const int32_t /* version */) {
+ return;
+ }
+ void get_schemas_by_cols(FindSchemasByColsResp& /* _return */, const FindSchemasByColsRqst& /* rqst */) {
+ return;
+ }
+ void map_schema_version_to_serde(const std::string& /* schemaName */, const int32_t /* version */, const std::string& /* serdeName */) {
+ return;
+ }
+ void set_schema_version_state(const std::string& /* schemaName */, const int32_t /* version */, const SchemaVersionState::type /* state */) {
+ return;
+ }
+ void add_serde(const SerDeInfo& /* serde */) {
+ return;
+ }
+ void get_serde(SerDeInfo& /* _return */, const std::string& /* serdeName */) {
+ return;
+ }
};
typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
@@ -23404,228 +23460,1917 @@ class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult {
};
-class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient {
+typedef struct _ThriftHiveMetastore_create_ischema_args__isset {
+ _ThriftHiveMetastore_create_ischema_args__isset() : schema(false) {}
+ bool schema :1;
+} _ThriftHiveMetastore_create_ischema_args__isset;
+
+class ThriftHiveMetastore_create_ischema_args {
public:
- ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
- ::facebook::fb303::FacebookServiceClient(prot, prot) {}
- ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ::facebook::fb303::FacebookServiceClient(iprot, oprot) {}
- boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
- return piprot_;
+
+ ThriftHiveMetastore_create_ischema_args(const ThriftHiveMetastore_create_ischema_args&);
+ ThriftHiveMetastore_create_ischema_args& operator=(const ThriftHiveMetastore_create_ischema_args&);
+ ThriftHiveMetastore_create_ischema_args() {
}
- boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
- return poprot_;
+
+ virtual ~ThriftHiveMetastore_create_ischema_args() throw();
+ ISchema schema;
+
+ _ThriftHiveMetastore_create_ischema_args__isset __isset;
+
+ void __set_schema(const ISchema& val);
+
+ bool operator == (const ThriftHiveMetastore_create_ischema_args & rhs) const
+ {
+ if (!(schema == rhs.schema))
+ return false;
+ return true;
}
- void getMetaConf(std::string& _return, const std::string& key);
- void send_getMetaConf(const std::string& key);
- void recv_getMetaConf(std::string& _return);
- void setMetaConf(const std::string& key, const std::string& value);
- void send_setMetaConf(const std::string& key, const std::string& value);
- void recv_setMetaConf();
- void create_database(const Database& database);
- void send_create_database(const Database& database);
- void recv_create_database();
- void get_database(Database& _return, const std::string& name);
- void send_get_database(const std::string& name);
- void recv_get_database(Database& _return);
- void drop_database(const std::string& name, const bool deleteData, const bool cascade);
- void send_drop_database(const std::string& name, const bool deleteData, const bool cascade);
- void recv_drop_database();
- void get_databases(std::vector<std::string> & _return, const std::string& pattern);
- void send_get_databases(const std::string& pattern);
- void recv_get_databases(std::vector<std::string> & _return);
- void get_all_databases(std::vector<std::string> & _return);
- void send_get_all_databases();
- void recv_get_all_databases(std::vector<std::string> & _return);
- void alter_database(const std::string& dbname, const Database& db);
- void send_alter_database(const std::string& dbname, const Database& db);
- void recv_alter_database();
- void get_type(Type& _return, const std::string& name);
- void send_get_type(const std::string& name);
- void recv_get_type(Type& _return);
- bool create_type(const Type& type);
- void send_create_type(const Type& type);
- bool recv_create_type();
- bool drop_type(const std::string& type);
- void send_drop_type(const std::string& type);
- bool recv_drop_type();
- void get_type_all(std::map<std::string, Type> & _return, const std::string& name);
- void send_get_type_all(const std::string& name);
- void recv_get_type_all(std::map<std::string, Type> & _return);
- void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
- void send_get_fields(const std::string& db_name, const std::string& table_name);
- void recv_get_fields(std::vector<FieldSchema> & _return);
- void get_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
- void send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
- void recv_get_fields_with_environment_context(std::vector<FieldSchema> & _return);
- void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
- void send_get_schema(const std::string& db_name, const std::string& table_name);
- void recv_get_schema(std::vector<FieldSchema> & _return);
- void get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
- void send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
- void recv_get_schema_with_environment_context(std::vector<FieldSchema> & _return);
- void create_table(const Table& tbl);
- void send_create_table(const Table& tbl);
- void recv_create_table();
- void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
- void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
- void recv_create_table_with_environment_context();
- void create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints);
- void send_create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints);
- void recv_create_table_with_constraints();
- void drop_constraint(const DropConstraintRequest& req);
- void send_drop_constraint(const DropConstraintRequest& req);
- void recv_drop_constraint();
- void add_primary_key(const AddPrimaryKeyRequest& req);
- void send_add_primary_key(const AddPrimaryKeyRequest& req);
- void recv_add_primary_key();
- void add_foreign_key(const AddForeignKeyRequest& req);
- void send_add_foreign_key(const AddForeignKeyRequest& req);
- void recv_add_foreign_key();
- void add_unique_constraint(const AddUniqueConstraintRequest& req);
- void send_add_unique_constraint(const AddUniqueConstraintRequest& req);
- void recv_add_unique_constraint();
- void add_not_null_constraint(const AddNotNullConstraintRequest& req);
- void send_add_not_null_constraint(const AddNotNullConstraintRequest& req);
- void recv_add_not_null_constraint();
- void drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
- void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
- void recv_drop_table();
- void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
- void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
- void recv_drop_table_with_environment_context();
- void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames);
- void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames);
- void recv_truncate_table();
- void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern);
- void send_get_tables(const std::string& db_name, const std::string& pattern);
- void recv_get_tables(std::vector<std::string> & _return);
- void get_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType);
- void send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType);
- void recv_get_tables_by_type(std::vector<std::string> & _return);
- void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name);
- void send_get_materialized_views_for_rewriting(const std::string& db_name);
- void recv_get_materialized_views_for_rewriting(std::vector<std::string> & _return);
- void get_table_meta(std::vector<TableMeta> & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types);
- void send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types);
- void recv_get_table_meta(std::vector<TableMeta> & _return);
- void get_all_tables(std::vector<std::string> & _return, const std::string& db_name);
- void send_get_all_tables(const std::string& db_name);
- void recv_get_all_tables(std::vector<std::string> & _return);
- void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name);
- void send_get_table(const std::string& dbname, const std::string& tbl_name);
- void recv_get_table(Table& _return);
- void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
- void send_get_table_objects_by_name(const std::string& dbname, const std::vector<std::string> & tbl_names);
- void recv_get_table_objects_by_name(std::vector<Table> & _return);
- void get_table_req(GetTableResult& _return, const GetTableRequest& req);
- void send_get_table_req(const GetTableRequest& req);
- void recv_get_table_req(GetTableResult& _return);
- void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req);
- void send_get_table_objects_by_name_req(const GetTablesRequest& req);
- void recv_get_table_objects_by_name_req(GetTablesResult& _return);
- void get_materialization_invalidation_info(std::map<std::string, Materialization> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
- void send_get_materialization_invalidation_info(const std::string& dbname, const std::vector<std::string> & tbl_names);
- void recv_get_materialization_invalidation_info(std::map<std::string, Materialization> & _return);
- void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables);
- void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables);
- void recv_get_table_names_by_filter(std::vector<std::string> & _return);
- void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
- void send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
- void recv_alter_table();
- void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context);
- void send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context);
- void recv_alter_table_with_environment_context();
- void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade);
- void send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade);
- void recv_alter_table_with_cascade();
- void add_partition(Partition& _return, const Partition& new_part);
- void send_add_partition(const Partition& new_part);
- void recv_add_partition(Partition& _return);
- void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context);
- void send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context);
- void recv_add_partition_with_environment_context(Partition& _return);
- int32_t add_partitions(const std::vector<Partition> & new_parts);
- void send_add_partitions(const std::vector<Partition> & new_parts);
- int32_t recv_add_partitions();
- int32_t add_partitions_pspec(const std::vector<PartitionSpec> & new_parts);
- void send_add_partitions_pspec(const std::vector<PartitionSpec> & new_parts);
- int32_t recv_add_partitions_pspec();
- void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
- void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
- void recv_append_partition(Partition& _return);
- void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request);
- void send_add_partitions_req(const AddPartitionsRequest& request);
- void recv_add_partitions_req(AddPartitionsResult& _return);
- void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context);
- void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context);
- void recv_append_partition_with_environment_context(Partition& _return);
- void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
- void send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
- void recv_append_partition_by_name(Partition& _return);
- void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context);
- void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context);
- void recv_append_partition_by_name_with_environment_context(Partition& _return);
- bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData);
- void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData);
- bool recv_drop_partition();
- bool drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData, const EnvironmentContext& environment_context);
- void send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData, const EnvironmentContext& environment_context);
- bool recv_drop_partition_with_environment_context();
- bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData);
- void send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData);
- bool recv_drop_partition_by_name();
- bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context);
- void send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context);
- bool recv_drop_partition_by_name_with_environment_context();
- void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req);
- void send_drop_partitions_req(const DropPartitionsRequest& req);
- void recv_drop_partitions_req(DropPartitionsResult& _return);
- void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
- void send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
- void recv_get_partition(Partition& _return);
- void exchange_partition(Partition& _return, const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
- void send_exchange_partition(const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
- void recv_exchange_partition(Partition& _return);
- void exchange_partitions(std::vector<Partition> & _return, const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
- void send_exchange_partitions(const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
- void recv_exchange_partitions(std::vector<Partition> & _return);
- void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const std::string& user_name, const std::vector<std::string> & group_names);
- void send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const std::string& user_name, const std::vector<std::string> & group_names);
- void recv_get_partition_with_auth(Partition& _return);
- void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
- void send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
- void recv_get_partition_by_name(Partition& _return);
- void get_partitions(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
- void send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
- void recv_get_partitions(std::vector<Partition> & _return);
- void get_partitions_with_auth(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
- void send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
- void recv_get_partitions_with_auth(std::vector<Partition> & _return);
- void get_partitions_pspec(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts);
- void send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts);
- void recv_get_partitions_pspec(std::vector<PartitionSpec> & _return);
- void get_partition_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
- void send_get_partition_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
- void recv_get_partition_names(std::vector<std::string> & _return);
- void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request);
- void send_get_partition_values(const PartitionValuesRequest& request);
- void recv_get_partition_values(PartitionValuesResponse& _return);
- void get_partitions_ps(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts);
- void send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts);
- void recv_get_partitions_ps(std::vector<Partition> & _return);
- void get_partitions_ps_with_auth(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
- void send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
- void recv_get_partitions_ps_with_auth(std::vector<Partition> & _return);
- void get_partition_names_ps(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts);
- void send_get_partition_names_ps(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts);
- void recv_get_partition_names_ps(std::vector<std::string> & _return);
- void get_partitions_by_filter(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
- void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
- void recv_get_partitions_by_filter(std::vector<Partition> & _return);
- void get_part_specs_by_filter(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts);
- void send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts);
- void recv_get_part_specs_by_filter(std::vector<PartitionSpec> & _return);
- void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req);
+ bool operator != (const ThriftHiveMetastore_create_ischema_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_create_ischema_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_create_ischema_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_create_ischema_pargs() throw();
+ const ISchema* schema;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_create_ischema_result__isset {
+ _ThriftHiveMetastore_create_ischema_result__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_create_ischema_result__isset;
+
+class ThriftHiveMetastore_create_ischema_result {
+ public:
+
+ ThriftHiveMetastore_create_ischema_result(const ThriftHiveMetastore_create_ischema_result&);
+ ThriftHiveMetastore_create_ischema_result& operator=(const ThriftHiveMetastore_create_ischema_result&);
+ ThriftHiveMetastore_create_ischema_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_create_ischema_result() throw();
+ AlreadyExistsException o1;
+ NoSuchObjectException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_create_ischema_result__isset __isset;
+
+ void __set_o1(const AlreadyExistsException& val);
+
+ void __set_o2(const NoSuchObjectException& val);
+
+ void __set_o3(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_create_ischema_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ if (!(o3 == rhs.o3))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_create_ischema_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_create_ischema_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_create_ischema_presult__isset {
+ _ThriftHiveMetastore_create_ischema_presult__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_create_ischema_presult__isset;
+
+class ThriftHiveMetastore_create_ischema_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_create_ischema_presult() throw();
+ AlreadyExistsException o1;
+ NoSuchObjectException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_create_ischema_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_alter_ischema_args__isset {
+ _ThriftHiveMetastore_alter_ischema_args__isset() : schemaName(false), newSchema(false) {}
+ bool schemaName :1;
+ bool newSchema :1;
+} _ThriftHiveMetastore_alter_ischema_args__isset;
+
+class ThriftHiveMetastore_alter_ischema_args {
+ public:
+
+ ThriftHiveMetastore_alter_ischema_args(const ThriftHiveMetastore_alter_ischema_args&);
+ ThriftHiveMetastore_alter_ischema_args& operator=(const ThriftHiveMetastore_alter_ischema_args&);
+ ThriftHiveMetastore_alter_ischema_args() : schemaName() {
+ }
+
+ virtual ~ThriftHiveMetastore_alter_ischema_args() throw();
+ std::string schemaName;
+ ISchema newSchema;
+
+ _ThriftHiveMetastore_alter_ischema_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ void __set_newSchema(const ISchema& val);
+
+ bool operator == (const ThriftHiveMetastore_alter_ischema_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ if (!(newSchema == rhs.newSchema))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_alter_ischema_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_alter_ischema_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_alter_ischema_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_alter_ischema_pargs() throw();
+ const std::string* schemaName;
+ const ISchema* newSchema;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_alter_ischema_result__isset {
+ _ThriftHiveMetastore_alter_ischema_result__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_alter_ischema_result__isset;
+
+class ThriftHiveMetastore_alter_ischema_result {
+ public:
+
+ ThriftHiveMetastore_alter_ischema_result(const ThriftHiveMetastore_alter_ischema_result&);
+ ThriftHiveMetastore_alter_ischema_result& operator=(const ThriftHiveMetastore_alter_ischema_result&);
+ ThriftHiveMetastore_alter_ischema_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_alter_ischema_result() throw();
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_alter_ischema_result__isset __isset;
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_alter_ischema_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_alter_ischema_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_alter_ischema_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_alter_ischema_presult__isset {
+ _ThriftHiveMetastore_alter_ischema_presult__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_alter_ischema_presult__isset;
+
+class ThriftHiveMetastore_alter_ischema_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_alter_ischema_presult() throw();
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_alter_ischema_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_ischema_args__isset {
+ _ThriftHiveMetastore_get_ischema_args__isset() : schemaName(false) {}
+ bool schemaName :1;
+} _ThriftHiveMetastore_get_ischema_args__isset;
+
+class ThriftHiveMetastore_get_ischema_args {
+ public:
+
+ ThriftHiveMetastore_get_ischema_args(const ThriftHiveMetastore_get_ischema_args&);
+ ThriftHiveMetastore_get_ischema_args& operator=(const ThriftHiveMetastore_get_ischema_args&);
+ ThriftHiveMetastore_get_ischema_args() : schemaName() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_ischema_args() throw();
+ std::string schemaName;
+
+ _ThriftHiveMetastore_get_ischema_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ bool operator == (const ThriftHiveMetastore_get_ischema_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_ischema_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_ischema_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_ischema_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_ischema_pargs() throw();
+ const std::string* schemaName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_ischema_result__isset {
+ _ThriftHiveMetastore_get_ischema_result__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_ischema_result__isset;
+
+class ThriftHiveMetastore_get_ischema_result {
+ public:
+
+ ThriftHiveMetastore_get_ischema_result(const ThriftHiveMetastore_get_ischema_result&);
+ ThriftHiveMetastore_get_ischema_result& operator=(const ThriftHiveMetastore_get_ischema_result&);
+ ThriftHiveMetastore_get_ischema_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_ischema_result() throw();
+ ISchema success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_ischema_result__isset __isset;
+
+ void __set_success(const ISchema& val);
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_ischema_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_ischema_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_ischema_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_ischema_presult__isset {
+ _ThriftHiveMetastore_get_ischema_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_ischema_presult__isset;
+
+class ThriftHiveMetastore_get_ischema_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_ischema_presult() throw();
+ ISchema* success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_ischema_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_ischema_args__isset {
+ _ThriftHiveMetastore_drop_ischema_args__isset() : schemaName(false) {}
+ bool schemaName :1;
+} _ThriftHiveMetastore_drop_ischema_args__isset;
+
+class ThriftHiveMetastore_drop_ischema_args {
+ public:
+
+ ThriftHiveMetastore_drop_ischema_args(const ThriftHiveMetastore_drop_ischema_args&);
+ ThriftHiveMetastore_drop_ischema_args& operator=(const ThriftHiveMetastore_drop_ischema_args&);
+ ThriftHiveMetastore_drop_ischema_args() : schemaName() {
+ }
+
+ virtual ~ThriftHiveMetastore_drop_ischema_args() throw();
+ std::string schemaName;
+
+ _ThriftHiveMetastore_drop_ischema_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ bool operator == (const ThriftHiveMetastore_drop_ischema_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_drop_ischema_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_drop_ischema_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_drop_ischema_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_drop_ischema_pargs() throw();
+ const std::string* schemaName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_ischema_result__isset {
+ _ThriftHiveMetastore_drop_ischema_result__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_drop_ischema_result__isset;
+
+class ThriftHiveMetastore_drop_ischema_result {
+ public:
+
+ ThriftHiveMetastore_drop_ischema_result(const ThriftHiveMetastore_drop_ischema_result&);
+ ThriftHiveMetastore_drop_ischema_result& operator=(const ThriftHiveMetastore_drop_ischema_result&);
+ ThriftHiveMetastore_drop_ischema_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_drop_ischema_result() throw();
+ NoSuchObjectException o1;
+ InvalidOperationException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_drop_ischema_result__isset __isset;
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const InvalidOperationException& val);
+
+ void __set_o3(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_drop_ischema_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ if (!(o3 == rhs.o3))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_drop_ischema_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_drop_ischema_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_ischema_presult__isset {
+ _ThriftHiveMetastore_drop_ischema_presult__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_drop_ischema_presult__isset;
+
+class ThriftHiveMetastore_drop_ischema_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_drop_ischema_presult() throw();
+ NoSuchObjectException o1;
+ InvalidOperationException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_drop_ischema_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_add_schema_version_args__isset {
+ _ThriftHiveMetastore_add_schema_version_args__isset() : schemaVersion(false) {}
+ bool schemaVersion :1;
+} _ThriftHiveMetastore_add_schema_version_args__isset;
+
+class ThriftHiveMetastore_add_schema_version_args {
+ public:
+
+ ThriftHiveMetastore_add_schema_version_args(const ThriftHiveMetastore_add_schema_version_args&);
+ ThriftHiveMetastore_add_schema_version_args& operator=(const ThriftHiveMetastore_add_schema_version_args&);
+ ThriftHiveMetastore_add_schema_version_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_add_schema_version_args() throw();
+ SchemaVersion schemaVersion;
+
+ _ThriftHiveMetastore_add_schema_version_args__isset __isset;
+
+ void __set_schemaVersion(const SchemaVersion& val);
+
+ bool operator == (const ThriftHiveMetastore_add_schema_version_args & rhs) const
+ {
+ if (!(schemaVersion == rhs.schemaVersion))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_add_schema_version_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_add_schema_version_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_add_schema_version_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_add_schema_version_pargs() throw();
+ const SchemaVersion* schemaVersion;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_schema_version_result__isset {
+ _ThriftHiveMetastore_add_schema_version_result__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_add_schema_version_result__isset;
+
+class ThriftHiveMetastore_add_schema_version_result {
+ public:
+
+ ThriftHiveMetastore_add_schema_version_result(const ThriftHiveMetastore_add_schema_version_result&);
+ ThriftHiveMetastore_add_schema_version_result& operator=(const ThriftHiveMetastore_add_schema_version_result&);
+ ThriftHiveMetastore_add_schema_version_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_add_schema_version_result() throw();
+ AlreadyExistsException o1;
+ NoSuchObjectException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_add_schema_version_result__isset __isset;
+
+ void __set_o1(const AlreadyExistsException& val);
+
+ void __set_o2(const NoSuchObjectException& val);
+
+ void __set_o3(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_add_schema_version_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ if (!(o3 == rhs.o3))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_add_schema_version_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_add_schema_version_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_schema_version_presult__isset {
+ _ThriftHiveMetastore_add_schema_version_presult__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_add_schema_version_presult__isset;
+
+class ThriftHiveMetastore_add_schema_version_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_add_schema_version_presult() throw();
+ AlreadyExistsException o1;
+ NoSuchObjectException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_add_schema_version_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_version_args__isset {
+ _ThriftHiveMetastore_get_schema_version_args__isset() : schemaName(false), version(false) {}
+ bool schemaName :1;
+ bool version :1;
+} _ThriftHiveMetastore_get_schema_version_args__isset;
+
+class ThriftHiveMetastore_get_schema_version_args {
+ public:
+
+ ThriftHiveMetastore_get_schema_version_args(const ThriftHiveMetastore_get_schema_version_args&);
+ ThriftHiveMetastore_get_schema_version_args& operator=(const ThriftHiveMetastore_get_schema_version_args&);
+ ThriftHiveMetastore_get_schema_version_args() : schemaName(), version(0) {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schema_version_args() throw();
+ std::string schemaName;
+ int32_t version;
+
+ _ThriftHiveMetastore_get_schema_version_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ void __set_version(const int32_t val);
+
+ bool operator == (const ThriftHiveMetastore_get_schema_version_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ if (!(version == rhs.version))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schema_version_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schema_version_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_schema_version_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schema_version_pargs() throw();
+ const std::string* schemaName;
+ const int32_t* version;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_version_result__isset {
+ _ThriftHiveMetastore_get_schema_version_result__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_schema_version_result__isset;
+
+class ThriftHiveMetastore_get_schema_version_result {
+ public:
+
+ ThriftHiveMetastore_get_schema_version_result(const ThriftHiveMetastore_get_schema_version_result&);
+ ThriftHiveMetastore_get_schema_version_result& operator=(const ThriftHiveMetastore_get_schema_version_result&);
+ ThriftHiveMetastore_get_schema_version_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schema_version_result() throw();
+ SchemaVersion success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_schema_version_result__isset __isset;
+
+ void __set_success(const SchemaVersion& val);
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schema_version_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schema_version_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schema_version_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_version_presult__isset {
+ _ThriftHiveMetastore_get_schema_version_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_schema_version_presult__isset;
+
+class ThriftHiveMetastore_get_schema_version_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schema_version_presult() throw();
+ SchemaVersion* success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_schema_version_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_latest_version_args__isset {
+ _ThriftHiveMetastore_get_schema_latest_version_args__isset() : schemaName(false) {}
+ bool schemaName :1;
+} _ThriftHiveMetastore_get_schema_latest_version_args__isset;
+
+class ThriftHiveMetastore_get_schema_latest_version_args {
+ public:
+
+ ThriftHiveMetastore_get_schema_latest_version_args(const ThriftHiveMetastore_get_schema_latest_version_args&);
+ ThriftHiveMetastore_get_schema_latest_version_args& operator=(const ThriftHiveMetastore_get_schema_latest_version_args&);
+ ThriftHiveMetastore_get_schema_latest_version_args() : schemaName() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schema_latest_version_args() throw();
+ std::string schemaName;
+
+ _ThriftHiveMetastore_get_schema_latest_version_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schema_latest_version_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schema_latest_version_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schema_latest_version_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_schema_latest_version_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schema_latest_version_pargs() throw();
+ const std::string* schemaName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_latest_version_result__isset {
+ _ThriftHiveMetastore_get_schema_latest_version_result__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_schema_latest_version_result__isset;
+
+class ThriftHiveMetastore_get_schema_latest_version_result {
+ public:
+
+ ThriftHiveMetastore_get_schema_latest_version_result(const ThriftHiveMetastore_get_schema_latest_version_result&);
+ ThriftHiveMetastore_get_schema_latest_version_result& operator=(const ThriftHiveMetastore_get_schema_latest_version_result&);
+ ThriftHiveMetastore_get_schema_latest_version_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schema_latest_version_result() throw();
+ SchemaVersion success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_schema_latest_version_result__isset __isset;
+
+ void __set_success(const SchemaVersion& val);
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schema_latest_version_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schema_latest_version_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schema_latest_version_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_latest_version_presult__isset {
+ _ThriftHiveMetastore_get_schema_latest_version_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_schema_latest_version_presult__isset;
+
+class ThriftHiveMetastore_get_schema_latest_version_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schema_latest_version_presult() throw();
+ SchemaVersion* success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_schema_latest_version_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_all_versions_args__isset {
+ _ThriftHiveMetastore_get_schema_all_versions_args__isset() : schemaName(false) {}
+ bool schemaName :1;
+} _ThriftHiveMetastore_get_schema_all_versions_args__isset;
+
+class ThriftHiveMetastore_get_schema_all_versions_args {
+ public:
+
+ ThriftHiveMetastore_get_schema_all_versions_args(const ThriftHiveMetastore_get_schema_all_versions_args&);
+ ThriftHiveMetastore_get_schema_all_versions_args& operator=(const ThriftHiveMetastore_get_schema_all_versions_args&);
+ ThriftHiveMetastore_get_schema_all_versions_args() : schemaName() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schema_all_versions_args() throw();
+ std::string schemaName;
+
+ _ThriftHiveMetastore_get_schema_all_versions_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schema_all_versions_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schema_all_versions_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schema_all_versions_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_schema_all_versions_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schema_all_versions_pargs() throw();
+ const std::string* schemaName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_all_versions_result__isset {
+ _ThriftHiveMetastore_get_schema_all_versions_result__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_schema_all_versions_result__isset;
+
+class ThriftHiveMetastore_get_schema_all_versions_result {
+ public:
+
+ ThriftHiveMetastore_get_schema_all_versions_result(const ThriftHiveMetastore_get_schema_all_versions_result&);
+ ThriftHiveMetastore_get_schema_all_versions_result& operator=(const ThriftHiveMetastore_get_schema_all_versions_result&);
+ ThriftHiveMetastore_get_schema_all_versions_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schema_all_versions_result() throw();
+ std::vector<SchemaVersion> success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_schema_all_versions_result__isset __isset;
+
+ void __set_success(const std::vector<SchemaVersion> & val);
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schema_all_versions_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schema_all_versions_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schema_all_versions_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schema_all_versions_presult__isset {
+ _ThriftHiveMetastore_get_schema_all_versions_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_schema_all_versions_presult__isset;
+
+class ThriftHiveMetastore_get_schema_all_versions_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schema_all_versions_presult() throw();
+ std::vector<SchemaVersion> * success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_schema_all_versions_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_schema_version_args__isset {
+ _ThriftHiveMetastore_drop_schema_version_args__isset() : schemaName(false), version(false) {}
+ bool schemaName :1;
+ bool version :1;
+} _ThriftHiveMetastore_drop_schema_version_args__isset;
+
+class ThriftHiveMetastore_drop_schema_version_args {
+ public:
+
+ ThriftHiveMetastore_drop_schema_version_args(const ThriftHiveMetastore_drop_schema_version_args&);
+ ThriftHiveMetastore_drop_schema_version_args& operator=(const ThriftHiveMetastore_drop_schema_version_args&);
+ ThriftHiveMetastore_drop_schema_version_args() : schemaName(), version(0) {
+ }
+
+ virtual ~ThriftHiveMetastore_drop_schema_version_args() throw();
+ std::string schemaName;
+ int32_t version;
+
+ _ThriftHiveMetastore_drop_schema_version_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ void __set_version(const int32_t val);
+
+ bool operator == (const ThriftHiveMetastore_drop_schema_version_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ if (!(version == rhs.version))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_drop_schema_version_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_drop_schema_version_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_drop_schema_version_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_drop_schema_version_pargs() throw();
+ const std::string* schemaName;
+ const int32_t* version;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_schema_version_result__isset {
+ _ThriftHiveMetastore_drop_schema_version_result__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_drop_schema_version_result__isset;
+
+class ThriftHiveMetastore_drop_schema_version_result {
+ public:
+
+ ThriftHiveMetastore_drop_schema_version_result(const ThriftHiveMetastore_drop_schema_version_result&);
+ ThriftHiveMetastore_drop_schema_version_result& operator=(const ThriftHiveMetastore_drop_schema_version_result&);
+ ThriftHiveMetastore_drop_schema_version_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_drop_schema_version_result() throw();
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_drop_schema_version_result__isset __isset;
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_drop_schema_version_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_drop_schema_version_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_drop_schema_version_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_schema_version_presult__isset {
+ _ThriftHiveMetastore_drop_schema_version_presult__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_drop_schema_version_presult__isset;
+
+class ThriftHiveMetastore_drop_schema_version_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_drop_schema_version_presult() throw();
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_drop_schema_version_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schemas_by_cols_args__isset {
+ _ThriftHiveMetastore_get_schemas_by_cols_args__isset() : rqst(false) {}
+ bool rqst :1;
+} _ThriftHiveMetastore_get_schemas_by_cols_args__isset;
+
+class ThriftHiveMetastore_get_schemas_by_cols_args {
+ public:
+
+ ThriftHiveMetastore_get_schemas_by_cols_args(const ThriftHiveMetastore_get_schemas_by_cols_args&);
+ ThriftHiveMetastore_get_schemas_by_cols_args& operator=(const ThriftHiveMetastore_get_schemas_by_cols_args&);
+ ThriftHiveMetastore_get_schemas_by_cols_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schemas_by_cols_args() throw();
+ FindSchemasByColsRqst rqst;
+
+ _ThriftHiveMetastore_get_schemas_by_cols_args__isset __isset;
+
+ void __set_rqst(const FindSchemasByColsRqst& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schemas_by_cols_args & rhs) const
+ {
+ if (!(rqst == rhs.rqst))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schemas_by_cols_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schemas_by_cols_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_schemas_by_cols_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schemas_by_cols_pargs() throw();
+ const FindSchemasByColsRqst* rqst;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schemas_by_cols_result__isset {
+ _ThriftHiveMetastore_get_schemas_by_cols_result__isset() : success(false), o1(false) {}
+ bool success :1;
+ bool o1 :1;
+} _ThriftHiveMetastore_get_schemas_by_cols_result__isset;
+
+class ThriftHiveMetastore_get_schemas_by_cols_result {
+ public:
+
+ ThriftHiveMetastore_get_schemas_by_cols_result(const ThriftHiveMetastore_get_schemas_by_cols_result&);
+ ThriftHiveMetastore_get_schemas_by_cols_result& operator=(const ThriftHiveMetastore_get_schemas_by_cols_result&);
+ ThriftHiveMetastore_get_schemas_by_cols_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_schemas_by_cols_result() throw();
+ FindSchemasByColsResp success;
+ MetaException o1;
+
+ _ThriftHiveMetastore_get_schemas_by_cols_result__isset __isset;
+
+ void __set_success(const FindSchemasByColsResp& val);
+
+ void __set_o1(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_schemas_by_cols_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_schemas_by_cols_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_schemas_by_cols_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_schemas_by_cols_presult__isset {
+ _ThriftHiveMetastore_get_schemas_by_cols_presult__isset() : success(false), o1(false) {}
+ bool success :1;
+ bool o1 :1;
+} _ThriftHiveMetastore_get_schemas_by_cols_presult__isset;
+
+class ThriftHiveMetastore_get_schemas_by_cols_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_schemas_by_cols_presult() throw();
+ FindSchemasByColsResp* success;
+ MetaException o1;
+
+ _ThriftHiveMetastore_get_schemas_by_cols_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_args__isset {
+ _ThriftHiveMetastore_map_schema_version_to_serde_args__isset() : schemaName(false), version(false), serdeName(false) {}
+ bool schemaName :1;
+ bool version :1;
+ bool serdeName :1;
+} _ThriftHiveMetastore_map_schema_version_to_serde_args__isset;
+
+class ThriftHiveMetastore_map_schema_version_to_serde_args {
+ public:
+
+ ThriftHiveMetastore_map_schema_version_to_serde_args(const ThriftHiveMetastore_map_schema_version_to_serde_args&);
+ ThriftHiveMetastore_map_schema_version_to_serde_args& operator=(const ThriftHiveMetastore_map_schema_version_to_serde_args&);
+ ThriftHiveMetastore_map_schema_version_to_serde_args() : schemaName(), version(0), serdeName() {
+ }
+
+ virtual ~ThriftHiveMetastore_map_schema_version_to_serde_args() throw();
+ std::string schemaName;
+ int32_t version;
+ std::string serdeName;
+
+ _ThriftHiveMetastore_map_schema_version_to_serde_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ void __set_version(const int32_t val);
+
+ void __set_serdeName(const std::string& val);
+
+ bool operator == (const ThriftHiveMetastore_map_schema_version_to_serde_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ if (!(version == rhs.version))
+ return false;
+ if (!(serdeName == rhs.serdeName))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_map_schema_version_to_serde_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_map_schema_version_to_serde_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_map_schema_version_to_serde_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_map_schema_version_to_serde_pargs() throw();
+ const std::string* schemaName;
+ const int32_t* version;
+ const std::string* serdeName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_result__isset {
+ _ThriftHiveMetastore_map_schema_version_to_serde_result__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_map_schema_version_to_serde_result__isset;
+
+class ThriftHiveMetastore_map_schema_version_to_serde_result {
+ public:
+
+ ThriftHiveMetastore_map_schema_version_to_serde_result(const ThriftHiveMetastore_map_schema_version_to_serde_result&);
+ ThriftHiveMetastore_map_schema_version_to_serde_result& operator=(const ThriftHiveMetastore_map_schema_version_to_serde_result&);
+ ThriftHiveMetastore_map_schema_version_to_serde_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_map_schema_version_to_serde_result() throw();
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_map_schema_version_to_serde_result__isset __isset;
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_map_schema_version_to_serde_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_map_schema_version_to_serde_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_map_schema_version_to_serde_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset {
+ _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset;
+
+class ThriftHiveMetastore_map_schema_version_to_serde_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_map_schema_version_to_serde_presult() throw();
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_set_schema_version_state_args__isset {
+ _ThriftHiveMetastore_set_schema_version_state_args__isset() : schemaName(false), version(false), state(false) {}
+ bool schemaName :1;
+ bool version :1;
+ bool state :1;
+} _ThriftHiveMetastore_set_schema_version_state_args__isset;
+
+class ThriftHiveMetastore_set_schema_version_state_args {
+ public:
+
+ ThriftHiveMetastore_set_schema_version_state_args(const ThriftHiveMetastore_set_schema_version_state_args&);
+ ThriftHiveMetastore_set_schema_version_state_args& operator=(const ThriftHiveMetastore_set_schema_version_state_args&);
+ ThriftHiveMetastore_set_schema_version_state_args() : schemaName(), version(0), state((SchemaVersionState::type)0) {
+ }
+
+ virtual ~ThriftHiveMetastore_set_schema_version_state_args() throw();
+ std::string schemaName;
+ int32_t version;
+ SchemaVersionState::type state;
+
+ _ThriftHiveMetastore_set_schema_version_state_args__isset __isset;
+
+ void __set_schemaName(const std::string& val);
+
+ void __set_version(const int32_t val);
+
+ void __set_state(const SchemaVersionState::type val);
+
+ bool operator == (const ThriftHiveMetastore_set_schema_version_state_args & rhs) const
+ {
+ if (!(schemaName == rhs.schemaName))
+ return false;
+ if (!(version == rhs.version))
+ return false;
+ if (!(state == rhs.state))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_set_schema_version_state_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_set_schema_version_state_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_set_schema_version_state_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_set_schema_version_state_pargs() throw();
+ const std::string* schemaName;
+ const int32_t* version;
+ const SchemaVersionState::type* state;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_set_schema_version_state_result__isset {
+ _ThriftHiveMetastore_set_schema_version_state_result__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_set_schema_version_state_result__isset;
+
+class ThriftHiveMetastore_set_schema_version_state_result {
+ public:
+
+ ThriftHiveMetastore_set_schema_version_state_result(const ThriftHiveMetastore_set_schema_version_state_result&);
+ ThriftHiveMetastore_set_schema_version_state_result& operator=(const ThriftHiveMetastore_set_schema_version_state_result&);
+ ThriftHiveMetastore_set_schema_version_state_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_set_schema_version_state_result() throw();
+ NoSuchObjectException o1;
+ InvalidOperationException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_set_schema_version_state_result__isset __isset;
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const InvalidOperationException& val);
+
+ void __set_o3(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_set_schema_version_state_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ if (!(o3 == rhs.o3))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_set_schema_version_state_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_set_schema_version_state_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_set_schema_version_state_presult__isset {
+ _ThriftHiveMetastore_set_schema_version_state_presult__isset() : o1(false), o2(false), o3(false) {}
+ bool o1 :1;
+ bool o2 :1;
+ bool o3 :1;
+} _ThriftHiveMetastore_set_schema_version_state_presult__isset;
+
+class ThriftHiveMetastore_set_schema_version_state_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_set_schema_version_state_presult() throw();
+ NoSuchObjectException o1;
+ InvalidOperationException o2;
+ MetaException o3;
+
+ _ThriftHiveMetastore_set_schema_version_state_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_add_serde_args__isset {
+ _ThriftHiveMetastore_add_serde_args__isset() : serde(false) {}
+ bool serde :1;
+} _ThriftHiveMetastore_add_serde_args__isset;
+
+class ThriftHiveMetastore_add_serde_args {
+ public:
+
+ ThriftHiveMetastore_add_serde_args(const ThriftHiveMetastore_add_serde_args&);
+ ThriftHiveMetastore_add_serde_args& operator=(const ThriftHiveMetastore_add_serde_args&);
+ ThriftHiveMetastore_add_serde_args() {
+ }
+
+ virtual ~ThriftHiveMetastore_add_serde_args() throw();
+ SerDeInfo serde;
+
+ _ThriftHiveMetastore_add_serde_args__isset __isset;
+
+ void __set_serde(const SerDeInfo& val);
+
+ bool operator == (const ThriftHiveMetastore_add_serde_args & rhs) const
+ {
+ if (!(serde == rhs.serde))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_add_serde_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_add_serde_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_add_serde_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_add_serde_pargs() throw();
+ const SerDeInfo* serde;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_serde_result__isset {
+ _ThriftHiveMetastore_add_serde_result__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_add_serde_result__isset;
+
+class ThriftHiveMetastore_add_serde_result {
+ public:
+
+ ThriftHiveMetastore_add_serde_result(const ThriftHiveMetastore_add_serde_result&);
+ ThriftHiveMetastore_add_serde_result& operator=(const ThriftHiveMetastore_add_serde_result&);
+ ThriftHiveMetastore_add_serde_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_add_serde_result() throw();
+ AlreadyExistsException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_add_serde_result__isset __isset;
+
+ void __set_o1(const AlreadyExistsException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_add_serde_result & rhs) const
+ {
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_add_serde_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_add_serde_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_serde_presult__isset {
+ _ThriftHiveMetastore_add_serde_presult__isset() : o1(false), o2(false) {}
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_add_serde_presult__isset;
+
+class ThriftHiveMetastore_add_serde_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_add_serde_presult() throw();
+ AlreadyExistsException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_add_serde_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_serde_args__isset {
+ _ThriftHiveMetastore_get_serde_args__isset() : serdeName(false) {}
+ bool serdeName :1;
+} _ThriftHiveMetastore_get_serde_args__isset;
+
+class ThriftHiveMetastore_get_serde_args {
+ public:
+
+ ThriftHiveMetastore_get_serde_args(const ThriftHiveMetastore_get_serde_args&);
+ ThriftHiveMetastore_get_serde_args& operator=(const ThriftHiveMetastore_get_serde_args&);
+ ThriftHiveMetastore_get_serde_args() : serdeName() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_serde_args() throw();
+ std::string serdeName;
+
+ _ThriftHiveMetastore_get_serde_args__isset __isset;
+
+ void __set_serdeName(const std::string& val);
+
+ bool operator == (const ThriftHiveMetastore_get_serde_args & rhs) const
+ {
+ if (!(serdeName == rhs.serdeName))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_serde_args &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_serde_args & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_serde_pargs {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_serde_pargs() throw();
+ const std::string* serdeName;
+
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_serde_result__isset {
+ _ThriftHiveMetastore_get_serde_result__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_serde_result__isset;
+
+class ThriftHiveMetastore_get_serde_result {
+ public:
+
+ ThriftHiveMetastore_get_serde_result(const ThriftHiveMetastore_get_serde_result&);
+ ThriftHiveMetastore_get_serde_result& operator=(const ThriftHiveMetastore_get_serde_result&);
+ ThriftHiveMetastore_get_serde_result() {
+ }
+
+ virtual ~ThriftHiveMetastore_get_serde_result() throw();
+ SerDeInfo success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_serde_result__isset __isset;
+
+ void __set_success(const SerDeInfo& val);
+
+ void __set_o1(const NoSuchObjectException& val);
+
+ void __set_o2(const MetaException& val);
+
+ bool operator == (const ThriftHiveMetastore_get_serde_result & rhs) const
+ {
+ if (!(success == rhs.success))
+ return false;
+ if (!(o1 == rhs.o1))
+ return false;
+ if (!(o2 == rhs.o2))
+ return false;
+ return true;
+ }
+ bool operator != (const ThriftHiveMetastore_get_serde_result &rhs) const {
+ return !(*this == rhs);
+ }
+
+ bool operator < (const ThriftHiveMetastore_get_serde_result & ) const;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+ uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_serde_presult__isset {
+ _ThriftHiveMetastore_get_serde_presult__isset() : success(false), o1(false), o2(false) {}
+ bool success :1;
+ bool o1 :1;
+ bool o2 :1;
+} _ThriftHiveMetastore_get_serde_presult__isset;
+
+class ThriftHiveMetastore_get_serde_presult {
+ public:
+
+
+ virtual ~ThriftHiveMetastore_get_serde_presult() throw();
+ SerDeInfo* success;
+ NoSuchObjectException o1;
+ MetaException o2;
+
+ _ThriftHiveMetastore_get_serde_presult__isset __isset;
+
+ uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public ::facebook::fb303::FacebookServiceClient {
+ public:
+ ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
+ ::facebook::fb303::FacebookServiceClient(prot, prot) {}
+ ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : ::facebook::fb303::FacebookServiceClient(iprot, oprot) {}
+ boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+ return piprot_;
+ }
+ boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+ return poprot_;
+ }
+ void getMetaConf(std::string& _return, const std::string& key);
+ void send_getMetaConf(const std::string& key);
+ void recv_getMetaConf(std::string& _return);
+ void setMetaConf(const std::string& key, const std::string& value);
+ void send_setMetaConf(const std::string& key, const std::string& value);
+ void recv_setMetaConf();
+ void create_database(const Database& database);
+ void send_create_database(const Database& database);
+ void recv_create_database();
+ void get_database(Database& _return, const std::string& name);
+ void send_get_database(const std::string& name);
+ void recv_get_database(Database& _return);
+ void drop_database(const std::string& name, const bool deleteData, const bool cascade);
+ void send_drop_database(const std::string& name, const bool deleteData, const bool cascade);
+ void recv_drop_database();
+ void get_databases(std::vector<std::string> & _return, const std::string& pattern);
+ void send_get_databases(const std::string& pattern);
+ void recv_get_databases(std::vector<std::string> & _return);
+ void get_all_databases(std::vector<std::string> & _return);
+ void send_get_all_databases();
+ void recv_get_all_databases(std::vector<std::string> & _return);
+ void alter_database(const std::string& dbname, const Database& db);
+ void send_alter_database(const std::string& dbname, const Database& db);
+ void recv_alter_database();
+ void get_type(Type& _return, const std::string& name);
+ void send_get_type(const std::string& name);
+ void recv_get_type(Type& _return);
+ bool create_type(const Type& type);
+ void send_create_type(const Type& type);
+ bool recv_create_type();
+ bool drop_type(const std::string& type);
+ void send_drop_type(const std::string& type);
+ bool recv_drop_type();
+ void get_type_all(std::map<std::string, Type> & _return, const std::string& name);
+ void send_get_type_all(const std::string& name);
+ void recv_get_type_all(std::map<std::string, Type> & _return);
+ void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
+ void send_get_fields(const std::string& db_name, const std::string& table_name);
+ void recv_get_fields(std::vector<FieldSchema> & _return);
+ void get_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
+ void send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
+ void recv_get_fields_with_environment_context(std::vector<FieldSchema> & _return);
+ void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
+ void send_get_schema(const std::string& db_name, const std::string& table_name);
+ void recv_get_schema(std::vector<FieldSchema> & _return);
+ void get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
+ void send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
+ void recv_get_schema_with_environment_context(std::vector<FieldSchema> & _return);
+ void create_table(const Table& tbl);
+ void send_create_table(const Table& tbl);
+ void recv_create_table();
+ void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
+ void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
+ void recv_create_table_with_environment_context();
+ void create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints);
+ void send_create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints);
+ void recv_create_table_with_constraints();
+ void drop_constraint(const DropConstraintRequest& req);
+ void send_drop_constraint(const DropConstraintRequest& req);
+ void recv_drop_constraint();
+ void add_primary_key(const AddPrimaryKeyRequest& req);
+ void send_add_primary_key(const AddPrimaryKeyRequest& req);
+ void recv_add_primary_key();
+ void add_foreign_key(const AddForeignKeyRequest& req);
+ void send_add_foreign_key(const AddForeignKeyRequest& req);
+ void recv_add_foreign_key();
+ void add_unique_constraint(const AddUniqueConstraintRequest& req);
+ void send_add_unique_constraint(const AddUniqueConstraintRequest& req);
+ void recv_add_unique_constraint();
+ void add_not_null_constraint(const AddNotNullConstraintRequest& req);
+ void send_add_not_null_constraint(const AddNotNullConstraintRequest& req);
+ void recv_add_not_null_constraint();
+ void drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
+ void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
+ void recv_drop_table();
+ void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
+ void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
+ void recv_drop_table_with_environment_context();
+ void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames);
+ void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames);
+ void recv_truncate_table();
+ void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern);
+ void send_get_tables(const std::string& db_name, const std::string& pattern);
+ void recv_get_tables(std::vector<std::string> & _return);
+ void get_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType);
+ void send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType);
+ void recv_get_tables_by_type(std::vector<std::string> & _return);
+ void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name);
+ void send_get_materialized_views_for_rewriting(const std::string& db_name);
+ void recv_get_materialized_views_for_rewriting(std::vector<std::string> & _return);
+ void get_table_meta(std::vector<TableMeta> & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types);
+ void send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types);
+ void recv_get_table_meta(std::vector<TableMeta> & _return);
+ void get_all_tables(std::vector<std::string> & _return, const std::string& db_name);
+ void send_get_all_tables(const std::string& db_name);
+ void recv_get_all_tables(std::vector<std::string> & _return);
+ void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name);
+ void send_get_table(const std::string& dbname, const std::string& tbl_name);
+ void recv_get_table(Table& _return);
+ void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
+ void send_get_table_objects_by_name(const std::string& dbname, const std::vector<std::string> & tbl_names);
+ void recv_get_table_objects_by_name(std::vector<Table> & _return);
+ void get_table_req(GetTableResult& _return, const GetTableRequest& req);
+ void send_get_table_req(const GetTableRequest& req);
+ void recv_get_table_req(GetTableResult& _return);
+ void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req);
+ void send_get_table_objects_by_name_req(const GetTablesRequest& req);
+ void recv_get_table_objects_by_name_req(GetTablesResult& _return);
+ void get_materialization_invalidation_info(std::map<std::string, Materialization> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
+ void send_get_materialization_invalidation_info(const std::string& dbname, const std::vector<std::string> & tbl_names);
+ void recv_get_materialization_invalidation_info(std::map<std::string, Materialization> & _return);
+ void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables);
+ void send_get_table_names_by_filter(const std::string
<TRUNCATED>