You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by se...@apache.org on 2018/07/13 01:40:49 UTC
[47/91] [abbrv] [partial] hive git commit: HIVE-20097 : Convert
standalone-metastore to a submodule (Alexander Kolbasov reviewed by Vihang
Karajgaonkar)
http://git-wip-us.apache.org/repos/asf/hive/blob/20eb7b51/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
new file mode 100644
index 0000000..789c150
--- /dev/null
+++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
@@ -0,0 +1,1079 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "ThriftHiveMetastore.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using boost::shared_ptr;
+
+using namespace ::Apache::Hadoop::Hive;
+
+class ThriftHiveMetastoreHandler : virtual public ThriftHiveMetastoreIf {
+ public:
+ ThriftHiveMetastoreHandler() {
+ // Your initialization goes here
+ }
+
+ void getMetaConf(std::string& _return, const std::string& key) {
+ // Your implementation goes here
+ printf("getMetaConf\n");
+ }
+
+ void setMetaConf(const std::string& key, const std::string& value) {
+ // Your implementation goes here
+ printf("setMetaConf\n");
+ }
+
+ void create_catalog(const CreateCatalogRequest& catalog) {
+ // Your implementation goes here
+ printf("create_catalog\n");
+ }
+
+ void alter_catalog(const AlterCatalogRequest& rqst) {
+ // Your implementation goes here
+ printf("alter_catalog\n");
+ }
+
+ void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) {
+ // Your implementation goes here
+ printf("get_catalog\n");
+ }
+
+ void get_catalogs(GetCatalogsResponse& _return) {
+ // Your implementation goes here
+ printf("get_catalogs\n");
+ }
+
+ void drop_catalog(const DropCatalogRequest& catName) {
+ // Your implementation goes here
+ printf("drop_catalog\n");
+ }
+
+ void create_database(const Database& database) {
+ // Your implementation goes here
+ printf("create_database\n");
+ }
+
+ void get_database(Database& _return, const std::string& name) {
+ // Your implementation goes here
+ printf("get_database\n");
+ }
+
+ void drop_database(const std::string& name, const bool deleteData, const bool cascade) {
+ // Your implementation goes here
+ printf("drop_database\n");
+ }
+
+ void get_databases(std::vector<std::string> & _return, const std::string& pattern) {
+ // Your implementation goes here
+ printf("get_databases\n");
+ }
+
+ void get_all_databases(std::vector<std::string> & _return) {
+ // Your implementation goes here
+ printf("get_all_databases\n");
+ }
+
+ void alter_database(const std::string& dbname, const Database& db) {
+ // Your implementation goes here
+ printf("alter_database\n");
+ }
+
+ void get_type(Type& _return, const std::string& name) {
+ // Your implementation goes here
+ printf("get_type\n");
+ }
+
+ bool create_type(const Type& type) {
+ // Your implementation goes here
+ printf("create_type\n");
+ }
+
+ bool drop_type(const std::string& type) {
+ // Your implementation goes here
+ printf("drop_type\n");
+ }
+
+ void get_type_all(std::map<std::string, Type> & _return, const std::string& name) {
+ // Your implementation goes here
+ printf("get_type_all\n");
+ }
+
+ void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) {
+ // Your implementation goes here
+ printf("get_fields\n");
+ }
+
+ void get_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("get_fields_with_environment_context\n");
+ }
+
+ void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) {
+ // Your implementation goes here
+ printf("get_schema\n");
+ }
+
+ void get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("get_schema_with_environment_context\n");
+ }
+
+ void create_table(const Table& tbl) {
+ // Your implementation goes here
+ printf("create_table\n");
+ }
+
+ void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("create_table_with_environment_context\n");
+ }
+
+ 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, const std::vector<SQLCheckConstraint> & checkConstraints) {
+ // Your implementation goes here
+ printf("create_table_with_constraints\n");
+ }
+
+ void drop_constraint(const DropConstraintRequest& req) {
+ // Your implementation goes here
+ printf("drop_constraint\n");
+ }
+
+ void add_primary_key(const AddPrimaryKeyRequest& req) {
+ // Your implementation goes here
+ printf("add_primary_key\n");
+ }
+
+ void add_foreign_key(const AddForeignKeyRequest& req) {
+ // Your implementation goes here
+ printf("add_foreign_key\n");
+ }
+
+ void add_unique_constraint(const AddUniqueConstraintRequest& req) {
+ // Your implementation goes here
+ printf("add_unique_constraint\n");
+ }
+
+ void add_not_null_constraint(const AddNotNullConstraintRequest& req) {
+ // Your implementation goes here
+ printf("add_not_null_constraint\n");
+ }
+
+ void add_default_constraint(const AddDefaultConstraintRequest& req) {
+ // Your implementation goes here
+ printf("add_default_constraint\n");
+ }
+
+ void add_check_constraint(const AddCheckConstraintRequest& req) {
+ // Your implementation goes here
+ printf("add_check_constraint\n");
+ }
+
+ void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) {
+ // Your implementation goes here
+ printf("drop_table\n");
+ }
+
+ void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("drop_table_with_environment_context\n");
+ }
+
+ void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames) {
+ // Your implementation goes here
+ printf("truncate_table\n");
+ }
+
+ void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) {
+ // Your implementation goes here
+ printf("get_tables\n");
+ }
+
+ void get_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) {
+ // Your implementation goes here
+ printf("get_tables_by_type\n");
+ }
+
+ void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name) {
+ // Your implementation goes here
+ printf("get_materialized_views_for_rewriting\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_table_meta\n");
+ }
+
+ void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) {
+ // Your implementation goes here
+ printf("get_all_tables\n");
+ }
+
+ void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name) {
+ // Your implementation goes here
+ printf("get_table\n");
+ }
+
+ void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) {
+ // Your implementation goes here
+ printf("get_table_objects_by_name\n");
+ }
+
+ void get_table_req(GetTableResult& _return, const GetTableRequest& req) {
+ // Your implementation goes here
+ printf("get_table_req\n");
+ }
+
+ void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) {
+ // Your implementation goes here
+ printf("get_table_objects_by_name_req\n");
+ }
+
+ void get_materialization_invalidation_info(std::map<std::string, Materialization> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) {
+ // Your implementation goes here
+ printf("get_materialization_invalidation_info\n");
+ }
+
+ void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) {
+ // Your implementation goes here
+ printf("update_creation_metadata\n");
+ }
+
+ void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) {
+ // Your implementation goes here
+ printf("get_table_names_by_filter\n");
+ }
+
+ void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) {
+ // Your implementation goes here
+ printf("alter_table\n");
+ }
+
+ void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("alter_table_with_environment_context\n");
+ }
+
+ void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) {
+ // Your implementation goes here
+ printf("alter_table_with_cascade\n");
+ }
+
+ void add_partition(Partition& _return, const Partition& new_part) {
+ // Your implementation goes here
+ printf("add_partition\n");
+ }
+
+ void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("add_partition_with_environment_context\n");
+ }
+
+ int32_t add_partitions(const std::vector<Partition> & new_parts) {
+ // Your implementation goes here
+ printf("add_partitions\n");
+ }
+
+ int32_t add_partitions_pspec(const std::vector<PartitionSpec> & new_parts) {
+ // Your implementation goes here
+ printf("add_partitions_pspec\n");
+ }
+
+ void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) {
+ // Your implementation goes here
+ printf("append_partition\n");
+ }
+
+ void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) {
+ // Your implementation goes here
+ printf("add_partitions_req\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("append_partition_with_environment_context\n");
+ }
+
+ void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) {
+ // Your implementation goes here
+ printf("append_partition_by_name\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("append_partition_by_name_with_environment_context\n");
+ }
+
+ bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData) {
+ // Your implementation goes here
+ printf("drop_partition\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("drop_partition_with_environment_context\n");
+ }
+
+ bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) {
+ // Your implementation goes here
+ printf("drop_partition_by_name\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("drop_partition_by_name_with_environment_context\n");
+ }
+
+ void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) {
+ // Your implementation goes here
+ printf("drop_partitions_req\n");
+ }
+
+ void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) {
+ // Your implementation goes here
+ printf("get_partition\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("exchange_partition\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("exchange_partitions\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_partition_with_auth\n");
+ }
+
+ void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) {
+ // Your implementation goes here
+ printf("get_partition_by_name\n");
+ }
+
+ void get_partitions(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) {
+ // Your implementation goes here
+ printf("get_partitions\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_partitions_with_auth\n");
+ }
+
+ void get_partitions_pspec(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) {
+ // Your implementation goes here
+ printf("get_partitions_pspec\n");
+ }
+
+ void get_partition_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) {
+ // Your implementation goes here
+ printf("get_partition_names\n");
+ }
+
+ void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) {
+ // Your implementation goes here
+ printf("get_partition_values\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_partitions_ps\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_partitions_ps_with_auth\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_partition_names_ps\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_partitions_by_filter\n");
+ }
+
+ 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) {
+ // Your implementation goes here
+ printf("get_part_specs_by_filter\n");
+ }
+
+ void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) {
+ // Your implementation goes here
+ printf("get_partitions_by_expr\n");
+ }
+
+ int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) {
+ // Your implementation goes here
+ printf("get_num_partitions_by_filter\n");
+ }
+
+ void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names) {
+ // Your implementation goes here
+ printf("get_partitions_by_names\n");
+ }
+
+ void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) {
+ // Your implementation goes here
+ printf("alter_partition\n");
+ }
+
+ void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts) {
+ // Your implementation goes here
+ printf("alter_partitions\n");
+ }
+
+ void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("alter_partitions_with_environment_context\n");
+ }
+
+ void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) {
+ // Your implementation goes here
+ printf("alter_partition_with_environment_context\n");
+ }
+
+ void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part) {
+ // Your implementation goes here
+ printf("rename_partition\n");
+ }
+
+ bool partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception) {
+ // Your implementation goes here
+ printf("partition_name_has_valid_characters\n");
+ }
+
+ void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) {
+ // Your implementation goes here
+ printf("get_config_value\n");
+ }
+
+ void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name) {
+ // Your implementation goes here
+ printf("partition_name_to_vals\n");
+ }
+
+ void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name) {
+ // Your implementation goes here
+ printf("partition_name_to_spec\n");
+ }
+
+ void markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) {
+ // Your implementation goes here
+ printf("markPartitionForEvent\n");
+ }
+
+ bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType) {
+ // Your implementation goes here
+ printf("isPartitionMarkedForEvent\n");
+ }
+
+ void get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) {
+ // Your implementation goes here
+ printf("get_primary_keys\n");
+ }
+
+ void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) {
+ // Your implementation goes here
+ printf("get_foreign_keys\n");
+ }
+
+ void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) {
+ // Your implementation goes here
+ printf("get_unique_constraints\n");
+ }
+
+ void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) {
+ // Your implementation goes here
+ printf("get_not_null_constraints\n");
+ }
+
+ void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) {
+ // Your implementation goes here
+ printf("get_default_constraints\n");
+ }
+
+ void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) {
+ // Your implementation goes here
+ printf("get_check_constraints\n");
+ }
+
+ bool update_table_column_statistics(const ColumnStatistics& stats_obj) {
+ // Your implementation goes here
+ printf("update_table_column_statistics\n");
+ }
+
+ bool update_partition_column_statistics(const ColumnStatistics& stats_obj) {
+ // Your implementation goes here
+ printf("update_partition_column_statistics\n");
+ }
+
+ void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) {
+ // Your implementation goes here
+ printf("get_table_column_statistics\n");
+ }
+
+ void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) {
+ // Your implementation goes here
+ printf("get_partition_column_statistics\n");
+ }
+
+ void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) {
+ // Your implementation goes here
+ printf("get_table_statistics_req\n");
+ }
+
+ void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) {
+ // Your implementation goes here
+ printf("get_partitions_statistics_req\n");
+ }
+
+ void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) {
+ // Your implementation goes here
+ printf("get_aggr_stats_for\n");
+ }
+
+ bool set_aggr_stats_for(const SetPartitionsStatsRequest& request) {
+ // Your implementation goes here
+ printf("set_aggr_stats_for\n");
+ }
+
+ bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name) {
+ // Your implementation goes here
+ printf("delete_partition_column_statistics\n");
+ }
+
+ bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) {
+ // Your implementation goes here
+ printf("delete_table_column_statistics\n");
+ }
+
+ void create_function(const Function& func) {
+ // Your implementation goes here
+ printf("create_function\n");
+ }
+
+ void drop_function(const std::string& dbName, const std::string& funcName) {
+ // Your implementation goes here
+ printf("drop_function\n");
+ }
+
+ void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) {
+ // Your implementation goes here
+ printf("alter_function\n");
+ }
+
+ void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) {
+ // Your implementation goes here
+ printf("get_functions\n");
+ }
+
+ void get_function(Function& _return, const std::string& dbName, const std::string& funcName) {
+ // Your implementation goes here
+ printf("get_function\n");
+ }
+
+ void get_all_functions(GetAllFunctionsResponse& _return) {
+ // Your implementation goes here
+ printf("get_all_functions\n");
+ }
+
+ bool create_role(const Role& role) {
+ // Your implementation goes here
+ printf("create_role\n");
+ }
+
+ bool drop_role(const std::string& role_name) {
+ // Your implementation goes here
+ printf("drop_role\n");
+ }
+
+ void get_role_names(std::vector<std::string> & _return) {
+ // Your implementation goes here
+ printf("get_role_names\n");
+ }
+
+ bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) {
+ // Your implementation goes here
+ printf("grant_role\n");
+ }
+
+ bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) {
+ // Your implementation goes here
+ printf("revoke_role\n");
+ }
+
+ void list_roles(std::vector<Role> & _return, const std::string& principal_name, const PrincipalType::type principal_type) {
+ // Your implementation goes here
+ printf("list_roles\n");
+ }
+
+ void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) {
+ // Your implementation goes here
+ printf("grant_revoke_role\n");
+ }
+
+ void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) {
+ // Your implementation goes here
+ printf("get_principals_in_role\n");
+ }
+
+ void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) {
+ // Your implementation goes here
+ printf("get_role_grants_for_principal\n");
+ }
+
+ void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector<std::string> & group_names) {
+ // Your implementation goes here
+ printf("get_privilege_set\n");
+ }
+
+ void list_privileges(std::vector<HiveObjectPrivilege> & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) {
+ // Your implementation goes here
+ printf("list_privileges\n");
+ }
+
+ bool grant_privileges(const PrivilegeBag& privileges) {
+ // Your implementation goes here
+ printf("grant_privileges\n");
+ }
+
+ bool revoke_privileges(const PrivilegeBag& privileges) {
+ // Your implementation goes here
+ printf("revoke_privileges\n");
+ }
+
+ void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) {
+ // Your implementation goes here
+ printf("grant_revoke_privileges\n");
+ }
+
+ void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) {
+ // Your implementation goes here
+ printf("refresh_privileges\n");
+ }
+
+ void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names) {
+ // Your implementation goes here
+ printf("set_ugi\n");
+ }
+
+ void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) {
+ // Your implementation goes here
+ printf("get_delegation_token\n");
+ }
+
+ int64_t renew_delegation_token(const std::string& token_str_form) {
+ // Your implementation goes here
+ printf("renew_delegation_token\n");
+ }
+
+ void cancel_delegation_token(const std::string& token_str_form) {
+ // Your implementation goes here
+ printf("cancel_delegation_token\n");
+ }
+
+ bool add_token(const std::string& token_identifier, const std::string& delegation_token) {
+ // Your implementation goes here
+ printf("add_token\n");
+ }
+
+ bool remove_token(const std::string& token_identifier) {
+ // Your implementation goes here
+ printf("remove_token\n");
+ }
+
+ void get_token(std::string& _return, const std::string& token_identifier) {
+ // Your implementation goes here
+ printf("get_token\n");
+ }
+
+ void get_all_token_identifiers(std::vector<std::string> & _return) {
+ // Your implementation goes here
+ printf("get_all_token_identifiers\n");
+ }
+
+ int32_t add_master_key(const std::string& key) {
+ // Your implementation goes here
+ printf("add_master_key\n");
+ }
+
+ void update_master_key(const int32_t seq_number, const std::string& key) {
+ // Your implementation goes here
+ printf("update_master_key\n");
+ }
+
+ bool remove_master_key(const int32_t key_seq) {
+ // Your implementation goes here
+ printf("remove_master_key\n");
+ }
+
+ void get_master_keys(std::vector<std::string> & _return) {
+ // Your implementation goes here
+ printf("get_master_keys\n");
+ }
+
+ void get_open_txns(GetOpenTxnsResponse& _return) {
+ // Your implementation goes here
+ printf("get_open_txns\n");
+ }
+
+ void get_open_txns_info(GetOpenTxnsInfoResponse& _return) {
+ // Your implementation goes here
+ printf("get_open_txns_info\n");
+ }
+
+ void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) {
+ // Your implementation goes here
+ printf("open_txns\n");
+ }
+
+ void abort_txn(const AbortTxnRequest& rqst) {
+ // Your implementation goes here
+ printf("abort_txn\n");
+ }
+
+ void abort_txns(const AbortTxnsRequest& rqst) {
+ // Your implementation goes here
+ printf("abort_txns\n");
+ }
+
+ void commit_txn(const CommitTxnRequest& rqst) {
+ // Your implementation goes here
+ printf("commit_txn\n");
+ }
+
+ void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) {
+ // Your implementation goes here
+ printf("repl_tbl_writeid_state\n");
+ }
+
+ void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) {
+ // Your implementation goes here
+ printf("get_valid_write_ids\n");
+ }
+
+ void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) {
+ // Your implementation goes here
+ printf("allocate_table_write_ids\n");
+ }
+
+ void lock(LockResponse& _return, const LockRequest& rqst) {
+ // Your implementation goes here
+ printf("lock\n");
+ }
+
+ void check_lock(LockResponse& _return, const CheckLockRequest& rqst) {
+ // Your implementation goes here
+ printf("check_lock\n");
+ }
+
+ void unlock(const UnlockRequest& rqst) {
+ // Your implementation goes here
+ printf("unlock\n");
+ }
+
+ void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) {
+ // Your implementation goes here
+ printf("show_locks\n");
+ }
+
+ void heartbeat(const HeartbeatRequest& ids) {
+ // Your implementation goes here
+ printf("heartbeat\n");
+ }
+
+ void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) {
+ // Your implementation goes here
+ printf("heartbeat_txn_range\n");
+ }
+
+ void compact(const CompactionRequest& rqst) {
+ // Your implementation goes here
+ printf("compact\n");
+ }
+
+ void compact2(CompactionResponse& _return, const CompactionRequest& rqst) {
+ // Your implementation goes here
+ printf("compact2\n");
+ }
+
+ void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) {
+ // Your implementation goes here
+ printf("show_compact\n");
+ }
+
+ void add_dynamic_partitions(const AddDynamicPartitions& rqst) {
+ // Your implementation goes here
+ printf("add_dynamic_partitions\n");
+ }
+
+ void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) {
+ // Your implementation goes here
+ printf("get_next_notification\n");
+ }
+
+ void get_current_notificationEventId(CurrentNotificationEventId& _return) {
+ // Your implementation goes here
+ printf("get_current_notificationEventId\n");
+ }
+
+ void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) {
+ // Your implementation goes here
+ printf("get_notification_events_count\n");
+ }
+
+ void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) {
+ // Your implementation goes here
+ printf("fire_listener_event\n");
+ }
+
+ void flushCache() {
+ // Your implementation goes here
+ printf("flushCache\n");
+ }
+
+ void add_write_notification_log(WriteNotificationLogResponse& _return, const WriteNotificationLogRequest& rqst) {
+ // Your implementation goes here
+ printf("add_write_notification_log\n");
+ }
+
+ void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) {
+ // Your implementation goes here
+ printf("cm_recycle\n");
+ }
+
+ void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) {
+ // Your implementation goes here
+ printf("get_file_metadata_by_expr\n");
+ }
+
+ void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) {
+ // Your implementation goes here
+ printf("get_file_metadata\n");
+ }
+
+ void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) {
+ // Your implementation goes here
+ printf("put_file_metadata\n");
+ }
+
+ void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) {
+ // Your implementation goes here
+ printf("clear_file_metadata\n");
+ }
+
+ void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) {
+ // Your implementation goes here
+ printf("cache_file_metadata\n");
+ }
+
+ void get_metastore_db_uuid(std::string& _return) {
+ // Your implementation goes here
+ printf("get_metastore_db_uuid\n");
+ }
+
+ void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("create_resource_plan\n");
+ }
+
+ void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("get_resource_plan\n");
+ }
+
+ void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("get_active_resource_plan\n");
+ }
+
+ void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("get_all_resource_plans\n");
+ }
+
+ void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("alter_resource_plan\n");
+ }
+
+ void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("validate_resource_plan\n");
+ }
+
+ void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) {
+ // Your implementation goes here
+ printf("drop_resource_plan\n");
+ }
+
+ void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) {
+ // Your implementation goes here
+ printf("create_wm_trigger\n");
+ }
+
+ void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) {
+ // Your implementation goes here
+ printf("alter_wm_trigger\n");
+ }
+
+ void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) {
+ // Your implementation goes here
+ printf("drop_wm_trigger\n");
+ }
+
+ void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) {
+ // Your implementation goes here
+ printf("get_triggers_for_resourceplan\n");
+ }
+
+ void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) {
+ // Your implementation goes here
+ printf("create_wm_pool\n");
+ }
+
+ void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) {
+ // Your implementation goes here
+ printf("alter_wm_pool\n");
+ }
+
+ void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) {
+ // Your implementation goes here
+ printf("drop_wm_pool\n");
+ }
+
+ void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) {
+ // Your implementation goes here
+ printf("create_or_update_wm_mapping\n");
+ }
+
+ void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) {
+ // Your implementation goes here
+ printf("drop_wm_mapping\n");
+ }
+
+ void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) {
+ // Your implementation goes here
+ printf("create_or_drop_wm_trigger_to_pool_mapping\n");
+ }
+
+ void create_ischema(const ISchema& schema) {
+ // Your implementation goes here
+ printf("create_ischema\n");
+ }
+
+ void alter_ischema(const AlterISchemaRequest& rqst) {
+ // Your implementation goes here
+ printf("alter_ischema\n");
+ }
+
+ void get_ischema(ISchema& _return, const ISchemaName& name) {
+ // Your implementation goes here
+ printf("get_ischema\n");
+ }
+
+ void drop_ischema(const ISchemaName& name) {
+ // Your implementation goes here
+ printf("drop_ischema\n");
+ }
+
+ void add_schema_version(const SchemaVersion& schemaVersion) {
+ // Your implementation goes here
+ printf("add_schema_version\n");
+ }
+
+ void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) {
+ // Your implementation goes here
+ printf("get_schema_version\n");
+ }
+
+ void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) {
+ // Your implementation goes here
+ printf("get_schema_latest_version\n");
+ }
+
+ void get_schema_all_versions(std::vector<SchemaVersion> & _return, const ISchemaName& schemaName) {
+ // Your implementation goes here
+ printf("get_schema_all_versions\n");
+ }
+
+ void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) {
+ // Your implementation goes here
+ printf("drop_schema_version\n");
+ }
+
+ void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) {
+ // Your implementation goes here
+ printf("get_schemas_by_cols\n");
+ }
+
+ void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) {
+ // Your implementation goes here
+ printf("map_schema_version_to_serde\n");
+ }
+
+ void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) {
+ // Your implementation goes here
+ printf("set_schema_version_state\n");
+ }
+
+ void add_serde(const SerDeInfo& serde) {
+ // Your implementation goes here
+ printf("add_serde\n");
+ }
+
+ void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) {
+ // Your implementation goes here
+ printf("get_serde\n");
+ }
+
+ void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) {
+ // Your implementation goes here
+ printf("get_lock_materialization_rebuild\n");
+ }
+
+ bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) {
+ // Your implementation goes here
+ printf("heartbeat_lock_materialization_rebuild\n");
+ }
+
+ void add_runtime_stats(const RuntimeStat& stat) {
+ // Your implementation goes here
+ printf("add_runtime_stats\n");
+ }
+
+ void get_runtime_stats(std::vector<RuntimeStat> & _return, const GetRuntimeStatsRequest& rqst) {
+ // Your implementation goes here
+ printf("get_runtime_stats\n");
+ }
+
+};
+
+int main(int argc, char **argv) {
+ int port = 9090;
+ shared_ptr<ThriftHiveMetastoreHandler> handler(new ThriftHiveMetastoreHandler());
+ shared_ptr<TProcessor> processor(new ThriftHiveMetastoreProcessor(handler));
+ shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+ shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+ shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+ TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+ server.serve();
+ return 0;
+}
+
http://git-wip-us.apache.org/repos/asf/hive/blob/20eb7b51/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp
----------------------------------------------------------------------
diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp
new file mode 100644
index 0000000..1c1b3ce
--- /dev/null
+++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.cpp
@@ -0,0 +1,67 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "hive_metastore_constants.h"
+
+namespace Apache { namespace Hadoop { namespace Hive {
+
+const hive_metastoreConstants g_hive_metastore_constants;
+
+hive_metastoreConstants::hive_metastoreConstants() {
+ DDL_TIME = "transient_lastDdlTime";
+
+ HIVE_FILTER_FIELD_OWNER = "hive_filter_field_owner__";
+
+ HIVE_FILTER_FIELD_PARAMS = "hive_filter_field_params__";
+
+ HIVE_FILTER_FIELD_LAST_ACCESS = "hive_filter_field_last_access__";
+
+ IS_ARCHIVED = "is_archived";
+
+ ORIGINAL_LOCATION = "original_location";
+
+ IS_IMMUTABLE = "immutable";
+
+ META_TABLE_COLUMNS = "columns";
+
+ META_TABLE_COLUMN_TYPES = "columns.types";
+
+ BUCKET_FIELD_NAME = "bucket_field_name";
+
+ BUCKET_COUNT = "bucket_count";
+
+ FIELD_TO_DIMENSION = "field_to_dimension";
+
+ META_TABLE_NAME = "name";
+
+ META_TABLE_DB = "db";
+
+ META_TABLE_LOCATION = "location";
+
+ META_TABLE_SERDE = "serde";
+
+ META_TABLE_PARTITION_COLUMNS = "partition_columns";
+
+ META_TABLE_PARTITION_COLUMN_TYPES = "partition_columns.types";
+
+ FILE_INPUT_FORMAT = "file.inputformat";
+
+ FILE_OUTPUT_FORMAT = "file.outputformat";
+
+ META_TABLE_STORAGE = "storage_handler";
+
+ TABLE_IS_TRANSACTIONAL = "transactional";
+
+ TABLE_NO_AUTO_COMPACT = "no_auto_compaction";
+
+ TABLE_TRANSACTIONAL_PROPERTIES = "transactional_properties";
+
+ TABLE_BUCKETING_VERSION = "bucketing_version";
+
+}
+
+}}} // namespace
+
http://git-wip-us.apache.org/repos/asf/hive/blob/20eb7b51/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.h b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.h
new file mode 100644
index 0000000..1f06253
--- /dev/null
+++ b/standalone-metastore/metastore-common/src/gen/thrift/gen-cpp/hive_metastore_constants.h
@@ -0,0 +1,49 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#ifndef hive_metastore_CONSTANTS_H
+#define hive_metastore_CONSTANTS_H
+
+#include "hive_metastore_types.h"
+
+namespace Apache { namespace Hadoop { namespace Hive {
+
+class hive_metastoreConstants {
+ public:
+ hive_metastoreConstants();
+
+ std::string DDL_TIME;
+ std::string HIVE_FILTER_FIELD_OWNER;
+ std::string HIVE_FILTER_FIELD_PARAMS;
+ std::string HIVE_FILTER_FIELD_LAST_ACCESS;
+ std::string IS_ARCHIVED;
+ std::string ORIGINAL_LOCATION;
+ std::string IS_IMMUTABLE;
+ std::string META_TABLE_COLUMNS;
+ std::string META_TABLE_COLUMN_TYPES;
+ std::string BUCKET_FIELD_NAME;
+ std::string BUCKET_COUNT;
+ std::string FIELD_TO_DIMENSION;
+ std::string META_TABLE_NAME;
+ std::string META_TABLE_DB;
+ std::string META_TABLE_LOCATION;
+ std::string META_TABLE_SERDE;
+ std::string META_TABLE_PARTITION_COLUMNS;
+ std::string META_TABLE_PARTITION_COLUMN_TYPES;
+ std::string FILE_INPUT_FORMAT;
+ std::string FILE_OUTPUT_FORMAT;
+ std::string META_TABLE_STORAGE;
+ std::string TABLE_IS_TRANSACTIONAL;
+ std::string TABLE_NO_AUTO_COMPACT;
+ std::string TABLE_TRANSACTIONAL_PROPERTIES;
+ std::string TABLE_BUCKETING_VERSION;
+};
+
+extern const hive_metastoreConstants g_hive_metastore_constants;
+
+}}} // namespace
+
+#endif