http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/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 0f9ba5d..7206e29 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h @@ -202,6 +202,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 AlterISchemaRequest& rqst) = 0; + virtual void get_ischema(ISchema& _return, const ISchemaName& name) = 0; + virtual void drop_ischema(const ISchemaName& name) = 0; + virtual void add_schema_version(const SchemaVersion& schemaVersion) = 0; + virtual void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) = 0; + virtual void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) = 0; + virtual void get_schema_all_versions(std::vector<SchemaVersion> & _return, const ISchemaName& schemaName) = 0; + virtual void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) = 0; + virtual void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) = 0; + virtual void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) = 0; + virtual void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) = 0; + virtual void add_serde(const SerDeInfo& serde) = 0; + virtual void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) = 0; }; class ThriftHiveMetastoreIfFactory : virtual public ::facebook::fb303::FacebookServiceIfFactory { @@ -798,6 +812,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 AlterISchemaRequest& /* rqst */) { + return; + } + void get_ischema(ISchema& /* _return */, const ISchemaName& /* name */) { + return; + } + void drop_ischema(const ISchemaName& /* name */) { + return; + } + void add_schema_version(const SchemaVersion& /* schemaVersion */) { + return; + } + void get_schema_version(SchemaVersion& /* _return */, const SchemaVersionDescriptor& /* schemaVersion */) { + return; + } + void get_schema_latest_version(SchemaVersion& /* _return */, const ISchemaName& /* schemaName */) { + return; + } + void get_schema_all_versions(std::vector<SchemaVersion> & /* _return */, const ISchemaName& /* schemaName */) { + return; + } + void drop_schema_version(const SchemaVersionDescriptor& /* schemaVersion */) { + return; + } + void get_schemas_by_cols(FindSchemasByColsResp& /* _return */, const FindSchemasByColsRqst& /* rqst */) { + return; + } + void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& /* rqst */) { + return; + } + void set_schema_version_state(const SetSchemaVersionStateRequest& /* rqst */) { + return; + } + void add_serde(const SerDeInfo& /* serde */) { + return; + } + void get_serde(SerDeInfo& /* _return */, const GetSerdeRequest& /* rqst */) { + return; + } }; typedef struct _ThriftHiveMetastore_getMetaConf_args__isset { @@ -22973,228 +23029,1868 @@ 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, const std::vector<SQLDefaultConstraint> & defaultConstraints); - 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, const std::vector<SQLDefaultConstraint> & defaultConstraints); - 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 add_default_constraint(const AddDefaultConstraintRequest& req); - void send_add_default_constraint(const AddDefaultConstraintRequest& req); - void recv_add_default_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 update_creation_metadata(const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata); - void send_update_creation_metadata(const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata); - void recv_update_creation_metadata(); - 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); + 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() : rqst(false) {} + bool rqst :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() { + } + + virtual ~ThriftHiveMetastore_alter_ischema_args() throw(); + AlterISchemaRequest rqst; + + _ThriftHiveMetastore_alter_ischema_args__isset __isset; + + void __set_rqst(const AlterISchemaRequest& val); + + bool operator == (const ThriftHiveMetastore_alter_ischema_args & rhs) const + { + if (!(rqst == rhs.rqst)) + 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 AlterISchemaRequest* rqst; + + 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() : name(false) {} + bool name :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() { + } + + virtual ~ThriftHiveMetastore_get_ischema_args() throw(); + ISchemaName name; + + _ThriftHiveMetastore_get_ischema_args__isset __isset; + + void __set_name(const ISchemaName& val); + + bool operator == (const ThriftHiveMetastore_get_ischema_args & rhs) const + { + if (!(name == rhs.name)) + 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 ISchemaName* name; + + 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() : name(false) {} + bool name :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() { + } + + virtual ~ThriftHiveMetastore_drop_ischema_args() throw(); + ISchemaName name; + + _ThriftHiveMetastore_drop_ischema_args__isset __isset; + + void __set_name(const ISchemaName& val); + + bool operator == (const ThriftHiveMetastore_drop_ischema_args & rhs) const + { + if (!(name == rhs.name)) + 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 ISchemaName* name; + + 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() : schemaVersion(false) {} + bool schemaVersion :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() { + } + + virtual ~ThriftHiveMetastore_get_schema_version_args() throw(); + SchemaVersionDescriptor schemaVersion; + + _ThriftHiveMetastore_get_schema_version_args__isset __isset; + + void __set_schemaVersion(const SchemaVersionDescriptor& val); + + bool operator == (const ThriftHiveMetastore_get_schema_version_args & rhs) const + { + if (!(schemaVersion == rhs.schemaVersion)) + 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 SchemaVersionDescriptor* schemaVersion; + + 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() { + } + + virtual ~ThriftHiveMetastore_get_schema_latest_version_args() throw(); + ISchemaName schemaName; + + _ThriftHiveMetastore_get_schema_latest_version_args__isset __isset; + + void __set_schemaName(const ISchemaName& 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 ISchemaName* 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() { + } + + virtual ~ThriftHiveMetastore_get_schema_all_versions_args() throw(); + ISchemaName schemaName; + + _ThriftHiveMetastore_get_schema_all_versions_args__isset __isset; + + void __set_schemaName(const ISchemaName& 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 ISchemaName* 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() : schemaVersion(false) {} + bool schemaVersion :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() { + } + + virtual ~ThriftHiveMetastore_drop_schema_version_args() throw(); + SchemaVersionDescriptor schemaVersion; + + _ThriftHiveMetastore_drop_schema_version_args__isset __isset; + + void __set_schemaVersion(const SchemaVersionDescriptor& val); + + bool operator == (const ThriftHiveMetastore_drop_schema_version_args & rhs) const + { + if (!(schemaVersion == rhs.schemaVersion)) + 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 SchemaVersionDescriptor* schemaVersion; + + 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() : rqst(false) {} + bool rqst :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() { + } + + virtual ~ThriftHiveMetastore_map_schema_version_to_serde_args() throw(); + MapSchemaVersionToSerdeRequest rqst; + + _ThriftHiveMetastore_map_schema_version_to_serde_args__isset __isset; + + void __set_rqst(const MapSchemaVersionToSerdeRequest& val); + + bool operator == (const ThriftHiveMetastore_map_schema_version_to_serde_args & rhs) const + { + if (!(rqst == rhs.rqst)) + 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 MapSchemaVersionToSerdeRequest* rqst; + + 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() : rqst(false) {} + bool rqst :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() { + } + + virtual ~ThriftHiveMetastore_set_schema_version_state_args() throw(); + SetSchemaVersionStateRequest rqst; + + _ThriftHiveMetastore_set_schema_version_state_args__isset __isset; + + void __set_rqst(const SetSchemaVersionStateRequest& val); + + bool operator == (const ThriftHiveMetastore_set_schema_version_state_args & rhs) const + { + if (!(rqst == rhs.rqst)) + 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 SetSchemaVersionStateRequest* rqst; + + 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() : rqst(false) {} + bool rqst :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() { + } + + virtual ~ThriftHiveMetastore_get_serde_args() throw(); + GetSerdeRequest rqst; + + _ThriftHiveMetastore_get_serde_args__isset __isset; + + void __set_rqst(const GetSerdeRequest& val); + + bool operator == (const ThriftHiveMetastore_get_serde_args & rhs) const + { + if (!(rqst == rhs.rqst)) + 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 GetSerdeRequest* rqst; + + 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, const std::vector<SQLDefaultConstraint> & defaultConstraints); + 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, const std::vector<SQLDefaultConstraint> & defaultConstraints); + 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 add_default_constraint(const AddDefaultConstraintRequest& req); + void send_add_default_constraint(const AddDefaultConstraintRequest& req); + void recv_add_default_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 update_creation_metadata(const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata); + void send_update_creation_metadata(const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata); + void recv_update_creation_metadata(); + 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
<TRUNCATED>