From d3238b1b2270533285025d69b35906506212f492 Mon Sep 17 00:00:00 2001 From: Laurent Goujon Date: Sun, 26 Feb 2017 10:23:59 -0800 Subject: DRILL-5301: Add C++ client support for Server metadata API Add support to the Server metadata API to the C++ client if available. If the API is not supported to the server, fallback to the previous hard-coded values. Update the querySubmitter example program to query the information. close #764 --- contrib/native/client/example/querySubmitter.cpp | 88 +- contrib/native/client/readme.boost | 2 +- .../client/src/clientlib/drillClientImpl.cpp | 119 +- .../client/src/clientlib/drillClientImpl.hpp | 17 +- contrib/native/client/src/clientlib/metadata.cpp | 1680 ++-- contrib/native/client/src/clientlib/metadata.hpp | 215 +- .../client/src/include/drill/drillClient.hpp | 43 +- contrib/native/client/src/protobuf/User.pb.cc | 3844 +++++++- contrib/native/client/src/protobuf/User.pb.h | 9971 +++++++++++++------- 9 files changed, 11565 insertions(+), 4414 deletions(-) diff --git a/contrib/native/client/example/querySubmitter.cpp b/contrib/native/client/example/querySubmitter.cpp index 5b85a3e5d..599089786 100644 --- a/contrib/native/client/example/querySubmitter.cpp +++ b/contrib/native/client/example/querySubmitter.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include "drill/drillc.hpp" int nOptions=15; @@ -32,12 +33,12 @@ struct Option{ }qsOptions[]= { {"plan", "Plan files separated by semicolons", false}, {"query", "Query strings, separated by semicolons", false}, - {"type", "Query type [physical|logical|sql]", true}, + {"type", "Query type [physical|logical|sql|server]", true}, {"connectStr", "Connect string", true}, {"schema", "Default schema", false}, - {"api", "API type [sync|async]", true}, + {"api", "API type [sync|async|meta]", true}, {"logLevel", "Logging level [trace|debug|info|warn|error|fatal]", false}, - {"testCancel", "Cancel the query afterthe first record batch.", false}, + {"testCancel", "Cancel the query after the first record batch.", false}, {"syncSend", "Send query only after previous result is received", false}, {"hshakeTimeout", "Handshake timeout (second).", false}, {"queryTimeout", "Query timeout (second).", false}, @@ -55,12 +56,12 @@ bool bSyncSend=false; Drill::status_t SchemaListener(void* ctx, Drill::FieldDefPtr fields, Drill::DrillClientError* err){ if(!err){ - printf("SCHEMA CHANGE DETECTED:\n"); + std::cout<< "SCHEMA CHANGE DETECTED:" << std::endl; for(size_t i=0; isize(); i++){ std::string name= fields->at(i)->getName(); - printf("%s\t", name.c_str()); + std::cout << name << "\t"; } - printf("\n"); + std::cout << std::endl; return Drill::QRY_SUCCESS ; }else{ std::cerr<< "ERROR: " << err->msg << std::endl; @@ -113,6 +114,7 @@ void print(const Drill::FieldMetadata* pFieldMetadata, void* buf, size_t sz){ switch (mode) { case common::DM_REQUIRED: sprintf((char*)printBuffer, "%lld", *(uint64_t*)buf); + break; case common::DM_OPTIONAL: break; case common::DM_REPEATED: @@ -123,6 +125,7 @@ void print(const Drill::FieldMetadata* pFieldMetadata, void* buf, size_t sz){ switch (mode) { case common::DM_REQUIRED: memcpy(printBuffer, buf, sz); + break; case common::DM_OPTIONAL: break; case common::DM_REPEATED: @@ -133,6 +136,7 @@ void print(const Drill::FieldMetadata* pFieldMetadata, void* buf, size_t sz){ switch (mode) { case common::DM_REQUIRED: memcpy(printBuffer, buf, sz); + break; case common::DM_OPTIONAL: break; case common::DM_REPEATED: @@ -233,6 +237,9 @@ int readQueries(const std::string& queryList, std::vector& queries) } bool validate(const std::string& type, const std::string& query, const std::string& plan){ + if (type != "sync" || type != "async") { + return true; + } if(query.empty() && plan.empty()){ std::cerr<< "Either query or plan must be specified"<getConnectorName() << std::endl; + std::cout << "\tversion:" << metadata->getConnectorVersion() << std::endl; + std::cout << std::endl; + std::cout << "Server:" << std::endl; + std::cout << "\tname:" << metadata->getServerName() << std::endl; + std::cout << "\tversion:" << metadata->getServerVersion() << std::endl; + std::cout << std::endl; + std::cout << "Metadata:" << std::endl; + std::cout << "\tall tables are selectable: " << metadata->areAllTableSelectable() << std::endl; + std::cout << "\tcatalog separator: " << metadata->getCatalogSeparator() << std::endl; + std::cout << "\tcatalog term: " << metadata->getCatalogTerm() << std::endl; + std::cout << "\tCOLLATE support: " << metadata->getCollateSupport() << std::endl; + std::cout << "\tcorrelation names: " << metadata->getCorrelationNames() << std::endl; + std::cout << "\tdate time functions: " << boost::algorithm::join(metadata->getDateTimeFunctions(), ", ") << std::endl; + std::cout << "\tdate time literals support: " << metadata->getDateTimeLiteralsSupport() << std::endl; + std::cout << "\tGROUP BY support: " << metadata->getGroupBySupport() << std::endl; + std::cout << "\tidentifier case: " << metadata->getIdentifierCase() << std::endl; + std::cout << "\tidentifier quote string: " << metadata->getIdentifierQuoteString() << std::endl; + std::cout << "\tmax binary literal length: " << metadata->getMaxBinaryLiteralLength() << std::endl; + std::cout << "\tmax catalog name length: " << metadata->getMaxCatalogNameLength() << std::endl; + std::cout << "\tmax char literal length: " << metadata->getMaxCharLiteralLength() << std::endl; + std::cout << "\tmax column name length: " << metadata->getMaxColumnNameLength() << std::endl; + std::cout << "\tmax columns in GROUP BY: " << metadata->getMaxColumnsInGroupBy() << std::endl; + std::cout << "\tmax columns in ORDER BY: " << metadata->getMaxColumnsInOrderBy() << std::endl; + std::cout << "\tmax columns in SELECT: " << metadata->getMaxColumnsInSelect() << std::endl; + std::cout << "\tmax cursor name length: " << metadata->getMaxCursorNameLength() << std::endl; + std::cout << "\tmax logical lob size: " << metadata->getMaxLogicalLobSize() << std::endl; + std::cout << "\tmax row size: " << metadata->getMaxRowSize() << std::endl; + std::cout << "\tmax schema name length: " << metadata->getMaxSchemaNameLength() << std::endl; + std::cout << "\tmax statement length: " << metadata->getMaxStatementLength() << std::endl; + std::cout << "\tmax statements: " << metadata->getMaxStatements() << std::endl; + std::cout << "\tmax table name length: " << metadata->getMaxTableNameLength() << std::endl; + std::cout << "\tmax tables in SELECT: " << metadata->getMaxTablesInSelect() << std::endl; + std::cout << "\tmax user name length: " << metadata->getMaxUserNameLength() << std::endl; + std::cout << "\tNULL collation: " << metadata->getNullCollation() << std::endl; + std::cout << "\tnumeric functions: " << boost::algorithm::join(metadata->getNumericFunctions(), ", ") << std::endl; + std::cout << "\tOUTER JOIN support: " << metadata->getOuterJoinSupport() << std::endl; + std::cout << "\tquoted identifier case: " << metadata->getQuotedIdentifierCase() << std::endl; + std::cout << "\tSQL keywords: " << boost::algorithm::join(metadata->getSQLKeywords(), ",") << std::endl; + std::cout << "\tschema term: " << metadata->getSchemaTerm() << std::endl; + std::cout << "\tsearch escape string: " << metadata->getSearchEscapeString() << std::endl; + std::cout << "\tspecial characters: " << metadata->getSpecialCharacters() << std::endl; + std::cout << "\tstring functions: " << boost::algorithm::join(metadata->getStringFunctions(), ",") << std::endl; + std::cout << "\tsub query support: " << metadata->getSubQuerySupport() << std::endl; + std::cout << "\tsystem functions: " << boost::algorithm::join(metadata->getSystemFunctions(), ",") << std::endl; + std::cout << "\ttable term: " << metadata->getTableTerm() << std::endl; + std::cout << "\tUNION support: " << metadata->getUnionSupport() << std::endl; + std::cout << "\tBLOB included in max row size: " << metadata->isBlobIncludedInMaxRowSize() << std::endl; + std::cout << "\tcatalog at start: " << metadata->isCatalogAtStart() << std::endl; + std::cout << "\tcolumn aliasing supported: " << metadata->isColumnAliasingSupported() << std::endl; + std::cout << "\tLIKE escape clause supported: " << metadata->isLikeEscapeClauseSupported() << std::endl; + std::cout << "\tNULL plus non NULL equals to NULL: " << metadata->isNullPlusNonNullNull() << std::endl; + std::cout << "\tread-only: " << metadata->isReadOnly() << std::endl; + std::cout << "\tSELECT FOR UPDATE supported: " << metadata->isSelectForUpdateSupported() << std::endl; + std::cout << "\ttransaction supported: " << metadata->isTransactionSupported() << std::endl; + std::cout << "\tunrelated columns in ORDER BY supported: " << metadata->isUnrelatedColumnsInOrderBySupported() << std::endl; + + client.freeMetadata(&metadata); + } else { + std::cerr << "Cannot get metadata:" << client.getError() << std::endl; + } + } else if(api=="sync"){ Drill::DrillClientError* err=NULL; Drill::status_t ret; int nQueries=0; diff --git a/contrib/native/client/readme.boost b/contrib/native/client/readme.boost index a6035e445..39a7bfb8c 100644 --- a/contrib/native/client/readme.boost +++ b/contrib/native/client/readme.boost @@ -34,7 +34,7 @@ $ cd $BOOST_BUILD_DIR/drill_boost_1_60_0 # the following builds a subset of boost without icu. You may need to add more modules to include icu. # bcp documentation can be found here: http://www.boost.org/doc/libs/1_60_0/tools/bcp/doc/html/index.html -$ $BOOST_BUILD_DIR/boost_1_60_0/dist/bin/bcp --namespace=drill_boost --namespace-alias --boost=$BOOST_BUILD_DIR/boost_1_60_0/ shared_ptr random context chrono date_time regex system timer thread asio smart_ptr bind config build regex config assign functional multiprecision $BOOST_BUILD_DIR/drill_boost_1_60_0 +$ $BOOST_BUILD_DIR/boost_1_60_0/dist/bin/bcp --namespace=drill_boost --namespace-alias --boost=$BOOST_BUILD_DIR/boost_1_60_0/ shared_ptr random context chrono date_time regex system timer thread asio smart_ptr bind config build regex config assign functional multiprecision algorithm $BOOST_BUILD_DIR/drill_boost_1_60_0 $ cd $BOOST_BUILD_DIR/drill_boost_1_60_0 $ ./bootstrap.sh --prefix=$BOOST_BUILD_DIR/drill_boost_1_60_0/ diff --git a/contrib/native/client/src/clientlib/drillClientImpl.cpp b/contrib/native/client/src/clientlib/drillClientImpl.cpp index 4486068e8..808595cc1 100644 --- a/contrib/native/client/src/clientlib/drillClientImpl.cpp +++ b/contrib/native/client/src/clientlib/drillClientImpl.cpp @@ -47,7 +47,7 @@ #include "saslAuthenticatorImpl.hpp" namespace Drill{ - +namespace { // anonymous namespace static std::map QUERYSTATE_TO_STATUS_MAP = boost::assign::map_list_of (exec::shared::QueryResult_QueryState_STARTING, QRY_PENDING) (exec::shared::QueryResult_QueryState_RUNNING, QRY_RUNNING) @@ -60,6 +60,13 @@ static std::string debugPrintQid(const exec::shared::QueryId& qid){ return std::string("[")+boost::lexical_cast(qid.part1()) +std::string(":") + boost::lexical_cast(qid.part2())+std::string("] "); } +// Convertion helper +struct ToRpcType: public std::unary_function { + exec::user::RpcType operator() (google::protobuf::int32 i) const { + return static_cast(i); + } +}; +} connectionStatus_t DrillClientImpl::connect(const char* connStr, DrillUserProperties* props){ std::string pathToDrill, protocol, hostPortStr; std::string host; @@ -319,6 +326,9 @@ void DrillClientImpl::handleHandshake(ByteBuf_t _buf, this->m_handshakeErrorId=b2u.errorid(); this->m_handshakeErrorMsg=b2u.errormessage(); this->m_serverInfos = b2u.server_infos(); + std::transform(b2u.supported_methods().begin(), b2u.supported_methods().end(), + std::back_inserter(this->m_supportedMethods), + ToRpcType()); for (int i=0; i deallocationGuard(allocatedBuffer); + boost::lock_guard lock(m_dcMutex); + + if(msg.m_coord_id==0){ + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "DrillClientImpl::processServerMetaResult: m_coord_id=0. Ignore and return QRY_SUCCESS." << std::endl;) + return QRY_SUCCESS; + } + std::map::const_iterator it=this->m_queryHandles.find(msg.m_coord_id); + if(it!=this->m_queryHandles.end()){ + DrillClientServerMetaHandle* pHandle=static_cast((*it).second); + exec::user::GetServerMetaResp* resp = new exec::user::GetServerMetaResp(); + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "Received GetServerMetaResp result Handle " << msg.m_pbody.size() << std::endl;) + if (!(resp->ParseFromArray(msg.m_pbody.data(), msg.m_pbody.size()))) { + return handleQryError(QRY_COMM_ERROR, "Cannot decode GetServerMetaResp results", pHandle); + } + if (resp->status() != exec::user::OK) { + return handleQryError(QRY_FAILED, resp->error(), pHandle); + } + pHandle->notifyListener(&(resp->server_meta()), NULL); + DRILL_MT_LOG(DRILL_LOG(LOG_DEBUG) << "GetServerMetaResp result " << std::endl;) + }else{ + return handleQryError(QRY_INTERNAL_ERROR, getMessage(ERR_QRY_INVQUERYID), NULL); + } + m_pendingRequests--; + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "DrillClientImpl::processServerMetaResult: " << m_pendingRequests << " requests pending." << std::endl;) + if(m_pendingRequests==0){ + // signal any waiting client that it can exit because there are no more any query results to arrive. + // We keep the heartbeat going though. + m_cv.notify_one(); + } + return ret; +} + DrillClientQueryResult* DrillClientImpl::findQueryResult(const exec::shared::QueryId& qid){ DrillClientQueryResult* pDrillClientQueryResult=NULL; DRILL_MT_LOG(DRILL_LOG(LOG_DEBUG) << "Searching for Query Id - " << debugPrintQid(qid) << std::endl;) @@ -1508,6 +1556,10 @@ void DrillClientImpl::handleRead(ByteBuf_t _buf, processSaslChallenge(allocatedBuffer, msg); break; + case exec::user::SERVER_META: + processServerMetaResult(allocatedBuffer, msg); + break; + case exec::user::ACK: // Cancel requests will result in an ACK sent back. // Consume silently @@ -1722,8 +1774,71 @@ void DrillClientImpl::shutdownSocket(){ DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "Socket shutdown" << std::endl;) } +namespace { // anonymous + +} + +namespace { // anonymous +// Helper class to wait on ServerMeta results +struct ServerMetaContext { + bool m_done; + status_t m_status; + exec::user::ServerMeta m_serverMeta; + boost::mutex m_mutex; + boost::condition_variable m_cv; + + static status_t listener(void* ctx, const exec::user::ServerMeta* serverMeta, DrillClientError* err) { + ServerMetaContext* context = static_cast(ctx); + if (err) { + context->m_status = QRY_FAILURE; + } else { + context->m_status = QRY_SUCCESS; + context->m_serverMeta.CopyFrom(*serverMeta); + } + + { + boost::lock_guard lock(context->m_mutex); + context->m_done = true; + } + context->m_cv.notify_one(); + return QRY_SUCCESS; + } +}; +} + meta::DrillMetadata* DrillClientImpl::getMetadata() { - return new meta::DrillMetadata(*this); + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "Getting metadata" << std::endl;) + if (std::find(m_supportedMethods.begin(), m_supportedMethods.end(), exec::user::GET_SERVER_META) == m_supportedMethods.end()) { + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "Server metadata not supported " << m_supportedMethods.size() << ". Falling back to default." << std::endl;) + return new meta::DrillMetadata(*this, meta::DrillMetadata::s_defaultServerMeta); + } + + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "Server metadata supported." << std::endl;) + exec::user::GetServerMetaReq req; + ServerMetaContext ctx; + boost::function factory = boost::bind( + boost::factory(), + boost::ref(*this), + _1, + ServerMetaContext::listener, + &ctx); + // Getting a query handle, and make sure to free when done + boost::shared_ptr handle = boost::shared_ptr( + sendMsg(factory, exec::user::GET_SERVER_META, req), + boost::bind(&DrillClientImpl::freeQueryResources, this, _1)); + { + boost::unique_lock lock(ctx.m_mutex); + while(!ctx.m_done) { + ctx.m_cv.wait(lock); + } + } + + DRILL_MT_LOG(DRILL_LOG(LOG_TRACE) << "Server metadata received." << std::endl;) + if (ctx.m_status != QRY_SUCCESS) { + return NULL; + } + return new meta::DrillMetadata(*this, ctx.m_serverMeta); + } void DrillClientImpl::freeMetadata(meta::DrillMetadata* metadata) { diff --git a/contrib/native/client/src/clientlib/drillClientImpl.hpp b/contrib/native/client/src/clientlib/drillClientImpl.hpp index 262edc9ea..5eb850dbc 100644 --- a/contrib/native/client/src/clientlib/drillClientImpl.hpp +++ b/contrib/native/client/src/clientlib/drillClientImpl.hpp @@ -201,7 +201,7 @@ class DrillClientQueryResult: public DrillClientBaseHandleclearAndDestroy(); }; @@ -307,6 +307,18 @@ class DrillClientPrepareHandle: public DrillClientBaseHandle { + public: + DrillClientServerMetaHandle(DrillClientImpl& client, int32_t coordId, pfnServerMetaListener listener, void* listenerCtx): + DrillClientBaseHandle(client, coordId, "server meta", listener, listenerCtx) { + }; + + private: + friend class DrillClientImpl; + +}; + template class DrillClientMetadataResult: public DrillClientBaseHandle*> { public: @@ -364,6 +376,7 @@ class DrillClientImpl : public DrillClientImplBase{ m_handshakeStatus(exec::user::SUCCESS), m_bIsConnected(false), m_saslAuthenticator(NULL), + m_saslResultCode(SASL_OK), m_saslDone(false), m_pendingRequests(0), m_pError(NULL), @@ -487,6 +500,7 @@ class DrillClientImpl : public DrillClientImplBase{ status_t processSchemasResult(AllocatedBufferPtr allocatedBuffer, const rpc::InBoundRpcMessage& msg ); status_t processTablesResult(AllocatedBufferPtr allocatedBuffer, const rpc::InBoundRpcMessage& msg ); status_t processColumnsResult(AllocatedBufferPtr allocatedBuffer, const rpc::InBoundRpcMessage& msg ); + status_t processServerMetaResult(AllocatedBufferPtr allocatedBuffer, const rpc::InBoundRpcMessage& msg ); DrillClientQueryResult* findQueryResult(const exec::shared::QueryId& qid); status_t processQueryStatusResult( exec::shared::QueryResult* qr, DrillClientQueryResult* pDrillClientQueryResult); @@ -533,6 +547,7 @@ class DrillClientImpl : public DrillClientImplBase{ std::string m_handshakeErrorId; std::string m_handshakeErrorMsg; exec::user::RpcEndpointInfos m_serverInfos; + std::vector m_supportedMethods; bool m_bIsConnected; std::vector m_serverAuthMechanisms; diff --git a/contrib/native/client/src/clientlib/metadata.cpp b/contrib/native/client/src/clientlib/metadata.cpp index 0364c7d81..7c2a7a86e 100644 --- a/contrib/native/client/src/clientlib/metadata.cpp +++ b/contrib/native/client/src/clientlib/metadata.cpp @@ -26,11 +26,18 @@ const std::string Drill::meta::DrillMetadata::s_connectorName(DRILL_CONNECTOR_NAME); const std::string Drill::meta::DrillMetadata::s_connectorVersion(DRILL_VERSION_STRING); -const std::string Drill::meta::DrillMetadata::s_catalogSeparator("."); -const std::string Drill::meta::DrillMetadata::s_catalogTerm("catalog"); -const std::string Drill::meta::DrillMetadata::s_identifierQuoteString("`"); +namespace Drill { +namespace meta { +namespace { // Anonymous namespace +using boost::assign::list_of; + +// Default values based on Drill 1.8 support +static const std::size_t s_maxIdentifierSize = 1024; +static const std::string s_catalogSeparator("."); +static const std::string s_catalogTerm("catalog"); +static const std::string s_identifierQuoteString("`"); -const std::vector Drill::meta::DrillMetadata::s_sqlKeywords = boost::assign::list_of +static const std::vector s_sqlKeywords = boost::assign::list_of ("ABS")("ALLOW")("ARRAY")("ASENSITIVE")("ASYMMETRIC")("ATOMIC")("BIGINT")("BINARY")("BLOB") ("BOOLEAN")("CALL")("CALLED")("CARDINALITY")("CEIL")("CEILING")("CLOB")("COLLECT")("CONDITION") ("CORR")("COVAR_POP")("COVAR_SAMP")("CUBE")("CUME_DIST")("CURRENT_CATALOG") @@ -51,643 +58,1070 @@ const std::vector Drill::meta::DrillMetadata::s_sqlKeywords = boost ("UESCAPE")("UNNEST")("UPSERT")("USE")("VARBINARY")("VAR_POP")("VAR_SAMP")("WIDTH_BUCKET") ("WINDOW")("WITHIN")("WITHOUT"); -const std::vector Drill::meta::DrillMetadata::s_numericFunctions = boost::assign::list_of - ("ABS")("ACOS")("ASIN")("ATAN")("ATAN2")("CEILING")("COS")("COT") - ("DEGREES")("EXP")("FLOOR")("LOG")("LOG10")("MOD")("PI") - ("POWER")("RADIANS")("RAND")("ROUND")("SIGN")("SIN")("SQRT") - ("TAN")("TRUNCATE"); +static const std::vector s_numericFunctions = boost::assign::list_of + ("ABS")("EXP")("LOG")("LOG10")("MOD")("POWER"); -const std::string Drill::meta::DrillMetadata::s_schemaTerm("schema"); -const std::string Drill::meta::DrillMetadata::s_searchEscapeString("\\"); -const std::string Drill::meta::DrillMetadata::s_specialCharacters; +static const std::string s_schemaTerm("schema"); +static const std::string s_searchEscapeString("\\"); +static const std::string s_specialCharacters; -const std::vector Drill::meta::DrillMetadata::s_stringFunctions = boost::assign::list_of - ("ASCII")("CHAR")("CONCAT")("DIFFERENCE")("INSERT")("LCASE") - ("LEFT")("LENGTH")("LOCATE")("LTRIM")("REPEAT")("REPLACE") - ("RIGHT")("RTRIM")("SOUNDEX")("SPACE")("SUBSTRING")("UCASE"); +static const std::vector s_stringFunctions = boost::assign::list_of + ("CONCAT")("INSERT")("LCASE")("LENGTH")("LOCATE")("LTRIM")("RTRIM")("SUBSTRING")("UCASE"); -const std::vector Drill::meta::DrillMetadata::s_systemFunctions = boost::assign::list_of - ("DATABASE")("IFNULL")("USER"); +static const std::vector s_systemFunctions; -const std::string Drill::meta::DrillMetadata::s_tableTerm("table"); +static const std::string s_tableTerm("table"); -const std::vector Drill::meta::DrillMetadata::s_dateTimeFunctions = boost::assign::list_of - ("CURDATE")("CURTIME")("DAYNAME")("DAYOFMONTH")("DAYOFWEEK") - ("DAYOFYEAR")("HOUR")("MINUTE")("MONTH")("MONTHNAME")("NOW") - ("QUARTER")("SECOND")("TIMESTAMPADD")("TIMESTAMPDIFF")("WEEK")("YEAR"); +static const std::vector s_dateTimeFunctions = boost::assign::list_of + ("CURDATE")("CURTIME")("NOW")("QUARTER"); -namespace Drill { -namespace meta { -namespace { -using boost::assign::list_of; +static const std::vector s_dateTimeLiterals = boost::assign::list_of + (exec::user::DL_DATE)(exec::user::DL_TIME)(exec::user::DL_TIMESTAMP)(exec::user::DL_INTERVAL_YEAR) + (exec::user::DL_INTERVAL_MONTH)(exec::user::DL_INTERVAL_DAY)(exec::user::DL_INTERVAL_HOUR) + (exec::user::DL_INTERVAL_MINUTE)(exec::user::DL_INTERVAL_SECOND)(exec::user::DL_INTERVAL_YEAR_TO_MONTH) + (exec::user::DL_INTERVAL_DAY_TO_HOUR)(exec::user::DL_INTERVAL_DAY_TO_MINUTE) + (exec::user::DL_INTERVAL_DAY_TO_SECOND)(exec::user::DL_INTERVAL_HOUR_TO_MINUTE) + (exec::user::DL_INTERVAL_HOUR_TO_SECOND)(exec::user::DL_INTERVAL_MINUTE_TO_SECOND); + +static const std::vector s_orderBySupport = boost::assign::list_of + (exec::user::OB_UNRELATED)(exec::user::OB_EXPRESSION); + +static const std::vector s_outerJoinSupport = boost::assign::list_of + (exec::user::OJ_LEFT)(exec::user::OJ_RIGHT)(exec::user::OJ_FULL); + +static const std::vector s_subQuerySupport = boost::assign::list_of + (exec::user::SQ_CORRELATED)(exec::user::SQ_IN_COMPARISON)(exec::user::SQ_IN_EXISTS) + (exec::user::SQ_IN_QUANTIFIED); + +static const std::vector s_unionSupport = boost::assign::list_of + (exec::user::U_UNION)(exec::user::U_UNION_ALL); + +static exec::user::ConvertSupport ConvertSupport(common::MinorType from, common::MinorType to) { + exec::user::ConvertSupport convertSupport; + convertSupport.set_from(from); + convertSupport.set_to(to); + + return convertSupport; +} + +static const convert_support_set s_convertMap = boost::assign::list_of + (ConvertSupport(common::TINYINT, common::INT)) + (ConvertSupport(common::TINYINT, common::BIGINT)) + (ConvertSupport(common::TINYINT, common::DECIMAL9)) + (ConvertSupport(common::TINYINT, common::DECIMAL18)) + (ConvertSupport(common::TINYINT, common::DECIMAL28SPARSE)) + (ConvertSupport(common::TINYINT, common::DECIMAL38SPARSE)) + (ConvertSupport(common::TINYINT, common::DATE)) + (ConvertSupport(common::TINYINT, common::TIME)) + (ConvertSupport(common::TINYINT, common::TIMESTAMP)) + (ConvertSupport(common::TINYINT, common::INTERVAL)) + (ConvertSupport(common::TINYINT, common::FLOAT4)) + (ConvertSupport(common::TINYINT, common::FLOAT8)) + (ConvertSupport(common::TINYINT, common::BIT)) + (ConvertSupport(common::TINYINT, common::VARCHAR)) + (ConvertSupport(common::TINYINT, common::VAR16CHAR)) + (ConvertSupport(common::TINYINT, common::VARBINARY)) + (ConvertSupport(common::TINYINT, common::INTERVALYEAR)) + (ConvertSupport(common::TINYINT, common::INTERVALDAY)) + (ConvertSupport(common::SMALLINT, common::INT)) + (ConvertSupport(common::SMALLINT, common::BIGINT)) + (ConvertSupport(common::SMALLINT, common::DECIMAL9)) + (ConvertSupport(common::SMALLINT, common::DECIMAL18)) + (ConvertSupport(common::SMALLINT, common::DECIMAL28SPARSE)) + (ConvertSupport(common::SMALLINT, common::DECIMAL38SPARSE)) + (ConvertSupport(common::SMALLINT, common::DATE)) + (ConvertSupport(common::SMALLINT, common::TIME)) + (ConvertSupport(common::SMALLINT, common::TIMESTAMP)) + (ConvertSupport(common::SMALLINT, common::INTERVAL)) + (ConvertSupport(common::SMALLINT, common::FLOAT4)) + (ConvertSupport(common::SMALLINT, common::FLOAT8)) + (ConvertSupport(common::SMALLINT, common::BIT)) + (ConvertSupport(common::SMALLINT, common::VARCHAR)) + (ConvertSupport(common::SMALLINT, common::VAR16CHAR)) + (ConvertSupport(common::SMALLINT, common::VARBINARY)) + (ConvertSupport(common::SMALLINT, common::INTERVALYEAR)) + (ConvertSupport(common::SMALLINT, common::INTERVALDAY)) + (ConvertSupport(common::INT, common::INT)) + (ConvertSupport(common::INT, common::BIGINT)) + (ConvertSupport(common::INT, common::DECIMAL9)) + (ConvertSupport(common::INT, common::DECIMAL18)) + (ConvertSupport(common::INT, common::DECIMAL28SPARSE)) + (ConvertSupport(common::INT, common::DECIMAL38SPARSE)) + (ConvertSupport(common::INT, common::DATE)) + (ConvertSupport(common::INT, common::TIME)) + (ConvertSupport(common::INT, common::TIMESTAMP)) + (ConvertSupport(common::INT, common::INTERVAL)) + (ConvertSupport(common::INT, common::FLOAT4)) + (ConvertSupport(common::INT, common::FLOAT8)) + (ConvertSupport(common::INT, common::BIT)) + (ConvertSupport(common::INT, common::VARCHAR)) + (ConvertSupport(common::INT, common::VAR16CHAR)) + (ConvertSupport(common::INT, common::VARBINARY)) + (ConvertSupport(common::INT, common::INTERVALYEAR)) + (ConvertSupport(common::INT, common::INTERVALDAY)) + (ConvertSupport(common::BIGINT, common::INT)) + (ConvertSupport(common::BIGINT, common::BIGINT)) + (ConvertSupport(common::BIGINT, common::DECIMAL9)) + (ConvertSupport(common::BIGINT, common::DECIMAL18)) + (ConvertSupport(common::BIGINT, common::DECIMAL28SPARSE)) + (ConvertSupport(common::BIGINT, common::DECIMAL38SPARSE)) + (ConvertSupport(common::BIGINT, common::DATE)) + (ConvertSupport(common::BIGINT, common::TIME)) + (ConvertSupport(common::BIGINT, common::TIMESTAMP)) + (ConvertSupport(common::BIGINT, common::INTERVAL)) + (ConvertSupport(common::BIGINT, common::FLOAT4)) + (ConvertSupport(common::BIGINT, common::FLOAT8)) + (ConvertSupport(common::BIGINT, common::BIT)) + (ConvertSupport(common::BIGINT, common::VARCHAR)) + (ConvertSupport(common::BIGINT, common::VAR16CHAR)) + (ConvertSupport(common::BIGINT, common::VARBINARY)) + (ConvertSupport(common::BIGINT, common::INTERVALYEAR)) + (ConvertSupport(common::BIGINT, common::INTERVALDAY)) + (ConvertSupport(common::DECIMAL9, common::INT)) + (ConvertSupport(common::DECIMAL9, common::BIGINT)) + (ConvertSupport(common::DECIMAL9, common::DECIMAL9)) + (ConvertSupport(common::DECIMAL9, common::DECIMAL18)) + (ConvertSupport(common::DECIMAL9, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DECIMAL9, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DECIMAL9, common::DATE)) + (ConvertSupport(common::DECIMAL9, common::TIME)) + (ConvertSupport(common::DECIMAL9, common::TIMESTAMP)) + (ConvertSupport(common::DECIMAL9, common::INTERVAL)) + (ConvertSupport(common::DECIMAL9, common::FLOAT4)) + (ConvertSupport(common::DECIMAL9, common::FLOAT8)) + (ConvertSupport(common::DECIMAL9, common::BIT)) + (ConvertSupport(common::DECIMAL9, common::VARCHAR)) + (ConvertSupport(common::DECIMAL9, common::VAR16CHAR)) + (ConvertSupport(common::DECIMAL9, common::VARBINARY)) + (ConvertSupport(common::DECIMAL9, common::INTERVALYEAR)) + (ConvertSupport(common::DECIMAL9, common::INTERVALDAY)) + (ConvertSupport(common::DECIMAL18, common::INT)) + (ConvertSupport(common::DECIMAL18, common::BIGINT)) + (ConvertSupport(common::DECIMAL18, common::DECIMAL9)) + (ConvertSupport(common::DECIMAL18, common::DECIMAL18)) + (ConvertSupport(common::DECIMAL18, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DECIMAL18, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DECIMAL18, common::DATE)) + (ConvertSupport(common::DECIMAL18, common::TIME)) + (ConvertSupport(common::DECIMAL18, common::TIMESTAMP)) + (ConvertSupport(common::DECIMAL18, common::INTERVAL)) + (ConvertSupport(common::DECIMAL18, common::FLOAT4)) + (ConvertSupport(common::DECIMAL18, common::FLOAT8)) + (ConvertSupport(common::DECIMAL18, common::BIT)) + (ConvertSupport(common::DECIMAL18, common::VARCHAR)) + (ConvertSupport(common::DECIMAL18, common::VAR16CHAR)) + (ConvertSupport(common::DECIMAL18, common::VARBINARY)) + (ConvertSupport(common::DECIMAL18, common::INTERVALYEAR)) + (ConvertSupport(common::DECIMAL18, common::INTERVALDAY)) + (ConvertSupport(common::DECIMAL28SPARSE, common::INT)) + (ConvertSupport(common::DECIMAL28SPARSE, common::BIGINT)) + (ConvertSupport(common::DECIMAL28SPARSE, common::DECIMAL9)) + (ConvertSupport(common::DECIMAL28SPARSE, common::DECIMAL18)) + (ConvertSupport(common::DECIMAL28SPARSE, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DECIMAL28SPARSE, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DECIMAL28SPARSE, common::DATE)) + (ConvertSupport(common::DECIMAL28SPARSE, common::TIME)) + (ConvertSupport(common::DECIMAL28SPARSE, common::TIMESTAMP)) + (ConvertSupport(common::DECIMAL28SPARSE, common::INTERVAL)) + (ConvertSupport(common::DECIMAL28SPARSE, common::FLOAT4)) + (ConvertSupport(common::DECIMAL28SPARSE, common::FLOAT8)) + (ConvertSupport(common::DECIMAL28SPARSE, common::BIT)) + (ConvertSupport(common::DECIMAL28SPARSE, common::VARCHAR)) + (ConvertSupport(common::DECIMAL28SPARSE, common::VAR16CHAR)) + (ConvertSupport(common::DECIMAL28SPARSE, common::VARBINARY)) + (ConvertSupport(common::DECIMAL28SPARSE, common::INTERVALYEAR)) + (ConvertSupport(common::DECIMAL28SPARSE, common::INTERVALDAY)) + (ConvertSupport(common::DECIMAL38SPARSE, common::INT)) + (ConvertSupport(common::DECIMAL38SPARSE, common::BIGINT)) + (ConvertSupport(common::DECIMAL38SPARSE, common::DECIMAL9)) + (ConvertSupport(common::DECIMAL38SPARSE, common::DECIMAL18)) + (ConvertSupport(common::DECIMAL38SPARSE, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DECIMAL38SPARSE, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DECIMAL38SPARSE, common::DATE)) + (ConvertSupport(common::DECIMAL38SPARSE, common::TIME)) + (ConvertSupport(common::DECIMAL38SPARSE, common::TIMESTAMP)) + (ConvertSupport(common::DECIMAL38SPARSE, common::INTERVAL)) + (ConvertSupport(common::DECIMAL38SPARSE, common::FLOAT4)) + (ConvertSupport(common::DECIMAL38SPARSE, common::FLOAT8)) + (ConvertSupport(common::DECIMAL38SPARSE, common::BIT)) + (ConvertSupport(common::DECIMAL38SPARSE, common::VARCHAR)) + (ConvertSupport(common::DECIMAL38SPARSE, common::VAR16CHAR)) + (ConvertSupport(common::DECIMAL38SPARSE, common::VARBINARY)) + (ConvertSupport(common::DECIMAL38SPARSE, common::INTERVALYEAR)) + (ConvertSupport(common::DECIMAL38SPARSE, common::INTERVALDAY)) + (ConvertSupport(common::MONEY, common::INT)) + (ConvertSupport(common::MONEY, common::BIGINT)) + (ConvertSupport(common::MONEY, common::DECIMAL9)) + (ConvertSupport(common::MONEY, common::DECIMAL18)) + (ConvertSupport(common::MONEY, common::DECIMAL28SPARSE)) + (ConvertSupport(common::MONEY, common::DECIMAL38SPARSE)) + (ConvertSupport(common::MONEY, common::DATE)) + (ConvertSupport(common::MONEY, common::TIME)) + (ConvertSupport(common::MONEY, common::TIMESTAMP)) + (ConvertSupport(common::MONEY, common::INTERVAL)) + (ConvertSupport(common::MONEY, common::FLOAT4)) + (ConvertSupport(common::MONEY, common::FLOAT8)) + (ConvertSupport(common::MONEY, common::BIT)) + (ConvertSupport(common::MONEY, common::VARCHAR)) + (ConvertSupport(common::MONEY, common::VAR16CHAR)) + (ConvertSupport(common::MONEY, common::VARBINARY)) + (ConvertSupport(common::MONEY, common::INTERVALYEAR)) + (ConvertSupport(common::MONEY, common::INTERVALDAY)) + (ConvertSupport(common::DATE, common::INT)) + (ConvertSupport(common::DATE, common::BIGINT)) + (ConvertSupport(common::DATE, common::DECIMAL9)) + (ConvertSupport(common::DATE, common::DECIMAL18)) + (ConvertSupport(common::DATE, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DATE, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DATE, common::DATE)) + (ConvertSupport(common::DATE, common::TIME)) + (ConvertSupport(common::DATE, common::TIMESTAMP)) + (ConvertSupport(common::DATE, common::INTERVAL)) + (ConvertSupport(common::DATE, common::FLOAT4)) + (ConvertSupport(common::DATE, common::FLOAT8)) + (ConvertSupport(common::DATE, common::BIT)) + (ConvertSupport(common::DATE, common::VARCHAR)) + (ConvertSupport(common::DATE, common::VAR16CHAR)) + (ConvertSupport(common::DATE, common::VARBINARY)) + (ConvertSupport(common::DATE, common::INTERVALYEAR)) + (ConvertSupport(common::DATE, common::INTERVALDAY)) + (ConvertSupport(common::TIME, common::INT)) + (ConvertSupport(common::TIME, common::BIGINT)) + (ConvertSupport(common::TIME, common::DECIMAL9)) + (ConvertSupport(common::TIME, common::DECIMAL18)) + (ConvertSupport(common::TIME, common::DECIMAL28SPARSE)) + (ConvertSupport(common::TIME, common::DECIMAL38SPARSE)) + (ConvertSupport(common::TIME, common::DATE)) + (ConvertSupport(common::TIME, common::TIME)) + (ConvertSupport(common::TIME, common::TIMESTAMP)) + (ConvertSupport(common::TIME, common::INTERVAL)) + (ConvertSupport(common::TIME, common::FLOAT4)) + (ConvertSupport(common::TIME, common::FLOAT8)) + (ConvertSupport(common::TIME, common::BIT)) + (ConvertSupport(common::TIME, common::VARCHAR)) + (ConvertSupport(common::TIME, common::VAR16CHAR)) + (ConvertSupport(common::TIME, common::VARBINARY)) + (ConvertSupport(common::TIME, common::INTERVALYEAR)) + (ConvertSupport(common::TIME, common::INTERVALDAY)) + (ConvertSupport(common::TIMESTAMPTZ, common::INT)) + (ConvertSupport(common::TIMESTAMPTZ, common::BIGINT)) + (ConvertSupport(common::TIMESTAMPTZ, common::DECIMAL9)) + (ConvertSupport(common::TIMESTAMPTZ, common::DECIMAL18)) + (ConvertSupport(common::TIMESTAMPTZ, common::DECIMAL28SPARSE)) + (ConvertSupport(common::TIMESTAMPTZ, common::DECIMAL38SPARSE)) + (ConvertSupport(common::TIMESTAMPTZ, common::DATE)) + (ConvertSupport(common::TIMESTAMPTZ, common::TIME)) + (ConvertSupport(common::TIMESTAMPTZ, common::TIMESTAMP)) + (ConvertSupport(common::TIMESTAMPTZ, common::INTERVAL)) + (ConvertSupport(common::TIMESTAMPTZ, common::FLOAT4)) + (ConvertSupport(common::TIMESTAMPTZ, common::FLOAT8)) + (ConvertSupport(common::TIMESTAMPTZ, common::BIT)) + (ConvertSupport(common::TIMESTAMPTZ, common::VARCHAR)) + (ConvertSupport(common::TIMESTAMPTZ, common::VAR16CHAR)) + (ConvertSupport(common::TIMESTAMPTZ, common::VARBINARY)) + (ConvertSupport(common::TIMESTAMPTZ, common::INTERVALYEAR)) + (ConvertSupport(common::TIMESTAMPTZ, common::INTERVALDAY)) + (ConvertSupport(common::TIMESTAMP, common::INT)) + (ConvertSupport(common::TIMESTAMP, common::BIGINT)) + (ConvertSupport(common::TIMESTAMP, common::DECIMAL9)) + (ConvertSupport(common::TIMESTAMP, common::DECIMAL18)) + (ConvertSupport(common::TIMESTAMP, common::DECIMAL28SPARSE)) + (ConvertSupport(common::TIMESTAMP, common::DECIMAL38SPARSE)) + (ConvertSupport(common::TIMESTAMP, common::DATE)) + (ConvertSupport(common::TIMESTAMP, common::TIME)) + (ConvertSupport(common::TIMESTAMP, common::TIMESTAMP)) + (ConvertSupport(common::TIMESTAMP, common::INTERVAL)) + (ConvertSupport(common::TIMESTAMP, common::FLOAT4)) + (ConvertSupport(common::TIMESTAMP, common::FLOAT8)) + (ConvertSupport(common::TIMESTAMP, common::BIT)) + (ConvertSupport(common::TIMESTAMP, common::VARCHAR)) + (ConvertSupport(common::TIMESTAMP, common::VAR16CHAR)) + (ConvertSupport(common::TIMESTAMP, common::VARBINARY)) + (ConvertSupport(common::TIMESTAMP, common::INTERVALYEAR)) + (ConvertSupport(common::TIMESTAMP, common::INTERVALDAY)) + (ConvertSupport(common::INTERVAL, common::INT)) + (ConvertSupport(common::INTERVAL, common::BIGINT)) + (ConvertSupport(common::INTERVAL, common::DECIMAL9)) + (ConvertSupport(common::INTERVAL, common::DECIMAL18)) + (ConvertSupport(common::INTERVAL, common::DECIMAL28SPARSE)) + (ConvertSupport(common::INTERVAL, common::DECIMAL38SPARSE)) + (ConvertSupport(common::INTERVAL, common::DATE)) + (ConvertSupport(common::INTERVAL, common::TIME)) + (ConvertSupport(common::INTERVAL, common::TIMESTAMP)) + (ConvertSupport(common::INTERVAL, common::INTERVAL)) + (ConvertSupport(common::INTERVAL, common::FLOAT4)) + (ConvertSupport(common::INTERVAL, common::FLOAT8)) + (ConvertSupport(common::INTERVAL, common::BIT)) + (ConvertSupport(common::INTERVAL, common::VARCHAR)) + (ConvertSupport(common::INTERVAL, common::VAR16CHAR)) + (ConvertSupport(common::INTERVAL, common::VARBINARY)) + (ConvertSupport(common::INTERVAL, common::INTERVALYEAR)) + (ConvertSupport(common::INTERVAL, common::INTERVALDAY)) + (ConvertSupport(common::FLOAT4, common::INT)) + (ConvertSupport(common::FLOAT4, common::BIGINT)) + (ConvertSupport(common::FLOAT4, common::DECIMAL9)) + (ConvertSupport(common::FLOAT4, common::DECIMAL18)) + (ConvertSupport(common::FLOAT4, common::DECIMAL28SPARSE)) + (ConvertSupport(common::FLOAT4, common::DECIMAL38SPARSE)) + (ConvertSupport(common::FLOAT4, common::DATE)) + (ConvertSupport(common::FLOAT4, common::TIME)) + (ConvertSupport(common::FLOAT4, common::TIMESTAMP)) + (ConvertSupport(common::FLOAT4, common::INTERVAL)) + (ConvertSupport(common::FLOAT4, common::FLOAT4)) + (ConvertSupport(common::FLOAT4, common::FLOAT8)) + (ConvertSupport(common::FLOAT4, common::BIT)) + (ConvertSupport(common::FLOAT4, common::VARCHAR)) + (ConvertSupport(common::FLOAT4, common::VAR16CHAR)) + (ConvertSupport(common::FLOAT4, common::VARBINARY)) + (ConvertSupport(common::FLOAT4, common::INTERVALYEAR)) + (ConvertSupport(common::FLOAT4, common::INTERVALDAY)) + (ConvertSupport(common::FLOAT8, common::INT)) + (ConvertSupport(common::FLOAT8, common::BIGINT)) + (ConvertSupport(common::FLOAT8, common::DECIMAL9)) + (ConvertSupport(common::FLOAT8, common::DECIMAL18)) + (ConvertSupport(common::FLOAT8, common::DECIMAL28SPARSE)) + (ConvertSupport(common::FLOAT8, common::DECIMAL38SPARSE)) + (ConvertSupport(common::FLOAT8, common::DATE)) + (ConvertSupport(common::FLOAT8, common::TIME)) + (ConvertSupport(common::FLOAT8, common::TIMESTAMP)) + (ConvertSupport(common::FLOAT8, common::INTERVAL)) + (ConvertSupport(common::FLOAT8, common::FLOAT4)) + (ConvertSupport(common::FLOAT8, common::FLOAT8)) + (ConvertSupport(common::FLOAT8, common::BIT)) + (ConvertSupport(common::FLOAT8, common::VARCHAR)) + (ConvertSupport(common::FLOAT8, common::VAR16CHAR)) + (ConvertSupport(common::FLOAT8, common::VARBINARY)) + (ConvertSupport(common::FLOAT8, common::INTERVALYEAR)) + (ConvertSupport(common::FLOAT8, common::INTERVALDAY)) + (ConvertSupport(common::BIT, common::TINYINT)) + (ConvertSupport(common::BIT, common::INT)) + (ConvertSupport(common::BIT, common::BIGINT)) + (ConvertSupport(common::BIT, common::DECIMAL9)) + (ConvertSupport(common::BIT, common::DECIMAL18)) + (ConvertSupport(common::BIT, common::DECIMAL28SPARSE)) + (ConvertSupport(common::BIT, common::DECIMAL38SPARSE)) + (ConvertSupport(common::BIT, common::DATE)) + (ConvertSupport(common::BIT, common::TIME)) + (ConvertSupport(common::BIT, common::TIMESTAMP)) + (ConvertSupport(common::BIT, common::INTERVAL)) + (ConvertSupport(common::BIT, common::FLOAT4)) + (ConvertSupport(common::BIT, common::FLOAT8)) + (ConvertSupport(common::BIT, common::BIT)) + (ConvertSupport(common::BIT, common::VARCHAR)) + (ConvertSupport(common::BIT, common::VAR16CHAR)) + (ConvertSupport(common::BIT, common::VARBINARY)) + (ConvertSupport(common::BIT, common::INTERVALYEAR)) + (ConvertSupport(common::BIT, common::INTERVALDAY)) + (ConvertSupport(common::FIXEDCHAR, common::TINYINT)) + (ConvertSupport(common::FIXEDCHAR, common::INT)) + (ConvertSupport(common::FIXEDCHAR, common::BIGINT)) + (ConvertSupport(common::FIXEDCHAR, common::DECIMAL9)) + (ConvertSupport(common::FIXEDCHAR, common::DECIMAL18)) + (ConvertSupport(common::FIXEDCHAR, common::DECIMAL28SPARSE)) + (ConvertSupport(common::FIXEDCHAR, common::DECIMAL38SPARSE)) + (ConvertSupport(common::FIXEDCHAR, common::DATE)) + (ConvertSupport(common::FIXEDCHAR, common::TIME)) + (ConvertSupport(common::FIXEDCHAR, common::TIMESTAMP)) + (ConvertSupport(common::FIXEDCHAR, common::INTERVAL)) + (ConvertSupport(common::FIXEDCHAR, common::FLOAT4)) + (ConvertSupport(common::FIXEDCHAR, common::FLOAT8)) + (ConvertSupport(common::FIXEDCHAR, common::BIT)) + (ConvertSupport(common::FIXEDCHAR, common::VARCHAR)) + (ConvertSupport(common::FIXEDCHAR, common::VAR16CHAR)) + (ConvertSupport(common::FIXEDCHAR, common::VARBINARY)) + (ConvertSupport(common::FIXEDCHAR, common::INTERVALYEAR)) + (ConvertSupport(common::FIXEDCHAR, common::INTERVALDAY)) + (ConvertSupport(common::FIXED16CHAR, common::TINYINT)) + (ConvertSupport(common::FIXED16CHAR, common::INT)) + (ConvertSupport(common::FIXED16CHAR, common::BIGINT)) + (ConvertSupport(common::FIXED16CHAR, common::DECIMAL9)) + (ConvertSupport(common::FIXED16CHAR, common::DECIMAL18)) + (ConvertSupport(common::FIXED16CHAR, common::DECIMAL28SPARSE)) + (ConvertSupport(common::FIXED16CHAR, common::DECIMAL38SPARSE)) + (ConvertSupport(common::FIXED16CHAR, common::DATE)) + (ConvertSupport(common::FIXED16CHAR, common::TIME)) + (ConvertSupport(common::FIXED16CHAR, common::TIMESTAMP)) + (ConvertSupport(common::FIXED16CHAR, common::INTERVAL)) + (ConvertSupport(common::FIXED16CHAR, common::FLOAT4)) + (ConvertSupport(common::FIXED16CHAR, common::FLOAT8)) + (ConvertSupport(common::FIXED16CHAR, common::BIT)) + (ConvertSupport(common::FIXED16CHAR, common::VARCHAR)) + (ConvertSupport(common::FIXED16CHAR, common::VAR16CHAR)) + (ConvertSupport(common::FIXED16CHAR, common::VARBINARY)) + (ConvertSupport(common::FIXED16CHAR, common::INTERVALYEAR)) + (ConvertSupport(common::FIXED16CHAR, common::INTERVALDAY)) + (ConvertSupport(common::FIXEDBINARY, common::INT)) + (ConvertSupport(common::FIXEDBINARY, common::BIGINT)) + (ConvertSupport(common::FIXEDBINARY, common::DECIMAL9)) + (ConvertSupport(common::FIXEDBINARY, common::DECIMAL18)) + (ConvertSupport(common::FIXEDBINARY, common::DECIMAL28SPARSE)) + (ConvertSupport(common::FIXEDBINARY, common::DECIMAL38SPARSE)) + (ConvertSupport(common::FIXEDBINARY, common::DATE)) + (ConvertSupport(common::FIXEDBINARY, common::TIME)) + (ConvertSupport(common::FIXEDBINARY, common::TIMESTAMP)) + (ConvertSupport(common::FIXEDBINARY, common::INTERVAL)) + (ConvertSupport(common::FIXEDBINARY, common::FLOAT4)) + (ConvertSupport(common::FIXEDBINARY, common::FLOAT8)) + (ConvertSupport(common::FIXEDBINARY, common::BIT)) + (ConvertSupport(common::FIXEDBINARY, common::VARCHAR)) + (ConvertSupport(common::FIXEDBINARY, common::VAR16CHAR)) + (ConvertSupport(common::FIXEDBINARY, common::VARBINARY)) + (ConvertSupport(common::FIXEDBINARY, common::INTERVALYEAR)) + (ConvertSupport(common::FIXEDBINARY, common::INTERVALDAY)) + (ConvertSupport(common::VARCHAR, common::TINYINT)) + (ConvertSupport(common::VARCHAR, common::INT)) + (ConvertSupport(common::VARCHAR, common::BIGINT)) + (ConvertSupport(common::VARCHAR, common::DECIMAL9)) + (ConvertSupport(common::VARCHAR, common::DECIMAL18)) + (ConvertSupport(common::VARCHAR, common::DECIMAL28SPARSE)) + (ConvertSupport(common::VARCHAR, common::DECIMAL38SPARSE)) + (ConvertSupport(common::VARCHAR, common::DATE)) + (ConvertSupport(common::VARCHAR, common::TIME)) + (ConvertSupport(common::VARCHAR, common::TIMESTAMP)) + (ConvertSupport(common::VARCHAR, common::INTERVAL)) + (ConvertSupport(common::VARCHAR, common::FLOAT4)) + (ConvertSupport(common::VARCHAR, common::FLOAT8)) + (ConvertSupport(common::VARCHAR, common::BIT)) + (ConvertSupport(common::VARCHAR, common::VARCHAR)) + (ConvertSupport(common::VARCHAR, common::VAR16CHAR)) + (ConvertSupport(common::VARCHAR, common::VARBINARY)) + (ConvertSupport(common::VARCHAR, common::INTERVALYEAR)) + (ConvertSupport(common::VARCHAR, common::INTERVALDAY)) + (ConvertSupport(common::VAR16CHAR, common::TINYINT)) + (ConvertSupport(common::VAR16CHAR, common::INT)) + (ConvertSupport(common::VAR16CHAR, common::BIGINT)) + (ConvertSupport(common::VAR16CHAR, common::DECIMAL9)) + (ConvertSupport(common::VAR16CHAR, common::DECIMAL18)) + (ConvertSupport(common::VAR16CHAR, common::DECIMAL28SPARSE)) + (ConvertSupport(common::VAR16CHAR, common::DECIMAL38SPARSE)) + (ConvertSupport(common::VAR16CHAR, common::DATE)) + (ConvertSupport(common::VAR16CHAR, common::TIME)) + (ConvertSupport(common::VAR16CHAR, common::TIMESTAMP)) + (ConvertSupport(common::VAR16CHAR, common::INTERVAL)) + (ConvertSupport(common::VAR16CHAR, common::FLOAT4)) + (ConvertSupport(common::VAR16CHAR, common::FLOAT8)) + (ConvertSupport(common::VAR16CHAR, common::BIT)) + (ConvertSupport(common::VAR16CHAR, common::VARCHAR)) + (ConvertSupport(common::VAR16CHAR, common::VARBINARY)) + (ConvertSupport(common::VAR16CHAR, common::INTERVALYEAR)) + (ConvertSupport(common::VAR16CHAR, common::INTERVALDAY)) + (ConvertSupport(common::VARBINARY, common::TINYINT)) + (ConvertSupport(common::VARBINARY, common::INT)) + (ConvertSupport(common::VARBINARY, common::BIGINT)) + (ConvertSupport(common::VARBINARY, common::DECIMAL9)) + (ConvertSupport(common::VARBINARY, common::DECIMAL18)) + (ConvertSupport(common::VARBINARY, common::DECIMAL28SPARSE)) + (ConvertSupport(common::VARBINARY, common::DECIMAL38SPARSE)) + (ConvertSupport(common::VARBINARY, common::DATE)) + (ConvertSupport(common::VARBINARY, common::TIME)) + (ConvertSupport(common::VARBINARY, common::TIMESTAMP)) + (ConvertSupport(common::VARBINARY, common::INTERVAL)) + (ConvertSupport(common::VARBINARY, common::FLOAT4)) + (ConvertSupport(common::VARBINARY, common::FLOAT8)) + (ConvertSupport(common::VARBINARY, common::BIT)) + (ConvertSupport(common::VARBINARY, common::VARCHAR)) + (ConvertSupport(common::VARBINARY, common::VAR16CHAR)) + (ConvertSupport(common::VARBINARY, common::VARBINARY)) + (ConvertSupport(common::VARBINARY, common::INTERVALYEAR)) + (ConvertSupport(common::VARBINARY, common::INTERVALDAY)) + (ConvertSupport(common::UINT1, common::INT)) + (ConvertSupport(common::UINT1, common::BIGINT)) + (ConvertSupport(common::UINT1, common::DECIMAL9)) + (ConvertSupport(common::UINT1, common::DECIMAL18)) + (ConvertSupport(common::UINT1, common::DECIMAL28SPARSE)) + (ConvertSupport(common::UINT1, common::DECIMAL38SPARSE)) + (ConvertSupport(common::UINT1, common::DATE)) + (ConvertSupport(common::UINT1, common::TIME)) + (ConvertSupport(common::UINT1, common::TIMESTAMP)) + (ConvertSupport(common::UINT1, common::INTERVAL)) + (ConvertSupport(common::UINT1, common::FLOAT4)) + (ConvertSupport(common::UINT1, common::FLOAT8)) + (ConvertSupport(common::UINT1, common::BIT)) + (ConvertSupport(common::UINT1, common::VARCHAR)) + (ConvertSupport(common::UINT1, common::VAR16CHAR)) + (ConvertSupport(common::UINT1, common::VARBINARY)) + (ConvertSupport(common::UINT1, common::INTERVALYEAR)) + (ConvertSupport(common::UINT1, common::INTERVALDAY)) + (ConvertSupport(common::UINT2, common::INT)) + (ConvertSupport(common::UINT2, common::BIGINT)) + (ConvertSupport(common::UINT2, common::DECIMAL9)) + (ConvertSupport(common::UINT2, common::DECIMAL18)) + (ConvertSupport(common::UINT2, common::DECIMAL28SPARSE)) + (ConvertSupport(common::UINT2, common::DECIMAL38SPARSE)) + (ConvertSupport(common::UINT2, common::DATE)) + (ConvertSupport(common::UINT2, common::TIME)) + (ConvertSupport(common::UINT2, common::TIMESTAMP)) + (ConvertSupport(common::UINT2, common::INTERVAL)) + (ConvertSupport(common::UINT2, common::FLOAT4)) + (ConvertSupport(common::UINT2, common::FLOAT8)) + (ConvertSupport(common::UINT2, common::BIT)) + (ConvertSupport(common::UINT2, common::VARCHAR)) + (ConvertSupport(common::UINT2, common::VAR16CHAR)) + (ConvertSupport(common::UINT2, common::VARBINARY)) + (ConvertSupport(common::UINT2, common::INTERVALYEAR)) + (ConvertSupport(common::UINT2, common::INTERVALDAY)) + (ConvertSupport(common::UINT4, common::INT)) + (ConvertSupport(common::UINT4, common::BIGINT)) + (ConvertSupport(common::UINT4, common::DECIMAL9)) + (ConvertSupport(common::UINT4, common::DECIMAL18)) + (ConvertSupport(common::UINT4, common::DECIMAL28SPARSE)) + (ConvertSupport(common::UINT4, common::DECIMAL38SPARSE)) + (ConvertSupport(common::UINT4, common::DATE)) + (ConvertSupport(common::UINT4, common::TIME)) + (ConvertSupport(common::UINT4, common::TIMESTAMP)) + (ConvertSupport(common::UINT4, common::INTERVAL)) + (ConvertSupport(common::UINT4, common::FLOAT4)) + (ConvertSupport(common::UINT4, common::FLOAT8)) + (ConvertSupport(common::UINT4, common::BIT)) + (ConvertSupport(common::UINT4, common::VARCHAR)) + (ConvertSupport(common::UINT4, common::VAR16CHAR)) + (ConvertSupport(common::UINT4, common::VARBINARY)) + (ConvertSupport(common::UINT4, common::INTERVALYEAR)) + (ConvertSupport(common::UINT4, common::INTERVALDAY)) + (ConvertSupport(common::UINT8, common::INT)) + (ConvertSupport(common::UINT8, common::BIGINT)) + (ConvertSupport(common::UINT8, common::DECIMAL9)) + (ConvertSupport(common::UINT8, common::DECIMAL18)) + (ConvertSupport(common::UINT8, common::DECIMAL28SPARSE)) + (ConvertSupport(common::UINT8, common::DECIMAL38SPARSE)) + (ConvertSupport(common::UINT8, common::DATE)) + (ConvertSupport(common::UINT8, common::TIME)) + (ConvertSupport(common::UINT8, common::TIMESTAMP)) + (ConvertSupport(common::UINT8, common::INTERVAL)) + (ConvertSupport(common::UINT8, common::FLOAT4)) + (ConvertSupport(common::UINT8, common::FLOAT8)) + (ConvertSupport(common::UINT8, common::BIT)) + (ConvertSupport(common::UINT8, common::VARCHAR)) + (ConvertSupport(common::UINT8, common::VAR16CHAR)) + (ConvertSupport(common::UINT8, common::VARBINARY)) + (ConvertSupport(common::UINT8, common::INTERVALYEAR)) + (ConvertSupport(common::UINT8, common::INTERVALDAY)) + (ConvertSupport(common::DECIMAL28DENSE, common::INT)) + (ConvertSupport(common::DECIMAL28DENSE, common::BIGINT)) + (ConvertSupport(common::DECIMAL28DENSE, common::DECIMAL9)) + (ConvertSupport(common::DECIMAL28DENSE, common::DECIMAL18)) + (ConvertSupport(common::DECIMAL28DENSE, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DECIMAL28DENSE, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DECIMAL28DENSE, common::DATE)) + (ConvertSupport(common::DECIMAL28DENSE, common::TIME)) + (ConvertSupport(common::DECIMAL28DENSE, common::TIMESTAMP)) + (ConvertSupport(common::DECIMAL28DENSE, common::INTERVAL)) + (ConvertSupport(common::DECIMAL28DENSE, common::FLOAT4)) + (ConvertSupport(common::DECIMAL28DENSE, common::FLOAT8)) + (ConvertSupport(common::DECIMAL28DENSE, common::BIT)) + (ConvertSupport(common::DECIMAL28DENSE, common::VARCHAR)) + (ConvertSupport(common::DECIMAL28DENSE, common::VAR16CHAR)) + (ConvertSupport(common::DECIMAL28DENSE, common::VARBINARY)) + (ConvertSupport(common::DECIMAL28DENSE, common::INTERVALYEAR)) + (ConvertSupport(common::DECIMAL28DENSE, common::INTERVALDAY)) + (ConvertSupport(common::DECIMAL38DENSE, common::INT)) + (ConvertSupport(common::DECIMAL38DENSE, common::BIGINT)) + (ConvertSupport(common::DECIMAL38DENSE, common::DECIMAL9)) + (ConvertSupport(common::DECIMAL38DENSE, common::DECIMAL18)) + (ConvertSupport(common::DECIMAL38DENSE, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DECIMAL38DENSE, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DECIMAL38DENSE, common::DATE)) + (ConvertSupport(common::DECIMAL38DENSE, common::TIME)) + (ConvertSupport(common::DECIMAL38DENSE, common::TIMESTAMP)) + (ConvertSupport(common::DECIMAL38DENSE, common::INTERVAL)) + (ConvertSupport(common::DECIMAL38DENSE, common::FLOAT4)) + (ConvertSupport(common::DECIMAL38DENSE, common::FLOAT8)) + (ConvertSupport(common::DECIMAL38DENSE, common::BIT)) + (ConvertSupport(common::DECIMAL38DENSE, common::VARCHAR)) + (ConvertSupport(common::DECIMAL38DENSE, common::VAR16CHAR)) + (ConvertSupport(common::DECIMAL38DENSE, common::VARBINARY)) + (ConvertSupport(common::DECIMAL38DENSE, common::INTERVALYEAR)) + (ConvertSupport(common::DECIMAL38DENSE, common::INTERVALDAY)) + (ConvertSupport(common::DM_UNKNOWN, common::TINYINT)) + (ConvertSupport(common::DM_UNKNOWN, common::INT)) + (ConvertSupport(common::DM_UNKNOWN, common::BIGINT)) + (ConvertSupport(common::DM_UNKNOWN, common::DECIMAL9)) + (ConvertSupport(common::DM_UNKNOWN, common::DECIMAL18)) + (ConvertSupport(common::DM_UNKNOWN, common::DECIMAL28SPARSE)) + (ConvertSupport(common::DM_UNKNOWN, common::DECIMAL38SPARSE)) + (ConvertSupport(common::DM_UNKNOWN, common::DATE)) + (ConvertSupport(common::DM_UNKNOWN, common::TIME)) + (ConvertSupport(common::DM_UNKNOWN, common::TIMESTAMP)) + (ConvertSupport(common::DM_UNKNOWN, common::INTERVAL)) + (ConvertSupport(common::DM_UNKNOWN, common::FLOAT4)) + (ConvertSupport(common::DM_UNKNOWN, common::FLOAT8)) + (ConvertSupport(common::DM_UNKNOWN, common::BIT)) + (ConvertSupport(common::DM_UNKNOWN, common::VARCHAR)) + (ConvertSupport(common::DM_UNKNOWN, common::VAR16CHAR)) + (ConvertSupport(common::DM_UNKNOWN, common::VARBINARY)) + (ConvertSupport(common::DM_UNKNOWN, common::INTERVALYEAR)) + (ConvertSupport(common::DM_UNKNOWN, common::INTERVALDAY)) + (ConvertSupport(common::INTERVALYEAR, common::INT)) + (ConvertSupport(common::INTERVALYEAR, common::BIGINT)) + (ConvertSupport(common::INTERVALYEAR, common::DECIMAL9)) + (ConvertSupport(common::INTERVALYEAR, common::DECIMAL18)) + (ConvertSupport(common::INTERVALYEAR, common::DECIMAL28SPARSE)) + (ConvertSupport(common::INTERVALYEAR, common::DECIMAL38SPARSE)) + (ConvertSupport(common::INTERVALYEAR, common::DATE)) + (ConvertSupport(common::INTERVALYEAR, common::TIME)) + (ConvertSupport(common::INTERVALYEAR, common::TIMESTAMP)) + (ConvertSupport(common::INTERVALYEAR, common::INTERVAL)) + (ConvertSupport(common::INTERVALYEAR, common::FLOAT4)) + (ConvertSupport(common::INTERVALYEAR, common::FLOAT8)) + (ConvertSupport(common::INTERVALYEAR, common::BIT)) + (ConvertSupport(common::INTERVALYEAR, common::VARCHAR)) + (ConvertSupport(common::INTERVALYEAR, common::VAR16CHAR)) + (ConvertSupport(common::INTERVALYEAR, common::VARBINARY)) + (ConvertSupport(common::INTERVALYEAR, common::INTERVALYEAR)) + (ConvertSupport(common::INTERVALYEAR, common::INTERVALDAY)) + (ConvertSupport(common::INTERVALDAY, common::INT)) + (ConvertSupport(common::INTERVALDAY, common::BIGINT)) + (ConvertSupport(common::INTERVALDAY, common::DECIMAL9)) + (ConvertSupport(common::INTERVALDAY, common::DECIMAL18)) + (ConvertSupport(common::INTERVALDAY, common::DECIMAL28SPARSE)) + (ConvertSupport(common::INTERVALDAY, common::DECIMAL38SPARSE)) + (ConvertSupport(common::INTERVALDAY, common::DATE)) + (ConvertSupport(common::INTERVALDAY, common::TIME)) + (ConvertSupport(common::INTERVALDAY, common::TIMESTAMP)) + (ConvertSupport(common::INTERVALDAY, common::INTERVAL)) + (ConvertSupport(common::INTERVALDAY, common::FLOAT4)) + (ConvertSupport(common::INTERVALDAY, common::FLOAT8)) + (ConvertSupport(common::INTERVALDAY, common::BIT)) + (ConvertSupport(common::INTERVALDAY, common::VARCHAR)) + (ConvertSupport(common::INTERVALDAY, common::VAR16CHAR)) + (ConvertSupport(common::INTERVALDAY, common::VARBINARY)) + (ConvertSupport(common::INTERVALDAY, common::INTERVALYEAR)) + (ConvertSupport(common::INTERVALDAY, common::INTERVALDAY)); + +static exec::user::ServerMeta createDefaultServerMeta() { + exec::user::ServerMeta result; + + result.set_all_tables_selectable(false); + result.set_blob_included_in_max_row_size(true); + result.set_catalog_at_start(true); + result.set_catalog_separator(s_catalogSeparator); + result.set_catalog_term(s_catalogTerm); + result.set_column_aliasing_supported(true); + std::copy(s_convertMap.begin(), s_convertMap.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_convert_support())); + result.set_correlation_names_support(exec::user::CN_ANY); + std::copy(s_dateTimeFunctions.begin(), s_dateTimeFunctions.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_date_time_functions())); + std::copy(s_dateTimeLiterals.begin(), s_dateTimeLiterals.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_date_time_literals_support())); + result.set_group_by_support(exec::user::GB_UNRELATED); + result.set_identifier_casing(exec::user::IC_STORES_MIXED); + result.set_identifier_quote_string(s_identifierQuoteString); + result.set_like_escape_clause_supported(true); + result.set_max_catalog_name_length(s_maxIdentifierSize); + result.set_max_column_name_length(s_maxIdentifierSize); + result.set_max_cursor_name_length(s_maxIdentifierSize); + result.set_max_schema_name_length(s_maxIdentifierSize); + result.set_max_table_name_length(s_maxIdentifierSize); + result.set_max_user_name_length(s_maxIdentifierSize); + result.set_null_collation(exec::user::NC_AT_END); + result.set_null_plus_non_null_equals_null(true); + std::copy(s_numericFunctions.begin(), s_numericFunctions.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_numeric_functions())); + std::copy(s_orderBySupport.begin(), s_orderBySupport.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_order_by_support())); + std::copy(s_outerJoinSupport.begin(), s_outerJoinSupport.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_outer_join_support())); + result.set_quoted_identifier_casing(exec::user::IC_STORES_MIXED); + result.set_read_only(false); + result.set_schema_term(s_schemaTerm); + result.set_search_escape_string(s_searchEscapeString); + result.set_special_characters(s_specialCharacters); + std::copy(s_sqlKeywords.begin(), s_sqlKeywords.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_sql_keywords())); + std::copy(s_stringFunctions.begin(), s_stringFunctions.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_string_functions())); + std::copy(s_subQuerySupport.begin(), s_subQuerySupport.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_subquery_support())); + std::copy(s_systemFunctions.begin(), s_systemFunctions.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_system_functions())); + result.set_table_term(s_tableTerm); + std::copy(s_unionSupport.begin(), s_unionSupport.end(), + google::protobuf::RepeatedFieldBackInserter(result.mutable_union_support())); + + return result; +} + +static Drill::meta::CollateSupport collateSupport(const google::protobuf::RepeatedField& collateSupportList) { + Drill::meta::CollateSupport result(Drill::meta::C_NONE); + + for(google::protobuf::RepeatedField::const_iterator it = collateSupportList.begin(); + it != collateSupportList.end(); + ++it) { + switch(static_cast(*it)) { + case exec::user::CS_GROUP_BY: + result |= Drill::meta::C_GROUPBY; + break; + + // ignore unknown + case exec::user::CS_UNKNOWN: + default: + break; + } + } + return result; +} + +static Drill::meta::CorrelationNamesSupport correlationNames(exec::user::CorrelationNamesSupport correlatioNamesSupport) { + switch(correlatioNamesSupport) { + case exec::user::CN_DIFFERENT_NAMES: + return Drill::meta::CN_DIFFERENT_NAMES; + + case exec::user::CN_ANY: + return Drill::meta::CN_ANY_NAMES; + + case exec::user::CN_NONE: + default: + // unknown value + return CN_NONE; + } +} + +static Drill::meta::DateTimeLiteralSupport dateTimeLiteralsSupport(const google::protobuf::RepeatedField& dateTimeLiteralsSupportList) { + Drill::meta::DateTimeLiteralSupport result(Drill::meta::DL_NONE); + + for(google::protobuf::RepeatedField::const_iterator it = dateTimeLiteralsSupportList.begin(); + it != dateTimeLiteralsSupportList.end(); + ++it) { + switch(static_cast(*it)) { + case exec::user::DL_DATE: + result |= Drill::meta::DL_DATE; + break; + + case exec::user::DL_TIME: + result |= Drill::meta::DL_TIME; + break; + + case exec::user::DL_TIMESTAMP: + result |= Drill::meta::DL_TIMESTAMP; + break; + + case exec::user::DL_INTERVAL_YEAR: + result |= Drill::meta::DL_INTERVAL_YEAR; + break; + + case exec::user::DL_INTERVAL_YEAR_TO_MONTH: + result |= Drill::meta::DL_INTERVAL_YEAR_TO_MONTH; + break; + + case exec::user::DL_INTERVAL_MONTH: + result |= Drill::meta::DL_INTERVAL_MONTH; + break; + + case exec::user::DL_INTERVAL_DAY: + result |= Drill::meta::DL_INTERVAL_DAY; + break; + + case exec::user::DL_INTERVAL_DAY_TO_HOUR: + result |= Drill::meta::DL_INTERVAL_DAY_TO_HOUR; + break; + + case exec::user::DL_INTERVAL_DAY_TO_MINUTE: + result |= Drill::meta::DL_INTERVAL_DAY_TO_MINUTE; + break; + + case exec::user::DL_INTERVAL_DAY_TO_SECOND: + result |= Drill::meta::DL_INTERVAL_DAY_TO_SECOND; + break; + + case exec::user::DL_INTERVAL_HOUR: + result |= Drill::meta::DL_INTERVAL_HOUR; + break; + + case exec::user::DL_INTERVAL_HOUR_TO_MINUTE: + result |= Drill::meta::DL_INTERVAL_HOUR_TO_MINUTE; + break; + + case exec::user::DL_INTERVAL_HOUR_TO_SECOND: + result |= Drill::meta::DL_INTERVAL_HOUR_TO_SECOND; + break; + + case exec::user::DL_INTERVAL_MINUTE: + result |= Drill::meta::DL_TIMESTAMP; + break; + + case exec::user::DL_INTERVAL_MINUTE_TO_SECOND: + result |= Drill::meta::DL_TIMESTAMP; + break; + + case exec::user::DL_INTERVAL_SECOND: + result |= Drill::meta::DL_INTERVAL_SECOND; + break; + + // ignore unknown + case exec::user::DL_UNKNOWN: + default: + break; + } + } + + return result; +} + +static Drill::meta::GroupBySupport groupBySupport(exec::user::GroupBySupport groupBySupport) { + switch(groupBySupport) { + case exec::user::GB_SELECT_ONLY: + return Drill::meta::GB_SELECT_ONLY; -struct FromTo { - FromTo(common::MinorType from, common::MinorType to): m_from(from), m_to(to) {} + case exec::user::GB_BEYOND_SELECT: + return Drill::meta::GB_BEYOND_SELECT; - common::MinorType m_from; - common::MinorType m_to; -}; + case exec::user::GB_NONE: + default: + // unknown value + return Drill::meta::GB_NONE; + } +} + +static Drill::meta::IdentifierCase identifierCase(exec::user::IdentifierCasing identifierCasing) { + switch(identifierCasing) { + case exec::user::IC_STORES_LOWER: + return Drill::meta::IC_STORES_LOWER; + + case exec::user::IC_STORES_MIXED: + return Drill::meta::IC_STORES_MIXED; + + case exec::user::IC_STORES_UPPER: + return Drill::meta::IC_STORES_UPPER; + + case exec::user::IC_SUPPORTS_MIXED: + return Drill::meta::IC_SUPPORTS_MIXED; + + case exec::user::IC_UNKNOWN: + default: + // unknown value + return Drill::meta::IC_UNKNOWN; + } +} + +static Drill::meta::NullCollation nullCollation(exec::user::NullCollation nullCollation) { + switch(nullCollation) { + case exec::user::NC_AT_END: + return Drill::meta::NC_AT_END; + + case exec::user::NC_AT_START: + return Drill::meta::NC_AT_START; + + case exec::user::NC_HIGH: + return Drill::meta::NC_HIGH; + + case exec::user::NC_LOW: + return Drill::meta::NC_LOW; + + case exec::user::NC_UNKNOWN: + default: + // unknown value + return Drill::meta::NC_UNKNOWN; + } +} + +static Drill::meta::OuterJoinSupport outerJoinSupport(const google::protobuf::RepeatedField& outerJoinSupportList) { + Drill::meta::OuterJoinSupport result(Drill::meta::OJ_NONE); + + for(google::protobuf::RepeatedField::const_iterator it = outerJoinSupportList.begin(); + it != outerJoinSupportList.end(); + ++it) { + switch(static_cast(*it)) { + case exec::user::OJ_LEFT: + result |= Drill::meta::OJ_LEFT; + break; + + case exec::user::OJ_RIGHT: + result |= Drill::meta::OJ_RIGHT; + break; + + case exec::user::OJ_FULL: + result |= Drill::meta::OJ_FULL; + break; + + case exec::user::OJ_NESTED: + result |= Drill::meta::OJ_NESTED; + break; + + case exec::user::OJ_INNER: + result |= Drill::meta::OJ_INNER; + break; + + case exec::user::OJ_NOT_ORDERED: + result |= Drill::meta::OJ_NOT_ORDERED; + break; + + case exec::user::OJ_ALL_COMPARISON_OPS: + result |= Drill::meta::OJ_ALL_COMPARISON_OPS; + break; + + // ignore unknown + case exec::user::OJ_UNKNOWN: + default: + break; + } + } -bool operator==(FromTo const& ft1, FromTo const& ft2) { - return ft1.m_from == ft2.m_from && ft1.m_to == ft2.m_to; + return result; } -std::size_t hash_value(FromTo const& ft) { - std::size_t hash = 0; - boost::hash_combine(hash, ft.m_from); - boost::hash_combine(hash, ft.m_to); +static Drill::meta::QuotedIdentifierCase quotedIdentifierCase(exec::user::IdentifierCasing identifierCasing) { + switch(identifierCasing) { + case exec::user::IC_STORES_LOWER: + return Drill::meta::QIC_STORES_LOWER; - return hash; + case exec::user::IC_STORES_MIXED: + return Drill::meta::QIC_STORES_MIXED; + + case exec::user::IC_STORES_UPPER: + return Drill::meta::QIC_STORES_UPPER; + + case exec::user::IC_SUPPORTS_MIXED: + return Drill::meta::QIC_SUPPORTS_MIXED; + + case exec::user::IC_UNKNOWN: + default: + // unknown value + return Drill::meta::QIC_UNKNOWN; + } +} + +static Drill::meta::SubQuerySupport subQuerySupport(const google::protobuf::RepeatedField& subQuerySupportList) { + Drill::meta::SubQuerySupport result(Drill::meta::SQ_NONE); + + for(google::protobuf::RepeatedField::const_iterator it = subQuerySupportList.begin(); + it != subQuerySupportList.end(); + ++it) { + switch(static_cast(*it)) { + case exec::user::SQ_CORRELATED: + result |= Drill::meta::SQ_CORRELATED; + break; + + case exec::user::SQ_IN_COMPARISON: + result |= Drill::meta::SQ_IN_COMPARISON; + break; + + case exec::user::SQ_IN_EXISTS: + result |= Drill::meta::SQ_IN_EXISTS; + break; + + case exec::user::SQ_IN_INSERT: + result |= Drill::meta::SQ_IN_INSERT; + break; + + case exec::user::SQ_IN_QUANTIFIED: + result |= Drill::meta::SQ_IN_QUANTIFIED; + break; + + // ignore unknown + case exec::user::SQ_UNKNOWN: + default: + break; + } + } + + return result; } -static boost::unordered_set s_convertMap = boost::assign::list_of - (FromTo(common::TINYINT, common::INT)) - (FromTo(common::TINYINT, common::BIGINT)) - (FromTo(common::TINYINT, common::DECIMAL9)) - (FromTo(common::TINYINT, common::DECIMAL18)) - (FromTo(common::TINYINT, common::DECIMAL28SPARSE)) - (FromTo(common::TINYINT, common::DECIMAL38SPARSE)) - (FromTo(common::TINYINT, common::DATE)) - (FromTo(common::TINYINT, common::TIME)) - (FromTo(common::TINYINT, common::TIMESTAMP)) - (FromTo(common::TINYINT, common::INTERVAL)) - (FromTo(common::TINYINT, common::FLOAT4)) - (FromTo(common::TINYINT, common::FLOAT8)) - (FromTo(common::TINYINT, common::BIT)) - (FromTo(common::TINYINT, common::VARCHAR)) - (FromTo(common::TINYINT, common::VAR16CHAR)) - (FromTo(common::TINYINT, common::VARBINARY)) - (FromTo(common::TINYINT, common::INTERVALYEAR)) - (FromTo(common::TINYINT, common::INTERVALDAY)) - (FromTo(common::SMALLINT, common::INT)) - (FromTo(common::SMALLINT, common::BIGINT)) - (FromTo(common::SMALLINT, common::DECIMAL9)) - (FromTo(common::SMALLINT, common::DECIMAL18)) - (FromTo(common::SMALLINT, common::DECIMAL28SPARSE)) - (FromTo(common::SMALLINT, common::DECIMAL38SPARSE)) - (FromTo(common::SMALLINT, common::DATE)) - (FromTo(common::SMALLINT, common::TIME)) - (FromTo(common::SMALLINT, common::TIMESTAMP)) - (FromTo(common::SMALLINT, common::INTERVAL)) - (FromTo(common::SMALLINT, common::FLOAT4)) - (FromTo(common::SMALLINT, common::FLOAT8)) - (FromTo(common::SMALLINT, common::BIT)) - (FromTo(common::SMALLINT, common::VARCHAR)) - (FromTo(common::SMALLINT, common::VAR16CHAR)) - (FromTo(common::SMALLINT, common::VARBINARY)) - (FromTo(common::SMALLINT, common::INTERVALYEAR)) - (FromTo(common::SMALLINT, common::INTERVALDAY)) - (FromTo(common::INT, common::INT)) - (FromTo(common::INT, common::BIGINT)) - (FromTo(common::INT, common::DECIMAL9)) - (FromTo(common::INT, common::DECIMAL18)) - (FromTo(common::INT, common::DECIMAL28SPARSE)) - (FromTo(common::INT, common::DECIMAL38SPARSE)) - (FromTo(common::INT, common::DATE)) - (FromTo(common::INT, common::TIME)) - (FromTo(common::INT, common::TIMESTAMP)) - (FromTo(common::INT, common::INTERVAL)) - (FromTo(common::INT, common::FLOAT4)) - (FromTo(common::INT, common::FLOAT8)) - (FromTo(common::INT, common::BIT)) - (FromTo(common::INT, common::VARCHAR)) - (FromTo(common::INT, common::VAR16CHAR)) - (FromTo(common::INT, common::VARBINARY)) - (FromTo(common::INT, common::INTERVALYEAR)) - (FromTo(common::INT, common::INTERVALDAY)) - (FromTo(common::BIGINT, common::INT)) - (FromTo(common::BIGINT, common::BIGINT)) - (FromTo(common::BIGINT, common::DECIMAL9)) - (FromTo(common::BIGINT, common::DECIMAL18)) - (FromTo(common::BIGINT, common::DECIMAL28SPARSE)) - (FromTo(common::BIGINT, common::DECIMAL38SPARSE)) - (FromTo(common::BIGINT, common::DATE)) - (FromTo(common::BIGINT, common::TIME)) - (FromTo(common::BIGINT, common::TIMESTAMP)) - (FromTo(common::BIGINT, common::INTERVAL)) - (FromTo(common::BIGINT, common::FLOAT4)) - (FromTo(common::BIGINT, common::FLOAT8)) - (FromTo(common::BIGINT, common::BIT)) - (FromTo(common::BIGINT, common::VARCHAR)) - (FromTo(common::BIGINT, common::VAR16CHAR)) - (FromTo(common::BIGINT, common::VARBINARY)) - (FromTo(common::BIGINT, common::INTERVALYEAR)) - (FromTo(common::BIGINT, common::INTERVALDAY)) - (FromTo(common::DECIMAL9, common::INT)) - (FromTo(common::DECIMAL9, common::BIGINT)) - (FromTo(common::DECIMAL9, common::DECIMAL9)) - (FromTo(common::DECIMAL9, common::DECIMAL18)) - (FromTo(common::DECIMAL9, common::DECIMAL28SPARSE)) - (FromTo(common::DECIMAL9, common::DECIMAL38SPARSE)) - (FromTo(common::DECIMAL9, common::DATE)) - (FromTo(common::DECIMAL9, common::TIME)) - (FromTo(common::DECIMAL9, common::TIMESTAMP)) - (FromTo(common::DECIMAL9, common::INTERVAL)) - (FromTo(common::DECIMAL9, common::FLOAT4)) - (FromTo(common::DECIMAL9, common::FLOAT8)) - (FromTo(common::DECIMAL9, common::BIT)) - (FromTo(common::DECIMAL9, common::VARCHAR)) - (FromTo(common::DECIMAL9, common::VAR16CHAR)) - (FromTo(common::DECIMAL9, common::VARBINARY)) - (FromTo(common::DECIMAL9, common::INTERVALYEAR)) - (FromTo(common::DECIMAL9, common::INTERVALDAY)) - (FromTo(common::DECIMAL18, common::INT)) - (FromTo(common::DECIMAL18, common::BIGINT)) - (FromTo(common::DECIMAL18, common::DECIMAL9)) - (FromTo(common::DECIMAL18, common::DECIMAL18)) - (FromTo(common::DECIMAL18, common::DECIMAL28SPARSE)) - (FromTo(common::DECIMAL18, common::DECIMAL38SPARSE)) - (FromTo(common::DECIMAL18, common::DATE)) - (FromTo(common::DECIMAL18, common::TIME)) - (FromTo(common::DECIMAL18, common::TIMESTAMP)) - (FromTo(common::DECIMAL18, common::INTERVAL)) - (FromTo(common::DECIMAL18, common::FLOAT4)) - (FromTo(common::DECIMAL18, common::FLOAT8)) - (FromTo(common::DECIMAL18, common::BIT)) - (FromTo(common::DECIMAL18, common::VARCHAR)) - (FromTo(common::DECIMAL18, common::VAR16CHAR)) - (FromTo(common::DECIMAL18, common::VARBINARY)) - (FromTo(common::DECIMAL18, common::INTERVALYEAR)) - (FromTo(common::DECIMAL18, common::INTERVALDAY)) - (FromTo(common::DECIMAL28SPARSE, common::INT)) - (FromTo(common::DECIMAL28SPARSE, common::BIGINT)) - (FromTo(common::DECIMAL28SPARSE, common::DECIMAL9)) - (FromTo(common::DECIMAL28SPARSE, common::DECIMAL18)) - (FromTo(common::DECIMAL28SPARSE, common::DECIMAL28SPARSE)) - (FromTo(common::DECIMAL28SPARSE, common::DECIMAL38SPARSE)) - (FromTo(common::DECIMAL28SPARSE, common::DATE)) - (FromTo(common::DECIMAL28SPARSE, common::TIME)) - (FromTo(common::DECIMAL28SPARSE, common::TIMESTAMP)) - (FromTo(common::DECIMAL28SPARSE, common::INTERVAL)) - (FromTo(common::DECIMAL28SPARSE, common::FLOAT4)) - (FromTo(common::DECIMAL28SPARSE, common::FLOAT8)) - (FromTo(common::DECIMAL28SPARSE, common::BIT)) - (FromTo(common::DECIMAL28SPARSE, common::VARCHAR)) - (FromTo(common::DECIMAL28SPARSE, common::VAR16CHAR)) - (FromTo(common::DECIMAL28SPARSE, common::VARBINARY)) - (FromTo(common::DECIMAL28SPARSE, common::INTERVALYEAR)) - (FromTo(common::DECIMAL28SPARSE, common::INTERVALDAY)) - (FromTo(common::DECIMAL38SPARSE, common::INT)) - (FromTo(common::DECIMAL38SPARSE, common::BIGINT)) - (FromTo(common::DECIMAL38SPARSE, common::DECIMAL9)) - (FromTo(common::DECIMAL38SPARSE, common::DECIMAL18)) - (FromTo(common::DECIMAL38SPARSE, common::DECIMAL28SPARSE)) - (FromTo(common::DECIMAL38SPARSE, common::DECIMAL38SPARSE)) - (FromTo(common::DECIMAL38SPARSE, common::DATE)) - (FromTo(common::DECIMAL38SPARSE, common::TIME)) - (FromTo(common::DECIMAL38SPARSE, common::TIMESTAMP)) - (FromTo(common::DECIMAL38SPARSE, common::INTERVAL)) - (FromTo(common::DECIMAL38SPARSE, common::FLOAT4)) - (FromTo(common::DECIMAL38SPARSE, common::FLOAT8)) - (FromTo(common::DECIMAL38SPARSE, common::BIT)) - (FromTo(common::DECIMAL38SPARSE, common::VARCHAR)) - (FromTo(common::DECIMAL38SPARSE, common::VAR16CHAR)) - (FromTo(common::DECIMAL38SPARSE, common::VARBINARY)) - (FromTo(common::DECIMAL38SPARSE, common::INTERVALYEAR)) - (FromTo(common::DECIMAL38SPARSE, common::INTERVALDAY)) - (FromTo(common::MONEY, common::INT)) - (FromTo(common::MONEY, common::BIGINT)) - (FromTo(common::MONEY, common::DECIMAL9)) - (FromTo(common::MONEY, common::DECIMAL18)) - (FromTo(common::MONEY, common::DECIMAL28SPARSE)) - (FromTo(common::MONEY, common::DECIMAL38SPARSE)) - (FromTo(common::MONEY, common::DATE)) - (FromTo(common::MONEY, common::TIME)) - (FromTo(common::MONEY, common::TIMESTAMP)) - (FromTo(common::MONEY, common::INTERVAL)) - (FromTo(common::MONEY, common::FLOAT4)) - (FromTo(common::MONEY, common::FLOAT8)) - (FromTo(common::MONEY, common::BIT)) - (FromTo(common::MONEY, common::VARCHAR)) - (FromTo(common::MONEY, common::VAR16CHAR)) - (FromTo(common::MONEY, common::VARBINARY)) - (FromTo(common::MONEY, common::INTERVALYEAR)) - (FromTo(common::MONEY, common::INTERVALDAY)) - (FromTo(common::DATE, common::INT)) - (FromTo(common::DATE, common::BIGINT)) - (FromTo(common::DATE, common::DECIMAL9)) - (FromTo(common::DATE, common::DECIMAL18)) - (FromTo(common::DATE, common::DECIMAL28SPARSE)) - (FromTo(common::DATE, common::DECIMAL38SPARSE)) - (FromTo(common::DATE, common::DATE)) - (FromTo(common::DATE, common::TIME)) - (FromTo(common::DATE, common::TIMESTAMP)) - (FromTo(common::DATE, common::INTERVAL)) - (FromTo(common::DATE, common::FLOAT4)) - (FromTo(common::DATE, common::FLOAT8)) - (FromTo(common::DATE, common::BIT)) - (FromTo(common::DATE, common::VARCHAR)) - (FromTo(common::DATE, common::VAR16CHAR)) - (FromTo(common::DATE, common::VARBINARY)) - (FromTo(common::DATE, common::INTERVALYEAR)) - (FromTo(common::DATE, common::INTERVALDAY)) - (FromTo(common::TIME, common::INT)) - (FromTo(common::TIME, common::BIGINT)) - (FromTo(common::TIME, common::DECIMAL9)) - (FromTo(common::TIME, common::DECIMAL18)) - (FromTo(common::TIME, common::DECIMAL28SPARSE)) - (FromTo(common::TIME, common::DECIMAL38SPARSE)) - (FromTo(common::TIME, common::DATE)) - (FromTo(common::TIME, common::TIME)) - (FromTo(common::TIME, common::TIMESTAMP)) - (FromTo(common::TIME, common::INTERVAL)) - (FromTo(common::TIME, common::FLOAT4)) - (FromTo(common::TIME, common::FLOAT8)) - (FromTo(common::TIME, common::BIT)) - (FromTo(common::TIME, common::VARCHAR)) - (FromTo(common::TIME, common::VAR16CHAR)) - (FromTo(common::TIME, common::VARBINARY)) - (FromTo(common::TIME, common::INTERVALYEAR)) - (FromTo(common::TIME, common::INTERVALDAY)) - (FromTo(common::TIMESTAMPTZ, common::INT)) - (FromTo(common::TIMESTAMPTZ, common::BIGINT)) - (FromTo(common::TIMESTAMPTZ, common::DECIMAL9)) - (FromTo(common::TIMESTAMPTZ, common::DECIMAL18)) - (FromTo(common::TIMESTAMPTZ, common::DECIMAL28SPARSE)) - (FromTo(common::TIMESTAMPTZ, common::DECIMAL38SPARSE)) - (FromTo(common::TIMESTAMPTZ, common::DATE)) - (FromTo(common::TIMESTAMPTZ, common::TIME)) - (FromTo(common::TIMESTAMPTZ, common::TIMESTAMP)) - (FromTo(common::TIMESTAMPTZ, common::INTERVAL)) - (FromTo(common::TIMESTAMPTZ, common::FLOAT4)) - (FromTo(common::TIMESTAMPTZ, common::FLOAT8)) - (FromTo(common::TIMESTAMPTZ, common::BIT)) - (FromTo(common::TIMESTAMPTZ, common::VARCHAR)) - (FromTo(common::TIMESTAMPTZ, common::VAR16CHAR)) - (FromTo(common::TIMESTAMPTZ, common::VARBINARY)) - (FromTo(common::TIMESTAMPTZ, common::INTERVALYEAR)) - (FromTo(common::TIMESTAMPTZ, common::INTERVALDAY)) - (FromTo(common::TIMESTAMP, common::INT)) - (FromTo(common::TIMESTAMP, common::BIGINT)) - (FromTo(common::TIMESTAMP, common::DECIMAL9)) - (FromTo(common::TIMESTAMP, common::DECIMAL18)) - (FromTo(common::TIMESTAMP, common::DECIMAL28SPARSE)) - (FromTo(common::TIMESTAMP, common::DECIMAL38SPARSE)) - (FromTo(common::TIMESTAMP, common::DATE)) - (FromTo(common::TIMESTAMP, common::TIME)) - (FromTo(common::TIMESTAMP, common::TIMESTAMP)) - (FromTo(common::TIMESTAMP, common::INTERVAL)) - (FromTo(common::TIMESTAMP, common::FLOAT4)) - (FromTo(common::TIMESTAMP, common::FLOAT8)) - (FromTo(common::TIMESTAMP, common::BIT)) - (FromTo(common::TIMESTAMP, common::VARCHAR)) - (FromTo(common::TIMESTAMP, common::VAR16CHAR)) - (FromTo(common::TIMESTAMP, common::VARBINARY)) - (FromTo(common::TIMESTAMP, common::INTERVALYEAR)) - (FromTo(common::TIMESTAMP, common::INTERVALDAY)) - (FromTo(common::INTERVAL, common::INT)) - (FromTo(common::INTERVAL, common::BIGINT)) - (FromTo(common::INTERVAL, common::DECIMAL9)) - (FromTo(common::INTERVAL, common::DECIMAL18)) - (FromTo(common::INTERVAL, common::DECIMAL28SPARSE)) - (FromTo(common::INTERVAL, common::DECIMAL38SPARSE)) - (FromTo(common::INTERVAL, common::DATE)) - (FromTo(common::INTERVAL, common::TIME)) - (FromTo(common::INTERVAL, common::TIMESTAMP)) - (FromTo(common::INTERVAL, common::INTERVAL)) - (FromTo(common::INTERVAL, common::FLOAT4)) - (FromTo(common::INTERVAL, common::FLOAT8)) - (FromTo(common::INTERVAL, common::BIT)) - (FromTo(common::INTERVAL, common::VARCHAR)) - (FromTo(common::INTERVAL, common::VAR16CHAR)) - (FromTo(common::INTERVAL, common::VARBINARY)) - (FromTo(common::INTERVAL, common::INTERVALYEAR)) - (FromTo(common::INTERVAL, common::INTERVALDAY)) - (FromTo(common::FLOAT4, common::INT)) - (FromTo(common::FLOAT4, common::BIGINT)) - (FromTo(common::FLOAT4, common::DECIMAL9)) - (FromTo(common::FLOAT4, common::DECIMAL18)) - (FromTo(common::FLOAT4, common::DECIMAL28SPARSE)) - (FromTo(common::FLOAT4, common::DECIMAL38SPARSE)) - (FromTo(common::FLOAT4, common::DATE)) - (FromTo(common::FLOAT4, common::TIME)) - (FromTo(common::FLOAT4, common::TIMESTAMP)) - (FromTo(common::FLOAT4, common::INTERVAL)) - (FromTo(common::FLOAT4, common::FLOAT4)) - (FromTo(common::FLOAT4, common::FLOAT8)) - (FromTo(common::FLOAT4, common::BIT)) - (FromTo(common::FLOAT4, common::VARCHAR)) - (FromTo(common::FLOAT4, common::VAR16CHAR)) - (FromTo(common::FLOAT4, common::VARBINARY)) - (FromTo(common::FLOAT4, common::INTERVALYEAR)) - (FromTo(common::FLOAT4, common::INTERVALDAY)) - (FromTo(common::FLOAT8, common::INT)) - (FromTo(common::FLOAT8, common::BIGINT)) - (FromTo(common::FLOAT8, common::DECIMAL9)) - (FromTo(common::FLOAT8, common::DECIMAL18)) - (FromTo(common::FLOAT8, common::DECIMAL28SPARSE)) - (FromTo(common::FLOAT8, common::DECIMAL38SPARSE)) - (FromTo(common::FLOAT8, common::DATE)) - (FromTo(common::FLOAT8, common::TIME)) - (FromTo(common::FLOAT8, common::TIMESTAMP)) - (FromTo(common::FLOAT8, common::INTERVAL)) - (FromTo(common::FLOAT8, common::FLOAT4)) - (FromTo(common::FLOAT8, common::FLOAT8)) - (FromTo(common::FLOAT8, common::BIT)) - (FromTo(common::FLOAT8, common::VARCHAR)) - (FromTo(common::FLOAT8, common::VAR16CHAR)) - (FromTo(common::FLOAT8, common::VARBINARY)) - (FromTo(common::FLOAT8, common::INTERVALYEAR)) - (FromTo(common::FLOAT8, common::INTERVALDAY)) - (FromTo(common::BIT, common::TINYINT)) - (FromTo(common::BIT, common::INT)) - (FromTo(common::BIT, common::BIGINT)) - (FromTo(common::BIT, common::DECIMAL9)) - (FromTo(common::BIT, common::DECIMAL18)) - (FromTo(common::BIT, common::DECIMAL28SPARSE)) - (FromTo(common::BIT, common::DECIMAL38SPARSE)) - (FromTo(common::BIT, common::DATE)) - (FromTo(common::BIT, common::TIME)) - (FromTo(common::BIT, common::TIMESTAMP)) - (FromTo(common::BIT, common::INTERVAL)) - (FromTo(common::BIT, common::FLOAT4)) - (FromTo(common::BIT, common::FLOAT8)) - (FromTo(common::BIT, common::BIT)) - (FromTo(common::BIT, common::VARCHAR)) - (FromTo(common::BIT, common::VAR16CHAR)) - (FromTo(common::BIT, common::VARBINARY)) - (FromTo(common::BIT, common::INTERVALYEAR)) - (FromTo(common::BIT, common::INTERVALDAY)) - (FromTo(common::FIXEDCHAR, common::TINYINT)) - (FromTo(common::FIXEDCHAR, common::INT)) - (FromTo(common::FIXEDCHAR, common::BIGINT)) - (FromTo(common::FIXEDCHAR, common::DECIMAL9)) - (FromTo(common::FIXEDCHAR, common::DECIMAL18)) - (FromTo(common::FIXEDCHAR, common::DECIMAL28SPARSE)) - (FromTo(common::FIXEDCHAR, common::DECIMAL38SPARSE)) - (FromTo(common::FIXEDCHAR, common::DATE)) - (FromTo(common::FIXEDCHAR, common::TIME)) - (FromTo(common::FIXEDCHAR, common::TIMESTAMP)) - (FromTo(common::FIXEDCHAR, common::INTERVAL)) - (FromTo(common::FIXEDCHAR, common::FLOAT4)) - (FromTo(common::FIXEDCHAR, common::FLOAT8)) - (FromTo(common::FIXEDCHAR, common::BIT)) - (FromTo(common::FIXEDCHAR, common::VARCHAR)) - (FromTo(common::FIXEDCHAR, common::VAR16CHAR)) - (FromTo(common::FIXEDCHAR, common::VARBINARY)) - (FromTo(common::FIXEDCHAR, common::INTERVALYEAR)) - (FromTo(common::FIXEDCHAR, common::INTERVALDAY)) - (FromTo(common::FIXED16CHAR, common::TINYINT)) - (FromTo(common::FIXED16CHAR, common::INT)) - (FromTo(common::FIXED16CHAR, common::BIGINT)) - (FromTo(common::FIXED16CHAR, common::DECIMAL9)) - (FromTo(common::FIXED16CHAR, common::DECIMAL18)) - (FromTo(common::FIXED16CHAR, common::DECIMAL28SPARSE)) - (FromTo(common::FIXED16CHAR, common::DECIMAL38SPARSE)) - (FromTo(common::FIXED16CHAR, common::DATE)) - (FromTo(common::FIXED16CHAR, common::TIME)) - (FromTo(common::FIXED16CHAR, common::TIMESTAMP)) - (FromTo(common::FIXED16CHAR, common::INTERVAL)) - (FromTo(common::FIXED16CHAR, common::FLOAT4)) - (FromTo(common::FIXED16CHAR, common::FLOAT8)) - (FromTo(common::FIXED16CHAR, common::BIT)) - (FromTo(common::FIXED16CHAR, common::VARCHAR)) - (FromTo(common::FIXED16CHAR, common::VAR16CHAR)) - (FromTo(common::FIXED16CHAR, common::VARBINARY)) - (FromTo(common::FIXED16CHAR, common::INTERVALYEAR)) - (FromTo(common::FIXED16CHAR, common::INTERVALDAY)) - (FromTo(common::FIXEDBINARY, common::INT)) - (FromTo(common::FIXEDBINARY, common::BIGINT)) - (FromTo(common::FIXEDBINARY, common::DECIMAL9)) - (FromTo(common::FIXEDBINARY, common::DECIMAL18)) - (FromTo(common::FIXEDBINARY, common::DECIMAL28SPARSE)) - (FromTo(common::FIXEDBINARY, common::DECIMAL38SPARSE)) - (FromTo(common::FIXEDBINARY, common::DATE)) - (FromTo(common::FIXEDBINARY, common::TIME)) - (FromTo(common::FIXEDBINARY, common::TIMESTAMP)) - (FromTo(common::FIXEDBINARY, common::INTERVAL)) - (FromTo(common::FIXEDBINARY, common::FLOAT4)) - (FromTo(common::FIXEDBINARY, common::FLOAT8)) - (FromTo(common::FIXEDBINARY, common::BIT)) - (FromTo(common::FIXEDBINARY, common::VARCHAR)) - (FromTo(common::FIXEDBINARY, common::VAR16CHAR)) - (FromTo(common::FIXEDBINARY, common::VARBINARY)) - (FromTo(common::FIXEDBINARY, common::INTERVALYEAR)) - (FromTo(common::FIXEDBINARY, common::INTERVALDAY)) - (FromTo(common::VARCHAR, common::TINYINT)) - (FromTo(common::VARCHAR, common::INT)) - (FromTo(common::VARCHAR, common::BIGINT)) - (FromTo(common::VARCHAR, common::DECIMAL9)) - (FromTo(common::VARCHAR, common::DECIMAL18)) - (FromTo(common::VARCHAR, common::DECIMAL28SPARSE)) - (FromTo(common::VARCHAR, common::DECIMAL38SPARSE)) - (FromTo(common::VARCHAR, common::DATE)) - (FromTo(common::VARCHAR, common::TIME)) - (FromTo(common::VARCHAR, common::TIMESTAMP)) - (FromTo(common::VARCHAR, common::INTERVAL)) - (FromTo(common::VARCHAR, common::FLOAT4)) - (FromTo(common::VARCHAR, common::FLOAT8)) - (FromTo(common::VARCHAR, common::BIT)) - (FromTo(common::VARCHAR, common::VARCHAR)) - (FromTo(common::VARCHAR, common::VAR16CHAR)) - (FromTo(common::VARCHAR, common::VARBINARY)) - (FromTo(common::VARCHAR, common::INTERVALYEAR)) - (FromTo(common::VARCHAR, common::INTERVALDAY)) - (FromTo(common::VAR16CHAR, common::TINYINT)) - (FromTo(common::VAR16CHAR, common::INT)) - (FromTo(common::VAR16CHAR, common::BIGINT)) - (FromTo(common::VAR16CHAR, common::DECIMAL9)) - (FromTo(common::VAR16CHAR, common::DECIMAL18)) - (FromTo(common::VAR16CHAR, common::DECIMAL28SPARSE)) - (FromTo(common::VAR16CHAR, common::DECIMAL38SPARSE)) - (FromTo(common::VAR16CHAR, common::DATE)) - (FromTo(common::VAR16CHAR, common::TIME)) - (FromTo(common::VAR16CHAR, common::TIMESTAMP)) - (FromTo(common::VAR16CHAR, common::INTERVAL)) - (FromTo(common::VAR16CHAR, common::FLOAT4)) - (FromTo(common::VAR16CHAR, common::FLOAT8)) - (FromTo(common::VAR16CHAR, common::BIT)) - (FromTo(common::VAR16CHAR, common::VARCHAR)) - (FromTo(common::VAR16CHAR, common::VARBINARY)) - (FromTo(common::VAR16CHAR, common::INTERVALYEAR)) - (FromTo(common::VAR16CHAR, common::INTERVALDAY)) - (FromTo(common::VARBINARY, common::TINYINT)) - (FromTo(common::VARBINARY, common::INT)) - (FromTo(common::VARBINARY, common::BIGINT)) - (FromTo(common::VARBINARY, common::DECIMAL9)) - (FromTo(common::VARBINARY, common::DECIMAL18)) - (FromTo(common::VARBINARY, common::DECIMAL28SPARSE)) - (FromTo(common::VARBINARY, common::DECIMAL38SPARSE)) - (FromTo(common::VARBINARY, common::DATE)) - (FromTo(common::VARBINARY, common::TIME)) - (FromTo(common::VARBINARY, common::TIMESTAMP)) - (FromTo(common::VARBINARY, common::INTERVAL)) - (FromTo(common::VARBINARY, common::FLOAT4)) - (FromTo(common::VARBINARY, common::FLOAT8)) - (FromTo(common::VARBINARY, common::BIT)) - (FromTo(common::VARBINARY, common::VARCHAR)) - (FromTo(common::VARBINARY, common::VAR16CHAR)) - (FromTo(common::VARBINARY, common::VARBINARY)) - (FromTo(common::VARBINARY, common::INTERVALYEAR)) - (FromTo(common::VARBINARY, common::INTERVALDAY)) - (FromTo(common::UINT1, common::INT)) - (FromTo(common::UINT1, common::BIGINT)) - (FromTo(common::UINT1, common::DECIMAL9)) - (FromTo(common::UINT1, common::DECIMAL18)) - (FromTo(common::UINT1, common::DECIMAL28SPARSE)) - (FromTo(common::UINT1, common::DECIMAL38SPARSE)) - (FromTo(common::UINT1, common::DATE)) - (FromTo(common::UINT1, common::TIME)) - (FromTo(common::UINT1, common::TIMESTAMP)) - (FromTo(common::UINT1, common::INTERVAL)) - (FromTo(common::UINT1, common::FLOAT4)) - (FromTo(common::UINT1, common::FLOAT8)) - (FromTo(common::UINT1, common::BIT)) - (FromTo(common::UINT1, common::VARCHAR)) - (FromTo(common::UINT1, common::VAR16CHAR)) - (FromTo(common::UINT1, common::VARBINARY)) - (FromTo(common::UINT1, common::INTERVALYEAR)) - (FromTo(common::UINT1, common::INTERVALDAY)) - (FromTo(common::UINT2, common::INT)) - (FromTo(common::UINT2, common::BIGINT)) - (FromTo(common::UINT2, common::DECIMAL9)) - (FromTo(common::UINT2, common::DECIMAL18)) - (FromTo(common::UINT2, common::DECIMAL28SPARSE)) - (FromTo(common::UINT2, common::DECIMAL38SPARSE)) - (FromTo(common::UINT2, common::DATE)) - (FromTo(common::UINT2, common::TIME)) - (FromTo(common::UINT2, common::TIMESTAMP)) - (FromTo(common::UINT2, common::INTERVAL)) - (FromTo(common::UINT2, common::FLOAT4)) - (FromTo(common::UINT2, common::FLOAT8)) - (FromTo(common::UINT2, common::BIT)) - (FromTo(common::UINT2, common::VARCHAR)) - (FromTo(common::UINT2, common::VAR16CHAR)) - (FromTo(common::UINT2, common::VARBINARY)) - (FromTo(common::UINT2, common::INTERVALYEAR)) - (FromTo(common::UINT2, common::INTERVALDAY)) - (FromTo(common::UINT4, common::INT)) - (FromTo(common::UINT4, common::BIGINT)) - (FromTo(common::UINT4, common::DECIMAL9)) - (FromTo(common::UINT4, common::DECIMAL18)) - (FromTo(common::UINT4, common::DECIMAL28SPARSE)) - (FromTo(common::UINT4, common::DECIMAL38SPARSE)) - (FromTo(common::UINT4, common::DATE)) - (FromTo(common::UINT4, common::TIME)) - (FromTo(common::UINT4, common::TIMESTAMP)) - (FromTo(common::UINT4, common::INTERVAL)) - (FromTo(common::UINT4, common::FLOAT4)) - (FromTo(common::UINT4, common::FLOAT8)) - (FromTo(common::UINT4, common::BIT)) - (FromTo(common::UINT4, common::VARCHAR)) - (FromTo(common::UINT4, common::VAR16CHAR)) - (FromTo(common::UINT4, common::VARBINARY)) - (FromTo(common::UINT4, common::INTERVALYEAR)) - (FromTo(common::UINT4, common::INTERVALDAY)) - (FromTo(common::UINT8, common::INT)) - (FromTo(common::UINT8, common::BIGINT)) - (FromTo(common::UINT8, common::DECIMAL9)) - (FromTo(common::UINT8, common::DECIMAL18)) - (FromTo(common::UINT8, common::DECIMAL28SPARSE)) - (FromTo(common::UINT8, common::DECIMAL38SPARSE)) - (FromTo(common::UINT8, common::DATE)) - (FromTo(common::UINT8, common::TIME)) - (FromTo(common::UINT8, common::TIMESTAMP)) - (FromTo(common::UINT8, common::INTERVAL)) - (FromTo(common::UINT8, common::FLOAT4)) - (FromTo(common::UINT8, common::FLOAT8)) - (FromTo(common::UINT8, common::BIT)) - (FromTo(common::UINT8, common::VARCHAR)) - (FromTo(common::UINT8, common::VAR16CHAR)) - (FromTo(common::UINT8, common::VARBINARY)) - (FromTo(common::UINT8, common::INTERVALYEAR)) - (FromTo(common::UINT8, common::INTERVALDAY)) - (FromTo(common::DECIMAL28DENSE, common::INT)) - (FromTo(common::DECIMAL28DENSE, common::BIGINT)) - (FromTo(common::DECIMAL28DENSE, common::DECIMAL9)) - (FromTo(common::DECIMAL28DENSE, common::DECIMAL18)) - (FromTo(common::DECIMAL28DENSE, common::DECIMAL28SPARSE)) - (FromTo(common::DECIMAL28DENSE, common::DECIMAL38SPARSE)) - (FromTo(common::DECIMAL28DENSE, common::DATE)) - (FromTo(common::DECIMAL28DENSE, common::TIME)) - (FromTo(common::DECIMAL28DENSE, common::TIMESTAMP)) - (FromTo(common::DECIMAL28DENSE, common::INTERVAL)) - (FromTo(common::DECIMAL28DENSE, common::FLOAT4)) - (FromTo(common::DECIMAL28DENSE, common::FLOAT8)) - (FromTo(common::DECIMAL28DENSE, common::BIT)) - (FromTo(common::DECIMAL28DENSE, common::VARCHAR)) - (FromTo(common::DECIMAL28DENSE, common::VAR16CHAR)) - (FromTo(common::DECIMAL28DENSE, common::VARBINARY)) - (FromTo(common::DECIMAL28DENSE, common::INTERVALYEAR)) - (FromTo(common::DECIMAL28DENSE, common::INTERVALDAY)) - (FromTo(common::DECIMAL38DENSE, common::INT)) - (FromTo(common::DECIMAL38DENSE, common::BIGINT)) - (FromTo(common::DECIMAL38DENSE, common::DECIMAL9)) - (FromTo(common::DECIMAL38DENSE, common::DECIMAL18)) - (FromTo(common::DECIMAL38DENSE, common::DECIMAL28SPARSE)) - (FromTo(common::DECIMAL38DENSE, common::DECIMAL38SPARSE)) - (FromTo(common::DECIMAL38DENSE, common::DATE)) - (FromTo(common::DECIMAL38DENSE, common::TIME)) - (FromTo(common::DECIMAL38DENSE, common::TIMESTAMP)) - (FromTo(common::DECIMAL38DENSE, common::INTERVAL)) - (FromTo(common::DECIMAL38DENSE, common::FLOAT4)) - (FromTo(common::DECIMAL38DENSE, common::FLOAT8)) - (FromTo(common::DECIMAL38DENSE, common::BIT)) - (FromTo(common::DECIMAL38DENSE, common::VARCHAR)) - (FromTo(common::DECIMAL38DENSE, common::VAR16CHAR)) - (FromTo(common::DECIMAL38DENSE, common::VARBINARY)) - (FromTo(common::DECIMAL38DENSE, common::INTERVALYEAR)) - (FromTo(common::DECIMAL38DENSE, common::INTERVALDAY)) - (FromTo(common::DM_UNKNOWN, common::TINYINT)) - (FromTo(common::DM_UNKNOWN, common::INT)) - (FromTo(common::DM_UNKNOWN, common::BIGINT)) - (FromTo(common::DM_UNKNOWN, common::DECIMAL9)) - (FromTo(common::DM_UNKNOWN, common::DECIMAL18)) - (FromTo(common::DM_UNKNOWN, common::DECIMAL28SPARSE)) - (FromTo(common::DM_UNKNOWN, common::DECIMAL38SPARSE)) - (FromTo(common::DM_UNKNOWN, common::DATE)) - (FromTo(common::DM_UNKNOWN, common::TIME)) - (FromTo(common::DM_UNKNOWN, common::TIMESTAMP)) - (FromTo(common::DM_UNKNOWN, common::INTERVAL)) - (FromTo(common::DM_UNKNOWN, common::FLOAT4)) - (FromTo(common::DM_UNKNOWN, common::FLOAT8)) - (FromTo(common::DM_UNKNOWN, common::BIT)) - (FromTo(common::DM_UNKNOWN, common::VARCHAR)) - (FromTo(common::DM_UNKNOWN, common::VAR16CHAR)) - (FromTo(common::DM_UNKNOWN, common::VARBINARY)) - (FromTo(common::DM_UNKNOWN, common::INTERVALYEAR)) - (FromTo(common::DM_UNKNOWN, common::INTERVALDAY)) - (FromTo(common::INTERVALYEAR, common::INT)) - (FromTo(common::INTERVALYEAR, common::BIGINT)) - (FromTo(common::INTERVALYEAR, common::DECIMAL9)) - (FromTo(common::INTERVALYEAR, common::DECIMAL18)) - (FromTo(common::INTERVALYEAR, common::DECIMAL28SPARSE)) - (FromTo(common::INTERVALYEAR, common::DECIMAL38SPARSE)) - (FromTo(common::INTERVALYEAR, common::DATE)) - (FromTo(common::INTERVALYEAR, common::TIME)) - (FromTo(common::INTERVALYEAR, common::TIMESTAMP)) - (FromTo(common::INTERVALYEAR, common::INTERVAL)) - (FromTo(common::INTERVALYEAR, common::FLOAT4)) - (FromTo(common::INTERVALYEAR, common::FLOAT8)) - (FromTo(common::INTERVALYEAR, common::BIT)) - (FromTo(common::INTERVALYEAR, common::VARCHAR)) - (FromTo(common::INTERVALYEAR, common::VAR16CHAR)) - (FromTo(common::INTERVALYEAR, common::VARBINARY)) - (FromTo(common::INTERVALYEAR, common::INTERVALYEAR)) - (FromTo(common::INTERVALYEAR, common::INTERVALDAY)) - (FromTo(common::INTERVALDAY, common::INT)) - (FromTo(common::INTERVALDAY, common::BIGINT)) - (FromTo(common::INTERVALDAY, common::DECIMAL9)) - (FromTo(common::INTERVALDAY, common::DECIMAL18)) - (FromTo(common::INTERVALDAY, common::DECIMAL28SPARSE)) - (FromTo(common::INTERVALDAY, common::DECIMAL38SPARSE)) - (FromTo(common::INTERVALDAY, common::DATE)) - (FromTo(common::INTERVALDAY, common::TIME)) - (FromTo(common::INTERVALDAY, common::TIMESTAMP)) - (FromTo(common::INTERVALDAY, common::INTERVAL)) - (FromTo(common::INTERVALDAY, common::FLOAT4)) - (FromTo(common::INTERVALDAY, common::FLOAT8)) - (FromTo(common::INTERVALDAY, common::BIT)) - (FromTo(common::INTERVALDAY, common::VARCHAR)) - (FromTo(common::INTERVALDAY, common::VAR16CHAR)) - (FromTo(common::INTERVALDAY, common::VARBINARY)) - (FromTo(common::INTERVALDAY, common::INTERVALYEAR)) - (FromTo(common::INTERVALDAY, common::INTERVALDAY)); +static Drill::meta::UnionSupport unionSupport(const google::protobuf::RepeatedField& unionSupportList) { + Drill::meta::UnionSupport result(Drill::meta::U_NONE); + + for(google::protobuf::RepeatedField::const_iterator it = unionSupportList.begin(); + it != unionSupportList.end(); + ++it) { + switch(static_cast(*it)) { + case exec::user::U_UNION: + result |= Drill::meta::U_UNION; + break; + + case exec::user::U_UNION_ALL: + result |= Drill::meta::U_UNION_ALL; + break; + + // ignore unknown + case exec::user::U_UNKNOWN: + default: + break; + } + } + + return result; +} + +static bool unrelatedColumnsInOrderBySupported(const google::protobuf::RepeatedField& orderBySupportList) { + for(google::protobuf::RepeatedField::const_iterator it = orderBySupportList.begin(); + it != orderBySupportList.end(); + ++it) { + switch(static_cast(*it)) { + case exec::user::OB_UNRELATED: + return true; + break; + + case exec::user::OB_EXPRESSION: + // ignore unknown + case exec::user::OB_UNKNOWN: + default: + break; + } + } + + return false; +} } // anonymous namespace +const exec::user::ServerMeta DrillMetadata::s_defaultServerMeta = createDefaultServerMeta(); + +DrillMetadata::DrillMetadata(DrillClientImpl& client, const exec::user::ServerMeta& serverMeta): Metadata(), m_client(client), + m_allTablesSelectable(serverMeta.all_tables_selectable()), + m_blobIncludedInMaxRowSize(serverMeta.blob_included_in_max_row_size()), + m_catalogAtStart(serverMeta.catalog_at_start()), + m_catalogSeparator(serverMeta.catalog_separator()), + m_catalogTerm(serverMeta.catalog_term()), + m_collateSupport(collateSupport(serverMeta.collate_support())), + m_columnAliasingSupported(serverMeta.column_aliasing_supported()), + m_correlationNamesSupport(correlationNames(serverMeta.correlation_names_support())), + m_convertSupport(serverMeta.convert_support().begin(), serverMeta.convert_support().end()), + m_dateTimeFunctions(serverMeta.date_time_functions().begin(), serverMeta.date_time_functions().end()), + m_dateTimeLiteralsSupport(dateTimeLiteralsSupport(serverMeta.date_time_literals_support())), + m_groupBySupport(groupBySupport(serverMeta.group_by_support())), + m_identifierCase(identifierCase(serverMeta.identifier_casing())), + m_identifierQuoteString(serverMeta.identifier_quote_string()), + m_likeEscapeClauseSupported(serverMeta.like_escape_clause_supported()), + m_maxBinaryLiteralLength(serverMeta.max_binary_literal_length()), + m_maxCatalogNameLength(serverMeta.max_catalog_name_length()), + m_maxCharLIteralLength(serverMeta.max_char_literal_length()), + m_maxColumnNameLength(serverMeta.max_column_name_length()), + m_maxColumnsInGroupBy(serverMeta.max_column_name_length()), + m_maxColumnsInOrderBy(serverMeta.max_columns_in_order_by()), + m_maxColumnsInSelect(serverMeta.max_columns_in_select()), + m_maxCursorNameLength(serverMeta.max_cursor_name_length()), + m_maxLogicalLobSize(serverMeta.max_logical_lob_size()), + m_maxRowSize(serverMeta.max_row_size()), + m_maxSchemaNameLength(serverMeta.max_schema_name_length()), + m_maxStatementLength(serverMeta.max_statement_length()), + m_maxStatements(serverMeta.max_statements()), + m_maxTableNameLength(serverMeta.max_table_name_length()), + m_maxTablesInSelectLength(serverMeta.max_tables_in_select()), + m_maxUserNameLength(serverMeta.max_user_name_length()), + m_nullCollation(nullCollation(serverMeta.null_collation())), + m_nullPlusNonNullEqualsNull(serverMeta.null_plus_non_null_equals_null()), + m_numericFunctions(serverMeta.numeric_functions().begin(), serverMeta.numeric_functions().end()), + m_outerJoinSupport(outerJoinSupport(serverMeta.outer_join_support())), + m_quotedIdentifierCase(quotedIdentifierCase(serverMeta.quoted_identifier_casing())), + m_readOnly(serverMeta.read_only()), + m_schemaTerm(serverMeta.schema_term()), + m_searchEscapeString(serverMeta.search_escape_string()), + m_selectForUpdateSupported(serverMeta.select_for_update_supported()), + m_specialCharacters(serverMeta.special_characters()), + m_sqlKeywords(serverMeta.sql_keywords().begin(), serverMeta.sql_keywords().end()), + m_stringFunctions(serverMeta.string_functions().begin(), serverMeta.string_functions().end()), + m_subQuerySupport(subQuerySupport(serverMeta.subquery_support())), + m_systemFunctions(serverMeta.system_functions().begin(), serverMeta.system_functions().end()), + m_tableTerm(serverMeta.table_term()), + m_transactionSupported(serverMeta.transaction_supported()), + m_unionSupport(unionSupport(serverMeta.union_support())), + m_unrelatedColumnsInOrderBySupported(unrelatedColumnsInOrderBySupported(serverMeta.order_by_support())) +{ +} + // Conversion scalar function support bool DrillMetadata::isConvertSupported(common::MinorType from, common::MinorType to) const { - return s_convertMap.find(FromTo(from,to)) != s_convertMap.end(); + return m_convertSupport.find(ConvertSupport(from,to)) != m_convertSupport.end(); } const std::string& DrillMetadata::getServerName() const { diff --git a/contrib/native/client/src/clientlib/metadata.hpp b/contrib/native/client/src/clientlib/metadata.hpp index 0cc8987ed..5edb16f32 100644 --- a/contrib/native/client/src/clientlib/metadata.hpp +++ b/contrib/native/client/src/clientlib/metadata.hpp @@ -21,6 +21,7 @@ #define DRILL_METADATA_H #include +#include #include "drill/common.hpp" #include "drill/drillClient.hpp" @@ -159,6 +160,25 @@ namespace meta { boost::reference_wrapper m_pMetadata; }; + struct ConvertSupportHasher { + std::size_t operator()(const exec::user::ConvertSupport& key) const { + std::size_t hash = 0; + + boost::hash_combine(hash, key.from()); + boost::hash_combine(hash, key.to()); + + return hash; + } + }; + + struct ConvertSupportEqualTo { + bool operator()(exec::user::ConvertSupport const& cs1, exec::user::ConvertSupport const& cs2) const { + return cs1.from() == cs2.from() && cs1.to() == cs2.to(); + } + }; + + typedef boost::unordered_set convert_support_set; + class DrillMetadata: public Metadata { public: static const std::string s_connectorName; @@ -167,21 +187,10 @@ namespace meta { static const std::string s_serverName; static const std::string s_serverVersion; - static const std::string s_catalogSeparator; - static const std::string s_catalogTerm; - - static const std::string s_identifierQuoteString; - static const std::vector s_sqlKeywords; - static const std::vector s_numericFunctions; - static const std::string s_schemaTerm; - static const std::string s_searchEscapeString; - static const std::string s_specialCharacters; - static const std::vector s_stringFunctions; - static const std::vector s_systemFunctions; - static const std::string s_tableTerm; - static const std::vector s_dateTimeFunctions; - - DrillMetadata(DrillClientImpl& client): Metadata(), m_client(client) {} + // Default server meta, to be used as fallback if cannot be queried + static const exec::user::ServerMeta s_defaultServerMeta; + + DrillMetadata(DrillClientImpl& client, const exec::user::ServerMeta& serverMeta); ~DrillMetadata() {} DrillClientImpl& client() { return m_client; } @@ -203,85 +212,111 @@ namespace meta { status_t getTables(const std::string& catalogPattern, const std::string& schemaPattern, const std::string& tablePattern, const std::vector* tableTypes, Metadata::pfnTableMetadataListener listener, void* listenerCtx, QueryHandle_t* qHandle); status_t getColumns(const std::string& catalogPattern, const std::string& schemaPattern, const std:: string& tablePattern, const std::string& columnPattern, Metadata::pfnColumnMetadataListener listener, void* listenerCtx, QueryHandle_t* qHandle); - bool areAllTableSelectable() const { return false; } - bool isCatalogAtStart() const { return true; } - const std::string& getCatalogSeparator() const { return s_catalogSeparator; } - const std::string& getCatalogTerm() const { return s_catalogTerm; } - bool isColumnAliasingSupported() const { return true; } - bool isNullPlusNonNullNull() const { return true; } + bool areAllTableSelectable() const { return m_allTablesSelectable; } + bool isCatalogAtStart() const { return m_catalogAtStart; } + const std::string& getCatalogSeparator() const { return m_catalogSeparator; } + const std::string& getCatalogTerm() const { return m_catalogTerm; } + bool isColumnAliasingSupported() const { return m_columnAliasingSupported; } + bool isNullPlusNonNullNull() const { return m_nullPlusNonNullEqualsNull; } bool isConvertSupported(common::MinorType from, common::MinorType to) const; - meta::CorrelationNamesSupport getCorrelationNames() const { return meta::CN_ANY_NAMES; } - bool isReadOnly() const { return false; } - meta::DateTimeLiteralSupport getDateTimeLiteralsSupport() const { - return DL_DATE - | DL_TIME - | DL_TIMESTAMP - | DL_INTERVAL_YEAR - | DL_INTERVAL_MONTH - | DL_INTERVAL_DAY - | DL_INTERVAL_HOUR - | DL_INTERVAL_MINUTE - | DL_INTERVAL_SECOND - | DL_INTERVAL_YEAR_TO_MONTH - | DL_INTERVAL_DAY_TO_HOUR - | DL_INTERVAL_DAY_TO_MINUTE - | DL_INTERVAL_DAY_TO_SECOND - | DL_INTERVAL_HOUR_TO_MINUTE - | DL_INTERVAL_HOUR_TO_SECOND - | DL_INTERVAL_MINUTE_TO_SECOND; - } - - meta::CollateSupport getCollateSupport() const { return meta::C_NONE; }// supported? - meta::GroupBySupport getGroupBySupport() const { return meta::GB_UNRELATED; } - meta::IdentifierCase getIdentifierCase() const { return meta::IC_STORES_UPPER; } // to check? - - const std::string& getIdentifierQuoteString() const { return s_identifierQuoteString; } - const std::vector& getSQLKeywords() const { return s_sqlKeywords; } - bool isLikeEscapeClauseSupported() const { return true; } - std::size_t getMaxBinaryLiteralLength() const { return 0; } - std::size_t getMaxCatalogNameLength() const { return 0; } - std::size_t getMaxCharLiteralLength() const { return 0; } - std::size_t getMaxColumnNameLength() const { return 0; } - std::size_t getMaxColumnsInGroupBy() const { return 0; } - std::size_t getMaxColumnsInOrderBy() const { return 0; } - std::size_t getMaxColumnsInSelect() const { return 0; } - std::size_t getMaxCursorNameLength() const { return 0; } - std::size_t getMaxLogicalLobSize() const { return 0; } - std::size_t getMaxStatements() const { return 0; } - std::size_t getMaxRowSize() const { return 0; } - bool isBlobIncludedInMaxRowSize() const { return true; } - std::size_t getMaxSchemaNameLength() const { return 0; } - std::size_t getMaxStatementLength() const { return 0; } - std::size_t getMaxTableNameLength() const { return 0; } - std::size_t getMaxTablesInSelect() const { return 0; } - std::size_t getMaxUserNameLength() const { return 0; } - meta::NullCollation getNullCollation() const { return meta::NC_AT_END; } - const std::vector& getNumericFunctions() const { return s_numericFunctions; } - meta::OuterJoinSupport getOuterJoinSupport() const { return meta::OJ_LEFT - | meta::OJ_RIGHT - | meta::OJ_FULL; - } - bool isUnrelatedColumnsInOrderBySupported() const { return true; } - meta::QuotedIdentifierCase getQuotedIdentifierCase() const { return meta::QIC_SUPPORTS_MIXED; } - const std::string& getSchemaTerm() const { return s_schemaTerm; } - const std::string& getSearchEscapeString() const { return s_searchEscapeString; } - const std::string& getSpecialCharacters() const { return s_specialCharacters; } - const std::vector& getStringFunctions() const { return s_stringFunctions; } - meta::SubQuerySupport getSubQuerySupport() const { return SQ_CORRELATED - | SQ_IN_COMPARISON - | SQ_IN_EXISTS - | SQ_IN_QUANTIFIED; - } - const std::vector& getSystemFunctions() const { return s_systemFunctions; } - const std::string& getTableTerm() const { return s_tableTerm; } - const std::vector& getDateTimeFunctions() const { return s_dateTimeFunctions; } - bool isTransactionSupported() const { return false; } - meta::UnionSupport getUnionSupport() const { return meta::U_UNION | meta::U_UNION_ALL; } - bool isSelectForUpdateSupported() const { return false; } + meta::CorrelationNamesSupport getCorrelationNames() const { return m_correlationNamesSupport; } + bool isReadOnly() const { return m_readOnly; } + meta::DateTimeLiteralSupport getDateTimeLiteralsSupport() const { return m_dateTimeLiteralsSupport; } + + meta::CollateSupport getCollateSupport() const { return m_collateSupport; } + meta::GroupBySupport getGroupBySupport() const { return m_groupBySupport; } + meta::IdentifierCase getIdentifierCase() const { return m_identifierCase; } + + const std::string& getIdentifierQuoteString() const { return m_identifierQuoteString; } + const std::vector& getSQLKeywords() const { return m_sqlKeywords; } + bool isLikeEscapeClauseSupported() const { return m_likeEscapeClauseSupported; } + std::size_t getMaxBinaryLiteralLength() const { return m_maxBinaryLiteralLength; } + std::size_t getMaxCatalogNameLength() const { return m_maxCatalogNameLength; } + std::size_t getMaxCharLiteralLength() const { return m_maxCharLIteralLength; } + std::size_t getMaxColumnNameLength() const { return m_maxColumnNameLength; } + std::size_t getMaxColumnsInGroupBy() const { return m_maxColumnsInGroupBy; } + std::size_t getMaxColumnsInOrderBy() const { return m_maxColumnsInOrderBy; } + std::size_t getMaxColumnsInSelect() const { return m_maxColumnsInSelect; } + std::size_t getMaxCursorNameLength() const { return m_maxCursorNameLength; } + std::size_t getMaxLogicalLobSize() const { return m_maxLogicalLobSize; } + std::size_t getMaxStatements() const { return m_maxStatements; } + std::size_t getMaxRowSize() const { return m_maxRowSize; } + bool isBlobIncludedInMaxRowSize() const { return m_blobIncludedInMaxRowSize; } + std::size_t getMaxSchemaNameLength() const { return m_maxSchemaNameLength; } + std::size_t getMaxStatementLength() const { return m_maxStatementLength; } + std::size_t getMaxTableNameLength() const { return m_maxTableNameLength; } + std::size_t getMaxTablesInSelect() const { return m_maxTablesInSelectLength; } + std::size_t getMaxUserNameLength() const { return m_maxUserNameLength; } + meta::NullCollation getNullCollation() const { return m_nullCollation; } + const std::vector& getNumericFunctions() const { return m_numericFunctions; } + meta::OuterJoinSupport getOuterJoinSupport() const { return m_outerJoinSupport; } + bool isUnrelatedColumnsInOrderBySupported() const { return m_unrelatedColumnsInOrderBySupported; } + meta::QuotedIdentifierCase getQuotedIdentifierCase() const { return m_quotedIdentifierCase; } + const std::string& getSchemaTerm() const { return m_schemaTerm; } + const std::string& getSearchEscapeString() const { return m_searchEscapeString; } + const std::string& getSpecialCharacters() const { return m_specialCharacters; } + const std::vector& getStringFunctions() const { return m_stringFunctions; } + meta::SubQuerySupport getSubQuerySupport() const { return m_subQuerySupport; } + const std::vector& getSystemFunctions() const { return m_systemFunctions; } + const std::string& getTableTerm() const { return m_tableTerm; } + const std::vector& getDateTimeFunctions() const { return m_dateTimeFunctions; } + bool isTransactionSupported() const { return m_transactionSupported; } + meta::UnionSupport getUnionSupport() const { return m_unionSupport; } + bool isSelectForUpdateSupported() const { return m_selectForUpdateSupported; } private: DrillClientImpl& m_client; - }; + + bool m_allTablesSelectable; + bool m_blobIncludedInMaxRowSize; + bool m_catalogAtStart; + std::string m_catalogSeparator; + std::string m_catalogTerm; + Drill::meta::CollateSupport m_collateSupport; + bool m_columnAliasingSupported; + Drill::meta::CorrelationNamesSupport m_correlationNamesSupport; + convert_support_set m_convertSupport; + std::vector m_dateTimeFunctions; + Drill::meta::DateTimeLiteralSupport m_dateTimeLiteralsSupport; + Drill::meta::GroupBySupport m_groupBySupport; + Drill::meta::IdentifierCase m_identifierCase; + std::string m_identifierQuoteString; + bool m_likeEscapeClauseSupported; + std::size_t m_maxBinaryLiteralLength; + std::size_t m_maxCatalogNameLength; + std::size_t m_maxCharLIteralLength; + std::size_t m_maxColumnNameLength; + std::size_t m_maxColumnsInGroupBy; + std::size_t m_maxColumnsInOrderBy; + std::size_t m_maxColumnsInSelect; + std::size_t m_maxCursorNameLength; + std::size_t m_maxLogicalLobSize; + std::size_t m_maxRowSize; + std::size_t m_maxSchemaNameLength; + std::size_t m_maxStatementLength; + std::size_t m_maxStatements; + std::size_t m_maxTableNameLength; + std::size_t m_maxTablesInSelectLength; + std::size_t m_maxUserNameLength; + Drill::meta::NullCollation m_nullCollation; + bool m_nullPlusNonNullEqualsNull; + std::vector m_numericFunctions; + Drill::meta::OuterJoinSupport m_outerJoinSupport; + Drill::meta::QuotedIdentifierCase m_quotedIdentifierCase; + bool m_readOnly; + std::string m_schemaTerm; + std::string m_searchEscapeString; + bool m_selectForUpdateSupported; + std::string m_specialCharacters; + std::vector m_sqlKeywords; + std::vector m_stringFunctions; + Drill::meta::SubQuerySupport m_subQuerySupport; + std::vector m_systemFunctions; + std::string m_tableTerm; + bool m_transactionSupported; + Drill::meta::UnionSupport m_unionSupport; + bool m_unrelatedColumnsInOrderBySupported; +}; } // namespace meta } // namespace Drill diff --git a/contrib/native/client/src/include/drill/drillClient.hpp b/contrib/native/client/src/include/drill/drillClient.hpp index 01c9f676f..1eb97cd80 100644 --- a/contrib/native/client/src/include/drill/drillClient.hpp +++ b/contrib/native/client/src/include/drill/drillClient.hpp @@ -439,24 +439,26 @@ namespace meta { * Identified case support */ enum IdentifierCase { - IC_STORES_LOWER, /**< Mixed case unquoted SQL identifier are treated as - case insensitive and stored in lower case */ - IC_STORES_MIXED, /**< Mixed case unquoted SQL identifier are treated as - case insensitive and stored in mixed case */ - IC_STORES_UPPER, /**< Mixed case unquoted SQL identifier are treated as - case insensitive and stored in upper case */ - IC_SUPPORTS_MIXED /**< Mixed case unquoted SQL identifier are treated as - case sensitive and stored in mixed case */ + IC_UNKNOWN = -1, /**< Unknown support */ + IC_STORES_LOWER = 0, /**< Mixed case unquoted SQL identifier are treated as + case insensitive and stored in lower case */ + IC_STORES_MIXED = 1, /**< Mixed case unquoted SQL identifier are treated as + case insensitive and stored in mixed case */ + IC_STORES_UPPER = 2, /**< Mixed case unquoted SQL identifier are treated as + case insensitive and stored in upper case */ + IC_SUPPORTS_MIXED =3 /**< Mixed case unquoted SQL identifier are treated as + case sensitive and stored in mixed case */ }; /** * Null collation support */ enum NullCollation { - NC_AT_START,/**< NULL values are sorted at the start regardless of the order*/ - NC_AT_END, /**< NULL values are sorted at the end regardless of the order*/ - NC_HIGH, /**< NULL is the highest value */ - NC_LOW /**< NULL is the lowest value */ + NC_UNKNOWN = -1, /**< Unknown support */ + NC_AT_START = 0, /**< NULL values are sorted at the start regardless of the order*/ + NC_AT_END = 1, /**< NULL values are sorted at the end regardless of the order*/ + NC_HIGH = 2, /**< NULL is the highest value */ + NC_LOW = 3 /**< NULL is the lowest value */ }; @@ -516,14 +518,15 @@ namespace meta { * Quoted Identified case support */ enum QuotedIdentifierCase { - QIC_STORES_LOWER, /**< Mixed case quoted SQL identifier are treated as - case insensitive and stored in lower case */ - QIC_STORES_MIXED, /**< Mixed case quoted SQL identifier are treated as - case insensitive and stored in mixed case */ - QIC_STORES_UPPER, /**< Mixed case quoted SQL identifier are treated as - case insensitive and stored in upper case */ - QIC_SUPPORTS_MIXED /**< Mixed case quoted SQL identifier are treated as - case sensitive and stored in mixed case */ + QIC_UNKNOWN = -1, /**< Unknown support */ + QIC_STORES_LOWER = 0, /**< Mixed case quoted SQL identifier are treated as + case insensitive and stored in lower case */ + QIC_STORES_MIXED = 1, /**< Mixed case quoted SQL identifier are treated as + case insensitive and stored in mixed case */ + QIC_STORES_UPPER = 2, /**< Mixed case quoted SQL identifier are treated as + case insensitive and stored in upper case */ + QIC_SUPPORTS_MIXED =3 /**< Mixed case quoted SQL identifier are treated as + case sensitive and stored in mixed case */ }; /* diff --git a/contrib/native/client/src/protobuf/User.pb.cc b/contrib/native/client/src/protobuf/User.pb.cc index aee70b829..be3f0016b 100644 --- a/contrib/native/client/src/protobuf/User.pb.cc +++ b/contrib/native/client/src/protobuf/User.pb.cc @@ -99,6 +99,18 @@ const ::google::protobuf::internal::GeneratedMessageReflection* const ::google::protobuf::Descriptor* CreatePreparedStatementResp_descriptor_ = NULL; const ::google::protobuf::internal::GeneratedMessageReflection* CreatePreparedStatementResp_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetServerMetaReq_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetServerMetaReq_reflection_ = NULL; +const ::google::protobuf::Descriptor* ConvertSupport_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ConvertSupport_reflection_ = NULL; +const ::google::protobuf::Descriptor* GetServerMetaResp_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + GetServerMetaResp_reflection_ = NULL; +const ::google::protobuf::Descriptor* ServerMeta_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + ServerMeta_reflection_ = NULL; const ::google::protobuf::Descriptor* RunQuery_descriptor_ = NULL; const ::google::protobuf::internal::GeneratedMessageReflection* RunQuery_reflection_ = NULL; @@ -109,6 +121,16 @@ const ::google::protobuf::EnumDescriptor* HandshakeStatus_descriptor_ = NULL; const ::google::protobuf::EnumDescriptor* RequestStatus_descriptor_ = NULL; const ::google::protobuf::EnumDescriptor* ColumnSearchability_descriptor_ = NULL; const ::google::protobuf::EnumDescriptor* ColumnUpdatability_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* NullCollation_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor_ = NULL; } // namespace @@ -599,7 +621,117 @@ void protobuf_AssignDesc_User_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(CreatePreparedStatementResp)); - RunQuery_descriptor_ = file->message_type(26); + GetServerMetaReq_descriptor_ = file->message_type(26); + static const int GetServerMetaReq_offsets_[1] = { + }; + GetServerMetaReq_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetServerMetaReq_descriptor_, + GetServerMetaReq::default_instance_, + GetServerMetaReq_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaReq, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaReq, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetServerMetaReq)); + ConvertSupport_descriptor_ = file->message_type(27); + static const int ConvertSupport_offsets_[2] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, from_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, to_), + }; + ConvertSupport_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ConvertSupport_descriptor_, + ConvertSupport::default_instance_, + ConvertSupport_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConvertSupport, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ConvertSupport)); + GetServerMetaResp_descriptor_ = file->message_type(28); + static const int GetServerMetaResp_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, status_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, server_meta_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, error_), + }; + GetServerMetaResp_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + GetServerMetaResp_descriptor_, + GetServerMetaResp::default_instance_, + GetServerMetaResp_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetServerMetaResp, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(GetServerMetaResp)); + ServerMeta_descriptor_ = file->message_type(29); + static const int ServerMeta_offsets_[49] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, all_tables_selectable_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, blob_included_in_max_row_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, catalog_at_start_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, catalog_separator_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, catalog_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, collate_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, column_aliasing_supported_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, convert_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, correlation_names_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, date_time_functions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, date_time_literals_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, group_by_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, identifier_casing_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, identifier_quote_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, like_escape_clause_supported_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_binary_literal_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_catalog_name_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_char_literal_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_column_name_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_columns_in_group_by_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_columns_in_order_by_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_columns_in_select_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_cursor_name_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_logical_lob_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_row_size_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_schema_name_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_statement_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_statements_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_table_name_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_tables_in_select_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, max_user_name_length_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, null_collation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, null_plus_non_null_equals_null_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, numeric_functions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, order_by_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, outer_join_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, quoted_identifier_casing_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, read_only_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, schema_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, search_escape_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, select_for_update_supported_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, special_characters_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, sql_keywords_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, string_functions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, subquery_support_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, system_functions_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, table_term_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, transaction_supported_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, union_support_), + }; + ServerMeta_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + ServerMeta_descriptor_, + ServerMeta::default_instance_, + ServerMeta_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerMeta, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(ServerMeta)); + RunQuery_descriptor_ = file->message_type(30); static const int RunQuery_offsets_[5] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, results_mode_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RunQuery, type_), @@ -625,6 +757,16 @@ void protobuf_AssignDesc_User_2eproto() { RequestStatus_descriptor_ = file->enum_type(4); ColumnSearchability_descriptor_ = file->enum_type(5); ColumnUpdatability_descriptor_ = file->enum_type(6); + CollateSupport_descriptor_ = file->enum_type(7); + CorrelationNamesSupport_descriptor_ = file->enum_type(8); + DateTimeLiteralsSupport_descriptor_ = file->enum_type(9); + GroupBySupport_descriptor_ = file->enum_type(10); + IdentifierCasing_descriptor_ = file->enum_type(11); + NullCollation_descriptor_ = file->enum_type(12); + OrderBySupport_descriptor_ = file->enum_type(13); + OuterJoinSupport_descriptor_ = file->enum_type(14); + SubQuerySupport_descriptor_ = file->enum_type(15); + UnionSupport_descriptor_ = file->enum_type(16); } namespace { @@ -689,6 +831,14 @@ void protobuf_RegisterTypes(const ::std::string&) { PreparedStatement_descriptor_, &PreparedStatement::default_instance()); ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( CreatePreparedStatementResp_descriptor_, &CreatePreparedStatementResp::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetServerMetaReq_descriptor_, &GetServerMetaReq::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ConvertSupport_descriptor_, &ConvertSupport::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + GetServerMetaResp_descriptor_, &GetServerMetaResp::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + ServerMeta_descriptor_, &ServerMeta::default_instance()); ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( RunQuery_descriptor_, &RunQuery::default_instance()); } @@ -748,6 +898,14 @@ void protobuf_ShutdownFile_User_2eproto() { delete PreparedStatement_reflection_; delete CreatePreparedStatementResp::default_instance_; delete CreatePreparedStatementResp_reflection_; + delete GetServerMetaReq::default_instance_; + delete GetServerMetaReq_reflection_; + delete ConvertSupport::default_instance_; + delete ConvertSupport_reflection_; + delete GetServerMetaResp::default_instance_; + delete GetServerMetaResp_reflection_; + delete ServerMeta::default_instance_; + delete ServerMeta_reflection_; delete RunQuery::default_instance_; delete RunQuery_reflection_; } @@ -759,148 +917,233 @@ void protobuf_AddDesc_User_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; ::exec::protobuf_AddDesc_SchemaDef_2eproto(); + ::common::protobuf_AddDesc_Types_2eproto(); ::exec::shared::protobuf_AddDesc_UserBitShared_2eproto(); ::exec::bit::data::protobuf_AddDesc_BitData_2eproto(); ::exec::bit::control::protobuf_AddDesc_BitControl_2eproto(); ::exec::bit::protobuf_AddDesc_ExecutionProtos_2eproto(); ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( "\n\nUser.proto\022\texec.user\032\017SchemaDef.proto" - "\032\023UserBitShared.proto\032\rBitData.proto\032\020Bi" - "tControl.proto\032\025ExecutionProtos.proto\"&\n" - "\010Property\022\013\n\003key\030\001 \002(\t\022\r\n\005value\030\002 \002(\t\"9\n" - "\016UserProperties\022\'\n\nproperties\030\001 \003(\0132\023.ex" - "ec.user.Property\"\267\001\n\020RpcEndpointInfos\022\014\n" - "\004name\030\001 \001(\t\022\017\n\007version\030\002 \001(\t\022\024\n\014majorVer" - "sion\030\003 \001(\r\022\024\n\014minorVersion\030\004 \001(\r\022\024\n\014patc" - "hVersion\030\005 \001(\r\022\023\n\013application\030\006 \001(\t\022\023\n\013b" - "uildNumber\030\007 \001(\r\022\030\n\020versionQualifier\030\010 \001" - "(\t\"\375\002\n\022UserToBitHandshake\022.\n\007channel\030\001 \001" - "(\0162\027.exec.shared.RpcChannel:\004USER\022\031\n\021sup" - "port_listening\030\002 \001(\010\022\023\n\013rpc_version\030\003 \001(" - "\005\0221\n\013credentials\030\004 \001(\0132\034.exec.shared.Use" - "rCredentials\022-\n\nproperties\030\005 \001(\0132\031.exec." - "user.UserProperties\022$\n\025support_complex_t" - "ypes\030\006 \001(\010:\005false\022\036\n\017support_timeout\030\007 \001" - "(\010:\005false\0221\n\014client_infos\030\010 \001(\0132\033.exec.u" - "ser.RpcEndpointInfos\022,\n\014sasl_support\030\t \001" - "(\0162\026.exec.user.SaslSupport\"S\n\016RequestRes" - "ults\022&\n\010query_id\030\001 \001(\0132\024.exec.shared.Que" - "ryId\022\031\n\021maximum_responses\030\002 \001(\005\"g\n\025GetQu" - "eryPlanFragments\022\r\n\005query\030\001 \002(\t\022$\n\004type\030" - "\002 \001(\0162\026.exec.shared.QueryType\022\031\n\nsplit_p" - "lan\030\003 \001(\010:\005false\"\316\001\n\022QueryPlanFragments\022" - "3\n\006status\030\001 \002(\0162#.exec.shared.QueryResul" - "t.QueryState\022&\n\010query_id\030\002 \001(\0132\024.exec.sh" - "ared.QueryId\0221\n\tfragments\030\003 \003(\0132\036.exec.b" - "it.control.PlanFragment\022(\n\005error\030\004 \001(\0132\031" - ".exec.shared.DrillPBError\"\200\002\n\022BitToUserH" - "andshake\022\023\n\013rpc_version\030\002 \001(\005\022*\n\006status\030" - "\003 \001(\0162\032.exec.user.HandshakeStatus\022\017\n\007err" - "orId\030\004 \001(\t\022\024\n\014errorMessage\030\005 \001(\t\0221\n\014serv" - "er_infos\030\006 \001(\0132\033.exec.user.RpcEndpointIn" - "fos\022 \n\030authenticationMechanisms\030\007 \003(\t\022-\n" - "\021supported_methods\030\010 \003(\0162\022.exec.user.Rpc" - "Type\"-\n\nLikeFilter\022\017\n\007pattern\030\001 \001(\t\022\016\n\006e" - "scape\030\002 \001(\t\"D\n\016GetCatalogsReq\0222\n\023catalog" - "_name_filter\030\001 \001(\0132\025.exec.user.LikeFilte" - "r\"M\n\017CatalogMetadata\022\024\n\014catalog_name\030\001 \001" - "(\t\022\023\n\013description\030\002 \001(\t\022\017\n\007connect\030\003 \001(\t" - "\"\223\001\n\017GetCatalogsResp\022(\n\006status\030\001 \001(\0162\030.e" - "xec.user.RequestStatus\022,\n\010catalogs\030\002 \003(\013" - "2\032.exec.user.CatalogMetadata\022(\n\005error\030\003 " - "\001(\0132\031.exec.shared.DrillPBError\"v\n\rGetSch" - "emasReq\0222\n\023catalog_name_filter\030\001 \001(\0132\025.e" - "xec.user.LikeFilter\0221\n\022schema_name_filte" - "r\030\002 \001(\0132\025.exec.user.LikeFilter\"i\n\016Schema" - "Metadata\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013schema" - "_name\030\002 \001(\t\022\r\n\005owner\030\003 \001(\t\022\014\n\004type\030\004 \001(\t" - "\022\017\n\007mutable\030\005 \001(\t\"\220\001\n\016GetSchemasResp\022(\n\006" - "status\030\001 \001(\0162\030.exec.user.RequestStatus\022*" - "\n\007schemas\030\002 \003(\0132\031.exec.user.SchemaMetada" - "ta\022(\n\005error\030\003 \001(\0132\031.exec.shared.DrillPBE" - "rror\"\302\001\n\014GetTablesReq\0222\n\023catalog_name_fi" - "lter\030\001 \001(\0132\025.exec.user.LikeFilter\0221\n\022sch" - "ema_name_filter\030\002 \001(\0132\025.exec.user.LikeFi" - "lter\0220\n\021table_name_filter\030\003 \001(\0132\025.exec.u" - "ser.LikeFilter\022\031\n\021table_type_filter\030\004 \003(" - "\t\"\\\n\rTableMetadata\022\024\n\014catalog_name\030\001 \001(\t" - "\022\023\n\013schema_name\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(" - "\t\022\014\n\004type\030\004 \001(\t\"\215\001\n\rGetTablesResp\022(\n\006sta" - "tus\030\001 \001(\0162\030.exec.user.RequestStatus\022(\n\006t" - "ables\030\002 \003(\0132\030.exec.user.TableMetadata\022(\n" - "\005error\030\003 \001(\0132\031.exec.shared.DrillPBError\"" - "\333\001\n\rGetColumnsReq\0222\n\023catalog_name_filter" - "\030\001 \001(\0132\025.exec.user.LikeFilter\0221\n\022schema_" - "name_filter\030\002 \001(\0132\025.exec.user.LikeFilter" - "\0220\n\021table_name_filter\030\003 \001(\0132\025.exec.user." - "LikeFilter\0221\n\022column_name_filter\030\004 \001(\0132\025" - ".exec.user.LikeFilter\"\251\003\n\016ColumnMetadata" - "\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013schema_name\030\002 " - "\001(\t\022\022\n\ntable_name\030\003 \001(\t\022\023\n\013column_name\030\004" - " \001(\t\022\030\n\020ordinal_position\030\005 \001(\005\022\025\n\rdefaul" - "t_value\030\006 \001(\t\022\023\n\013is_nullable\030\007 \001(\010\022\021\n\tda" - "ta_type\030\010 \001(\t\022\027\n\017char_max_length\030\t \001(\005\022\031" - "\n\021char_octet_length\030\n \001(\005\022\031\n\021numeric_pre" - "cision\030\013 \001(\005\022\037\n\027numeric_precision_radix\030" - "\014 \001(\005\022\025\n\rnumeric_scale\030\r \001(\005\022\033\n\023date_tim" - "e_precision\030\016 \001(\005\022\025\n\rinterval_type\030\017 \001(\t" - "\022\032\n\022interval_precision\030\020 \001(\005\022\023\n\013column_s" - "ize\030\021 \001(\005\"\220\001\n\016GetColumnsResp\022(\n\006status\030\001" - " \001(\0162\030.exec.user.RequestStatus\022*\n\007column" - "s\030\002 \003(\0132\031.exec.user.ColumnMetadata\022(\n\005er" - "ror\030\003 \001(\0132\031.exec.shared.DrillPBError\"/\n\032" - "CreatePreparedStatementReq\022\021\n\tsql_query\030" - "\001 \001(\t\"\326\003\n\024ResultColumnMetadata\022\024\n\014catalo" - "g_name\030\001 \001(\t\022\023\n\013schema_name\030\002 \001(\t\022\022\n\ntab" - "le_name\030\003 \001(\t\022\023\n\013column_name\030\004 \001(\t\022\r\n\005la" - "bel\030\005 \001(\t\022\021\n\tdata_type\030\006 \001(\t\022\023\n\013is_nulla" - "ble\030\007 \001(\010\022\021\n\tprecision\030\010 \001(\005\022\r\n\005scale\030\t " - "\001(\005\022\016\n\006signed\030\n \001(\010\022\024\n\014display_size\030\013 \001(" - "\005\022\022\n\nis_aliased\030\014 \001(\010\0225\n\rsearchability\030\r" - " \001(\0162\036.exec.user.ColumnSearchability\0223\n\014" - "updatability\030\016 \001(\0162\035.exec.user.ColumnUpd" - "atability\022\026\n\016auto_increment\030\017 \001(\010\022\030\n\020cas" - "e_sensitivity\030\020 \001(\010\022\020\n\010sortable\030\021 \001(\010\022\022\n" - "\nclass_name\030\022 \001(\t\022\023\n\013is_currency\030\024 \001(\010\"." - "\n\027PreparedStatementHandle\022\023\n\013server_info" - "\030\001 \001(\014\"\200\001\n\021PreparedStatement\0220\n\007columns\030" - "\001 \003(\0132\037.exec.user.ResultColumnMetadata\0229" - "\n\rserver_handle\030\002 \001(\0132\".exec.user.Prepar" - "edStatementHandle\"\253\001\n\033CreatePreparedStat" - "ementResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Re" - "questStatus\0228\n\022prepared_statement\030\002 \001(\0132" - "\034.exec.user.PreparedStatement\022(\n\005error\030\003" - " \001(\0132\031.exec.shared.DrillPBError\"\353\001\n\010RunQ" - "uery\0221\n\014results_mode\030\001 \001(\0162\033.exec.user.Q" - "ueryResultsMode\022$\n\004type\030\002 \001(\0162\026.exec.sha" - "red.QueryType\022\014\n\004plan\030\003 \001(\t\0221\n\tfragments" - "\030\004 \003(\0132\036.exec.bit.control.PlanFragment\022E" - "\n\031prepared_statement_handle\030\005 \001(\0132\".exec" - ".user.PreparedStatementHandle*\332\003\n\007RpcTyp" - "e\022\r\n\tHANDSHAKE\020\000\022\007\n\003ACK\020\001\022\013\n\007GOODBYE\020\002\022\r" - "\n\tRUN_QUERY\020\003\022\020\n\014CANCEL_QUERY\020\004\022\023\n\017REQUE" - "ST_RESULTS\020\005\022\027\n\023RESUME_PAUSED_QUERY\020\013\022\034\n" - "\030GET_QUERY_PLAN_FRAGMENTS\020\014\022\020\n\014GET_CATAL" - "OGS\020\016\022\017\n\013GET_SCHEMAS\020\017\022\016\n\nGET_TABLES\020\020\022\017" - "\n\013GET_COLUMNS\020\021\022\035\n\031CREATE_PREPARED_STATE" - "MENT\020\026\022\016\n\nQUERY_DATA\020\006\022\020\n\014QUERY_HANDLE\020\007" + "\032\013Types.proto\032\023UserBitShared.proto\032\rBitD" + "ata.proto\032\020BitControl.proto\032\025ExecutionPr" + "otos.proto\"&\n\010Property\022\013\n\003key\030\001 \002(\t\022\r\n\005v" + "alue\030\002 \002(\t\"9\n\016UserProperties\022\'\n\nproperti" + "es\030\001 \003(\0132\023.exec.user.Property\"\267\001\n\020RpcEnd" + "pointInfos\022\014\n\004name\030\001 \001(\t\022\017\n\007version\030\002 \001(" + "\t\022\024\n\014majorVersion\030\003 \001(\r\022\024\n\014minorVersion\030" + "\004 \001(\r\022\024\n\014patchVersion\030\005 \001(\r\022\023\n\013applicati" + "on\030\006 \001(\t\022\023\n\013buildNumber\030\007 \001(\r\022\030\n\020version" + "Qualifier\030\010 \001(\t\"\375\002\n\022UserToBitHandshake\022." + "\n\007channel\030\001 \001(\0162\027.exec.shared.RpcChannel" + ":\004USER\022\031\n\021support_listening\030\002 \001(\010\022\023\n\013rpc" + "_version\030\003 \001(\005\0221\n\013credentials\030\004 \001(\0132\034.ex" + "ec.shared.UserCredentials\022-\n\nproperties\030" + "\005 \001(\0132\031.exec.user.UserProperties\022$\n\025supp" + "ort_complex_types\030\006 \001(\010:\005false\022\036\n\017suppor" + "t_timeout\030\007 \001(\010:\005false\0221\n\014client_infos\030\010" + " \001(\0132\033.exec.user.RpcEndpointInfos\022,\n\014sas" + "l_support\030\t \001(\0162\026.exec.user.SaslSupport\"" + "S\n\016RequestResults\022&\n\010query_id\030\001 \001(\0132\024.ex" + "ec.shared.QueryId\022\031\n\021maximum_responses\030\002" + " \001(\005\"g\n\025GetQueryPlanFragments\022\r\n\005query\030\001" + " \002(\t\022$\n\004type\030\002 \001(\0162\026.exec.shared.QueryTy" + "pe\022\031\n\nsplit_plan\030\003 \001(\010:\005false\"\316\001\n\022QueryP" + "lanFragments\0223\n\006status\030\001 \002(\0162#.exec.shar" + "ed.QueryResult.QueryState\022&\n\010query_id\030\002 " + "\001(\0132\024.exec.shared.QueryId\0221\n\tfragments\030\003" + " \003(\0132\036.exec.bit.control.PlanFragment\022(\n\005" + "error\030\004 \001(\0132\031.exec.shared.DrillPBError\"\200" + "\002\n\022BitToUserHandshake\022\023\n\013rpc_version\030\002 \001" + "(\005\022*\n\006status\030\003 \001(\0162\032.exec.user.Handshake" + "Status\022\017\n\007errorId\030\004 \001(\t\022\024\n\014errorMessage\030" + "\005 \001(\t\0221\n\014server_infos\030\006 \001(\0132\033.exec.user." + "RpcEndpointInfos\022 \n\030authenticationMechan" + "isms\030\007 \003(\t\022-\n\021supported_methods\030\010 \003(\0162\022." + "exec.user.RpcType\"-\n\nLikeFilter\022\017\n\007patte" + "rn\030\001 \001(\t\022\016\n\006escape\030\002 \001(\t\"D\n\016GetCatalogsR" + "eq\0222\n\023catalog_name_filter\030\001 \001(\0132\025.exec.u" + "ser.LikeFilter\"M\n\017CatalogMetadata\022\024\n\014cat" + "alog_name\030\001 \001(\t\022\023\n\013description\030\002 \001(\t\022\017\n\007" + "connect\030\003 \001(\t\"\223\001\n\017GetCatalogsResp\022(\n\006sta" + "tus\030\001 \001(\0162\030.exec.user.RequestStatus\022,\n\010c" + "atalogs\030\002 \003(\0132\032.exec.user.CatalogMetadat" + "a\022(\n\005error\030\003 \001(\0132\031.exec.shared.DrillPBEr" + "ror\"v\n\rGetSchemasReq\0222\n\023catalog_name_fil" + "ter\030\001 \001(\0132\025.exec.user.LikeFilter\0221\n\022sche" + "ma_name_filter\030\002 \001(\0132\025.exec.user.LikeFil" + "ter\"i\n\016SchemaMetadata\022\024\n\014catalog_name\030\001 " + "\001(\t\022\023\n\013schema_name\030\002 \001(\t\022\r\n\005owner\030\003 \001(\t\022" + "\014\n\004type\030\004 \001(\t\022\017\n\007mutable\030\005 \001(\t\"\220\001\n\016GetSc" + "hemasResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Re" + "questStatus\022*\n\007schemas\030\002 \003(\0132\031.exec.user" + ".SchemaMetadata\022(\n\005error\030\003 \001(\0132\031.exec.sh" + "ared.DrillPBError\"\302\001\n\014GetTablesReq\0222\n\023ca" + "talog_name_filter\030\001 \001(\0132\025.exec.user.Like" + "Filter\0221\n\022schema_name_filter\030\002 \001(\0132\025.exe" + "c.user.LikeFilter\0220\n\021table_name_filter\030\003" + " \001(\0132\025.exec.user.LikeFilter\022\031\n\021table_typ" + "e_filter\030\004 \003(\t\"\\\n\rTableMetadata\022\024\n\014catal" + "og_name\030\001 \001(\t\022\023\n\013schema_name\030\002 \001(\t\022\022\n\nta" + "ble_name\030\003 \001(\t\022\014\n\004type\030\004 \001(\t\"\215\001\n\rGetTabl" + "esResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Reque" + "stStatus\022(\n\006tables\030\002 \003(\0132\030.exec.user.Tab" + "leMetadata\022(\n\005error\030\003 \001(\0132\031.exec.shared." + "DrillPBError\"\333\001\n\rGetColumnsReq\0222\n\023catalo" + "g_name_filter\030\001 \001(\0132\025.exec.user.LikeFilt" + "er\0221\n\022schema_name_filter\030\002 \001(\0132\025.exec.us" + "er.LikeFilter\0220\n\021table_name_filter\030\003 \001(\013" + "2\025.exec.user.LikeFilter\0221\n\022column_name_f" + "ilter\030\004 \001(\0132\025.exec.user.LikeFilter\"\251\003\n\016C" + "olumnMetadata\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013s" + "chema_name\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(\t\022\023\n\013" + "column_name\030\004 \001(\t\022\030\n\020ordinal_position\030\005 " + "\001(\005\022\025\n\rdefault_value\030\006 \001(\t\022\023\n\013is_nullabl" + "e\030\007 \001(\010\022\021\n\tdata_type\030\010 \001(\t\022\027\n\017char_max_l" + "ength\030\t \001(\005\022\031\n\021char_octet_length\030\n \001(\005\022\031" + "\n\021numeric_precision\030\013 \001(\005\022\037\n\027numeric_pre" + "cision_radix\030\014 \001(\005\022\025\n\rnumeric_scale\030\r \001(" + "\005\022\033\n\023date_time_precision\030\016 \001(\005\022\025\n\rinterv" + "al_type\030\017 \001(\t\022\032\n\022interval_precision\030\020 \001(" + "\005\022\023\n\013column_size\030\021 \001(\005\"\220\001\n\016GetColumnsRes" + "p\022(\n\006status\030\001 \001(\0162\030.exec.user.RequestSta" + "tus\022*\n\007columns\030\002 \003(\0132\031.exec.user.ColumnM" + "etadata\022(\n\005error\030\003 \001(\0132\031.exec.shared.Dri" + "llPBError\"/\n\032CreatePreparedStatementReq\022" + "\021\n\tsql_query\030\001 \001(\t\"\326\003\n\024ResultColumnMetad" + "ata\022\024\n\014catalog_name\030\001 \001(\t\022\023\n\013schema_name" + "\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(\t\022\023\n\013column_nam" + "e\030\004 \001(\t\022\r\n\005label\030\005 \001(\t\022\021\n\tdata_type\030\006 \001(" + "\t\022\023\n\013is_nullable\030\007 \001(\010\022\021\n\tprecision\030\010 \001(" + "\005\022\r\n\005scale\030\t \001(\005\022\016\n\006signed\030\n \001(\010\022\024\n\014disp" + "lay_size\030\013 \001(\005\022\022\n\nis_aliased\030\014 \001(\010\0225\n\rse" + "archability\030\r \001(\0162\036.exec.user.ColumnSear" + "chability\0223\n\014updatability\030\016 \001(\0162\035.exec.u" + "ser.ColumnUpdatability\022\026\n\016auto_increment" + "\030\017 \001(\010\022\030\n\020case_sensitivity\030\020 \001(\010\022\020\n\010sort" + "able\030\021 \001(\010\022\022\n\nclass_name\030\022 \001(\t\022\023\n\013is_cur" + "rency\030\024 \001(\010\".\n\027PreparedStatementHandle\022\023" + "\n\013server_info\030\001 \001(\014\"\200\001\n\021PreparedStatemen" + "t\0220\n\007columns\030\001 \003(\0132\037.exec.user.ResultCol" + "umnMetadata\0229\n\rserver_handle\030\002 \001(\0132\".exe" + "c.user.PreparedStatementHandle\"\253\001\n\033Creat" + "ePreparedStatementResp\022(\n\006status\030\001 \001(\0162\030" + ".exec.user.RequestStatus\0228\n\022prepared_sta" + "tement\030\002 \001(\0132\034.exec.user.PreparedStateme" + "nt\022(\n\005error\030\003 \001(\0132\031.exec.shared.DrillPBE" + "rror\"\022\n\020GetServerMetaReq\"P\n\016ConvertSuppo" + "rt\022\037\n\004from\030\001 \002(\0162\021.common.MinorType\022\035\n\002t" + "o\030\002 \002(\0162\021.common.MinorType\"\223\001\n\021GetServer" + "MetaResp\022(\n\006status\030\001 \001(\0162\030.exec.user.Req" + "uestStatus\022*\n\013server_meta\030\002 \001(\0132\025.exec.u" + "ser.ServerMeta\022(\n\005error\030\003 \001(\0132\031.exec.sha" + "red.DrillPBError\"\377\r\n\nServerMeta\022\035\n\025all_t" + "ables_selectable\030\001 \001(\010\022%\n\035blob_included_" + "in_max_row_size\030\002 \001(\010\022\030\n\020catalog_at_star" + "t\030\003 \001(\010\022\031\n\021catalog_separator\030\004 \001(\t\022\024\n\014ca" + "talog_term\030\005 \001(\t\0222\n\017collate_support\030\006 \003(" + "\0162\031.exec.user.CollateSupport\022!\n\031column_a" + "liasing_supported\030\007 \001(\010\0222\n\017convert_suppo" + "rt\030\010 \003(\0132\031.exec.user.ConvertSupport\022E\n\031c" + "orrelation_names_support\030\t \001(\0162\".exec.us" + "er.CorrelationNamesSupport\022\033\n\023date_time_" + "functions\030\n \003(\t\022F\n\032date_time_literals_su" + "pport\030\013 \003(\0162\".exec.user.DateTimeLiterals" + "Support\0223\n\020group_by_support\030\014 \001(\0162\031.exec" + ".user.GroupBySupport\0226\n\021identifier_casin" + "g\030\r \001(\0162\033.exec.user.IdentifierCasing\022\037\n\027" + "identifier_quote_string\030\016 \001(\t\022$\n\034like_es" + "cape_clause_supported\030\017 \001(\010\022!\n\031max_binar" + "y_literal_length\030\020 \001(\r\022\037\n\027max_catalog_na" + "me_length\030\021 \001(\r\022\037\n\027max_char_literal_leng" + "th\030\022 \001(\r\022\036\n\026max_column_name_length\030\023 \001(\r" + "\022\037\n\027max_columns_in_group_by\030\024 \001(\r\022\037\n\027max" + "_columns_in_order_by\030\025 \001(\r\022\035\n\025max_column" + "s_in_select\030\026 \001(\r\022\036\n\026max_cursor_name_len" + "gth\030\027 \001(\r\022\034\n\024max_logical_lob_size\030\030 \001(\r\022" + "\024\n\014max_row_size\030\031 \001(\r\022\036\n\026max_schema_name" + "_length\030\032 \001(\r\022\034\n\024max_statement_length\030\033 " + "\001(\r\022\026\n\016max_statements\030\034 \001(\r\022\035\n\025max_table" + "_name_length\030\035 \001(\r\022\034\n\024max_tables_in_sele" + "ct\030\036 \001(\r\022\034\n\024max_user_name_length\030\037 \001(\r\0220" + "\n\016null_collation\030 \001(\0162\030.exec.user.NullC" + "ollation\022&\n\036null_plus_non_null_equals_nu" + "ll\030! \001(\010\022\031\n\021numeric_functions\030\" \003(\t\0223\n\020o" + "rder_by_support\030# \003(\0162\031.exec.user.OrderB" + "ySupport\0227\n\022outer_join_support\030$ \003(\0162\033.e" + "xec.user.OuterJoinSupport\022=\n\030quoted_iden" + "tifier_casing\030% \001(\0162\033.exec.user.Identifi" + "erCasing\022\021\n\tread_only\030& \001(\010\022\023\n\013schema_te" + "rm\030\' \001(\t\022\034\n\024search_escape_string\030( \001(\t\022#" + "\n\033select_for_update_supported\030) \001(\010\022\032\n\022s" + "pecial_characters\030* \001(\t\022\024\n\014sql_keywords\030" + "+ \003(\t\022\030\n\020string_functions\030, \003(\t\0224\n\020subqu" + "ery_support\030- \003(\0162\032.exec.user.SubQuerySu" + "pport\022\030\n\020system_functions\030. \003(\t\022\022\n\ntable" + "_term\030/ \001(\t\022\035\n\025transaction_supported\0300 \001" + "(\010\022.\n\runion_support\0301 \003(\0162\027.exec.user.Un" + "ionSupport\"\353\001\n\010RunQuery\0221\n\014results_mode\030" + "\001 \001(\0162\033.exec.user.QueryResultsMode\022$\n\004ty" + "pe\030\002 \001(\0162\026.exec.shared.QueryType\022\014\n\004plan" + "\030\003 \001(\t\0221\n\tfragments\030\004 \003(\0132\036.exec.bit.con" + "trol.PlanFragment\022E\n\031prepared_statement_" + "handle\030\005 \001(\0132\".exec.user.PreparedStateme" + "ntHandle*\320\003\n\007RpcType\022\r\n\tHANDSHAKE\020\000\022\007\n\003A" + "CK\020\001\022\013\n\007GOODBYE\020\002\022\r\n\tRUN_QUERY\020\003\022\020\n\014CANC" + "EL_QUERY\020\004\022\023\n\017REQUEST_RESULTS\020\005\022\027\n\023RESUM" + "E_PAUSED_QUERY\020\013\022\034\n\030GET_QUERY_PLAN_FRAGM" + "ENTS\020\014\022\020\n\014GET_CATALOGS\020\016\022\017\n\013GET_SCHEMAS\020" + "\017\022\016\n\nGET_TABLES\020\020\022\017\n\013GET_COLUMNS\020\021\022\035\n\031CR" + "EATE_PREPARED_STATEMENT\020\026\022\023\n\017GET_SERVER_" + "META\020\010\022\016\n\nQUERY_DATA\020\006\022\020\n\014QUERY_HANDLE\020\007" "\022\030\n\024QUERY_PLAN_FRAGMENTS\020\r\022\014\n\010CATALOGS\020\022" "\022\013\n\007SCHEMAS\020\023\022\n\n\006TABLES\020\024\022\013\n\007COLUMNS\020\025\022\026" - "\n\022PREPARED_STATEMENT\020\027\022\026\n\022REQ_META_FUNCT" - "IONS\020\010\022\026\n\022RESP_FUNCTION_LIST\020\t\022\020\n\014QUERY_" - "RESULT\020\n\022\020\n\014SASL_MESSAGE\020\030*6\n\013SaslSuppor" - "t\022\030\n\024UNKNOWN_SASL_SUPPORT\020\000\022\r\n\tSASL_AUTH" - "\020\001*#\n\020QueryResultsMode\022\017\n\013STREAM_FULL\020\001*" - "q\n\017HandshakeStatus\022\013\n\007SUCCESS\020\001\022\030\n\024RPC_V" - "ERSION_MISMATCH\020\002\022\017\n\013AUTH_FAILED\020\003\022\023\n\017UN" - "KNOWN_FAILURE\020\004\022\021\n\rAUTH_REQUIRED\020\005*D\n\rRe" - "questStatus\022\022\n\016UNKNOWN_STATUS\020\000\022\006\n\002OK\020\001\022" - "\n\n\006FAILED\020\002\022\013\n\007TIMEOUT\020\003*Y\n\023ColumnSearch" - "ability\022\031\n\025UNKNOWN_SEARCHABILITY\020\000\022\010\n\004NO" - "NE\020\001\022\010\n\004CHAR\020\002\022\n\n\006NUMBER\020\003\022\007\n\003ALL\020\004*K\n\022C" - "olumnUpdatability\022\030\n\024UNKNOWN_UPDATABILIT" - "Y\020\000\022\r\n\tREAD_ONLY\020\001\022\014\n\010WRITABLE\020\002B+\n\033org." - "apache.drill.exec.protoB\nUserProtosH\001", 5477); + "\n\022PREPARED_STATEMENT\020\027\022\017\n\013SERVER_META\020\t\022" + "\020\n\014QUERY_RESULT\020\n\022\020\n\014SASL_MESSAGE\020\030*6\n\013S" + "aslSupport\022\030\n\024UNKNOWN_SASL_SUPPORT\020\000\022\r\n\t" + "SASL_AUTH\020\001*#\n\020QueryResultsMode\022\017\n\013STREA" + "M_FULL\020\001*q\n\017HandshakeStatus\022\013\n\007SUCCESS\020\001" + "\022\030\n\024RPC_VERSION_MISMATCH\020\002\022\017\n\013AUTH_FAILE" + "D\020\003\022\023\n\017UNKNOWN_FAILURE\020\004\022\021\n\rAUTH_REQUIRE" + "D\020\005*D\n\rRequestStatus\022\022\n\016UNKNOWN_STATUS\020\000" + "\022\006\n\002OK\020\001\022\n\n\006FAILED\020\002\022\013\n\007TIMEOUT\020\003*Y\n\023Col" + "umnSearchability\022\031\n\025UNKNOWN_SEARCHABILIT" + "Y\020\000\022\010\n\004NONE\020\001\022\010\n\004CHAR\020\002\022\n\n\006NUMBER\020\003\022\007\n\003A" + "LL\020\004*K\n\022ColumnUpdatability\022\030\n\024UNKNOWN_UP" + "DATABILITY\020\000\022\r\n\tREAD_ONLY\020\001\022\014\n\010WRITABLE\020" + "\002*1\n\016CollateSupport\022\016\n\nCS_UNKNOWN\020\000\022\017\n\013C" + "S_GROUP_BY\020\001*J\n\027CorrelationNamesSupport\022" + "\013\n\007CN_NONE\020\001\022\026\n\022CN_DIFFERENT_NAMES\020\002\022\n\n\006" + "CN_ANY\020\003*\271\003\n\027DateTimeLiteralsSupport\022\016\n\n" + "DL_UNKNOWN\020\000\022\013\n\007DL_DATE\020\001\022\013\n\007DL_TIME\020\002\022\020" + "\n\014DL_TIMESTAMP\020\003\022\024\n\020DL_INTERVAL_YEAR\020\004\022\025" + "\n\021DL_INTERVAL_MONTH\020\005\022\023\n\017DL_INTERVAL_DAY" + "\020\006\022\024\n\020DL_INTERVAL_HOUR\020\007\022\026\n\022DL_INTERVAL_" + "MINUTE\020\010\022\026\n\022DL_INTERVAL_SECOND\020\t\022\035\n\031DL_I" + "NTERVAL_YEAR_TO_MONTH\020\n\022\033\n\027DL_INTERVAL_D" + "AY_TO_HOUR\020\013\022\035\n\031DL_INTERVAL_DAY_TO_MINUT" + "E\020\014\022\035\n\031DL_INTERVAL_DAY_TO_SECOND\020\r\022\036\n\032DL" + "_INTERVAL_HOUR_TO_MINUTE\020\016\022\036\n\032DL_INTERVA" + "L_HOUR_TO_SECOND\020\017\022 \n\034DL_INTERVAL_MINUTE" + "_TO_SECOND\020\020*Y\n\016GroupBySupport\022\013\n\007GB_NON" + "E\020\001\022\022\n\016GB_SELECT_ONLY\020\002\022\024\n\020GB_BEYOND_SEL" + "ECT\020\003\022\020\n\014GB_UNRELATED\020\004*x\n\020IdentifierCas" + "ing\022\016\n\nIC_UNKNOWN\020\000\022\023\n\017IC_STORES_LOWER\020\001" + "\022\023\n\017IC_STORES_MIXED\020\002\022\023\n\017IC_STORES_UPPER" + "\020\003\022\025\n\021IC_SUPPORTS_MIXED\020\004*X\n\rNullCollati" + "on\022\016\n\nNC_UNKNOWN\020\000\022\017\n\013NC_AT_START\020\001\022\r\n\tN" + "C_AT_END\020\002\022\013\n\007NC_HIGH\020\003\022\n\n\006NC_LOW\020\004*E\n\016O" + "rderBySupport\022\016\n\nOB_UNKNOWN\020\000\022\020\n\014OB_UNRE" + "LATED\020\001\022\021\n\rOB_EXPRESSION\020\002*\226\001\n\020OuterJoin" + "Support\022\016\n\nOJ_UNKNOWN\020\000\022\013\n\007OJ_LEFT\020\001\022\014\n\010" + "OJ_RIGHT\020\002\022\013\n\007OJ_FULL\020\003\022\r\n\tOJ_NESTED\020\004\022\022" + "\n\016OJ_NOT_ORDERED\020\005\022\014\n\010OJ_INNER\020\006\022\031\n\025OJ_A" + "LL_COMPARISON_OPS\020\007*\204\001\n\017SubQuerySupport\022" + "\016\n\nSQ_UNKNOWN\020\000\022\021\n\rSQ_CORRELATED\020\001\022\024\n\020SQ" + "_IN_COMPARISON\020\002\022\020\n\014SQ_IN_EXISTS\020\003\022\020\n\014SQ" + "_IN_INSERT\020\004\022\024\n\020SQ_IN_QUANTIFIED\020\005*;\n\014Un" + "ionSupport\022\r\n\tU_UNKNOWN\020\000\022\013\n\007U_UNION\020\001\022\017" + "\n\013U_UNION_ALL\020\002B+\n\033org.apache.drill.exec" + ".protoB\nUserProtosH\001", 8820); ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( "User.proto", &protobuf_RegisterTypes); Property::default_instance_ = new Property(); @@ -929,6 +1172,10 @@ void protobuf_AddDesc_User_2eproto() { PreparedStatementHandle::default_instance_ = new PreparedStatementHandle(); PreparedStatement::default_instance_ = new PreparedStatement(); CreatePreparedStatementResp::default_instance_ = new CreatePreparedStatementResp(); + GetServerMetaReq::default_instance_ = new GetServerMetaReq(); + ConvertSupport::default_instance_ = new ConvertSupport(); + GetServerMetaResp::default_instance_ = new GetServerMetaResp(); + ServerMeta::default_instance_ = new ServerMeta(); RunQuery::default_instance_ = new RunQuery(); Property::default_instance_->InitAsDefaultInstance(); UserProperties::default_instance_->InitAsDefaultInstance(); @@ -956,6 +1203,10 @@ void protobuf_AddDesc_User_2eproto() { PreparedStatementHandle::default_instance_->InitAsDefaultInstance(); PreparedStatement::default_instance_->InitAsDefaultInstance(); CreatePreparedStatementResp::default_instance_->InitAsDefaultInstance(); + GetServerMetaReq::default_instance_->InitAsDefaultInstance(); + ConvertSupport::default_instance_->InitAsDefaultInstance(); + GetServerMetaResp::default_instance_->InitAsDefaultInstance(); + ServerMeta::default_instance_->InitAsDefaultInstance(); RunQuery::default_instance_->InitAsDefaultInstance(); ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_User_2eproto); } @@ -1095,6 +1346,182 @@ bool ColumnUpdatability_IsValid(int value) { } } +const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return CollateSupport_descriptor_; +} +bool CollateSupport_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return CorrelationNamesSupport_descriptor_; +} +bool CorrelationNamesSupport_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return DateTimeLiteralsSupport_descriptor_; +} +bool DateTimeLiteralsSupport_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return GroupBySupport_descriptor_; +} +bool GroupBySupport_IsValid(int value) { + switch(value) { + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor() { + protobuf_AssignDescriptorsOnce(); + return IdentifierCasing_descriptor_; +} +bool IdentifierCasing_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* NullCollation_descriptor() { + protobuf_AssignDescriptorsOnce(); + return NullCollation_descriptor_; +} +bool NullCollation_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return OrderBySupport_descriptor_; +} +bool OrderBySupport_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return OuterJoinSupport_descriptor_; +} +bool OuterJoinSupport_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return SubQuerySupport_descriptor_; +} +bool SubQuerySupport_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor() { + protobuf_AssignDescriptorsOnce(); + return UnionSupport_descriptor_; +} +bool UnionSupport_IsValid(int value) { + switch(value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + // =================================================================== @@ -10992,6 +11419,3153 @@ void CreatePreparedStatementResp::Swap(CreatePreparedStatementResp* other) { } +// =================================================================== + +#ifndef _MSC_VER +#endif // !_MSC_VER + +GetServerMetaReq::GetServerMetaReq() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void GetServerMetaReq::InitAsDefaultInstance() { +} + +GetServerMetaReq::GetServerMetaReq(const GetServerMetaReq& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void GetServerMetaReq::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetServerMetaReq::~GetServerMetaReq() { + SharedDtor(); +} + +void GetServerMetaReq::SharedDtor() { + if (this != default_instance_) { + } +} + +void GetServerMetaReq::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetServerMetaReq::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetServerMetaReq_descriptor_; +} + +const GetServerMetaReq& GetServerMetaReq::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto(); + return *default_instance_; +} + +GetServerMetaReq* GetServerMetaReq::default_instance_ = NULL; + +GetServerMetaReq* GetServerMetaReq::New() const { + return new GetServerMetaReq; +} + +void GetServerMetaReq::Clear() { + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetServerMetaReq::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + } + return true; +#undef DO_ +} + +void GetServerMetaReq::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* GetServerMetaReq::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int GetServerMetaReq::ByteSize() const { + int total_size = 0; + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GetServerMetaReq::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetServerMetaReq* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetServerMetaReq::MergeFrom(const GetServerMetaReq& from) { + GOOGLE_CHECK_NE(&from, this); + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetServerMetaReq::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetServerMetaReq::CopyFrom(const GetServerMetaReq& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetServerMetaReq::IsInitialized() const { + + return true; +} + +void GetServerMetaReq::Swap(GetServerMetaReq* other) { + if (other != this) { + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GetServerMetaReq::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetServerMetaReq_descriptor_; + metadata.reflection = GetServerMetaReq_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ConvertSupport::kFromFieldNumber; +const int ConvertSupport::kToFieldNumber; +#endif // !_MSC_VER + +ConvertSupport::ConvertSupport() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ConvertSupport::InitAsDefaultInstance() { +} + +ConvertSupport::ConvertSupport(const ConvertSupport& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ConvertSupport::SharedCtor() { + _cached_size_ = 0; + from_ = 0; + to_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ConvertSupport::~ConvertSupport() { + SharedDtor(); +} + +void ConvertSupport::SharedDtor() { + if (this != default_instance_) { + } +} + +void ConvertSupport::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ConvertSupport::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ConvertSupport_descriptor_; +} + +const ConvertSupport& ConvertSupport::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto(); + return *default_instance_; +} + +ConvertSupport* ConvertSupport::default_instance_ = NULL; + +ConvertSupport* ConvertSupport::New() const { + return new ConvertSupport; +} + +void ConvertSupport::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + from_ = 0; + to_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ConvertSupport::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .common.MinorType from = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::common::MinorType_IsValid(value)) { + set_from(static_cast< ::common::MinorType >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_to; + break; + } + + // required .common.MinorType to = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_to: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::common::MinorType_IsValid(value)) { + set_to(static_cast< ::common::MinorType >(value)); + } else { + mutable_unknown_fields()->AddVarint(2, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ConvertSupport::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .common.MinorType from = 1; + if (has_from()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->from(), output); + } + + // required .common.MinorType to = 2; + if (has_to()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->to(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ConvertSupport::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required .common.MinorType from = 1; + if (has_from()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->from(), target); + } + + // required .common.MinorType to = 2; + if (has_to()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->to(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ConvertSupport::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .common.MinorType from = 1; + if (has_from()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->from()); + } + + // required .common.MinorType to = 2; + if (has_to()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->to()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ConvertSupport::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ConvertSupport* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ConvertSupport::MergeFrom(const ConvertSupport& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_from()) { + set_from(from.from()); + } + if (from.has_to()) { + set_to(from.to()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ConvertSupport::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ConvertSupport::CopyFrom(const ConvertSupport& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConvertSupport::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void ConvertSupport::Swap(ConvertSupport* other) { + if (other != this) { + std::swap(from_, other->from_); + std::swap(to_, other->to_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ConvertSupport::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ConvertSupport_descriptor_; + metadata.reflection = ConvertSupport_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int GetServerMetaResp::kStatusFieldNumber; +const int GetServerMetaResp::kServerMetaFieldNumber; +const int GetServerMetaResp::kErrorFieldNumber; +#endif // !_MSC_VER + +GetServerMetaResp::GetServerMetaResp() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void GetServerMetaResp::InitAsDefaultInstance() { + server_meta_ = const_cast< ::exec::user::ServerMeta*>(&::exec::user::ServerMeta::default_instance()); + error_ = const_cast< ::exec::shared::DrillPBError*>(&::exec::shared::DrillPBError::default_instance()); +} + +GetServerMetaResp::GetServerMetaResp(const GetServerMetaResp& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void GetServerMetaResp::SharedCtor() { + _cached_size_ = 0; + status_ = 0; + server_meta_ = NULL; + error_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +GetServerMetaResp::~GetServerMetaResp() { + SharedDtor(); +} + +void GetServerMetaResp::SharedDtor() { + if (this != default_instance_) { + delete server_meta_; + delete error_; + } +} + +void GetServerMetaResp::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GetServerMetaResp::descriptor() { + protobuf_AssignDescriptorsOnce(); + return GetServerMetaResp_descriptor_; +} + +const GetServerMetaResp& GetServerMetaResp::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto(); + return *default_instance_; +} + +GetServerMetaResp* GetServerMetaResp::default_instance_ = NULL; + +GetServerMetaResp* GetServerMetaResp::New() const { + return new GetServerMetaResp; +} + +void GetServerMetaResp::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + status_ = 0; + if (has_server_meta()) { + if (server_meta_ != NULL) server_meta_->::exec::user::ServerMeta::Clear(); + } + if (has_error()) { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool GetServerMetaResp::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .exec.user.RequestStatus status = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::RequestStatus_IsValid(value)) { + set_status(static_cast< ::exec::user::RequestStatus >(value)); + } else { + mutable_unknown_fields()->AddVarint(1, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_server_meta; + break; + } + + // optional .exec.user.ServerMeta server_meta = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_server_meta: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_server_meta())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_error; + break; + } + + // optional .exec.shared.DrillPBError error = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_error: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_error())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void GetServerMetaResp::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional .exec.user.RequestStatus status = 1; + if (has_status()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->status(), output); + } + + // optional .exec.user.ServerMeta server_meta = 2; + if (has_server_meta()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, this->server_meta(), output); + } + + // optional .exec.shared.DrillPBError error = 3; + if (has_error()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, this->error(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* GetServerMetaResp::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional .exec.user.RequestStatus status = 1; + if (has_status()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->status(), target); + } + + // optional .exec.user.ServerMeta server_meta = 2; + if (has_server_meta()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 2, this->server_meta(), target); + } + + // optional .exec.shared.DrillPBError error = 3; + if (has_error()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 3, this->error(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int GetServerMetaResp::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional .exec.user.RequestStatus status = 1; + if (has_status()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->status()); + } + + // optional .exec.user.ServerMeta server_meta = 2; + if (has_server_meta()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->server_meta()); + } + + // optional .exec.shared.DrillPBError error = 3; + if (has_error()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->error()); + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GetServerMetaResp::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const GetServerMetaResp* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void GetServerMetaResp::MergeFrom(const GetServerMetaResp& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_status()) { + set_status(from.status()); + } + if (from.has_server_meta()) { + mutable_server_meta()->::exec::user::ServerMeta::MergeFrom(from.server_meta()); + } + if (from.has_error()) { + mutable_error()->::exec::shared::DrillPBError::MergeFrom(from.error()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void GetServerMetaResp::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GetServerMetaResp::CopyFrom(const GetServerMetaResp& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GetServerMetaResp::IsInitialized() const { + + if (has_server_meta()) { + if (!this->server_meta().IsInitialized()) return false; + } + return true; +} + +void GetServerMetaResp::Swap(GetServerMetaResp* other) { + if (other != this) { + std::swap(status_, other->status_); + std::swap(server_meta_, other->server_meta_); + std::swap(error_, other->error_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata GetServerMetaResp::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = GetServerMetaResp_descriptor_; + metadata.reflection = GetServerMetaResp_reflection_; + return metadata; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ServerMeta::kAllTablesSelectableFieldNumber; +const int ServerMeta::kBlobIncludedInMaxRowSizeFieldNumber; +const int ServerMeta::kCatalogAtStartFieldNumber; +const int ServerMeta::kCatalogSeparatorFieldNumber; +const int ServerMeta::kCatalogTermFieldNumber; +const int ServerMeta::kCollateSupportFieldNumber; +const int ServerMeta::kColumnAliasingSupportedFieldNumber; +const int ServerMeta::kConvertSupportFieldNumber; +const int ServerMeta::kCorrelationNamesSupportFieldNumber; +const int ServerMeta::kDateTimeFunctionsFieldNumber; +const int ServerMeta::kDateTimeLiteralsSupportFieldNumber; +const int ServerMeta::kGroupBySupportFieldNumber; +const int ServerMeta::kIdentifierCasingFieldNumber; +const int ServerMeta::kIdentifierQuoteStringFieldNumber; +const int ServerMeta::kLikeEscapeClauseSupportedFieldNumber; +const int ServerMeta::kMaxBinaryLiteralLengthFieldNumber; +const int ServerMeta::kMaxCatalogNameLengthFieldNumber; +const int ServerMeta::kMaxCharLiteralLengthFieldNumber; +const int ServerMeta::kMaxColumnNameLengthFieldNumber; +const int ServerMeta::kMaxColumnsInGroupByFieldNumber; +const int ServerMeta::kMaxColumnsInOrderByFieldNumber; +const int ServerMeta::kMaxColumnsInSelectFieldNumber; +const int ServerMeta::kMaxCursorNameLengthFieldNumber; +const int ServerMeta::kMaxLogicalLobSizeFieldNumber; +const int ServerMeta::kMaxRowSizeFieldNumber; +const int ServerMeta::kMaxSchemaNameLengthFieldNumber; +const int ServerMeta::kMaxStatementLengthFieldNumber; +const int ServerMeta::kMaxStatementsFieldNumber; +const int ServerMeta::kMaxTableNameLengthFieldNumber; +const int ServerMeta::kMaxTablesInSelectFieldNumber; +const int ServerMeta::kMaxUserNameLengthFieldNumber; +const int ServerMeta::kNullCollationFieldNumber; +const int ServerMeta::kNullPlusNonNullEqualsNullFieldNumber; +const int ServerMeta::kNumericFunctionsFieldNumber; +const int ServerMeta::kOrderBySupportFieldNumber; +const int ServerMeta::kOuterJoinSupportFieldNumber; +const int ServerMeta::kQuotedIdentifierCasingFieldNumber; +const int ServerMeta::kReadOnlyFieldNumber; +const int ServerMeta::kSchemaTermFieldNumber; +const int ServerMeta::kSearchEscapeStringFieldNumber; +const int ServerMeta::kSelectForUpdateSupportedFieldNumber; +const int ServerMeta::kSpecialCharactersFieldNumber; +const int ServerMeta::kSqlKeywordsFieldNumber; +const int ServerMeta::kStringFunctionsFieldNumber; +const int ServerMeta::kSubquerySupportFieldNumber; +const int ServerMeta::kSystemFunctionsFieldNumber; +const int ServerMeta::kTableTermFieldNumber; +const int ServerMeta::kTransactionSupportedFieldNumber; +const int ServerMeta::kUnionSupportFieldNumber; +#endif // !_MSC_VER + +ServerMeta::ServerMeta() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void ServerMeta::InitAsDefaultInstance() { +} + +ServerMeta::ServerMeta(const ServerMeta& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void ServerMeta::SharedCtor() { + _cached_size_ = 0; + all_tables_selectable_ = false; + blob_included_in_max_row_size_ = false; + catalog_at_start_ = false; + catalog_separator_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + column_aliasing_supported_ = false; + correlation_names_support_ = 1; + group_by_support_ = 1; + identifier_casing_ = 0; + identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + like_escape_clause_supported_ = false; + max_binary_literal_length_ = 0u; + max_catalog_name_length_ = 0u; + max_char_literal_length_ = 0u; + max_column_name_length_ = 0u; + max_columns_in_group_by_ = 0u; + max_columns_in_order_by_ = 0u; + max_columns_in_select_ = 0u; + max_cursor_name_length_ = 0u; + max_logical_lob_size_ = 0u; + max_row_size_ = 0u; + max_schema_name_length_ = 0u; + max_statement_length_ = 0u; + max_statements_ = 0u; + max_table_name_length_ = 0u; + max_tables_in_select_ = 0u; + max_user_name_length_ = 0u; + null_collation_ = 0; + null_plus_non_null_equals_null_ = false; + quoted_identifier_casing_ = 0; + read_only_ = false; + schema_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + select_for_update_supported_ = false; + special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + table_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + transaction_supported_ = false; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ServerMeta::~ServerMeta() { + SharedDtor(); +} + +void ServerMeta::SharedDtor() { + if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_separator_; + } + if (catalog_term_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_term_; + } + if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) { + delete identifier_quote_string_; + } + if (schema_term_ != &::google::protobuf::internal::kEmptyString) { + delete schema_term_; + } + if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) { + delete search_escape_string_; + } + if (special_characters_ != &::google::protobuf::internal::kEmptyString) { + delete special_characters_; + } + if (table_term_ != &::google::protobuf::internal::kEmptyString) { + delete table_term_; + } + if (this != default_instance_) { + } +} + +void ServerMeta::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ServerMeta::descriptor() { + protobuf_AssignDescriptorsOnce(); + return ServerMeta_descriptor_; +} + +const ServerMeta& ServerMeta::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_User_2eproto(); + return *default_instance_; +} + +ServerMeta* ServerMeta::default_instance_ = NULL; + +ServerMeta* ServerMeta::New() const { + return new ServerMeta; +} + +void ServerMeta::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + all_tables_selectable_ = false; + blob_included_in_max_row_size_ = false; + catalog_at_start_ = false; + if (has_catalog_separator()) { + if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) { + catalog_separator_->clear(); + } + } + if (has_catalog_term()) { + if (catalog_term_ != &::google::protobuf::internal::kEmptyString) { + catalog_term_->clear(); + } + } + column_aliasing_supported_ = false; + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + correlation_names_support_ = 1; + group_by_support_ = 1; + identifier_casing_ = 0; + if (has_identifier_quote_string()) { + if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) { + identifier_quote_string_->clear(); + } + } + like_escape_clause_supported_ = false; + max_binary_literal_length_ = 0u; + } + if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + max_catalog_name_length_ = 0u; + max_char_literal_length_ = 0u; + max_column_name_length_ = 0u; + max_columns_in_group_by_ = 0u; + max_columns_in_order_by_ = 0u; + max_columns_in_select_ = 0u; + max_cursor_name_length_ = 0u; + max_logical_lob_size_ = 0u; + } + if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) { + max_row_size_ = 0u; + max_schema_name_length_ = 0u; + max_statement_length_ = 0u; + max_statements_ = 0u; + max_table_name_length_ = 0u; + max_tables_in_select_ = 0u; + max_user_name_length_ = 0u; + null_collation_ = 0; + } + if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) { + null_plus_non_null_equals_null_ = false; + quoted_identifier_casing_ = 0; + read_only_ = false; + if (has_schema_term()) { + if (schema_term_ != &::google::protobuf::internal::kEmptyString) { + schema_term_->clear(); + } + } + if (has_search_escape_string()) { + if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) { + search_escape_string_->clear(); + } + } + } + if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) { + select_for_update_supported_ = false; + if (has_special_characters()) { + if (special_characters_ != &::google::protobuf::internal::kEmptyString) { + special_characters_->clear(); + } + } + if (has_table_term()) { + if (table_term_ != &::google::protobuf::internal::kEmptyString) { + table_term_->clear(); + } + } + transaction_supported_ = false; + } + collate_support_.Clear(); + convert_support_.Clear(); + date_time_functions_.Clear(); + date_time_literals_support_.Clear(); + numeric_functions_.Clear(); + order_by_support_.Clear(); + outer_join_support_.Clear(); + sql_keywords_.Clear(); + string_functions_.Clear(); + subquery_support_.Clear(); + system_functions_.Clear(); + union_support_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool ServerMeta::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional bool all_tables_selectable = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &all_tables_selectable_))); + set_has_all_tables_selectable(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_blob_included_in_max_row_size; + break; + } + + // optional bool blob_included_in_max_row_size = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_blob_included_in_max_row_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &blob_included_in_max_row_size_))); + set_has_blob_included_in_max_row_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(24)) goto parse_catalog_at_start; + break; + } + + // optional bool catalog_at_start = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_catalog_at_start: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &catalog_at_start_))); + set_has_catalog_at_start(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_catalog_separator; + break; + } + + // optional string catalog_separator = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_catalog_separator: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_catalog_separator())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->catalog_separator().data(), this->catalog_separator().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_catalog_term; + break; + } + + // optional string catalog_term = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_catalog_term: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_catalog_term())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->catalog_term().data(), this->catalog_term().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_collate_support; + break; + } + + // repeated .exec.user.CollateSupport collate_support = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_collate_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::CollateSupport_IsValid(value)) { + add_collate_support(static_cast< ::exec::user::CollateSupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::exec::user::CollateSupport_IsValid, + this->mutable_collate_support()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_collate_support; + if (input->ExpectTag(56)) goto parse_column_aliasing_supported; + break; + } + + // optional bool column_aliasing_supported = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_column_aliasing_supported: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &column_aliasing_supported_))); + set_has_column_aliasing_supported(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_convert_support; + break; + } + + // repeated .exec.user.ConvertSupport convert_support = 8; + case 8: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_convert_support: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_convert_support())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(66)) goto parse_convert_support; + if (input->ExpectTag(72)) goto parse_correlation_names_support; + break; + } + + // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9; + case 9: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_correlation_names_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::CorrelationNamesSupport_IsValid(value)) { + set_correlation_names_support(static_cast< ::exec::user::CorrelationNamesSupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(9, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(82)) goto parse_date_time_functions; + break; + } + + // repeated string date_time_functions = 10; + case 10: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_date_time_functions: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_date_time_functions())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->date_time_functions(this->date_time_functions_size() - 1).data(), + this->date_time_functions(this->date_time_functions_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(82)) goto parse_date_time_functions; + if (input->ExpectTag(88)) goto parse_date_time_literals_support; + break; + } + + // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11; + case 11: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_date_time_literals_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::DateTimeLiteralsSupport_IsValid(value)) { + add_date_time_literals_support(static_cast< ::exec::user::DateTimeLiteralsSupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(11, value); + } + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::exec::user::DateTimeLiteralsSupport_IsValid, + this->mutable_date_time_literals_support()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(88)) goto parse_date_time_literals_support; + if (input->ExpectTag(96)) goto parse_group_by_support; + break; + } + + // optional .exec.user.GroupBySupport group_by_support = 12; + case 12: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_group_by_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::GroupBySupport_IsValid(value)) { + set_group_by_support(static_cast< ::exec::user::GroupBySupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(12, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(104)) goto parse_identifier_casing; + break; + } + + // optional .exec.user.IdentifierCasing identifier_casing = 13; + case 13: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_identifier_casing: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::IdentifierCasing_IsValid(value)) { + set_identifier_casing(static_cast< ::exec::user::IdentifierCasing >(value)); + } else { + mutable_unknown_fields()->AddVarint(13, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(114)) goto parse_identifier_quote_string; + break; + } + + // optional string identifier_quote_string = 14; + case 14: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_identifier_quote_string: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_identifier_quote_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->identifier_quote_string().data(), this->identifier_quote_string().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(120)) goto parse_like_escape_clause_supported; + break; + } + + // optional bool like_escape_clause_supported = 15; + case 15: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_like_escape_clause_supported: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &like_escape_clause_supported_))); + set_has_like_escape_clause_supported(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(128)) goto parse_max_binary_literal_length; + break; + } + + // optional uint32 max_binary_literal_length = 16; + case 16: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_binary_literal_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_binary_literal_length_))); + set_has_max_binary_literal_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(136)) goto parse_max_catalog_name_length; + break; + } + + // optional uint32 max_catalog_name_length = 17; + case 17: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_catalog_name_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_catalog_name_length_))); + set_has_max_catalog_name_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(144)) goto parse_max_char_literal_length; + break; + } + + // optional uint32 max_char_literal_length = 18; + case 18: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_char_literal_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_char_literal_length_))); + set_has_max_char_literal_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(152)) goto parse_max_column_name_length; + break; + } + + // optional uint32 max_column_name_length = 19; + case 19: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_column_name_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_column_name_length_))); + set_has_max_column_name_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(160)) goto parse_max_columns_in_group_by; + break; + } + + // optional uint32 max_columns_in_group_by = 20; + case 20: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_columns_in_group_by: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_columns_in_group_by_))); + set_has_max_columns_in_group_by(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(168)) goto parse_max_columns_in_order_by; + break; + } + + // optional uint32 max_columns_in_order_by = 21; + case 21: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_columns_in_order_by: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_columns_in_order_by_))); + set_has_max_columns_in_order_by(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(176)) goto parse_max_columns_in_select; + break; + } + + // optional uint32 max_columns_in_select = 22; + case 22: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_columns_in_select: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_columns_in_select_))); + set_has_max_columns_in_select(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(184)) goto parse_max_cursor_name_length; + break; + } + + // optional uint32 max_cursor_name_length = 23; + case 23: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_cursor_name_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_cursor_name_length_))); + set_has_max_cursor_name_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(192)) goto parse_max_logical_lob_size; + break; + } + + // optional uint32 max_logical_lob_size = 24; + case 24: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_logical_lob_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_logical_lob_size_))); + set_has_max_logical_lob_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(200)) goto parse_max_row_size; + break; + } + + // optional uint32 max_row_size = 25; + case 25: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_row_size: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_row_size_))); + set_has_max_row_size(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(208)) goto parse_max_schema_name_length; + break; + } + + // optional uint32 max_schema_name_length = 26; + case 26: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_schema_name_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_schema_name_length_))); + set_has_max_schema_name_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(216)) goto parse_max_statement_length; + break; + } + + // optional uint32 max_statement_length = 27; + case 27: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_statement_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_statement_length_))); + set_has_max_statement_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(224)) goto parse_max_statements; + break; + } + + // optional uint32 max_statements = 28; + case 28: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_statements: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_statements_))); + set_has_max_statements(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(232)) goto parse_max_table_name_length; + break; + } + + // optional uint32 max_table_name_length = 29; + case 29: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_table_name_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_table_name_length_))); + set_has_max_table_name_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(240)) goto parse_max_tables_in_select; + break; + } + + // optional uint32 max_tables_in_select = 30; + case 30: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_tables_in_select: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_tables_in_select_))); + set_has_max_tables_in_select(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(248)) goto parse_max_user_name_length; + break; + } + + // optional uint32 max_user_name_length = 31; + case 31: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_max_user_name_length: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( + input, &max_user_name_length_))); + set_has_max_user_name_length(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(256)) goto parse_null_collation; + break; + } + + // optional .exec.user.NullCollation null_collation = 32; + case 32: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_null_collation: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::NullCollation_IsValid(value)) { + set_null_collation(static_cast< ::exec::user::NullCollation >(value)); + } else { + mutable_unknown_fields()->AddVarint(32, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(264)) goto parse_null_plus_non_null_equals_null; + break; + } + + // optional bool null_plus_non_null_equals_null = 33; + case 33: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_null_plus_non_null_equals_null: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &null_plus_non_null_equals_null_))); + set_has_null_plus_non_null_equals_null(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(274)) goto parse_numeric_functions; + break; + } + + // repeated string numeric_functions = 34; + case 34: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_numeric_functions: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_numeric_functions())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->numeric_functions(this->numeric_functions_size() - 1).data(), + this->numeric_functions(this->numeric_functions_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(274)) goto parse_numeric_functions; + if (input->ExpectTag(280)) goto parse_order_by_support; + break; + } + + // repeated .exec.user.OrderBySupport order_by_support = 35; + case 35: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_order_by_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::OrderBySupport_IsValid(value)) { + add_order_by_support(static_cast< ::exec::user::OrderBySupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(35, value); + } + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::exec::user::OrderBySupport_IsValid, + this->mutable_order_by_support()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(280)) goto parse_order_by_support; + if (input->ExpectTag(288)) goto parse_outer_join_support; + break; + } + + // repeated .exec.user.OuterJoinSupport outer_join_support = 36; + case 36: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_outer_join_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::OuterJoinSupport_IsValid(value)) { + add_outer_join_support(static_cast< ::exec::user::OuterJoinSupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(36, value); + } + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::exec::user::OuterJoinSupport_IsValid, + this->mutable_outer_join_support()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(288)) goto parse_outer_join_support; + if (input->ExpectTag(296)) goto parse_quoted_identifier_casing; + break; + } + + // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37; + case 37: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_quoted_identifier_casing: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::IdentifierCasing_IsValid(value)) { + set_quoted_identifier_casing(static_cast< ::exec::user::IdentifierCasing >(value)); + } else { + mutable_unknown_fields()->AddVarint(37, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(304)) goto parse_read_only; + break; + } + + // optional bool read_only = 38; + case 38: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_read_only: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &read_only_))); + set_has_read_only(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(314)) goto parse_schema_term; + break; + } + + // optional string schema_term = 39; + case 39: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_schema_term: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_schema_term())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->schema_term().data(), this->schema_term().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(322)) goto parse_search_escape_string; + break; + } + + // optional string search_escape_string = 40; + case 40: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_search_escape_string: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_search_escape_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->search_escape_string().data(), this->search_escape_string().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(328)) goto parse_select_for_update_supported; + break; + } + + // optional bool select_for_update_supported = 41; + case 41: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_select_for_update_supported: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &select_for_update_supported_))); + set_has_select_for_update_supported(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(338)) goto parse_special_characters; + break; + } + + // optional string special_characters = 42; + case 42: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_special_characters: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_special_characters())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->special_characters().data(), this->special_characters().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(346)) goto parse_sql_keywords; + break; + } + + // repeated string sql_keywords = 43; + case 43: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_sql_keywords: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_sql_keywords())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->sql_keywords(this->sql_keywords_size() - 1).data(), + this->sql_keywords(this->sql_keywords_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(346)) goto parse_sql_keywords; + if (input->ExpectTag(354)) goto parse_string_functions; + break; + } + + // repeated string string_functions = 44; + case 44: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_string_functions: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_string_functions())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->string_functions(this->string_functions_size() - 1).data(), + this->string_functions(this->string_functions_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(354)) goto parse_string_functions; + if (input->ExpectTag(360)) goto parse_subquery_support; + break; + } + + // repeated .exec.user.SubQuerySupport subquery_support = 45; + case 45: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_subquery_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::SubQuerySupport_IsValid(value)) { + add_subquery_support(static_cast< ::exec::user::SubQuerySupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(45, value); + } + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::exec::user::SubQuerySupport_IsValid, + this->mutable_subquery_support()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(360)) goto parse_subquery_support; + if (input->ExpectTag(370)) goto parse_system_functions; + break; + } + + // repeated string system_functions = 46; + case 46: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_system_functions: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_system_functions())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->system_functions(this->system_functions_size() - 1).data(), + this->system_functions(this->system_functions_size() - 1).length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(370)) goto parse_system_functions; + if (input->ExpectTag(378)) goto parse_table_term; + break; + } + + // optional string table_term = 47; + case 47: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_table_term: + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_table_term())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->table_term().data(), this->table_term().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(384)) goto parse_transaction_supported; + break; + } + + // optional bool transaction_supported = 48; + case 48: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_transaction_supported: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( + input, &transaction_supported_))); + set_has_transaction_supported(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(392)) goto parse_union_support; + break; + } + + // repeated .exec.user.UnionSupport union_support = 49; + case 49: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_union_support: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::exec::user::UnionSupport_IsValid(value)) { + add_union_support(static_cast< ::exec::user::UnionSupport >(value)); + } else { + mutable_unknown_fields()->AddVarint(49, value); + } + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedEnumNoInline( + input, + &::exec::user::UnionSupport_IsValid, + this->mutable_union_support()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(392)) goto parse_union_support; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void ServerMeta::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // optional bool all_tables_selectable = 1; + if (has_all_tables_selectable()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all_tables_selectable(), output); + } + + // optional bool blob_included_in_max_row_size = 2; + if (has_blob_included_in_max_row_size()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->blob_included_in_max_row_size(), output); + } + + // optional bool catalog_at_start = 3; + if (has_catalog_at_start()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->catalog_at_start(), output); + } + + // optional string catalog_separator = 4; + if (has_catalog_separator()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->catalog_separator().data(), this->catalog_separator().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 4, this->catalog_separator(), output); + } + + // optional string catalog_term = 5; + if (has_catalog_term()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->catalog_term().data(), this->catalog_term().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 5, this->catalog_term(), output); + } + + // repeated .exec.user.CollateSupport collate_support = 6; + for (int i = 0; i < this->collate_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->collate_support(i), output); + } + + // optional bool column_aliasing_supported = 7; + if (has_column_aliasing_supported()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->column_aliasing_supported(), output); + } + + // repeated .exec.user.ConvertSupport convert_support = 8; + for (int i = 0; i < this->convert_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->convert_support(i), output); + } + + // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9; + if (has_correlation_names_support()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 9, this->correlation_names_support(), output); + } + + // repeated string date_time_functions = 10; + for (int i = 0; i < this->date_time_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->date_time_functions(i).data(), this->date_time_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 10, this->date_time_functions(i), output); + } + + // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11; + for (int i = 0; i < this->date_time_literals_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 11, this->date_time_literals_support(i), output); + } + + // optional .exec.user.GroupBySupport group_by_support = 12; + if (has_group_by_support()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 12, this->group_by_support(), output); + } + + // optional .exec.user.IdentifierCasing identifier_casing = 13; + if (has_identifier_casing()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 13, this->identifier_casing(), output); + } + + // optional string identifier_quote_string = 14; + if (has_identifier_quote_string()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->identifier_quote_string().data(), this->identifier_quote_string().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 14, this->identifier_quote_string(), output); + } + + // optional bool like_escape_clause_supported = 15; + if (has_like_escape_clause_supported()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->like_escape_clause_supported(), output); + } + + // optional uint32 max_binary_literal_length = 16; + if (has_max_binary_literal_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(16, this->max_binary_literal_length(), output); + } + + // optional uint32 max_catalog_name_length = 17; + if (has_max_catalog_name_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(17, this->max_catalog_name_length(), output); + } + + // optional uint32 max_char_literal_length = 18; + if (has_max_char_literal_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(18, this->max_char_literal_length(), output); + } + + // optional uint32 max_column_name_length = 19; + if (has_max_column_name_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(19, this->max_column_name_length(), output); + } + + // optional uint32 max_columns_in_group_by = 20; + if (has_max_columns_in_group_by()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(20, this->max_columns_in_group_by(), output); + } + + // optional uint32 max_columns_in_order_by = 21; + if (has_max_columns_in_order_by()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(21, this->max_columns_in_order_by(), output); + } + + // optional uint32 max_columns_in_select = 22; + if (has_max_columns_in_select()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(22, this->max_columns_in_select(), output); + } + + // optional uint32 max_cursor_name_length = 23; + if (has_max_cursor_name_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(23, this->max_cursor_name_length(), output); + } + + // optional uint32 max_logical_lob_size = 24; + if (has_max_logical_lob_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(24, this->max_logical_lob_size(), output); + } + + // optional uint32 max_row_size = 25; + if (has_max_row_size()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(25, this->max_row_size(), output); + } + + // optional uint32 max_schema_name_length = 26; + if (has_max_schema_name_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(26, this->max_schema_name_length(), output); + } + + // optional uint32 max_statement_length = 27; + if (has_max_statement_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(27, this->max_statement_length(), output); + } + + // optional uint32 max_statements = 28; + if (has_max_statements()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(28, this->max_statements(), output); + } + + // optional uint32 max_table_name_length = 29; + if (has_max_table_name_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(29, this->max_table_name_length(), output); + } + + // optional uint32 max_tables_in_select = 30; + if (has_max_tables_in_select()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(30, this->max_tables_in_select(), output); + } + + // optional uint32 max_user_name_length = 31; + if (has_max_user_name_length()) { + ::google::protobuf::internal::WireFormatLite::WriteUInt32(31, this->max_user_name_length(), output); + } + + // optional .exec.user.NullCollation null_collation = 32; + if (has_null_collation()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 32, this->null_collation(), output); + } + + // optional bool null_plus_non_null_equals_null = 33; + if (has_null_plus_non_null_equals_null()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(33, this->null_plus_non_null_equals_null(), output); + } + + // repeated string numeric_functions = 34; + for (int i = 0; i < this->numeric_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->numeric_functions(i).data(), this->numeric_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 34, this->numeric_functions(i), output); + } + + // repeated .exec.user.OrderBySupport order_by_support = 35; + for (int i = 0; i < this->order_by_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 35, this->order_by_support(i), output); + } + + // repeated .exec.user.OuterJoinSupport outer_join_support = 36; + for (int i = 0; i < this->outer_join_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 36, this->outer_join_support(i), output); + } + + // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37; + if (has_quoted_identifier_casing()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 37, this->quoted_identifier_casing(), output); + } + + // optional bool read_only = 38; + if (has_read_only()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(38, this->read_only(), output); + } + + // optional string schema_term = 39; + if (has_schema_term()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->schema_term().data(), this->schema_term().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 39, this->schema_term(), output); + } + + // optional string search_escape_string = 40; + if (has_search_escape_string()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->search_escape_string().data(), this->search_escape_string().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 40, this->search_escape_string(), output); + } + + // optional bool select_for_update_supported = 41; + if (has_select_for_update_supported()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(41, this->select_for_update_supported(), output); + } + + // optional string special_characters = 42; + if (has_special_characters()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->special_characters().data(), this->special_characters().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 42, this->special_characters(), output); + } + + // repeated string sql_keywords = 43; + for (int i = 0; i < this->sql_keywords_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->sql_keywords(i).data(), this->sql_keywords(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 43, this->sql_keywords(i), output); + } + + // repeated string string_functions = 44; + for (int i = 0; i < this->string_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->string_functions(i).data(), this->string_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 44, this->string_functions(i), output); + } + + // repeated .exec.user.SubQuerySupport subquery_support = 45; + for (int i = 0; i < this->subquery_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 45, this->subquery_support(i), output); + } + + // repeated string system_functions = 46; + for (int i = 0; i < this->system_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->system_functions(i).data(), this->system_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 46, this->system_functions(i), output); + } + + // optional string table_term = 47; + if (has_table_term()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->table_term().data(), this->table_term().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 47, this->table_term(), output); + } + + // optional bool transaction_supported = 48; + if (has_transaction_supported()) { + ::google::protobuf::internal::WireFormatLite::WriteBool(48, this->transaction_supported(), output); + } + + // repeated .exec.user.UnionSupport union_support = 49; + for (int i = 0; i < this->union_support_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 49, this->union_support(i), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* ServerMeta::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // optional bool all_tables_selectable = 1; + if (has_all_tables_selectable()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all_tables_selectable(), target); + } + + // optional bool blob_included_in_max_row_size = 2; + if (has_blob_included_in_max_row_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->blob_included_in_max_row_size(), target); + } + + // optional bool catalog_at_start = 3; + if (has_catalog_at_start()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->catalog_at_start(), target); + } + + // optional string catalog_separator = 4; + if (has_catalog_separator()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->catalog_separator().data(), this->catalog_separator().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->catalog_separator(), target); + } + + // optional string catalog_term = 5; + if (has_catalog_term()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->catalog_term().data(), this->catalog_term().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 5, this->catalog_term(), target); + } + + // repeated .exec.user.CollateSupport collate_support = 6; + for (int i = 0; i < this->collate_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->collate_support(i), target); + } + + // optional bool column_aliasing_supported = 7; + if (has_column_aliasing_supported()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->column_aliasing_supported(), target); + } + + // repeated .exec.user.ConvertSupport convert_support = 8; + for (int i = 0; i < this->convert_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 8, this->convert_support(i), target); + } + + // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9; + if (has_correlation_names_support()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 9, this->correlation_names_support(), target); + } + + // repeated string date_time_functions = 10; + for (int i = 0; i < this->date_time_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->date_time_functions(i).data(), this->date_time_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(10, this->date_time_functions(i), target); + } + + // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11; + for (int i = 0; i < this->date_time_literals_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 11, this->date_time_literals_support(i), target); + } + + // optional .exec.user.GroupBySupport group_by_support = 12; + if (has_group_by_support()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 12, this->group_by_support(), target); + } + + // optional .exec.user.IdentifierCasing identifier_casing = 13; + if (has_identifier_casing()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 13, this->identifier_casing(), target); + } + + // optional string identifier_quote_string = 14; + if (has_identifier_quote_string()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->identifier_quote_string().data(), this->identifier_quote_string().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 14, this->identifier_quote_string(), target); + } + + // optional bool like_escape_clause_supported = 15; + if (has_like_escape_clause_supported()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->like_escape_clause_supported(), target); + } + + // optional uint32 max_binary_literal_length = 16; + if (has_max_binary_literal_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(16, this->max_binary_literal_length(), target); + } + + // optional uint32 max_catalog_name_length = 17; + if (has_max_catalog_name_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(17, this->max_catalog_name_length(), target); + } + + // optional uint32 max_char_literal_length = 18; + if (has_max_char_literal_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(18, this->max_char_literal_length(), target); + } + + // optional uint32 max_column_name_length = 19; + if (has_max_column_name_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(19, this->max_column_name_length(), target); + } + + // optional uint32 max_columns_in_group_by = 20; + if (has_max_columns_in_group_by()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(20, this->max_columns_in_group_by(), target); + } + + // optional uint32 max_columns_in_order_by = 21; + if (has_max_columns_in_order_by()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(21, this->max_columns_in_order_by(), target); + } + + // optional uint32 max_columns_in_select = 22; + if (has_max_columns_in_select()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(22, this->max_columns_in_select(), target); + } + + // optional uint32 max_cursor_name_length = 23; + if (has_max_cursor_name_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(23, this->max_cursor_name_length(), target); + } + + // optional uint32 max_logical_lob_size = 24; + if (has_max_logical_lob_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(24, this->max_logical_lob_size(), target); + } + + // optional uint32 max_row_size = 25; + if (has_max_row_size()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(25, this->max_row_size(), target); + } + + // optional uint32 max_schema_name_length = 26; + if (has_max_schema_name_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(26, this->max_schema_name_length(), target); + } + + // optional uint32 max_statement_length = 27; + if (has_max_statement_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(27, this->max_statement_length(), target); + } + + // optional uint32 max_statements = 28; + if (has_max_statements()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(28, this->max_statements(), target); + } + + // optional uint32 max_table_name_length = 29; + if (has_max_table_name_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(29, this->max_table_name_length(), target); + } + + // optional uint32 max_tables_in_select = 30; + if (has_max_tables_in_select()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(30, this->max_tables_in_select(), target); + } + + // optional uint32 max_user_name_length = 31; + if (has_max_user_name_length()) { + target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(31, this->max_user_name_length(), target); + } + + // optional .exec.user.NullCollation null_collation = 32; + if (has_null_collation()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 32, this->null_collation(), target); + } + + // optional bool null_plus_non_null_equals_null = 33; + if (has_null_plus_non_null_equals_null()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(33, this->null_plus_non_null_equals_null(), target); + } + + // repeated string numeric_functions = 34; + for (int i = 0; i < this->numeric_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->numeric_functions(i).data(), this->numeric_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(34, this->numeric_functions(i), target); + } + + // repeated .exec.user.OrderBySupport order_by_support = 35; + for (int i = 0; i < this->order_by_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 35, this->order_by_support(i), target); + } + + // repeated .exec.user.OuterJoinSupport outer_join_support = 36; + for (int i = 0; i < this->outer_join_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 36, this->outer_join_support(i), target); + } + + // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37; + if (has_quoted_identifier_casing()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 37, this->quoted_identifier_casing(), target); + } + + // optional bool read_only = 38; + if (has_read_only()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(38, this->read_only(), target); + } + + // optional string schema_term = 39; + if (has_schema_term()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->schema_term().data(), this->schema_term().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 39, this->schema_term(), target); + } + + // optional string search_escape_string = 40; + if (has_search_escape_string()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->search_escape_string().data(), this->search_escape_string().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 40, this->search_escape_string(), target); + } + + // optional bool select_for_update_supported = 41; + if (has_select_for_update_supported()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(41, this->select_for_update_supported(), target); + } + + // optional string special_characters = 42; + if (has_special_characters()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->special_characters().data(), this->special_characters().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 42, this->special_characters(), target); + } + + // repeated string sql_keywords = 43; + for (int i = 0; i < this->sql_keywords_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->sql_keywords(i).data(), this->sql_keywords(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(43, this->sql_keywords(i), target); + } + + // repeated string string_functions = 44; + for (int i = 0; i < this->string_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->string_functions(i).data(), this->string_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(44, this->string_functions(i), target); + } + + // repeated .exec.user.SubQuerySupport subquery_support = 45; + for (int i = 0; i < this->subquery_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 45, this->subquery_support(i), target); + } + + // repeated string system_functions = 46; + for (int i = 0; i < this->system_functions_size(); i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->system_functions(i).data(), this->system_functions(i).length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(46, this->system_functions(i), target); + } + + // optional string table_term = 47; + if (has_table_term()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->table_term().data(), this->table_term().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 47, this->table_term(), target); + } + + // optional bool transaction_supported = 48; + if (has_transaction_supported()) { + target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(48, this->transaction_supported(), target); + } + + // repeated .exec.user.UnionSupport union_support = 49; + for (int i = 0; i < this->union_support_size(); i++) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 49, this->union_support(i), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int ServerMeta::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // optional bool all_tables_selectable = 1; + if (has_all_tables_selectable()) { + total_size += 1 + 1; + } + + // optional bool blob_included_in_max_row_size = 2; + if (has_blob_included_in_max_row_size()) { + total_size += 1 + 1; + } + + // optional bool catalog_at_start = 3; + if (has_catalog_at_start()) { + total_size += 1 + 1; + } + + // optional string catalog_separator = 4; + if (has_catalog_separator()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->catalog_separator()); + } + + // optional string catalog_term = 5; + if (has_catalog_term()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->catalog_term()); + } + + // optional bool column_aliasing_supported = 7; + if (has_column_aliasing_supported()) { + total_size += 1 + 1; + } + + } + if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) { + // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9; + if (has_correlation_names_support()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->correlation_names_support()); + } + + // optional .exec.user.GroupBySupport group_by_support = 12; + if (has_group_by_support()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->group_by_support()); + } + + // optional .exec.user.IdentifierCasing identifier_casing = 13; + if (has_identifier_casing()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->identifier_casing()); + } + + // optional string identifier_quote_string = 14; + if (has_identifier_quote_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->identifier_quote_string()); + } + + // optional bool like_escape_clause_supported = 15; + if (has_like_escape_clause_supported()) { + total_size += 1 + 1; + } + + // optional uint32 max_binary_literal_length = 16; + if (has_max_binary_literal_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_binary_literal_length()); + } + + } + if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) { + // optional uint32 max_catalog_name_length = 17; + if (has_max_catalog_name_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_catalog_name_length()); + } + + // optional uint32 max_char_literal_length = 18; + if (has_max_char_literal_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_char_literal_length()); + } + + // optional uint32 max_column_name_length = 19; + if (has_max_column_name_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_column_name_length()); + } + + // optional uint32 max_columns_in_group_by = 20; + if (has_max_columns_in_group_by()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_columns_in_group_by()); + } + + // optional uint32 max_columns_in_order_by = 21; + if (has_max_columns_in_order_by()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_columns_in_order_by()); + } + + // optional uint32 max_columns_in_select = 22; + if (has_max_columns_in_select()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_columns_in_select()); + } + + // optional uint32 max_cursor_name_length = 23; + if (has_max_cursor_name_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_cursor_name_length()); + } + + // optional uint32 max_logical_lob_size = 24; + if (has_max_logical_lob_size()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_logical_lob_size()); + } + + } + if (_has_bits_[24 / 32] & (0xffu << (24 % 32))) { + // optional uint32 max_row_size = 25; + if (has_max_row_size()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_row_size()); + } + + // optional uint32 max_schema_name_length = 26; + if (has_max_schema_name_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_schema_name_length()); + } + + // optional uint32 max_statement_length = 27; + if (has_max_statement_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_statement_length()); + } + + // optional uint32 max_statements = 28; + if (has_max_statements()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_statements()); + } + + // optional uint32 max_table_name_length = 29; + if (has_max_table_name_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_table_name_length()); + } + + // optional uint32 max_tables_in_select = 30; + if (has_max_tables_in_select()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_tables_in_select()); + } + + // optional uint32 max_user_name_length = 31; + if (has_max_user_name_length()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::UInt32Size( + this->max_user_name_length()); + } + + // optional .exec.user.NullCollation null_collation = 32; + if (has_null_collation()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->null_collation()); + } + + } + if (_has_bits_[32 / 32] & (0xffu << (32 % 32))) { + // optional bool null_plus_non_null_equals_null = 33; + if (has_null_plus_non_null_equals_null()) { + total_size += 2 + 1; + } + + // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37; + if (has_quoted_identifier_casing()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->quoted_identifier_casing()); + } + + // optional bool read_only = 38; + if (has_read_only()) { + total_size += 2 + 1; + } + + // optional string schema_term = 39; + if (has_schema_term()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->schema_term()); + } + + // optional string search_escape_string = 40; + if (has_search_escape_string()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->search_escape_string()); + } + + } + if (_has_bits_[40 / 32] & (0xffu << (40 % 32))) { + // optional bool select_for_update_supported = 41; + if (has_select_for_update_supported()) { + total_size += 2 + 1; + } + + // optional string special_characters = 42; + if (has_special_characters()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->special_characters()); + } + + // optional string table_term = 47; + if (has_table_term()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->table_term()); + } + + // optional bool transaction_supported = 48; + if (has_transaction_supported()) { + total_size += 2 + 1; + } + + } + // repeated .exec.user.CollateSupport collate_support = 6; + { + int data_size = 0; + for (int i = 0; i < this->collate_support_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->collate_support(i)); + } + total_size += 1 * this->collate_support_size() + data_size; + } + + // repeated .exec.user.ConvertSupport convert_support = 8; + total_size += 1 * this->convert_support_size(); + for (int i = 0; i < this->convert_support_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->convert_support(i)); + } + + // repeated string date_time_functions = 10; + total_size += 1 * this->date_time_functions_size(); + for (int i = 0; i < this->date_time_functions_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->date_time_functions(i)); + } + + // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11; + { + int data_size = 0; + for (int i = 0; i < this->date_time_literals_support_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->date_time_literals_support(i)); + } + total_size += 1 * this->date_time_literals_support_size() + data_size; + } + + // repeated string numeric_functions = 34; + total_size += 2 * this->numeric_functions_size(); + for (int i = 0; i < this->numeric_functions_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->numeric_functions(i)); + } + + // repeated .exec.user.OrderBySupport order_by_support = 35; + { + int data_size = 0; + for (int i = 0; i < this->order_by_support_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->order_by_support(i)); + } + total_size += 2 * this->order_by_support_size() + data_size; + } + + // repeated .exec.user.OuterJoinSupport outer_join_support = 36; + { + int data_size = 0; + for (int i = 0; i < this->outer_join_support_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->outer_join_support(i)); + } + total_size += 2 * this->outer_join_support_size() + data_size; + } + + // repeated string sql_keywords = 43; + total_size += 2 * this->sql_keywords_size(); + for (int i = 0; i < this->sql_keywords_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->sql_keywords(i)); + } + + // repeated string string_functions = 44; + total_size += 2 * this->string_functions_size(); + for (int i = 0; i < this->string_functions_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->string_functions(i)); + } + + // repeated .exec.user.SubQuerySupport subquery_support = 45; + { + int data_size = 0; + for (int i = 0; i < this->subquery_support_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->subquery_support(i)); + } + total_size += 2 * this->subquery_support_size() + data_size; + } + + // repeated string system_functions = 46; + total_size += 2 * this->system_functions_size(); + for (int i = 0; i < this->system_functions_size(); i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->system_functions(i)); + } + + // repeated .exec.user.UnionSupport union_support = 49; + { + int data_size = 0; + for (int i = 0; i < this->union_support_size(); i++) { + data_size += ::google::protobuf::internal::WireFormatLite::EnumSize( + this->union_support(i)); + } + total_size += 2 * this->union_support_size() + data_size; + } + + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ServerMeta::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const ServerMeta* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void ServerMeta::MergeFrom(const ServerMeta& from) { + GOOGLE_CHECK_NE(&from, this); + collate_support_.MergeFrom(from.collate_support_); + convert_support_.MergeFrom(from.convert_support_); + date_time_functions_.MergeFrom(from.date_time_functions_); + date_time_literals_support_.MergeFrom(from.date_time_literals_support_); + numeric_functions_.MergeFrom(from.numeric_functions_); + order_by_support_.MergeFrom(from.order_by_support_); + outer_join_support_.MergeFrom(from.outer_join_support_); + sql_keywords_.MergeFrom(from.sql_keywords_); + string_functions_.MergeFrom(from.string_functions_); + subquery_support_.MergeFrom(from.subquery_support_); + system_functions_.MergeFrom(from.system_functions_); + union_support_.MergeFrom(from.union_support_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_all_tables_selectable()) { + set_all_tables_selectable(from.all_tables_selectable()); + } + if (from.has_blob_included_in_max_row_size()) { + set_blob_included_in_max_row_size(from.blob_included_in_max_row_size()); + } + if (from.has_catalog_at_start()) { + set_catalog_at_start(from.catalog_at_start()); + } + if (from.has_catalog_separator()) { + set_catalog_separator(from.catalog_separator()); + } + if (from.has_catalog_term()) { + set_catalog_term(from.catalog_term()); + } + if (from.has_column_aliasing_supported()) { + set_column_aliasing_supported(from.column_aliasing_supported()); + } + } + if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) { + if (from.has_correlation_names_support()) { + set_correlation_names_support(from.correlation_names_support()); + } + if (from.has_group_by_support()) { + set_group_by_support(from.group_by_support()); + } + if (from.has_identifier_casing()) { + set_identifier_casing(from.identifier_casing()); + } + if (from.has_identifier_quote_string()) { + set_identifier_quote_string(from.identifier_quote_string()); + } + if (from.has_like_escape_clause_supported()) { + set_like_escape_clause_supported(from.like_escape_clause_supported()); + } + if (from.has_max_binary_literal_length()) { + set_max_binary_literal_length(from.max_binary_literal_length()); + } + } + if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) { + if (from.has_max_catalog_name_length()) { + set_max_catalog_name_length(from.max_catalog_name_length()); + } + if (from.has_max_char_literal_length()) { + set_max_char_literal_length(from.max_char_literal_length()); + } + if (from.has_max_column_name_length()) { + set_max_column_name_length(from.max_column_name_length()); + } + if (from.has_max_columns_in_group_by()) { + set_max_columns_in_group_by(from.max_columns_in_group_by()); + } + if (from.has_max_columns_in_order_by()) { + set_max_columns_in_order_by(from.max_columns_in_order_by()); + } + if (from.has_max_columns_in_select()) { + set_max_columns_in_select(from.max_columns_in_select()); + } + if (from.has_max_cursor_name_length()) { + set_max_cursor_name_length(from.max_cursor_name_length()); + } + if (from.has_max_logical_lob_size()) { + set_max_logical_lob_size(from.max_logical_lob_size()); + } + } + if (from._has_bits_[24 / 32] & (0xffu << (24 % 32))) { + if (from.has_max_row_size()) { + set_max_row_size(from.max_row_size()); + } + if (from.has_max_schema_name_length()) { + set_max_schema_name_length(from.max_schema_name_length()); + } + if (from.has_max_statement_length()) { + set_max_statement_length(from.max_statement_length()); + } + if (from.has_max_statements()) { + set_max_statements(from.max_statements()); + } + if (from.has_max_table_name_length()) { + set_max_table_name_length(from.max_table_name_length()); + } + if (from.has_max_tables_in_select()) { + set_max_tables_in_select(from.max_tables_in_select()); + } + if (from.has_max_user_name_length()) { + set_max_user_name_length(from.max_user_name_length()); + } + if (from.has_null_collation()) { + set_null_collation(from.null_collation()); + } + } + if (from._has_bits_[32 / 32] & (0xffu << (32 % 32))) { + if (from.has_null_plus_non_null_equals_null()) { + set_null_plus_non_null_equals_null(from.null_plus_non_null_equals_null()); + } + if (from.has_quoted_identifier_casing()) { + set_quoted_identifier_casing(from.quoted_identifier_casing()); + } + if (from.has_read_only()) { + set_read_only(from.read_only()); + } + if (from.has_schema_term()) { + set_schema_term(from.schema_term()); + } + if (from.has_search_escape_string()) { + set_search_escape_string(from.search_escape_string()); + } + } + if (from._has_bits_[40 / 32] & (0xffu << (40 % 32))) { + if (from.has_select_for_update_supported()) { + set_select_for_update_supported(from.select_for_update_supported()); + } + if (from.has_special_characters()) { + set_special_characters(from.special_characters()); + } + if (from.has_table_term()) { + set_table_term(from.table_term()); + } + if (from.has_transaction_supported()) { + set_transaction_supported(from.transaction_supported()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void ServerMeta::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ServerMeta::CopyFrom(const ServerMeta& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ServerMeta::IsInitialized() const { + + for (int i = 0; i < convert_support_size(); i++) { + if (!this->convert_support(i).IsInitialized()) return false; + } + return true; +} + +void ServerMeta::Swap(ServerMeta* other) { + if (other != this) { + std::swap(all_tables_selectable_, other->all_tables_selectable_); + std::swap(blob_included_in_max_row_size_, other->blob_included_in_max_row_size_); + std::swap(catalog_at_start_, other->catalog_at_start_); + std::swap(catalog_separator_, other->catalog_separator_); + std::swap(catalog_term_, other->catalog_term_); + collate_support_.Swap(&other->collate_support_); + std::swap(column_aliasing_supported_, other->column_aliasing_supported_); + convert_support_.Swap(&other->convert_support_); + std::swap(correlation_names_support_, other->correlation_names_support_); + date_time_functions_.Swap(&other->date_time_functions_); + date_time_literals_support_.Swap(&other->date_time_literals_support_); + std::swap(group_by_support_, other->group_by_support_); + std::swap(identifier_casing_, other->identifier_casing_); + std::swap(identifier_quote_string_, other->identifier_quote_string_); + std::swap(like_escape_clause_supported_, other->like_escape_clause_supported_); + std::swap(max_binary_literal_length_, other->max_binary_literal_length_); + std::swap(max_catalog_name_length_, other->max_catalog_name_length_); + std::swap(max_char_literal_length_, other->max_char_literal_length_); + std::swap(max_column_name_length_, other->max_column_name_length_); + std::swap(max_columns_in_group_by_, other->max_columns_in_group_by_); + std::swap(max_columns_in_order_by_, other->max_columns_in_order_by_); + std::swap(max_columns_in_select_, other->max_columns_in_select_); + std::swap(max_cursor_name_length_, other->max_cursor_name_length_); + std::swap(max_logical_lob_size_, other->max_logical_lob_size_); + std::swap(max_row_size_, other->max_row_size_); + std::swap(max_schema_name_length_, other->max_schema_name_length_); + std::swap(max_statement_length_, other->max_statement_length_); + std::swap(max_statements_, other->max_statements_); + std::swap(max_table_name_length_, other->max_table_name_length_); + std::swap(max_tables_in_select_, other->max_tables_in_select_); + std::swap(max_user_name_length_, other->max_user_name_length_); + std::swap(null_collation_, other->null_collation_); + std::swap(null_plus_non_null_equals_null_, other->null_plus_non_null_equals_null_); + numeric_functions_.Swap(&other->numeric_functions_); + order_by_support_.Swap(&other->order_by_support_); + outer_join_support_.Swap(&other->outer_join_support_); + std::swap(quoted_identifier_casing_, other->quoted_identifier_casing_); + std::swap(read_only_, other->read_only_); + std::swap(schema_term_, other->schema_term_); + std::swap(search_escape_string_, other->search_escape_string_); + std::swap(select_for_update_supported_, other->select_for_update_supported_); + std::swap(special_characters_, other->special_characters_); + sql_keywords_.Swap(&other->sql_keywords_); + string_functions_.Swap(&other->string_functions_); + subquery_support_.Swap(&other->subquery_support_); + system_functions_.Swap(&other->system_functions_); + std::swap(table_term_, other->table_term_); + std::swap(transaction_supported_, other->transaction_supported_); + union_support_.Swap(&other->union_support_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_has_bits_[1], other->_has_bits_[1]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata ServerMeta::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = ServerMeta_descriptor_; + metadata.reflection = ServerMeta_reflection_; + return metadata; +} + + // =================================================================== #ifndef _MSC_VER diff --git a/contrib/native/client/src/protobuf/User.pb.h b/contrib/native/client/src/protobuf/User.pb.h index d332c3678..a8f8db4d3 100644 --- a/contrib/native/client/src/protobuf/User.pb.h +++ b/contrib/native/client/src/protobuf/User.pb.h @@ -26,6 +26,7 @@ #include #include #include "SchemaDef.pb.h" +#include "Types.pb.h" #include "UserBitShared.pb.h" #include "BitData.pb.h" #include "BitControl.pb.h" @@ -66,6 +67,10 @@ class ResultColumnMetadata; class PreparedStatementHandle; class PreparedStatement; class CreatePreparedStatementResp; +class GetServerMetaReq; +class ConvertSupport; +class GetServerMetaResp; +class ServerMeta; class RunQuery; enum RpcType { @@ -82,6 +87,7 @@ enum RpcType { GET_TABLES = 16, GET_COLUMNS = 17, CREATE_PREPARED_STATEMENT = 22, + GET_SERVER_META = 8, QUERY_DATA = 6, QUERY_HANDLE = 7, QUERY_PLAN_FRAGMENTS = 13, @@ -90,8 +96,7 @@ enum RpcType { TABLES = 20, COLUMNS = 21, PREPARED_STATEMENT = 23, - REQ_META_FUNCTIONS = 8, - RESP_FUNCTION_LIST = 9, + SERVER_META = 9, QUERY_RESULT = 10, SASL_MESSAGE = 24 }; @@ -232,6 +237,232 @@ inline bool ColumnUpdatability_Parse( return ::google::protobuf::internal::ParseNamedEnum( ColumnUpdatability_descriptor(), name, value); } +enum CollateSupport { + CS_UNKNOWN = 0, + CS_GROUP_BY = 1 +}; +bool CollateSupport_IsValid(int value); +const CollateSupport CollateSupport_MIN = CS_UNKNOWN; +const CollateSupport CollateSupport_MAX = CS_GROUP_BY; +const int CollateSupport_ARRAYSIZE = CollateSupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* CollateSupport_descriptor(); +inline const ::std::string& CollateSupport_Name(CollateSupport value) { + return ::google::protobuf::internal::NameOfEnum( + CollateSupport_descriptor(), value); +} +inline bool CollateSupport_Parse( + const ::std::string& name, CollateSupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + CollateSupport_descriptor(), name, value); +} +enum CorrelationNamesSupport { + CN_NONE = 1, + CN_DIFFERENT_NAMES = 2, + CN_ANY = 3 +}; +bool CorrelationNamesSupport_IsValid(int value); +const CorrelationNamesSupport CorrelationNamesSupport_MIN = CN_NONE; +const CorrelationNamesSupport CorrelationNamesSupport_MAX = CN_ANY; +const int CorrelationNamesSupport_ARRAYSIZE = CorrelationNamesSupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* CorrelationNamesSupport_descriptor(); +inline const ::std::string& CorrelationNamesSupport_Name(CorrelationNamesSupport value) { + return ::google::protobuf::internal::NameOfEnum( + CorrelationNamesSupport_descriptor(), value); +} +inline bool CorrelationNamesSupport_Parse( + const ::std::string& name, CorrelationNamesSupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + CorrelationNamesSupport_descriptor(), name, value); +} +enum DateTimeLiteralsSupport { + DL_UNKNOWN = 0, + DL_DATE = 1, + DL_TIME = 2, + DL_TIMESTAMP = 3, + DL_INTERVAL_YEAR = 4, + DL_INTERVAL_MONTH = 5, + DL_INTERVAL_DAY = 6, + DL_INTERVAL_HOUR = 7, + DL_INTERVAL_MINUTE = 8, + DL_INTERVAL_SECOND = 9, + DL_INTERVAL_YEAR_TO_MONTH = 10, + DL_INTERVAL_DAY_TO_HOUR = 11, + DL_INTERVAL_DAY_TO_MINUTE = 12, + DL_INTERVAL_DAY_TO_SECOND = 13, + DL_INTERVAL_HOUR_TO_MINUTE = 14, + DL_INTERVAL_HOUR_TO_SECOND = 15, + DL_INTERVAL_MINUTE_TO_SECOND = 16 +}; +bool DateTimeLiteralsSupport_IsValid(int value); +const DateTimeLiteralsSupport DateTimeLiteralsSupport_MIN = DL_UNKNOWN; +const DateTimeLiteralsSupport DateTimeLiteralsSupport_MAX = DL_INTERVAL_MINUTE_TO_SECOND; +const int DateTimeLiteralsSupport_ARRAYSIZE = DateTimeLiteralsSupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* DateTimeLiteralsSupport_descriptor(); +inline const ::std::string& DateTimeLiteralsSupport_Name(DateTimeLiteralsSupport value) { + return ::google::protobuf::internal::NameOfEnum( + DateTimeLiteralsSupport_descriptor(), value); +} +inline bool DateTimeLiteralsSupport_Parse( + const ::std::string& name, DateTimeLiteralsSupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + DateTimeLiteralsSupport_descriptor(), name, value); +} +enum GroupBySupport { + GB_NONE = 1, + GB_SELECT_ONLY = 2, + GB_BEYOND_SELECT = 3, + GB_UNRELATED = 4 +}; +bool GroupBySupport_IsValid(int value); +const GroupBySupport GroupBySupport_MIN = GB_NONE; +const GroupBySupport GroupBySupport_MAX = GB_UNRELATED; +const int GroupBySupport_ARRAYSIZE = GroupBySupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* GroupBySupport_descriptor(); +inline const ::std::string& GroupBySupport_Name(GroupBySupport value) { + return ::google::protobuf::internal::NameOfEnum( + GroupBySupport_descriptor(), value); +} +inline bool GroupBySupport_Parse( + const ::std::string& name, GroupBySupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + GroupBySupport_descriptor(), name, value); +} +enum IdentifierCasing { + IC_UNKNOWN = 0, + IC_STORES_LOWER = 1, + IC_STORES_MIXED = 2, + IC_STORES_UPPER = 3, + IC_SUPPORTS_MIXED = 4 +}; +bool IdentifierCasing_IsValid(int value); +const IdentifierCasing IdentifierCasing_MIN = IC_UNKNOWN; +const IdentifierCasing IdentifierCasing_MAX = IC_SUPPORTS_MIXED; +const int IdentifierCasing_ARRAYSIZE = IdentifierCasing_MAX + 1; + +const ::google::protobuf::EnumDescriptor* IdentifierCasing_descriptor(); +inline const ::std::string& IdentifierCasing_Name(IdentifierCasing value) { + return ::google::protobuf::internal::NameOfEnum( + IdentifierCasing_descriptor(), value); +} +inline bool IdentifierCasing_Parse( + const ::std::string& name, IdentifierCasing* value) { + return ::google::protobuf::internal::ParseNamedEnum( + IdentifierCasing_descriptor(), name, value); +} +enum NullCollation { + NC_UNKNOWN = 0, + NC_AT_START = 1, + NC_AT_END = 2, + NC_HIGH = 3, + NC_LOW = 4 +}; +bool NullCollation_IsValid(int value); +const NullCollation NullCollation_MIN = NC_UNKNOWN; +const NullCollation NullCollation_MAX = NC_LOW; +const int NullCollation_ARRAYSIZE = NullCollation_MAX + 1; + +const ::google::protobuf::EnumDescriptor* NullCollation_descriptor(); +inline const ::std::string& NullCollation_Name(NullCollation value) { + return ::google::protobuf::internal::NameOfEnum( + NullCollation_descriptor(), value); +} +inline bool NullCollation_Parse( + const ::std::string& name, NullCollation* value) { + return ::google::protobuf::internal::ParseNamedEnum( + NullCollation_descriptor(), name, value); +} +enum OrderBySupport { + OB_UNKNOWN = 0, + OB_UNRELATED = 1, + OB_EXPRESSION = 2 +}; +bool OrderBySupport_IsValid(int value); +const OrderBySupport OrderBySupport_MIN = OB_UNKNOWN; +const OrderBySupport OrderBySupport_MAX = OB_EXPRESSION; +const int OrderBySupport_ARRAYSIZE = OrderBySupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* OrderBySupport_descriptor(); +inline const ::std::string& OrderBySupport_Name(OrderBySupport value) { + return ::google::protobuf::internal::NameOfEnum( + OrderBySupport_descriptor(), value); +} +inline bool OrderBySupport_Parse( + const ::std::string& name, OrderBySupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + OrderBySupport_descriptor(), name, value); +} +enum OuterJoinSupport { + OJ_UNKNOWN = 0, + OJ_LEFT = 1, + OJ_RIGHT = 2, + OJ_FULL = 3, + OJ_NESTED = 4, + OJ_NOT_ORDERED = 5, + OJ_INNER = 6, + OJ_ALL_COMPARISON_OPS = 7 +}; +bool OuterJoinSupport_IsValid(int value); +const OuterJoinSupport OuterJoinSupport_MIN = OJ_UNKNOWN; +const OuterJoinSupport OuterJoinSupport_MAX = OJ_ALL_COMPARISON_OPS; +const int OuterJoinSupport_ARRAYSIZE = OuterJoinSupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* OuterJoinSupport_descriptor(); +inline const ::std::string& OuterJoinSupport_Name(OuterJoinSupport value) { + return ::google::protobuf::internal::NameOfEnum( + OuterJoinSupport_descriptor(), value); +} +inline bool OuterJoinSupport_Parse( + const ::std::string& name, OuterJoinSupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + OuterJoinSupport_descriptor(), name, value); +} +enum SubQuerySupport { + SQ_UNKNOWN = 0, + SQ_CORRELATED = 1, + SQ_IN_COMPARISON = 2, + SQ_IN_EXISTS = 3, + SQ_IN_INSERT = 4, + SQ_IN_QUANTIFIED = 5 +}; +bool SubQuerySupport_IsValid(int value); +const SubQuerySupport SubQuerySupport_MIN = SQ_UNKNOWN; +const SubQuerySupport SubQuerySupport_MAX = SQ_IN_QUANTIFIED; +const int SubQuerySupport_ARRAYSIZE = SubQuerySupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* SubQuerySupport_descriptor(); +inline const ::std::string& SubQuerySupport_Name(SubQuerySupport value) { + return ::google::protobuf::internal::NameOfEnum( + SubQuerySupport_descriptor(), value); +} +inline bool SubQuerySupport_Parse( + const ::std::string& name, SubQuerySupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + SubQuerySupport_descriptor(), name, value); +} +enum UnionSupport { + U_UNKNOWN = 0, + U_UNION = 1, + U_UNION_ALL = 2 +}; +bool UnionSupport_IsValid(int value); +const UnionSupport UnionSupport_MIN = U_UNKNOWN; +const UnionSupport UnionSupport_MAX = U_UNION_ALL; +const int UnionSupport_ARRAYSIZE = UnionSupport_MAX + 1; + +const ::google::protobuf::EnumDescriptor* UnionSupport_descriptor(); +inline const ::std::string& UnionSupport_Name(UnionSupport value) { + return ::google::protobuf::internal::NameOfEnum( + UnionSupport_descriptor(), value); +} +inline bool UnionSupport_Parse( + const ::std::string& name, UnionSupport* value) { + return ::google::protobuf::internal::ParseNamedEnum( + UnionSupport_descriptor(), name, value); +} // =================================================================== class Property : public ::google::protobuf::Message { @@ -3545,14 +3776,14 @@ class CreatePreparedStatementResp : public ::google::protobuf::Message { }; // ------------------------------------------------------------------- -class RunQuery : public ::google::protobuf::Message { +class GetServerMetaReq : public ::google::protobuf::Message { public: - RunQuery(); - virtual ~RunQuery(); + GetServerMetaReq(); + virtual ~GetServerMetaReq(); - RunQuery(const RunQuery& from); + GetServerMetaReq(const GetServerMetaReq& from); - inline RunQuery& operator=(const RunQuery& from) { + inline GetServerMetaReq& operator=(const GetServerMetaReq& from) { CopyFrom(from); return *this; } @@ -3566,17 +3797,17 @@ class RunQuery : public ::google::protobuf::Message { } static const ::google::protobuf::Descriptor* descriptor(); - static const RunQuery& default_instance(); + static const GetServerMetaReq& default_instance(); - void Swap(RunQuery* other); + void Swap(GetServerMetaReq* other); // implements Message ---------------------------------------------- - RunQuery* New() const; + GetServerMetaReq* New() const; void CopyFrom(const ::google::protobuf::Message& from); void MergeFrom(const ::google::protobuf::Message& from); - void CopyFrom(const RunQuery& from); - void MergeFrom(const RunQuery& from); + void CopyFrom(const GetServerMetaReq& from); + void MergeFrom(const GetServerMetaReq& from); void Clear(); bool IsInitialized() const; @@ -3599,1668 +3830,3985 @@ class RunQuery : public ::google::protobuf::Message { // accessors ------------------------------------------------------- - // optional .exec.user.QueryResultsMode results_mode = 1; - inline bool has_results_mode() const; - inline void clear_results_mode(); - static const int kResultsModeFieldNumber = 1; - inline ::exec::user::QueryResultsMode results_mode() const; - inline void set_results_mode(::exec::user::QueryResultsMode value); + // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaReq) + private: - // optional .exec.shared.QueryType type = 2; - inline bool has_type() const; - inline void clear_type(); - static const int kTypeFieldNumber = 2; - inline ::exec::shared::QueryType type() const; - inline void set_type(::exec::shared::QueryType value); + ::google::protobuf::UnknownFieldSet _unknown_fields_; - // optional string plan = 3; - inline bool has_plan() const; - inline void clear_plan(); - static const int kPlanFieldNumber = 3; - inline const ::std::string& plan() const; - inline void set_plan(const ::std::string& value); - inline void set_plan(const char* value); - inline void set_plan(const char* value, size_t size); - inline ::std::string* mutable_plan(); - inline ::std::string* release_plan(); - inline void set_allocated_plan(::std::string* plan); - // repeated .exec.bit.control.PlanFragment fragments = 4; - inline int fragments_size() const; - inline void clear_fragments(); - static const int kFragmentsFieldNumber = 4; - inline const ::exec::bit::control::PlanFragment& fragments(int index) const; - inline ::exec::bit::control::PlanFragment* mutable_fragments(int index); - inline ::exec::bit::control::PlanFragment* add_fragments(); - inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >& - fragments() const; - inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >* - mutable_fragments(); + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[1]; - // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5; - inline bool has_prepared_statement_handle() const; - inline void clear_prepared_statement_handle(); - static const int kPreparedStatementHandleFieldNumber = 5; - inline const ::exec::user::PreparedStatementHandle& prepared_statement_handle() const; - inline ::exec::user::PreparedStatementHandle* mutable_prepared_statement_handle(); - inline ::exec::user::PreparedStatementHandle* release_prepared_statement_handle(); - inline void set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle); + friend void protobuf_AddDesc_User_2eproto(); + friend void protobuf_AssignDesc_User_2eproto(); + friend void protobuf_ShutdownFile_User_2eproto(); - // @@protoc_insertion_point(class_scope:exec.user.RunQuery) + void InitAsDefaultInstance(); + static GetServerMetaReq* default_instance_; +}; +// ------------------------------------------------------------------- + +class ConvertSupport : public ::google::protobuf::Message { + public: + ConvertSupport(); + virtual ~ConvertSupport(); + + ConvertSupport(const ConvertSupport& from); + + inline ConvertSupport& operator=(const ConvertSupport& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ConvertSupport& default_instance(); + + void Swap(ConvertSupport* other); + + // implements Message ---------------------------------------------- + + ConvertSupport* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ConvertSupport& from); + void MergeFrom(const ConvertSupport& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .common.MinorType from = 1; + inline bool has_from() const; + inline void clear_from(); + static const int kFromFieldNumber = 1; + inline ::common::MinorType from() const; + inline void set_from(::common::MinorType value); + + // required .common.MinorType to = 2; + inline bool has_to() const; + inline void clear_to(); + static const int kToFieldNumber = 2; + inline ::common::MinorType to() const; + inline void set_to(::common::MinorType value); + + // @@protoc_insertion_point(class_scope:exec.user.ConvertSupport) private: - inline void set_has_results_mode(); - inline void clear_has_results_mode(); - inline void set_has_type(); - inline void clear_has_type(); - inline void set_has_plan(); - inline void clear_has_plan(); - inline void set_has_prepared_statement_handle(); - inline void clear_has_prepared_statement_handle(); + inline void set_has_from(); + inline void clear_has_from(); + inline void set_has_to(); + inline void clear_has_to(); ::google::protobuf::UnknownFieldSet _unknown_fields_; - int results_mode_; - int type_; - ::std::string* plan_; - ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_; - ::exec::user::PreparedStatementHandle* prepared_statement_handle_; + int from_; + int to_; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; friend void protobuf_AddDesc_User_2eproto(); friend void protobuf_AssignDesc_User_2eproto(); friend void protobuf_ShutdownFile_User_2eproto(); void InitAsDefaultInstance(); - static RunQuery* default_instance_; + static ConvertSupport* default_instance_; }; -// =================================================================== - +// ------------------------------------------------------------------- -// =================================================================== +class GetServerMetaResp : public ::google::protobuf::Message { + public: + GetServerMetaResp(); + virtual ~GetServerMetaResp(); -// Property + GetServerMetaResp(const GetServerMetaResp& from); -// required string key = 1; -inline bool Property::has_key() const { - return (_has_bits_[0] & 0x00000001u) != 0; -} -inline void Property::set_has_key() { - _has_bits_[0] |= 0x00000001u; -} -inline void Property::clear_has_key() { - _has_bits_[0] &= ~0x00000001u; -} -inline void Property::clear_key() { - if (key_ != &::google::protobuf::internal::kEmptyString) { - key_->clear(); - } - clear_has_key(); -} -inline const ::std::string& Property::key() const { - return *key_; -} -inline void Property::set_key(const ::std::string& value) { - set_has_key(); - if (key_ == &::google::protobuf::internal::kEmptyString) { - key_ = new ::std::string; - } - key_->assign(value); -} -inline void Property::set_key(const char* value) { - set_has_key(); - if (key_ == &::google::protobuf::internal::kEmptyString) { - key_ = new ::std::string; - } - key_->assign(value); -} -inline void Property::set_key(const char* value, size_t size) { - set_has_key(); - if (key_ == &::google::protobuf::internal::kEmptyString) { - key_ = new ::std::string; - } - key_->assign(reinterpret_cast(value), size); -} -inline ::std::string* Property::mutable_key() { - set_has_key(); - if (key_ == &::google::protobuf::internal::kEmptyString) { - key_ = new ::std::string; - } - return key_; -} -inline ::std::string* Property::release_key() { - clear_has_key(); - if (key_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = key_; - key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } -} -inline void Property::set_allocated_key(::std::string* key) { - if (key_ != &::google::protobuf::internal::kEmptyString) { - delete key_; + inline GetServerMetaResp& operator=(const GetServerMetaResp& from) { + CopyFrom(from); + return *this; } - if (key) { - set_has_key(); - key_ = key; - } else { - clear_has_key(); - key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; } -} -// required string value = 2; -inline bool Property::has_value() const { - return (_has_bits_[0] & 0x00000002u) != 0; -} -inline void Property::set_has_value() { - _has_bits_[0] |= 0x00000002u; -} -inline void Property::clear_has_value() { - _has_bits_[0] &= ~0x00000002u; -} -inline void Property::clear_value() { - if (value_ != &::google::protobuf::internal::kEmptyString) { - value_->clear(); + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; } - clear_has_value(); -} + + static const ::google::protobuf::Descriptor* descriptor(); + static const GetServerMetaResp& default_instance(); + + void Swap(GetServerMetaResp* other); + + // implements Message ---------------------------------------------- + + GetServerMetaResp* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const GetServerMetaResp& from); + void MergeFrom(const GetServerMetaResp& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .exec.user.RequestStatus status = 1; + inline bool has_status() const; + inline void clear_status(); + static const int kStatusFieldNumber = 1; + inline ::exec::user::RequestStatus status() const; + inline void set_status(::exec::user::RequestStatus value); + + // optional .exec.user.ServerMeta server_meta = 2; + inline bool has_server_meta() const; + inline void clear_server_meta(); + static const int kServerMetaFieldNumber = 2; + inline const ::exec::user::ServerMeta& server_meta() const; + inline ::exec::user::ServerMeta* mutable_server_meta(); + inline ::exec::user::ServerMeta* release_server_meta(); + inline void set_allocated_server_meta(::exec::user::ServerMeta* server_meta); + + // optional .exec.shared.DrillPBError error = 3; + inline bool has_error() const; + inline void clear_error(); + static const int kErrorFieldNumber = 3; + inline const ::exec::shared::DrillPBError& error() const; + inline ::exec::shared::DrillPBError* mutable_error(); + inline ::exec::shared::DrillPBError* release_error(); + inline void set_allocated_error(::exec::shared::DrillPBError* error); + + // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaResp) + private: + inline void set_has_status(); + inline void clear_has_status(); + inline void set_has_server_meta(); + inline void clear_has_server_meta(); + inline void set_has_error(); + inline void clear_has_error(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::exec::user::ServerMeta* server_meta_; + ::exec::shared::DrillPBError* error_; + int status_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_User_2eproto(); + friend void protobuf_AssignDesc_User_2eproto(); + friend void protobuf_ShutdownFile_User_2eproto(); + + void InitAsDefaultInstance(); + static GetServerMetaResp* default_instance_; +}; +// ------------------------------------------------------------------- + +class ServerMeta : public ::google::protobuf::Message { + public: + ServerMeta(); + virtual ~ServerMeta(); + + ServerMeta(const ServerMeta& from); + + inline ServerMeta& operator=(const ServerMeta& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const ServerMeta& default_instance(); + + void Swap(ServerMeta* other); + + // implements Message ---------------------------------------------- + + ServerMeta* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const ServerMeta& from); + void MergeFrom(const ServerMeta& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional bool all_tables_selectable = 1; + inline bool has_all_tables_selectable() const; + inline void clear_all_tables_selectable(); + static const int kAllTablesSelectableFieldNumber = 1; + inline bool all_tables_selectable() const; + inline void set_all_tables_selectable(bool value); + + // optional bool blob_included_in_max_row_size = 2; + inline bool has_blob_included_in_max_row_size() const; + inline void clear_blob_included_in_max_row_size(); + static const int kBlobIncludedInMaxRowSizeFieldNumber = 2; + inline bool blob_included_in_max_row_size() const; + inline void set_blob_included_in_max_row_size(bool value); + + // optional bool catalog_at_start = 3; + inline bool has_catalog_at_start() const; + inline void clear_catalog_at_start(); + static const int kCatalogAtStartFieldNumber = 3; + inline bool catalog_at_start() const; + inline void set_catalog_at_start(bool value); + + // optional string catalog_separator = 4; + inline bool has_catalog_separator() const; + inline void clear_catalog_separator(); + static const int kCatalogSeparatorFieldNumber = 4; + inline const ::std::string& catalog_separator() const; + inline void set_catalog_separator(const ::std::string& value); + inline void set_catalog_separator(const char* value); + inline void set_catalog_separator(const char* value, size_t size); + inline ::std::string* mutable_catalog_separator(); + inline ::std::string* release_catalog_separator(); + inline void set_allocated_catalog_separator(::std::string* catalog_separator); + + // optional string catalog_term = 5; + inline bool has_catalog_term() const; + inline void clear_catalog_term(); + static const int kCatalogTermFieldNumber = 5; + inline const ::std::string& catalog_term() const; + inline void set_catalog_term(const ::std::string& value); + inline void set_catalog_term(const char* value); + inline void set_catalog_term(const char* value, size_t size); + inline ::std::string* mutable_catalog_term(); + inline ::std::string* release_catalog_term(); + inline void set_allocated_catalog_term(::std::string* catalog_term); + + // repeated .exec.user.CollateSupport collate_support = 6; + inline int collate_support_size() const; + inline void clear_collate_support(); + static const int kCollateSupportFieldNumber = 6; + inline ::exec::user::CollateSupport collate_support(int index) const; + inline void set_collate_support(int index, ::exec::user::CollateSupport value); + inline void add_collate_support(::exec::user::CollateSupport value); + inline const ::google::protobuf::RepeatedField& collate_support() const; + inline ::google::protobuf::RepeatedField* mutable_collate_support(); + + // optional bool column_aliasing_supported = 7; + inline bool has_column_aliasing_supported() const; + inline void clear_column_aliasing_supported(); + static const int kColumnAliasingSupportedFieldNumber = 7; + inline bool column_aliasing_supported() const; + inline void set_column_aliasing_supported(bool value); + + // repeated .exec.user.ConvertSupport convert_support = 8; + inline int convert_support_size() const; + inline void clear_convert_support(); + static const int kConvertSupportFieldNumber = 8; + inline const ::exec::user::ConvertSupport& convert_support(int index) const; + inline ::exec::user::ConvertSupport* mutable_convert_support(int index); + inline ::exec::user::ConvertSupport* add_convert_support(); + inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >& + convert_support() const; + inline ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >* + mutable_convert_support(); + + // optional .exec.user.CorrelationNamesSupport correlation_names_support = 9; + inline bool has_correlation_names_support() const; + inline void clear_correlation_names_support(); + static const int kCorrelationNamesSupportFieldNumber = 9; + inline ::exec::user::CorrelationNamesSupport correlation_names_support() const; + inline void set_correlation_names_support(::exec::user::CorrelationNamesSupport value); + + // repeated string date_time_functions = 10; + inline int date_time_functions_size() const; + inline void clear_date_time_functions(); + static const int kDateTimeFunctionsFieldNumber = 10; + inline const ::std::string& date_time_functions(int index) const; + inline ::std::string* mutable_date_time_functions(int index); + inline void set_date_time_functions(int index, const ::std::string& value); + inline void set_date_time_functions(int index, const char* value); + inline void set_date_time_functions(int index, const char* value, size_t size); + inline ::std::string* add_date_time_functions(); + inline void add_date_time_functions(const ::std::string& value); + inline void add_date_time_functions(const char* value); + inline void add_date_time_functions(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& date_time_functions() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_date_time_functions(); + + // repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11; + inline int date_time_literals_support_size() const; + inline void clear_date_time_literals_support(); + static const int kDateTimeLiteralsSupportFieldNumber = 11; + inline ::exec::user::DateTimeLiteralsSupport date_time_literals_support(int index) const; + inline void set_date_time_literals_support(int index, ::exec::user::DateTimeLiteralsSupport value); + inline void add_date_time_literals_support(::exec::user::DateTimeLiteralsSupport value); + inline const ::google::protobuf::RepeatedField& date_time_literals_support() const; + inline ::google::protobuf::RepeatedField* mutable_date_time_literals_support(); + + // optional .exec.user.GroupBySupport group_by_support = 12; + inline bool has_group_by_support() const; + inline void clear_group_by_support(); + static const int kGroupBySupportFieldNumber = 12; + inline ::exec::user::GroupBySupport group_by_support() const; + inline void set_group_by_support(::exec::user::GroupBySupport value); + + // optional .exec.user.IdentifierCasing identifier_casing = 13; + inline bool has_identifier_casing() const; + inline void clear_identifier_casing(); + static const int kIdentifierCasingFieldNumber = 13; + inline ::exec::user::IdentifierCasing identifier_casing() const; + inline void set_identifier_casing(::exec::user::IdentifierCasing value); + + // optional string identifier_quote_string = 14; + inline bool has_identifier_quote_string() const; + inline void clear_identifier_quote_string(); + static const int kIdentifierQuoteStringFieldNumber = 14; + inline const ::std::string& identifier_quote_string() const; + inline void set_identifier_quote_string(const ::std::string& value); + inline void set_identifier_quote_string(const char* value); + inline void set_identifier_quote_string(const char* value, size_t size); + inline ::std::string* mutable_identifier_quote_string(); + inline ::std::string* release_identifier_quote_string(); + inline void set_allocated_identifier_quote_string(::std::string* identifier_quote_string); + + // optional bool like_escape_clause_supported = 15; + inline bool has_like_escape_clause_supported() const; + inline void clear_like_escape_clause_supported(); + static const int kLikeEscapeClauseSupportedFieldNumber = 15; + inline bool like_escape_clause_supported() const; + inline void set_like_escape_clause_supported(bool value); + + // optional uint32 max_binary_literal_length = 16; + inline bool has_max_binary_literal_length() const; + inline void clear_max_binary_literal_length(); + static const int kMaxBinaryLiteralLengthFieldNumber = 16; + inline ::google::protobuf::uint32 max_binary_literal_length() const; + inline void set_max_binary_literal_length(::google::protobuf::uint32 value); + + // optional uint32 max_catalog_name_length = 17; + inline bool has_max_catalog_name_length() const; + inline void clear_max_catalog_name_length(); + static const int kMaxCatalogNameLengthFieldNumber = 17; + inline ::google::protobuf::uint32 max_catalog_name_length() const; + inline void set_max_catalog_name_length(::google::protobuf::uint32 value); + + // optional uint32 max_char_literal_length = 18; + inline bool has_max_char_literal_length() const; + inline void clear_max_char_literal_length(); + static const int kMaxCharLiteralLengthFieldNumber = 18; + inline ::google::protobuf::uint32 max_char_literal_length() const; + inline void set_max_char_literal_length(::google::protobuf::uint32 value); + + // optional uint32 max_column_name_length = 19; + inline bool has_max_column_name_length() const; + inline void clear_max_column_name_length(); + static const int kMaxColumnNameLengthFieldNumber = 19; + inline ::google::protobuf::uint32 max_column_name_length() const; + inline void set_max_column_name_length(::google::protobuf::uint32 value); + + // optional uint32 max_columns_in_group_by = 20; + inline bool has_max_columns_in_group_by() const; + inline void clear_max_columns_in_group_by(); + static const int kMaxColumnsInGroupByFieldNumber = 20; + inline ::google::protobuf::uint32 max_columns_in_group_by() const; + inline void set_max_columns_in_group_by(::google::protobuf::uint32 value); + + // optional uint32 max_columns_in_order_by = 21; + inline bool has_max_columns_in_order_by() const; + inline void clear_max_columns_in_order_by(); + static const int kMaxColumnsInOrderByFieldNumber = 21; + inline ::google::protobuf::uint32 max_columns_in_order_by() const; + inline void set_max_columns_in_order_by(::google::protobuf::uint32 value); + + // optional uint32 max_columns_in_select = 22; + inline bool has_max_columns_in_select() const; + inline void clear_max_columns_in_select(); + static const int kMaxColumnsInSelectFieldNumber = 22; + inline ::google::protobuf::uint32 max_columns_in_select() const; + inline void set_max_columns_in_select(::google::protobuf::uint32 value); + + // optional uint32 max_cursor_name_length = 23; + inline bool has_max_cursor_name_length() const; + inline void clear_max_cursor_name_length(); + static const int kMaxCursorNameLengthFieldNumber = 23; + inline ::google::protobuf::uint32 max_cursor_name_length() const; + inline void set_max_cursor_name_length(::google::protobuf::uint32 value); + + // optional uint32 max_logical_lob_size = 24; + inline bool has_max_logical_lob_size() const; + inline void clear_max_logical_lob_size(); + static const int kMaxLogicalLobSizeFieldNumber = 24; + inline ::google::protobuf::uint32 max_logical_lob_size() const; + inline void set_max_logical_lob_size(::google::protobuf::uint32 value); + + // optional uint32 max_row_size = 25; + inline bool has_max_row_size() const; + inline void clear_max_row_size(); + static const int kMaxRowSizeFieldNumber = 25; + inline ::google::protobuf::uint32 max_row_size() const; + inline void set_max_row_size(::google::protobuf::uint32 value); + + // optional uint32 max_schema_name_length = 26; + inline bool has_max_schema_name_length() const; + inline void clear_max_schema_name_length(); + static const int kMaxSchemaNameLengthFieldNumber = 26; + inline ::google::protobuf::uint32 max_schema_name_length() const; + inline void set_max_schema_name_length(::google::protobuf::uint32 value); + + // optional uint32 max_statement_length = 27; + inline bool has_max_statement_length() const; + inline void clear_max_statement_length(); + static const int kMaxStatementLengthFieldNumber = 27; + inline ::google::protobuf::uint32 max_statement_length() const; + inline void set_max_statement_length(::google::protobuf::uint32 value); + + // optional uint32 max_statements = 28; + inline bool has_max_statements() const; + inline void clear_max_statements(); + static const int kMaxStatementsFieldNumber = 28; + inline ::google::protobuf::uint32 max_statements() const; + inline void set_max_statements(::google::protobuf::uint32 value); + + // optional uint32 max_table_name_length = 29; + inline bool has_max_table_name_length() const; + inline void clear_max_table_name_length(); + static const int kMaxTableNameLengthFieldNumber = 29; + inline ::google::protobuf::uint32 max_table_name_length() const; + inline void set_max_table_name_length(::google::protobuf::uint32 value); + + // optional uint32 max_tables_in_select = 30; + inline bool has_max_tables_in_select() const; + inline void clear_max_tables_in_select(); + static const int kMaxTablesInSelectFieldNumber = 30; + inline ::google::protobuf::uint32 max_tables_in_select() const; + inline void set_max_tables_in_select(::google::protobuf::uint32 value); + + // optional uint32 max_user_name_length = 31; + inline bool has_max_user_name_length() const; + inline void clear_max_user_name_length(); + static const int kMaxUserNameLengthFieldNumber = 31; + inline ::google::protobuf::uint32 max_user_name_length() const; + inline void set_max_user_name_length(::google::protobuf::uint32 value); + + // optional .exec.user.NullCollation null_collation = 32; + inline bool has_null_collation() const; + inline void clear_null_collation(); + static const int kNullCollationFieldNumber = 32; + inline ::exec::user::NullCollation null_collation() const; + inline void set_null_collation(::exec::user::NullCollation value); + + // optional bool null_plus_non_null_equals_null = 33; + inline bool has_null_plus_non_null_equals_null() const; + inline void clear_null_plus_non_null_equals_null(); + static const int kNullPlusNonNullEqualsNullFieldNumber = 33; + inline bool null_plus_non_null_equals_null() const; + inline void set_null_plus_non_null_equals_null(bool value); + + // repeated string numeric_functions = 34; + inline int numeric_functions_size() const; + inline void clear_numeric_functions(); + static const int kNumericFunctionsFieldNumber = 34; + inline const ::std::string& numeric_functions(int index) const; + inline ::std::string* mutable_numeric_functions(int index); + inline void set_numeric_functions(int index, const ::std::string& value); + inline void set_numeric_functions(int index, const char* value); + inline void set_numeric_functions(int index, const char* value, size_t size); + inline ::std::string* add_numeric_functions(); + inline void add_numeric_functions(const ::std::string& value); + inline void add_numeric_functions(const char* value); + inline void add_numeric_functions(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& numeric_functions() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_numeric_functions(); + + // repeated .exec.user.OrderBySupport order_by_support = 35; + inline int order_by_support_size() const; + inline void clear_order_by_support(); + static const int kOrderBySupportFieldNumber = 35; + inline ::exec::user::OrderBySupport order_by_support(int index) const; + inline void set_order_by_support(int index, ::exec::user::OrderBySupport value); + inline void add_order_by_support(::exec::user::OrderBySupport value); + inline const ::google::protobuf::RepeatedField& order_by_support() const; + inline ::google::protobuf::RepeatedField* mutable_order_by_support(); + + // repeated .exec.user.OuterJoinSupport outer_join_support = 36; + inline int outer_join_support_size() const; + inline void clear_outer_join_support(); + static const int kOuterJoinSupportFieldNumber = 36; + inline ::exec::user::OuterJoinSupport outer_join_support(int index) const; + inline void set_outer_join_support(int index, ::exec::user::OuterJoinSupport value); + inline void add_outer_join_support(::exec::user::OuterJoinSupport value); + inline const ::google::protobuf::RepeatedField& outer_join_support() const; + inline ::google::protobuf::RepeatedField* mutable_outer_join_support(); + + // optional .exec.user.IdentifierCasing quoted_identifier_casing = 37; + inline bool has_quoted_identifier_casing() const; + inline void clear_quoted_identifier_casing(); + static const int kQuotedIdentifierCasingFieldNumber = 37; + inline ::exec::user::IdentifierCasing quoted_identifier_casing() const; + inline void set_quoted_identifier_casing(::exec::user::IdentifierCasing value); + + // optional bool read_only = 38; + inline bool has_read_only() const; + inline void clear_read_only(); + static const int kReadOnlyFieldNumber = 38; + inline bool read_only() const; + inline void set_read_only(bool value); + + // optional string schema_term = 39; + inline bool has_schema_term() const; + inline void clear_schema_term(); + static const int kSchemaTermFieldNumber = 39; + inline const ::std::string& schema_term() const; + inline void set_schema_term(const ::std::string& value); + inline void set_schema_term(const char* value); + inline void set_schema_term(const char* value, size_t size); + inline ::std::string* mutable_schema_term(); + inline ::std::string* release_schema_term(); + inline void set_allocated_schema_term(::std::string* schema_term); + + // optional string search_escape_string = 40; + inline bool has_search_escape_string() const; + inline void clear_search_escape_string(); + static const int kSearchEscapeStringFieldNumber = 40; + inline const ::std::string& search_escape_string() const; + inline void set_search_escape_string(const ::std::string& value); + inline void set_search_escape_string(const char* value); + inline void set_search_escape_string(const char* value, size_t size); + inline ::std::string* mutable_search_escape_string(); + inline ::std::string* release_search_escape_string(); + inline void set_allocated_search_escape_string(::std::string* search_escape_string); + + // optional bool select_for_update_supported = 41; + inline bool has_select_for_update_supported() const; + inline void clear_select_for_update_supported(); + static const int kSelectForUpdateSupportedFieldNumber = 41; + inline bool select_for_update_supported() const; + inline void set_select_for_update_supported(bool value); + + // optional string special_characters = 42; + inline bool has_special_characters() const; + inline void clear_special_characters(); + static const int kSpecialCharactersFieldNumber = 42; + inline const ::std::string& special_characters() const; + inline void set_special_characters(const ::std::string& value); + inline void set_special_characters(const char* value); + inline void set_special_characters(const char* value, size_t size); + inline ::std::string* mutable_special_characters(); + inline ::std::string* release_special_characters(); + inline void set_allocated_special_characters(::std::string* special_characters); + + // repeated string sql_keywords = 43; + inline int sql_keywords_size() const; + inline void clear_sql_keywords(); + static const int kSqlKeywordsFieldNumber = 43; + inline const ::std::string& sql_keywords(int index) const; + inline ::std::string* mutable_sql_keywords(int index); + inline void set_sql_keywords(int index, const ::std::string& value); + inline void set_sql_keywords(int index, const char* value); + inline void set_sql_keywords(int index, const char* value, size_t size); + inline ::std::string* add_sql_keywords(); + inline void add_sql_keywords(const ::std::string& value); + inline void add_sql_keywords(const char* value); + inline void add_sql_keywords(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& sql_keywords() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_sql_keywords(); + + // repeated string string_functions = 44; + inline int string_functions_size() const; + inline void clear_string_functions(); + static const int kStringFunctionsFieldNumber = 44; + inline const ::std::string& string_functions(int index) const; + inline ::std::string* mutable_string_functions(int index); + inline void set_string_functions(int index, const ::std::string& value); + inline void set_string_functions(int index, const char* value); + inline void set_string_functions(int index, const char* value, size_t size); + inline ::std::string* add_string_functions(); + inline void add_string_functions(const ::std::string& value); + inline void add_string_functions(const char* value); + inline void add_string_functions(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& string_functions() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_functions(); + + // repeated .exec.user.SubQuerySupport subquery_support = 45; + inline int subquery_support_size() const; + inline void clear_subquery_support(); + static const int kSubquerySupportFieldNumber = 45; + inline ::exec::user::SubQuerySupport subquery_support(int index) const; + inline void set_subquery_support(int index, ::exec::user::SubQuerySupport value); + inline void add_subquery_support(::exec::user::SubQuerySupport value); + inline const ::google::protobuf::RepeatedField& subquery_support() const; + inline ::google::protobuf::RepeatedField* mutable_subquery_support(); + + // repeated string system_functions = 46; + inline int system_functions_size() const; + inline void clear_system_functions(); + static const int kSystemFunctionsFieldNumber = 46; + inline const ::std::string& system_functions(int index) const; + inline ::std::string* mutable_system_functions(int index); + inline void set_system_functions(int index, const ::std::string& value); + inline void set_system_functions(int index, const char* value); + inline void set_system_functions(int index, const char* value, size_t size); + inline ::std::string* add_system_functions(); + inline void add_system_functions(const ::std::string& value); + inline void add_system_functions(const char* value); + inline void add_system_functions(const char* value, size_t size); + inline const ::google::protobuf::RepeatedPtrField< ::std::string>& system_functions() const; + inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_system_functions(); + + // optional string table_term = 47; + inline bool has_table_term() const; + inline void clear_table_term(); + static const int kTableTermFieldNumber = 47; + inline const ::std::string& table_term() const; + inline void set_table_term(const ::std::string& value); + inline void set_table_term(const char* value); + inline void set_table_term(const char* value, size_t size); + inline ::std::string* mutable_table_term(); + inline ::std::string* release_table_term(); + inline void set_allocated_table_term(::std::string* table_term); + + // optional bool transaction_supported = 48; + inline bool has_transaction_supported() const; + inline void clear_transaction_supported(); + static const int kTransactionSupportedFieldNumber = 48; + inline bool transaction_supported() const; + inline void set_transaction_supported(bool value); + + // repeated .exec.user.UnionSupport union_support = 49; + inline int union_support_size() const; + inline void clear_union_support(); + static const int kUnionSupportFieldNumber = 49; + inline ::exec::user::UnionSupport union_support(int index) const; + inline void set_union_support(int index, ::exec::user::UnionSupport value); + inline void add_union_support(::exec::user::UnionSupport value); + inline const ::google::protobuf::RepeatedField& union_support() const; + inline ::google::protobuf::RepeatedField* mutable_union_support(); + + // @@protoc_insertion_point(class_scope:exec.user.ServerMeta) + private: + inline void set_has_all_tables_selectable(); + inline void clear_has_all_tables_selectable(); + inline void set_has_blob_included_in_max_row_size(); + inline void clear_has_blob_included_in_max_row_size(); + inline void set_has_catalog_at_start(); + inline void clear_has_catalog_at_start(); + inline void set_has_catalog_separator(); + inline void clear_has_catalog_separator(); + inline void set_has_catalog_term(); + inline void clear_has_catalog_term(); + inline void set_has_column_aliasing_supported(); + inline void clear_has_column_aliasing_supported(); + inline void set_has_correlation_names_support(); + inline void clear_has_correlation_names_support(); + inline void set_has_group_by_support(); + inline void clear_has_group_by_support(); + inline void set_has_identifier_casing(); + inline void clear_has_identifier_casing(); + inline void set_has_identifier_quote_string(); + inline void clear_has_identifier_quote_string(); + inline void set_has_like_escape_clause_supported(); + inline void clear_has_like_escape_clause_supported(); + inline void set_has_max_binary_literal_length(); + inline void clear_has_max_binary_literal_length(); + inline void set_has_max_catalog_name_length(); + inline void clear_has_max_catalog_name_length(); + inline void set_has_max_char_literal_length(); + inline void clear_has_max_char_literal_length(); + inline void set_has_max_column_name_length(); + inline void clear_has_max_column_name_length(); + inline void set_has_max_columns_in_group_by(); + inline void clear_has_max_columns_in_group_by(); + inline void set_has_max_columns_in_order_by(); + inline void clear_has_max_columns_in_order_by(); + inline void set_has_max_columns_in_select(); + inline void clear_has_max_columns_in_select(); + inline void set_has_max_cursor_name_length(); + inline void clear_has_max_cursor_name_length(); + inline void set_has_max_logical_lob_size(); + inline void clear_has_max_logical_lob_size(); + inline void set_has_max_row_size(); + inline void clear_has_max_row_size(); + inline void set_has_max_schema_name_length(); + inline void clear_has_max_schema_name_length(); + inline void set_has_max_statement_length(); + inline void clear_has_max_statement_length(); + inline void set_has_max_statements(); + inline void clear_has_max_statements(); + inline void set_has_max_table_name_length(); + inline void clear_has_max_table_name_length(); + inline void set_has_max_tables_in_select(); + inline void clear_has_max_tables_in_select(); + inline void set_has_max_user_name_length(); + inline void clear_has_max_user_name_length(); + inline void set_has_null_collation(); + inline void clear_has_null_collation(); + inline void set_has_null_plus_non_null_equals_null(); + inline void clear_has_null_plus_non_null_equals_null(); + inline void set_has_quoted_identifier_casing(); + inline void clear_has_quoted_identifier_casing(); + inline void set_has_read_only(); + inline void clear_has_read_only(); + inline void set_has_schema_term(); + inline void clear_has_schema_term(); + inline void set_has_search_escape_string(); + inline void clear_has_search_escape_string(); + inline void set_has_select_for_update_supported(); + inline void clear_has_select_for_update_supported(); + inline void set_has_special_characters(); + inline void clear_has_special_characters(); + inline void set_has_table_term(); + inline void clear_has_table_term(); + inline void set_has_transaction_supported(); + inline void clear_has_transaction_supported(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* catalog_separator_; + bool all_tables_selectable_; + bool blob_included_in_max_row_size_; + bool catalog_at_start_; + bool column_aliasing_supported_; + int correlation_names_support_; + ::std::string* catalog_term_; + ::google::protobuf::RepeatedField collate_support_; + ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport > convert_support_; + ::google::protobuf::RepeatedPtrField< ::std::string> date_time_functions_; + ::google::protobuf::RepeatedField date_time_literals_support_; + int group_by_support_; + int identifier_casing_; + ::std::string* identifier_quote_string_; + ::google::protobuf::uint32 max_binary_literal_length_; + ::google::protobuf::uint32 max_catalog_name_length_; + ::google::protobuf::uint32 max_char_literal_length_; + ::google::protobuf::uint32 max_column_name_length_; + ::google::protobuf::uint32 max_columns_in_group_by_; + ::google::protobuf::uint32 max_columns_in_order_by_; + ::google::protobuf::uint32 max_columns_in_select_; + ::google::protobuf::uint32 max_cursor_name_length_; + ::google::protobuf::uint32 max_logical_lob_size_; + ::google::protobuf::uint32 max_row_size_; + ::google::protobuf::uint32 max_schema_name_length_; + ::google::protobuf::uint32 max_statement_length_; + ::google::protobuf::uint32 max_statements_; + ::google::protobuf::uint32 max_table_name_length_; + ::google::protobuf::uint32 max_tables_in_select_; + ::google::protobuf::uint32 max_user_name_length_; + bool like_escape_clause_supported_; + bool null_plus_non_null_equals_null_; + bool read_only_; + bool select_for_update_supported_; + int null_collation_; + ::google::protobuf::RepeatedPtrField< ::std::string> numeric_functions_; + ::google::protobuf::RepeatedField order_by_support_; + ::google::protobuf::RepeatedField outer_join_support_; + ::std::string* schema_term_; + ::std::string* search_escape_string_; + ::std::string* special_characters_; + int quoted_identifier_casing_; + bool transaction_supported_; + ::google::protobuf::RepeatedPtrField< ::std::string> sql_keywords_; + ::google::protobuf::RepeatedPtrField< ::std::string> string_functions_; + ::google::protobuf::RepeatedField subquery_support_; + ::google::protobuf::RepeatedPtrField< ::std::string> system_functions_; + ::std::string* table_term_; + ::google::protobuf::RepeatedField union_support_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(49 + 31) / 32]; + + friend void protobuf_AddDesc_User_2eproto(); + friend void protobuf_AssignDesc_User_2eproto(); + friend void protobuf_ShutdownFile_User_2eproto(); + + void InitAsDefaultInstance(); + static ServerMeta* default_instance_; +}; +// ------------------------------------------------------------------- + +class RunQuery : public ::google::protobuf::Message { + public: + RunQuery(); + virtual ~RunQuery(); + + RunQuery(const RunQuery& from); + + inline RunQuery& operator=(const RunQuery& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const RunQuery& default_instance(); + + void Swap(RunQuery* other); + + // implements Message ---------------------------------------------- + + RunQuery* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const RunQuery& from); + void MergeFrom(const RunQuery& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // optional .exec.user.QueryResultsMode results_mode = 1; + inline bool has_results_mode() const; + inline void clear_results_mode(); + static const int kResultsModeFieldNumber = 1; + inline ::exec::user::QueryResultsMode results_mode() const; + inline void set_results_mode(::exec::user::QueryResultsMode value); + + // optional .exec.shared.QueryType type = 2; + inline bool has_type() const; + inline void clear_type(); + static const int kTypeFieldNumber = 2; + inline ::exec::shared::QueryType type() const; + inline void set_type(::exec::shared::QueryType value); + + // optional string plan = 3; + inline bool has_plan() const; + inline void clear_plan(); + static const int kPlanFieldNumber = 3; + inline const ::std::string& plan() const; + inline void set_plan(const ::std::string& value); + inline void set_plan(const char* value); + inline void set_plan(const char* value, size_t size); + inline ::std::string* mutable_plan(); + inline ::std::string* release_plan(); + inline void set_allocated_plan(::std::string* plan); + + // repeated .exec.bit.control.PlanFragment fragments = 4; + inline int fragments_size() const; + inline void clear_fragments(); + static const int kFragmentsFieldNumber = 4; + inline const ::exec::bit::control::PlanFragment& fragments(int index) const; + inline ::exec::bit::control::PlanFragment* mutable_fragments(int index); + inline ::exec::bit::control::PlanFragment* add_fragments(); + inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >& + fragments() const; + inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >* + mutable_fragments(); + + // optional .exec.user.PreparedStatementHandle prepared_statement_handle = 5; + inline bool has_prepared_statement_handle() const; + inline void clear_prepared_statement_handle(); + static const int kPreparedStatementHandleFieldNumber = 5; + inline const ::exec::user::PreparedStatementHandle& prepared_statement_handle() const; + inline ::exec::user::PreparedStatementHandle* mutable_prepared_statement_handle(); + inline ::exec::user::PreparedStatementHandle* release_prepared_statement_handle(); + inline void set_allocated_prepared_statement_handle(::exec::user::PreparedStatementHandle* prepared_statement_handle); + + // @@protoc_insertion_point(class_scope:exec.user.RunQuery) + private: + inline void set_has_results_mode(); + inline void clear_has_results_mode(); + inline void set_has_type(); + inline void clear_has_type(); + inline void set_has_plan(); + inline void clear_has_plan(); + inline void set_has_prepared_statement_handle(); + inline void clear_has_prepared_statement_handle(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + int results_mode_; + int type_; + ::std::string* plan_; + ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment > fragments_; + ::exec::user::PreparedStatementHandle* prepared_statement_handle_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; + + friend void protobuf_AddDesc_User_2eproto(); + friend void protobuf_AssignDesc_User_2eproto(); + friend void protobuf_ShutdownFile_User_2eproto(); + + void InitAsDefaultInstance(); + static RunQuery* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// Property + +// required string key = 1; +inline bool Property::has_key() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void Property::set_has_key() { + _has_bits_[0] |= 0x00000001u; +} +inline void Property::clear_has_key() { + _has_bits_[0] &= ~0x00000001u; +} +inline void Property::clear_key() { + if (key_ != &::google::protobuf::internal::kEmptyString) { + key_->clear(); + } + clear_has_key(); +} +inline const ::std::string& Property::key() const { + return *key_; +} +inline void Property::set_key(const ::std::string& value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + key_->assign(value); +} +inline void Property::set_key(const char* value) { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + key_->assign(value); +} +inline void Property::set_key(const char* value, size_t size) { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + key_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Property::mutable_key() { + set_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + key_ = new ::std::string; + } + return key_; +} +inline ::std::string* Property::release_key() { + clear_has_key(); + if (key_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = key_; + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Property::set_allocated_key(::std::string* key) { + if (key_ != &::google::protobuf::internal::kEmptyString) { + delete key_; + } + if (key) { + set_has_key(); + key_ = key; + } else { + clear_has_key(); + key_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// required string value = 2; +inline bool Property::has_value() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void Property::set_has_value() { + _has_bits_[0] |= 0x00000002u; +} +inline void Property::clear_has_value() { + _has_bits_[0] &= ~0x00000002u; +} +inline void Property::clear_value() { + if (value_ != &::google::protobuf::internal::kEmptyString) { + value_->clear(); + } + clear_has_value(); +} inline const ::std::string& Property::value() const { return *value_; } -inline void Property::set_value(const ::std::string& value) { - set_has_value(); - if (value_ == &::google::protobuf::internal::kEmptyString) { - value_ = new ::std::string; +inline void Property::set_value(const ::std::string& value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void Property::set_value(const char* value) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(value); +} +inline void Property::set_value(const char* value, size_t size) { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + value_->assign(reinterpret_cast(value), size); +} +inline ::std::string* Property::mutable_value() { + set_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + value_ = new ::std::string; + } + return value_; +} +inline ::std::string* Property::release_value() { + clear_has_value(); + if (value_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = value_; + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void Property::set_allocated_value(::std::string* value) { + if (value_ != &::google::protobuf::internal::kEmptyString) { + delete value_; + } + if (value) { + set_has_value(); + value_ = value; + } else { + clear_has_value(); + value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// UserProperties + +// repeated .exec.user.Property properties = 1; +inline int UserProperties::properties_size() const { + return properties_.size(); +} +inline void UserProperties::clear_properties() { + properties_.Clear(); +} +inline const ::exec::user::Property& UserProperties::properties(int index) const { + return properties_.Get(index); +} +inline ::exec::user::Property* UserProperties::mutable_properties(int index) { + return properties_.Mutable(index); +} +inline ::exec::user::Property* UserProperties::add_properties() { + return properties_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >& +UserProperties::properties() const { + return properties_; +} +inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >* +UserProperties::mutable_properties() { + return &properties_; +} + +// ------------------------------------------------------------------- + +// RpcEndpointInfos + +// optional string name = 1; +inline bool RpcEndpointInfos::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RpcEndpointInfos::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void RpcEndpointInfos::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RpcEndpointInfos::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& RpcEndpointInfos::name() const { + return *name_; +} +inline void RpcEndpointInfos::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void RpcEndpointInfos::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void RpcEndpointInfos::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RpcEndpointInfos::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* RpcEndpointInfos::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RpcEndpointInfos::set_allocated_name(::std::string* name) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (name) { + set_has_name(); + name_ = name; + } else { + clear_has_name(); + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string version = 2; +inline bool RpcEndpointInfos::has_version() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RpcEndpointInfos::set_has_version() { + _has_bits_[0] |= 0x00000002u; +} +inline void RpcEndpointInfos::clear_has_version() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RpcEndpointInfos::clear_version() { + if (version_ != &::google::protobuf::internal::kEmptyString) { + version_->clear(); + } + clear_has_version(); +} +inline const ::std::string& RpcEndpointInfos::version() const { + return *version_; +} +inline void RpcEndpointInfos::set_version(const ::std::string& value) { + set_has_version(); + if (version_ == &::google::protobuf::internal::kEmptyString) { + version_ = new ::std::string; + } + version_->assign(value); +} +inline void RpcEndpointInfos::set_version(const char* value) { + set_has_version(); + if (version_ == &::google::protobuf::internal::kEmptyString) { + version_ = new ::std::string; + } + version_->assign(value); +} +inline void RpcEndpointInfos::set_version(const char* value, size_t size) { + set_has_version(); + if (version_ == &::google::protobuf::internal::kEmptyString) { + version_ = new ::std::string; + } + version_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RpcEndpointInfos::mutable_version() { + set_has_version(); + if (version_ == &::google::protobuf::internal::kEmptyString) { + version_ = new ::std::string; + } + return version_; +} +inline ::std::string* RpcEndpointInfos::release_version() { + clear_has_version(); + if (version_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = version_; + version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RpcEndpointInfos::set_allocated_version(::std::string* version) { + if (version_ != &::google::protobuf::internal::kEmptyString) { + delete version_; + } + if (version) { + set_has_version(); + version_ = version; + } else { + clear_has_version(); + version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional uint32 majorVersion = 3; +inline bool RpcEndpointInfos::has_majorversion() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void RpcEndpointInfos::set_has_majorversion() { + _has_bits_[0] |= 0x00000004u; +} +inline void RpcEndpointInfos::clear_has_majorversion() { + _has_bits_[0] &= ~0x00000004u; +} +inline void RpcEndpointInfos::clear_majorversion() { + majorversion_ = 0u; + clear_has_majorversion(); +} +inline ::google::protobuf::uint32 RpcEndpointInfos::majorversion() const { + return majorversion_; +} +inline void RpcEndpointInfos::set_majorversion(::google::protobuf::uint32 value) { + set_has_majorversion(); + majorversion_ = value; +} + +// optional uint32 minorVersion = 4; +inline bool RpcEndpointInfos::has_minorversion() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void RpcEndpointInfos::set_has_minorversion() { + _has_bits_[0] |= 0x00000008u; +} +inline void RpcEndpointInfos::clear_has_minorversion() { + _has_bits_[0] &= ~0x00000008u; +} +inline void RpcEndpointInfos::clear_minorversion() { + minorversion_ = 0u; + clear_has_minorversion(); +} +inline ::google::protobuf::uint32 RpcEndpointInfos::minorversion() const { + return minorversion_; +} +inline void RpcEndpointInfos::set_minorversion(::google::protobuf::uint32 value) { + set_has_minorversion(); + minorversion_ = value; +} + +// optional uint32 patchVersion = 5; +inline bool RpcEndpointInfos::has_patchversion() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void RpcEndpointInfos::set_has_patchversion() { + _has_bits_[0] |= 0x00000010u; +} +inline void RpcEndpointInfos::clear_has_patchversion() { + _has_bits_[0] &= ~0x00000010u; +} +inline void RpcEndpointInfos::clear_patchversion() { + patchversion_ = 0u; + clear_has_patchversion(); +} +inline ::google::protobuf::uint32 RpcEndpointInfos::patchversion() const { + return patchversion_; +} +inline void RpcEndpointInfos::set_patchversion(::google::protobuf::uint32 value) { + set_has_patchversion(); + patchversion_ = value; +} + +// optional string application = 6; +inline bool RpcEndpointInfos::has_application() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void RpcEndpointInfos::set_has_application() { + _has_bits_[0] |= 0x00000020u; +} +inline void RpcEndpointInfos::clear_has_application() { + _has_bits_[0] &= ~0x00000020u; +} +inline void RpcEndpointInfos::clear_application() { + if (application_ != &::google::protobuf::internal::kEmptyString) { + application_->clear(); + } + clear_has_application(); +} +inline const ::std::string& RpcEndpointInfos::application() const { + return *application_; +} +inline void RpcEndpointInfos::set_application(const ::std::string& value) { + set_has_application(); + if (application_ == &::google::protobuf::internal::kEmptyString) { + application_ = new ::std::string; + } + application_->assign(value); +} +inline void RpcEndpointInfos::set_application(const char* value) { + set_has_application(); + if (application_ == &::google::protobuf::internal::kEmptyString) { + application_ = new ::std::string; + } + application_->assign(value); +} +inline void RpcEndpointInfos::set_application(const char* value, size_t size) { + set_has_application(); + if (application_ == &::google::protobuf::internal::kEmptyString) { + application_ = new ::std::string; + } + application_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RpcEndpointInfos::mutable_application() { + set_has_application(); + if (application_ == &::google::protobuf::internal::kEmptyString) { + application_ = new ::std::string; + } + return application_; +} +inline ::std::string* RpcEndpointInfos::release_application() { + clear_has_application(); + if (application_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = application_; + application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RpcEndpointInfos::set_allocated_application(::std::string* application) { + if (application_ != &::google::protobuf::internal::kEmptyString) { + delete application_; + } + if (application) { + set_has_application(); + application_ = application; + } else { + clear_has_application(); + application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional uint32 buildNumber = 7; +inline bool RpcEndpointInfos::has_buildnumber() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void RpcEndpointInfos::set_has_buildnumber() { + _has_bits_[0] |= 0x00000040u; +} +inline void RpcEndpointInfos::clear_has_buildnumber() { + _has_bits_[0] &= ~0x00000040u; +} +inline void RpcEndpointInfos::clear_buildnumber() { + buildnumber_ = 0u; + clear_has_buildnumber(); +} +inline ::google::protobuf::uint32 RpcEndpointInfos::buildnumber() const { + return buildnumber_; +} +inline void RpcEndpointInfos::set_buildnumber(::google::protobuf::uint32 value) { + set_has_buildnumber(); + buildnumber_ = value; +} + +// optional string versionQualifier = 8; +inline bool RpcEndpointInfos::has_versionqualifier() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void RpcEndpointInfos::set_has_versionqualifier() { + _has_bits_[0] |= 0x00000080u; +} +inline void RpcEndpointInfos::clear_has_versionqualifier() { + _has_bits_[0] &= ~0x00000080u; +} +inline void RpcEndpointInfos::clear_versionqualifier() { + if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) { + versionqualifier_->clear(); + } + clear_has_versionqualifier(); +} +inline const ::std::string& RpcEndpointInfos::versionqualifier() const { + return *versionqualifier_; +} +inline void RpcEndpointInfos::set_versionqualifier(const ::std::string& value) { + set_has_versionqualifier(); + if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { + versionqualifier_ = new ::std::string; + } + versionqualifier_->assign(value); +} +inline void RpcEndpointInfos::set_versionqualifier(const char* value) { + set_has_versionqualifier(); + if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { + versionqualifier_ = new ::std::string; + } + versionqualifier_->assign(value); +} +inline void RpcEndpointInfos::set_versionqualifier(const char* value, size_t size) { + set_has_versionqualifier(); + if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { + versionqualifier_ = new ::std::string; + } + versionqualifier_->assign(reinterpret_cast(value), size); +} +inline ::std::string* RpcEndpointInfos::mutable_versionqualifier() { + set_has_versionqualifier(); + if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { + versionqualifier_ = new ::std::string; + } + return versionqualifier_; +} +inline ::std::string* RpcEndpointInfos::release_versionqualifier() { + clear_has_versionqualifier(); + if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = versionqualifier_; + versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void RpcEndpointInfos::set_allocated_versionqualifier(::std::string* versionqualifier) { + if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) { + delete versionqualifier_; + } + if (versionqualifier) { + set_has_versionqualifier(); + versionqualifier_ = versionqualifier; + } else { + clear_has_versionqualifier(); + versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// ------------------------------------------------------------------- + +// UserToBitHandshake + +// optional .exec.shared.RpcChannel channel = 1 [default = USER]; +inline bool UserToBitHandshake::has_channel() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void UserToBitHandshake::set_has_channel() { + _has_bits_[0] |= 0x00000001u; +} +inline void UserToBitHandshake::clear_has_channel() { + _has_bits_[0] &= ~0x00000001u; +} +inline void UserToBitHandshake::clear_channel() { + channel_ = 2; + clear_has_channel(); +} +inline ::exec::shared::RpcChannel UserToBitHandshake::channel() const { + return static_cast< ::exec::shared::RpcChannel >(channel_); +} +inline void UserToBitHandshake::set_channel(::exec::shared::RpcChannel value) { + assert(::exec::shared::RpcChannel_IsValid(value)); + set_has_channel(); + channel_ = value; +} + +// optional bool support_listening = 2; +inline bool UserToBitHandshake::has_support_listening() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void UserToBitHandshake::set_has_support_listening() { + _has_bits_[0] |= 0x00000002u; +} +inline void UserToBitHandshake::clear_has_support_listening() { + _has_bits_[0] &= ~0x00000002u; +} +inline void UserToBitHandshake::clear_support_listening() { + support_listening_ = false; + clear_has_support_listening(); +} +inline bool UserToBitHandshake::support_listening() const { + return support_listening_; +} +inline void UserToBitHandshake::set_support_listening(bool value) { + set_has_support_listening(); + support_listening_ = value; +} + +// optional int32 rpc_version = 3; +inline bool UserToBitHandshake::has_rpc_version() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void UserToBitHandshake::set_has_rpc_version() { + _has_bits_[0] |= 0x00000004u; +} +inline void UserToBitHandshake::clear_has_rpc_version() { + _has_bits_[0] &= ~0x00000004u; +} +inline void UserToBitHandshake::clear_rpc_version() { + rpc_version_ = 0; + clear_has_rpc_version(); +} +inline ::google::protobuf::int32 UserToBitHandshake::rpc_version() const { + return rpc_version_; +} +inline void UserToBitHandshake::set_rpc_version(::google::protobuf::int32 value) { + set_has_rpc_version(); + rpc_version_ = value; +} + +// optional .exec.shared.UserCredentials credentials = 4; +inline bool UserToBitHandshake::has_credentials() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void UserToBitHandshake::set_has_credentials() { + _has_bits_[0] |= 0x00000008u; +} +inline void UserToBitHandshake::clear_has_credentials() { + _has_bits_[0] &= ~0x00000008u; +} +inline void UserToBitHandshake::clear_credentials() { + if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear(); + clear_has_credentials(); +} +inline const ::exec::shared::UserCredentials& UserToBitHandshake::credentials() const { + return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_; +} +inline ::exec::shared::UserCredentials* UserToBitHandshake::mutable_credentials() { + set_has_credentials(); + if (credentials_ == NULL) credentials_ = new ::exec::shared::UserCredentials; + return credentials_; +} +inline ::exec::shared::UserCredentials* UserToBitHandshake::release_credentials() { + clear_has_credentials(); + ::exec::shared::UserCredentials* temp = credentials_; + credentials_ = NULL; + return temp; +} +inline void UserToBitHandshake::set_allocated_credentials(::exec::shared::UserCredentials* credentials) { + delete credentials_; + credentials_ = credentials; + if (credentials) { + set_has_credentials(); + } else { + clear_has_credentials(); + } +} + +// optional .exec.user.UserProperties properties = 5; +inline bool UserToBitHandshake::has_properties() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void UserToBitHandshake::set_has_properties() { + _has_bits_[0] |= 0x00000010u; +} +inline void UserToBitHandshake::clear_has_properties() { + _has_bits_[0] &= ~0x00000010u; +} +inline void UserToBitHandshake::clear_properties() { + if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear(); + clear_has_properties(); +} +inline const ::exec::user::UserProperties& UserToBitHandshake::properties() const { + return properties_ != NULL ? *properties_ : *default_instance_->properties_; +} +inline ::exec::user::UserProperties* UserToBitHandshake::mutable_properties() { + set_has_properties(); + if (properties_ == NULL) properties_ = new ::exec::user::UserProperties; + return properties_; +} +inline ::exec::user::UserProperties* UserToBitHandshake::release_properties() { + clear_has_properties(); + ::exec::user::UserProperties* temp = properties_; + properties_ = NULL; + return temp; +} +inline void UserToBitHandshake::set_allocated_properties(::exec::user::UserProperties* properties) { + delete properties_; + properties_ = properties; + if (properties) { + set_has_properties(); + } else { + clear_has_properties(); + } +} + +// optional bool support_complex_types = 6 [default = false]; +inline bool UserToBitHandshake::has_support_complex_types() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void UserToBitHandshake::set_has_support_complex_types() { + _has_bits_[0] |= 0x00000020u; +} +inline void UserToBitHandshake::clear_has_support_complex_types() { + _has_bits_[0] &= ~0x00000020u; +} +inline void UserToBitHandshake::clear_support_complex_types() { + support_complex_types_ = false; + clear_has_support_complex_types(); +} +inline bool UserToBitHandshake::support_complex_types() const { + return support_complex_types_; +} +inline void UserToBitHandshake::set_support_complex_types(bool value) { + set_has_support_complex_types(); + support_complex_types_ = value; +} + +// optional bool support_timeout = 7 [default = false]; +inline bool UserToBitHandshake::has_support_timeout() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void UserToBitHandshake::set_has_support_timeout() { + _has_bits_[0] |= 0x00000040u; +} +inline void UserToBitHandshake::clear_has_support_timeout() { + _has_bits_[0] &= ~0x00000040u; +} +inline void UserToBitHandshake::clear_support_timeout() { + support_timeout_ = false; + clear_has_support_timeout(); +} +inline bool UserToBitHandshake::support_timeout() const { + return support_timeout_; +} +inline void UserToBitHandshake::set_support_timeout(bool value) { + set_has_support_timeout(); + support_timeout_ = value; +} + +// optional .exec.user.RpcEndpointInfos client_infos = 8; +inline bool UserToBitHandshake::has_client_infos() const { + return (_has_bits_[0] & 0x00000080u) != 0; +} +inline void UserToBitHandshake::set_has_client_infos() { + _has_bits_[0] |= 0x00000080u; +} +inline void UserToBitHandshake::clear_has_client_infos() { + _has_bits_[0] &= ~0x00000080u; +} +inline void UserToBitHandshake::clear_client_infos() { + if (client_infos_ != NULL) client_infos_->::exec::user::RpcEndpointInfos::Clear(); + clear_has_client_infos(); +} +inline const ::exec::user::RpcEndpointInfos& UserToBitHandshake::client_infos() const { + return client_infos_ != NULL ? *client_infos_ : *default_instance_->client_infos_; +} +inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::mutable_client_infos() { + set_has_client_infos(); + if (client_infos_ == NULL) client_infos_ = new ::exec::user::RpcEndpointInfos; + return client_infos_; +} +inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::release_client_infos() { + clear_has_client_infos(); + ::exec::user::RpcEndpointInfos* temp = client_infos_; + client_infos_ = NULL; + return temp; +} +inline void UserToBitHandshake::set_allocated_client_infos(::exec::user::RpcEndpointInfos* client_infos) { + delete client_infos_; + client_infos_ = client_infos; + if (client_infos) { + set_has_client_infos(); + } else { + clear_has_client_infos(); + } +} + +// optional .exec.user.SaslSupport sasl_support = 9; +inline bool UserToBitHandshake::has_sasl_support() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void UserToBitHandshake::set_has_sasl_support() { + _has_bits_[0] |= 0x00000100u; +} +inline void UserToBitHandshake::clear_has_sasl_support() { + _has_bits_[0] &= ~0x00000100u; +} +inline void UserToBitHandshake::clear_sasl_support() { + sasl_support_ = 0; + clear_has_sasl_support(); +} +inline ::exec::user::SaslSupport UserToBitHandshake::sasl_support() const { + return static_cast< ::exec::user::SaslSupport >(sasl_support_); +} +inline void UserToBitHandshake::set_sasl_support(::exec::user::SaslSupport value) { + assert(::exec::user::SaslSupport_IsValid(value)); + set_has_sasl_support(); + sasl_support_ = value; +} + +// ------------------------------------------------------------------- + +// RequestResults + +// optional .exec.shared.QueryId query_id = 1; +inline bool RequestResults::has_query_id() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void RequestResults::set_has_query_id() { + _has_bits_[0] |= 0x00000001u; +} +inline void RequestResults::clear_has_query_id() { + _has_bits_[0] &= ~0x00000001u; +} +inline void RequestResults::clear_query_id() { + if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear(); + clear_has_query_id(); +} +inline const ::exec::shared::QueryId& RequestResults::query_id() const { + return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_; +} +inline ::exec::shared::QueryId* RequestResults::mutable_query_id() { + set_has_query_id(); + if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId; + return query_id_; +} +inline ::exec::shared::QueryId* RequestResults::release_query_id() { + clear_has_query_id(); + ::exec::shared::QueryId* temp = query_id_; + query_id_ = NULL; + return temp; +} +inline void RequestResults::set_allocated_query_id(::exec::shared::QueryId* query_id) { + delete query_id_; + query_id_ = query_id; + if (query_id) { + set_has_query_id(); + } else { + clear_has_query_id(); + } +} + +// optional int32 maximum_responses = 2; +inline bool RequestResults::has_maximum_responses() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void RequestResults::set_has_maximum_responses() { + _has_bits_[0] |= 0x00000002u; +} +inline void RequestResults::clear_has_maximum_responses() { + _has_bits_[0] &= ~0x00000002u; +} +inline void RequestResults::clear_maximum_responses() { + maximum_responses_ = 0; + clear_has_maximum_responses(); +} +inline ::google::protobuf::int32 RequestResults::maximum_responses() const { + return maximum_responses_; +} +inline void RequestResults::set_maximum_responses(::google::protobuf::int32 value) { + set_has_maximum_responses(); + maximum_responses_ = value; +} + +// ------------------------------------------------------------------- + +// GetQueryPlanFragments + +// required string query = 1; +inline bool GetQueryPlanFragments::has_query() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetQueryPlanFragments::set_has_query() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetQueryPlanFragments::clear_has_query() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetQueryPlanFragments::clear_query() { + if (query_ != &::google::protobuf::internal::kEmptyString) { + query_->clear(); + } + clear_has_query(); +} +inline const ::std::string& GetQueryPlanFragments::query() const { + return *query_; +} +inline void GetQueryPlanFragments::set_query(const ::std::string& value) { + set_has_query(); + if (query_ == &::google::protobuf::internal::kEmptyString) { + query_ = new ::std::string; + } + query_->assign(value); +} +inline void GetQueryPlanFragments::set_query(const char* value) { + set_has_query(); + if (query_ == &::google::protobuf::internal::kEmptyString) { + query_ = new ::std::string; + } + query_->assign(value); +} +inline void GetQueryPlanFragments::set_query(const char* value, size_t size) { + set_has_query(); + if (query_ == &::google::protobuf::internal::kEmptyString) { + query_ = new ::std::string; + } + query_->assign(reinterpret_cast(value), size); +} +inline ::std::string* GetQueryPlanFragments::mutable_query() { + set_has_query(); + if (query_ == &::google::protobuf::internal::kEmptyString) { + query_ = new ::std::string; + } + return query_; +} +inline ::std::string* GetQueryPlanFragments::release_query() { + clear_has_query(); + if (query_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = query_; + query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void GetQueryPlanFragments::set_allocated_query(::std::string* query) { + if (query_ != &::google::protobuf::internal::kEmptyString) { + delete query_; + } + if (query) { + set_has_query(); + query_ = query; + } else { + clear_has_query(); + query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional .exec.shared.QueryType type = 2; +inline bool GetQueryPlanFragments::has_type() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetQueryPlanFragments::set_has_type() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetQueryPlanFragments::clear_has_type() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetQueryPlanFragments::clear_type() { + type_ = 1; + clear_has_type(); +} +inline ::exec::shared::QueryType GetQueryPlanFragments::type() const { + return static_cast< ::exec::shared::QueryType >(type_); +} +inline void GetQueryPlanFragments::set_type(::exec::shared::QueryType value) { + assert(::exec::shared::QueryType_IsValid(value)); + set_has_type(); + type_ = value; +} + +// optional bool split_plan = 3 [default = false]; +inline bool GetQueryPlanFragments::has_split_plan() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetQueryPlanFragments::set_has_split_plan() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetQueryPlanFragments::clear_has_split_plan() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetQueryPlanFragments::clear_split_plan() { + split_plan_ = false; + clear_has_split_plan(); +} +inline bool GetQueryPlanFragments::split_plan() const { + return split_plan_; +} +inline void GetQueryPlanFragments::set_split_plan(bool value) { + set_has_split_plan(); + split_plan_ = value; +} + +// ------------------------------------------------------------------- + +// QueryPlanFragments + +// required .exec.shared.QueryResult.QueryState status = 1; +inline bool QueryPlanFragments::has_status() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void QueryPlanFragments::set_has_status() { + _has_bits_[0] |= 0x00000001u; +} +inline void QueryPlanFragments::clear_has_status() { + _has_bits_[0] &= ~0x00000001u; +} +inline void QueryPlanFragments::clear_status() { + status_ = 0; + clear_has_status(); +} +inline ::exec::shared::QueryResult_QueryState QueryPlanFragments::status() const { + return static_cast< ::exec::shared::QueryResult_QueryState >(status_); +} +inline void QueryPlanFragments::set_status(::exec::shared::QueryResult_QueryState value) { + assert(::exec::shared::QueryResult_QueryState_IsValid(value)); + set_has_status(); + status_ = value; +} + +// optional .exec.shared.QueryId query_id = 2; +inline bool QueryPlanFragments::has_query_id() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void QueryPlanFragments::set_has_query_id() { + _has_bits_[0] |= 0x00000002u; +} +inline void QueryPlanFragments::clear_has_query_id() { + _has_bits_[0] &= ~0x00000002u; +} +inline void QueryPlanFragments::clear_query_id() { + if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear(); + clear_has_query_id(); +} +inline const ::exec::shared::QueryId& QueryPlanFragments::query_id() const { + return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_; +} +inline ::exec::shared::QueryId* QueryPlanFragments::mutable_query_id() { + set_has_query_id(); + if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId; + return query_id_; +} +inline ::exec::shared::QueryId* QueryPlanFragments::release_query_id() { + clear_has_query_id(); + ::exec::shared::QueryId* temp = query_id_; + query_id_ = NULL; + return temp; +} +inline void QueryPlanFragments::set_allocated_query_id(::exec::shared::QueryId* query_id) { + delete query_id_; + query_id_ = query_id; + if (query_id) { + set_has_query_id(); + } else { + clear_has_query_id(); + } +} + +// repeated .exec.bit.control.PlanFragment fragments = 3; +inline int QueryPlanFragments::fragments_size() const { + return fragments_.size(); +} +inline void QueryPlanFragments::clear_fragments() { + fragments_.Clear(); +} +inline const ::exec::bit::control::PlanFragment& QueryPlanFragments::fragments(int index) const { + return fragments_.Get(index); +} +inline ::exec::bit::control::PlanFragment* QueryPlanFragments::mutable_fragments(int index) { + return fragments_.Mutable(index); +} +inline ::exec::bit::control::PlanFragment* QueryPlanFragments::add_fragments() { + return fragments_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >& +QueryPlanFragments::fragments() const { + return fragments_; +} +inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >* +QueryPlanFragments::mutable_fragments() { + return &fragments_; +} + +// optional .exec.shared.DrillPBError error = 4; +inline bool QueryPlanFragments::has_error() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void QueryPlanFragments::set_has_error() { + _has_bits_[0] |= 0x00000008u; +} +inline void QueryPlanFragments::clear_has_error() { + _has_bits_[0] &= ~0x00000008u; +} +inline void QueryPlanFragments::clear_error() { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + clear_has_error(); +} +inline const ::exec::shared::DrillPBError& QueryPlanFragments::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; +} +inline ::exec::shared::DrillPBError* QueryPlanFragments::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; + return error_; +} +inline ::exec::shared::DrillPBError* QueryPlanFragments::release_error() { + clear_has_error(); + ::exec::shared::DrillPBError* temp = error_; + error_ = NULL; + return temp; +} +inline void QueryPlanFragments::set_allocated_error(::exec::shared::DrillPBError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); + } else { + clear_has_error(); + } +} + +// ------------------------------------------------------------------- + +// BitToUserHandshake + +// optional int32 rpc_version = 2; +inline bool BitToUserHandshake::has_rpc_version() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void BitToUserHandshake::set_has_rpc_version() { + _has_bits_[0] |= 0x00000001u; +} +inline void BitToUserHandshake::clear_has_rpc_version() { + _has_bits_[0] &= ~0x00000001u; +} +inline void BitToUserHandshake::clear_rpc_version() { + rpc_version_ = 0; + clear_has_rpc_version(); +} +inline ::google::protobuf::int32 BitToUserHandshake::rpc_version() const { + return rpc_version_; +} +inline void BitToUserHandshake::set_rpc_version(::google::protobuf::int32 value) { + set_has_rpc_version(); + rpc_version_ = value; +} + +// optional .exec.user.HandshakeStatus status = 3; +inline bool BitToUserHandshake::has_status() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void BitToUserHandshake::set_has_status() { + _has_bits_[0] |= 0x00000002u; +} +inline void BitToUserHandshake::clear_has_status() { + _has_bits_[0] &= ~0x00000002u; +} +inline void BitToUserHandshake::clear_status() { + status_ = 1; + clear_has_status(); +} +inline ::exec::user::HandshakeStatus BitToUserHandshake::status() const { + return static_cast< ::exec::user::HandshakeStatus >(status_); +} +inline void BitToUserHandshake::set_status(::exec::user::HandshakeStatus value) { + assert(::exec::user::HandshakeStatus_IsValid(value)); + set_has_status(); + status_ = value; +} + +// optional string errorId = 4; +inline bool BitToUserHandshake::has_errorid() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void BitToUserHandshake::set_has_errorid() { + _has_bits_[0] |= 0x00000004u; +} +inline void BitToUserHandshake::clear_has_errorid() { + _has_bits_[0] &= ~0x00000004u; +} +inline void BitToUserHandshake::clear_errorid() { + if (errorid_ != &::google::protobuf::internal::kEmptyString) { + errorid_->clear(); } - value_->assign(value); + clear_has_errorid(); } -inline void Property::set_value(const char* value) { - set_has_value(); - if (value_ == &::google::protobuf::internal::kEmptyString) { - value_ = new ::std::string; +inline const ::std::string& BitToUserHandshake::errorid() const { + return *errorid_; +} +inline void BitToUserHandshake::set_errorid(const ::std::string& value) { + set_has_errorid(); + if (errorid_ == &::google::protobuf::internal::kEmptyString) { + errorid_ = new ::std::string; } - value_->assign(value); + errorid_->assign(value); } -inline void Property::set_value(const char* value, size_t size) { - set_has_value(); - if (value_ == &::google::protobuf::internal::kEmptyString) { - value_ = new ::std::string; +inline void BitToUserHandshake::set_errorid(const char* value) { + set_has_errorid(); + if (errorid_ == &::google::protobuf::internal::kEmptyString) { + errorid_ = new ::std::string; } - value_->assign(reinterpret_cast(value), size); + errorid_->assign(value); } -inline ::std::string* Property::mutable_value() { - set_has_value(); - if (value_ == &::google::protobuf::internal::kEmptyString) { - value_ = new ::std::string; +inline void BitToUserHandshake::set_errorid(const char* value, size_t size) { + set_has_errorid(); + if (errorid_ == &::google::protobuf::internal::kEmptyString) { + errorid_ = new ::std::string; } - return value_; + errorid_->assign(reinterpret_cast(value), size); } -inline ::std::string* Property::release_value() { - clear_has_value(); - if (value_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* BitToUserHandshake::mutable_errorid() { + set_has_errorid(); + if (errorid_ == &::google::protobuf::internal::kEmptyString) { + errorid_ = new ::std::string; + } + return errorid_; +} +inline ::std::string* BitToUserHandshake::release_errorid() { + clear_has_errorid(); + if (errorid_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = value_; - value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = errorid_; + errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void Property::set_allocated_value(::std::string* value) { - if (value_ != &::google::protobuf::internal::kEmptyString) { - delete value_; +inline void BitToUserHandshake::set_allocated_errorid(::std::string* errorid) { + if (errorid_ != &::google::protobuf::internal::kEmptyString) { + delete errorid_; } - if (value) { - set_has_value(); - value_ = value; + if (errorid) { + set_has_errorid(); + errorid_ = errorid; } else { - clear_has_value(); - value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_errorid(); + errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// ------------------------------------------------------------------- +// optional string errorMessage = 5; +inline bool BitToUserHandshake::has_errormessage() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void BitToUserHandshake::set_has_errormessage() { + _has_bits_[0] |= 0x00000008u; +} +inline void BitToUserHandshake::clear_has_errormessage() { + _has_bits_[0] &= ~0x00000008u; +} +inline void BitToUserHandshake::clear_errormessage() { + if (errormessage_ != &::google::protobuf::internal::kEmptyString) { + errormessage_->clear(); + } + clear_has_errormessage(); +} +inline const ::std::string& BitToUserHandshake::errormessage() const { + return *errormessage_; +} +inline void BitToUserHandshake::set_errormessage(const ::std::string& value) { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + errormessage_->assign(value); +} +inline void BitToUserHandshake::set_errormessage(const char* value) { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + errormessage_->assign(value); +} +inline void BitToUserHandshake::set_errormessage(const char* value, size_t size) { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + errormessage_->assign(reinterpret_cast(value), size); +} +inline ::std::string* BitToUserHandshake::mutable_errormessage() { + set_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + errormessage_ = new ::std::string; + } + return errormessage_; +} +inline ::std::string* BitToUserHandshake::release_errormessage() { + clear_has_errormessage(); + if (errormessage_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = errormessage_; + errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void BitToUserHandshake::set_allocated_errormessage(::std::string* errormessage) { + if (errormessage_ != &::google::protobuf::internal::kEmptyString) { + delete errormessage_; + } + if (errormessage) { + set_has_errormessage(); + errormessage_ = errormessage; + } else { + clear_has_errormessage(); + errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} -// UserProperties +// optional .exec.user.RpcEndpointInfos server_infos = 6; +inline bool BitToUserHandshake::has_server_infos() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void BitToUserHandshake::set_has_server_infos() { + _has_bits_[0] |= 0x00000010u; +} +inline void BitToUserHandshake::clear_has_server_infos() { + _has_bits_[0] &= ~0x00000010u; +} +inline void BitToUserHandshake::clear_server_infos() { + if (server_infos_ != NULL) server_infos_->::exec::user::RpcEndpointInfos::Clear(); + clear_has_server_infos(); +} +inline const ::exec::user::RpcEndpointInfos& BitToUserHandshake::server_infos() const { + return server_infos_ != NULL ? *server_infos_ : *default_instance_->server_infos_; +} +inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::mutable_server_infos() { + set_has_server_infos(); + if (server_infos_ == NULL) server_infos_ = new ::exec::user::RpcEndpointInfos; + return server_infos_; +} +inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::release_server_infos() { + clear_has_server_infos(); + ::exec::user::RpcEndpointInfos* temp = server_infos_; + server_infos_ = NULL; + return temp; +} +inline void BitToUserHandshake::set_allocated_server_infos(::exec::user::RpcEndpointInfos* server_infos) { + delete server_infos_; + server_infos_ = server_infos; + if (server_infos) { + set_has_server_infos(); + } else { + clear_has_server_infos(); + } +} + +// repeated string authenticationMechanisms = 7; +inline int BitToUserHandshake::authenticationmechanisms_size() const { + return authenticationmechanisms_.size(); +} +inline void BitToUserHandshake::clear_authenticationmechanisms() { + authenticationmechanisms_.Clear(); +} +inline const ::std::string& BitToUserHandshake::authenticationmechanisms(int index) const { + return authenticationmechanisms_.Get(index); +} +inline ::std::string* BitToUserHandshake::mutable_authenticationmechanisms(int index) { + return authenticationmechanisms_.Mutable(index); +} +inline void BitToUserHandshake::set_authenticationmechanisms(int index, const ::std::string& value) { + authenticationmechanisms_.Mutable(index)->assign(value); +} +inline void BitToUserHandshake::set_authenticationmechanisms(int index, const char* value) { + authenticationmechanisms_.Mutable(index)->assign(value); +} +inline void BitToUserHandshake::set_authenticationmechanisms(int index, const char* value, size_t size) { + authenticationmechanisms_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* BitToUserHandshake::add_authenticationmechanisms() { + return authenticationmechanisms_.Add(); +} +inline void BitToUserHandshake::add_authenticationmechanisms(const ::std::string& value) { + authenticationmechanisms_.Add()->assign(value); +} +inline void BitToUserHandshake::add_authenticationmechanisms(const char* value) { + authenticationmechanisms_.Add()->assign(value); +} +inline void BitToUserHandshake::add_authenticationmechanisms(const char* value, size_t size) { + authenticationmechanisms_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +BitToUserHandshake::authenticationmechanisms() const { + return authenticationmechanisms_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +BitToUserHandshake::mutable_authenticationmechanisms() { + return &authenticationmechanisms_; +} -// repeated .exec.user.Property properties = 1; -inline int UserProperties::properties_size() const { - return properties_.size(); +// repeated .exec.user.RpcType supported_methods = 8; +inline int BitToUserHandshake::supported_methods_size() const { + return supported_methods_.size(); } -inline void UserProperties::clear_properties() { - properties_.Clear(); +inline void BitToUserHandshake::clear_supported_methods() { + supported_methods_.Clear(); } -inline const ::exec::user::Property& UserProperties::properties(int index) const { - return properties_.Get(index); +inline ::exec::user::RpcType BitToUserHandshake::supported_methods(int index) const { + return static_cast< ::exec::user::RpcType >(supported_methods_.Get(index)); } -inline ::exec::user::Property* UserProperties::mutable_properties(int index) { - return properties_.Mutable(index); +inline void BitToUserHandshake::set_supported_methods(int index, ::exec::user::RpcType value) { + assert(::exec::user::RpcType_IsValid(value)); + supported_methods_.Set(index, value); } -inline ::exec::user::Property* UserProperties::add_properties() { - return properties_.Add(); +inline void BitToUserHandshake::add_supported_methods(::exec::user::RpcType value) { + assert(::exec::user::RpcType_IsValid(value)); + supported_methods_.Add(value); } -inline const ::google::protobuf::RepeatedPtrField< ::exec::user::Property >& -UserProperties::properties() const { - return properties_; +inline const ::google::protobuf::RepeatedField& +BitToUserHandshake::supported_methods() const { + return supported_methods_; } -inline ::google::protobuf::RepeatedPtrField< ::exec::user::Property >* -UserProperties::mutable_properties() { - return &properties_; +inline ::google::protobuf::RepeatedField* +BitToUserHandshake::mutable_supported_methods() { + return &supported_methods_; } // ------------------------------------------------------------------- -// RpcEndpointInfos +// LikeFilter -// optional string name = 1; -inline bool RpcEndpointInfos::has_name() const { +// optional string pattern = 1; +inline bool LikeFilter::has_pattern() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void RpcEndpointInfos::set_has_name() { +inline void LikeFilter::set_has_pattern() { _has_bits_[0] |= 0x00000001u; } -inline void RpcEndpointInfos::clear_has_name() { +inline void LikeFilter::clear_has_pattern() { _has_bits_[0] &= ~0x00000001u; } -inline void RpcEndpointInfos::clear_name() { - if (name_ != &::google::protobuf::internal::kEmptyString) { - name_->clear(); +inline void LikeFilter::clear_pattern() { + if (pattern_ != &::google::protobuf::internal::kEmptyString) { + pattern_->clear(); } - clear_has_name(); + clear_has_pattern(); } -inline const ::std::string& RpcEndpointInfos::name() const { - return *name_; +inline const ::std::string& LikeFilter::pattern() const { + return *pattern_; } -inline void RpcEndpointInfos::set_name(const ::std::string& value) { - set_has_name(); - if (name_ == &::google::protobuf::internal::kEmptyString) { - name_ = new ::std::string; +inline void LikeFilter::set_pattern(const ::std::string& value) { + set_has_pattern(); + if (pattern_ == &::google::protobuf::internal::kEmptyString) { + pattern_ = new ::std::string; } - name_->assign(value); + pattern_->assign(value); } -inline void RpcEndpointInfos::set_name(const char* value) { - set_has_name(); - if (name_ == &::google::protobuf::internal::kEmptyString) { - name_ = new ::std::string; +inline void LikeFilter::set_pattern(const char* value) { + set_has_pattern(); + if (pattern_ == &::google::protobuf::internal::kEmptyString) { + pattern_ = new ::std::string; } - name_->assign(value); + pattern_->assign(value); } -inline void RpcEndpointInfos::set_name(const char* value, size_t size) { - set_has_name(); - if (name_ == &::google::protobuf::internal::kEmptyString) { - name_ = new ::std::string; +inline void LikeFilter::set_pattern(const char* value, size_t size) { + set_has_pattern(); + if (pattern_ == &::google::protobuf::internal::kEmptyString) { + pattern_ = new ::std::string; } - name_->assign(reinterpret_cast(value), size); + pattern_->assign(reinterpret_cast(value), size); } -inline ::std::string* RpcEndpointInfos::mutable_name() { - set_has_name(); - if (name_ == &::google::protobuf::internal::kEmptyString) { - name_ = new ::std::string; +inline ::std::string* LikeFilter::mutable_pattern() { + set_has_pattern(); + if (pattern_ == &::google::protobuf::internal::kEmptyString) { + pattern_ = new ::std::string; } - return name_; + return pattern_; } -inline ::std::string* RpcEndpointInfos::release_name() { - clear_has_name(); - if (name_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* LikeFilter::release_pattern() { + clear_has_pattern(); + if (pattern_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = name_; - name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = pattern_; + pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void RpcEndpointInfos::set_allocated_name(::std::string* name) { - if (name_ != &::google::protobuf::internal::kEmptyString) { - delete name_; +inline void LikeFilter::set_allocated_pattern(::std::string* pattern) { + if (pattern_ != &::google::protobuf::internal::kEmptyString) { + delete pattern_; } - if (name) { - set_has_name(); - name_ = name; + if (pattern) { + set_has_pattern(); + pattern_ = pattern; } else { - clear_has_name(); - name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_pattern(); + pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string version = 2; -inline bool RpcEndpointInfos::has_version() const { +// optional string escape = 2; +inline bool LikeFilter::has_escape() const { return (_has_bits_[0] & 0x00000002u) != 0; } -inline void RpcEndpointInfos::set_has_version() { +inline void LikeFilter::set_has_escape() { _has_bits_[0] |= 0x00000002u; } -inline void RpcEndpointInfos::clear_has_version() { +inline void LikeFilter::clear_has_escape() { _has_bits_[0] &= ~0x00000002u; } -inline void RpcEndpointInfos::clear_version() { - if (version_ != &::google::protobuf::internal::kEmptyString) { - version_->clear(); +inline void LikeFilter::clear_escape() { + if (escape_ != &::google::protobuf::internal::kEmptyString) { + escape_->clear(); } - clear_has_version(); + clear_has_escape(); } -inline const ::std::string& RpcEndpointInfos::version() const { - return *version_; +inline const ::std::string& LikeFilter::escape() const { + return *escape_; } -inline void RpcEndpointInfos::set_version(const ::std::string& value) { - set_has_version(); - if (version_ == &::google::protobuf::internal::kEmptyString) { - version_ = new ::std::string; +inline void LikeFilter::set_escape(const ::std::string& value) { + set_has_escape(); + if (escape_ == &::google::protobuf::internal::kEmptyString) { + escape_ = new ::std::string; } - version_->assign(value); + escape_->assign(value); } -inline void RpcEndpointInfos::set_version(const char* value) { - set_has_version(); - if (version_ == &::google::protobuf::internal::kEmptyString) { - version_ = new ::std::string; +inline void LikeFilter::set_escape(const char* value) { + set_has_escape(); + if (escape_ == &::google::protobuf::internal::kEmptyString) { + escape_ = new ::std::string; } - version_->assign(value); + escape_->assign(value); } -inline void RpcEndpointInfos::set_version(const char* value, size_t size) { - set_has_version(); - if (version_ == &::google::protobuf::internal::kEmptyString) { - version_ = new ::std::string; +inline void LikeFilter::set_escape(const char* value, size_t size) { + set_has_escape(); + if (escape_ == &::google::protobuf::internal::kEmptyString) { + escape_ = new ::std::string; } - version_->assign(reinterpret_cast(value), size); + escape_->assign(reinterpret_cast(value), size); } -inline ::std::string* RpcEndpointInfos::mutable_version() { - set_has_version(); - if (version_ == &::google::protobuf::internal::kEmptyString) { - version_ = new ::std::string; +inline ::std::string* LikeFilter::mutable_escape() { + set_has_escape(); + if (escape_ == &::google::protobuf::internal::kEmptyString) { + escape_ = new ::std::string; } - return version_; + return escape_; } -inline ::std::string* RpcEndpointInfos::release_version() { - clear_has_version(); - if (version_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* LikeFilter::release_escape() { + clear_has_escape(); + if (escape_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = version_; - version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = escape_; + escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void RpcEndpointInfos::set_allocated_version(::std::string* version) { - if (version_ != &::google::protobuf::internal::kEmptyString) { - delete version_; +inline void LikeFilter::set_allocated_escape(::std::string* escape) { + if (escape_ != &::google::protobuf::internal::kEmptyString) { + delete escape_; } - if (version) { - set_has_version(); - version_ = version; + if (escape) { + set_has_escape(); + escape_ = escape; } else { - clear_has_version(); - version_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } -} - -// optional uint32 majorVersion = 3; -inline bool RpcEndpointInfos::has_majorversion() const { - return (_has_bits_[0] & 0x00000004u) != 0; -} -inline void RpcEndpointInfos::set_has_majorversion() { - _has_bits_[0] |= 0x00000004u; -} -inline void RpcEndpointInfos::clear_has_majorversion() { - _has_bits_[0] &= ~0x00000004u; -} -inline void RpcEndpointInfos::clear_majorversion() { - majorversion_ = 0u; - clear_has_majorversion(); -} -inline ::google::protobuf::uint32 RpcEndpointInfos::majorversion() const { - return majorversion_; -} -inline void RpcEndpointInfos::set_majorversion(::google::protobuf::uint32 value) { - set_has_majorversion(); - majorversion_ = value; -} - -// optional uint32 minorVersion = 4; -inline bool RpcEndpointInfos::has_minorversion() const { - return (_has_bits_[0] & 0x00000008u) != 0; -} -inline void RpcEndpointInfos::set_has_minorversion() { - _has_bits_[0] |= 0x00000008u; -} -inline void RpcEndpointInfos::clear_has_minorversion() { - _has_bits_[0] &= ~0x00000008u; -} -inline void RpcEndpointInfos::clear_minorversion() { - minorversion_ = 0u; - clear_has_minorversion(); -} -inline ::google::protobuf::uint32 RpcEndpointInfos::minorversion() const { - return minorversion_; -} -inline void RpcEndpointInfos::set_minorversion(::google::protobuf::uint32 value) { - set_has_minorversion(); - minorversion_ = value; + clear_has_escape(); + escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional uint32 patchVersion = 5; -inline bool RpcEndpointInfos::has_patchversion() const { - return (_has_bits_[0] & 0x00000010u) != 0; +// ------------------------------------------------------------------- + +// GetCatalogsReq + +// optional .exec.user.LikeFilter catalog_name_filter = 1; +inline bool GetCatalogsReq::has_catalog_name_filter() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void RpcEndpointInfos::set_has_patchversion() { - _has_bits_[0] |= 0x00000010u; +inline void GetCatalogsReq::set_has_catalog_name_filter() { + _has_bits_[0] |= 0x00000001u; } -inline void RpcEndpointInfos::clear_has_patchversion() { - _has_bits_[0] &= ~0x00000010u; +inline void GetCatalogsReq::clear_has_catalog_name_filter() { + _has_bits_[0] &= ~0x00000001u; } -inline void RpcEndpointInfos::clear_patchversion() { - patchversion_ = 0u; - clear_has_patchversion(); +inline void GetCatalogsReq::clear_catalog_name_filter() { + if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_catalog_name_filter(); } -inline ::google::protobuf::uint32 RpcEndpointInfos::patchversion() const { - return patchversion_; +inline const ::exec::user::LikeFilter& GetCatalogsReq::catalog_name_filter() const { + return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; } -inline void RpcEndpointInfos::set_patchversion(::google::protobuf::uint32 value) { - set_has_patchversion(); - patchversion_ = value; +inline ::exec::user::LikeFilter* GetCatalogsReq::mutable_catalog_name_filter() { + set_has_catalog_name_filter(); + if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; + return catalog_name_filter_; +} +inline ::exec::user::LikeFilter* GetCatalogsReq::release_catalog_name_filter() { + clear_has_catalog_name_filter(); + ::exec::user::LikeFilter* temp = catalog_name_filter_; + catalog_name_filter_ = NULL; + return temp; +} +inline void GetCatalogsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { + delete catalog_name_filter_; + catalog_name_filter_ = catalog_name_filter; + if (catalog_name_filter) { + set_has_catalog_name_filter(); + } else { + clear_has_catalog_name_filter(); + } } -// optional string application = 6; -inline bool RpcEndpointInfos::has_application() const { - return (_has_bits_[0] & 0x00000020u) != 0; +// ------------------------------------------------------------------- + +// CatalogMetadata + +// optional string catalog_name = 1; +inline bool CatalogMetadata::has_catalog_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void RpcEndpointInfos::set_has_application() { - _has_bits_[0] |= 0x00000020u; +inline void CatalogMetadata::set_has_catalog_name() { + _has_bits_[0] |= 0x00000001u; } -inline void RpcEndpointInfos::clear_has_application() { - _has_bits_[0] &= ~0x00000020u; +inline void CatalogMetadata::clear_has_catalog_name() { + _has_bits_[0] &= ~0x00000001u; } -inline void RpcEndpointInfos::clear_application() { - if (application_ != &::google::protobuf::internal::kEmptyString) { - application_->clear(); +inline void CatalogMetadata::clear_catalog_name() { + if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { + catalog_name_->clear(); } - clear_has_application(); + clear_has_catalog_name(); } -inline const ::std::string& RpcEndpointInfos::application() const { - return *application_; +inline const ::std::string& CatalogMetadata::catalog_name() const { + return *catalog_name_; } -inline void RpcEndpointInfos::set_application(const ::std::string& value) { - set_has_application(); - if (application_ == &::google::protobuf::internal::kEmptyString) { - application_ = new ::std::string; +inline void CatalogMetadata::set_catalog_name(const ::std::string& value) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; } - application_->assign(value); + catalog_name_->assign(value); } -inline void RpcEndpointInfos::set_application(const char* value) { - set_has_application(); - if (application_ == &::google::protobuf::internal::kEmptyString) { - application_ = new ::std::string; +inline void CatalogMetadata::set_catalog_name(const char* value) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; } - application_->assign(value); + catalog_name_->assign(value); } -inline void RpcEndpointInfos::set_application(const char* value, size_t size) { - set_has_application(); - if (application_ == &::google::protobuf::internal::kEmptyString) { - application_ = new ::std::string; +inline void CatalogMetadata::set_catalog_name(const char* value, size_t size) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; } - application_->assign(reinterpret_cast(value), size); + catalog_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* RpcEndpointInfos::mutable_application() { - set_has_application(); - if (application_ == &::google::protobuf::internal::kEmptyString) { - application_ = new ::std::string; +inline ::std::string* CatalogMetadata::mutable_catalog_name() { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; } - return application_; + return catalog_name_; } -inline ::std::string* RpcEndpointInfos::release_application() { - clear_has_application(); - if (application_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* CatalogMetadata::release_catalog_name() { + clear_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = application_; - application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = catalog_name_; + catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void RpcEndpointInfos::set_allocated_application(::std::string* application) { - if (application_ != &::google::protobuf::internal::kEmptyString) { - delete application_; +inline void CatalogMetadata::set_allocated_catalog_name(::std::string* catalog_name) { + if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_name_; } - if (application) { - set_has_application(); - application_ = application; + if (catalog_name) { + set_has_catalog_name(); + catalog_name_ = catalog_name; } else { - clear_has_application(); - application_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_catalog_name(); + catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional uint32 buildNumber = 7; -inline bool RpcEndpointInfos::has_buildnumber() const { - return (_has_bits_[0] & 0x00000040u) != 0; +// optional string description = 2; +inline bool CatalogMetadata::has_description() const { + return (_has_bits_[0] & 0x00000002u) != 0; } -inline void RpcEndpointInfos::set_has_buildnumber() { - _has_bits_[0] |= 0x00000040u; +inline void CatalogMetadata::set_has_description() { + _has_bits_[0] |= 0x00000002u; } -inline void RpcEndpointInfos::clear_has_buildnumber() { - _has_bits_[0] &= ~0x00000040u; +inline void CatalogMetadata::clear_has_description() { + _has_bits_[0] &= ~0x00000002u; } -inline void RpcEndpointInfos::clear_buildnumber() { - buildnumber_ = 0u; - clear_has_buildnumber(); +inline void CatalogMetadata::clear_description() { + if (description_ != &::google::protobuf::internal::kEmptyString) { + description_->clear(); + } + clear_has_description(); } -inline ::google::protobuf::uint32 RpcEndpointInfos::buildnumber() const { - return buildnumber_; +inline const ::std::string& CatalogMetadata::description() const { + return *description_; } -inline void RpcEndpointInfos::set_buildnumber(::google::protobuf::uint32 value) { - set_has_buildnumber(); - buildnumber_ = value; +inline void CatalogMetadata::set_description(const ::std::string& value) { + set_has_description(); + if (description_ == &::google::protobuf::internal::kEmptyString) { + description_ = new ::std::string; + } + description_->assign(value); +} +inline void CatalogMetadata::set_description(const char* value) { + set_has_description(); + if (description_ == &::google::protobuf::internal::kEmptyString) { + description_ = new ::std::string; + } + description_->assign(value); +} +inline void CatalogMetadata::set_description(const char* value, size_t size) { + set_has_description(); + if (description_ == &::google::protobuf::internal::kEmptyString) { + description_ = new ::std::string; + } + description_->assign(reinterpret_cast(value), size); +} +inline ::std::string* CatalogMetadata::mutable_description() { + set_has_description(); + if (description_ == &::google::protobuf::internal::kEmptyString) { + description_ = new ::std::string; + } + return description_; +} +inline ::std::string* CatalogMetadata::release_description() { + clear_has_description(); + if (description_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = description_; + description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void CatalogMetadata::set_allocated_description(::std::string* description) { + if (description_ != &::google::protobuf::internal::kEmptyString) { + delete description_; + } + if (description) { + set_has_description(); + description_ = description; + } else { + clear_has_description(); + description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional string versionQualifier = 8; -inline bool RpcEndpointInfos::has_versionqualifier() const { - return (_has_bits_[0] & 0x00000080u) != 0; +// optional string connect = 3; +inline bool CatalogMetadata::has_connect() const { + return (_has_bits_[0] & 0x00000004u) != 0; } -inline void RpcEndpointInfos::set_has_versionqualifier() { - _has_bits_[0] |= 0x00000080u; +inline void CatalogMetadata::set_has_connect() { + _has_bits_[0] |= 0x00000004u; } -inline void RpcEndpointInfos::clear_has_versionqualifier() { - _has_bits_[0] &= ~0x00000080u; +inline void CatalogMetadata::clear_has_connect() { + _has_bits_[0] &= ~0x00000004u; } -inline void RpcEndpointInfos::clear_versionqualifier() { - if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) { - versionqualifier_->clear(); +inline void CatalogMetadata::clear_connect() { + if (connect_ != &::google::protobuf::internal::kEmptyString) { + connect_->clear(); } - clear_has_versionqualifier(); + clear_has_connect(); } -inline const ::std::string& RpcEndpointInfos::versionqualifier() const { - return *versionqualifier_; +inline const ::std::string& CatalogMetadata::connect() const { + return *connect_; } -inline void RpcEndpointInfos::set_versionqualifier(const ::std::string& value) { - set_has_versionqualifier(); - if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { - versionqualifier_ = new ::std::string; +inline void CatalogMetadata::set_connect(const ::std::string& value) { + set_has_connect(); + if (connect_ == &::google::protobuf::internal::kEmptyString) { + connect_ = new ::std::string; } - versionqualifier_->assign(value); + connect_->assign(value); } -inline void RpcEndpointInfos::set_versionqualifier(const char* value) { - set_has_versionqualifier(); - if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { - versionqualifier_ = new ::std::string; +inline void CatalogMetadata::set_connect(const char* value) { + set_has_connect(); + if (connect_ == &::google::protobuf::internal::kEmptyString) { + connect_ = new ::std::string; } - versionqualifier_->assign(value); + connect_->assign(value); } -inline void RpcEndpointInfos::set_versionqualifier(const char* value, size_t size) { - set_has_versionqualifier(); - if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { - versionqualifier_ = new ::std::string; +inline void CatalogMetadata::set_connect(const char* value, size_t size) { + set_has_connect(); + if (connect_ == &::google::protobuf::internal::kEmptyString) { + connect_ = new ::std::string; } - versionqualifier_->assign(reinterpret_cast(value), size); + connect_->assign(reinterpret_cast(value), size); } -inline ::std::string* RpcEndpointInfos::mutable_versionqualifier() { - set_has_versionqualifier(); - if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { - versionqualifier_ = new ::std::string; +inline ::std::string* CatalogMetadata::mutable_connect() { + set_has_connect(); + if (connect_ == &::google::protobuf::internal::kEmptyString) { + connect_ = new ::std::string; } - return versionqualifier_; + return connect_; } -inline ::std::string* RpcEndpointInfos::release_versionqualifier() { - clear_has_versionqualifier(); - if (versionqualifier_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* CatalogMetadata::release_connect() { + clear_has_connect(); + if (connect_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = versionqualifier_; - versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = connect_; + connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void RpcEndpointInfos::set_allocated_versionqualifier(::std::string* versionqualifier) { - if (versionqualifier_ != &::google::protobuf::internal::kEmptyString) { - delete versionqualifier_; +inline void CatalogMetadata::set_allocated_connect(::std::string* connect) { + if (connect_ != &::google::protobuf::internal::kEmptyString) { + delete connect_; } - if (versionqualifier) { - set_has_versionqualifier(); - versionqualifier_ = versionqualifier; + if (connect) { + set_has_connect(); + connect_ = connect; } else { - clear_has_versionqualifier(); - versionqualifier_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_connect(); + connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } // ------------------------------------------------------------------- -// UserToBitHandshake +// GetCatalogsResp -// optional .exec.shared.RpcChannel channel = 1 [default = USER]; -inline bool UserToBitHandshake::has_channel() const { +// optional .exec.user.RequestStatus status = 1; +inline bool GetCatalogsResp::has_status() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void UserToBitHandshake::set_has_channel() { +inline void GetCatalogsResp::set_has_status() { _has_bits_[0] |= 0x00000001u; } -inline void UserToBitHandshake::clear_has_channel() { +inline void GetCatalogsResp::clear_has_status() { _has_bits_[0] &= ~0x00000001u; } -inline void UserToBitHandshake::clear_channel() { - channel_ = 2; - clear_has_channel(); +inline void GetCatalogsResp::clear_status() { + status_ = 0; + clear_has_status(); } -inline ::exec::shared::RpcChannel UserToBitHandshake::channel() const { - return static_cast< ::exec::shared::RpcChannel >(channel_); +inline ::exec::user::RequestStatus GetCatalogsResp::status() const { + return static_cast< ::exec::user::RequestStatus >(status_); } -inline void UserToBitHandshake::set_channel(::exec::shared::RpcChannel value) { - assert(::exec::shared::RpcChannel_IsValid(value)); - set_has_channel(); - channel_ = value; +inline void GetCatalogsResp::set_status(::exec::user::RequestStatus value) { + assert(::exec::user::RequestStatus_IsValid(value)); + set_has_status(); + status_ = value; } -// optional bool support_listening = 2; -inline bool UserToBitHandshake::has_support_listening() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// repeated .exec.user.CatalogMetadata catalogs = 2; +inline int GetCatalogsResp::catalogs_size() const { + return catalogs_.size(); } -inline void UserToBitHandshake::set_has_support_listening() { - _has_bits_[0] |= 0x00000002u; +inline void GetCatalogsResp::clear_catalogs() { + catalogs_.Clear(); } -inline void UserToBitHandshake::clear_has_support_listening() { - _has_bits_[0] &= ~0x00000002u; +inline const ::exec::user::CatalogMetadata& GetCatalogsResp::catalogs(int index) const { + return catalogs_.Get(index); } -inline void UserToBitHandshake::clear_support_listening() { - support_listening_ = false; - clear_has_support_listening(); +inline ::exec::user::CatalogMetadata* GetCatalogsResp::mutable_catalogs(int index) { + return catalogs_.Mutable(index); } -inline bool UserToBitHandshake::support_listening() const { - return support_listening_; +inline ::exec::user::CatalogMetadata* GetCatalogsResp::add_catalogs() { + return catalogs_.Add(); } -inline void UserToBitHandshake::set_support_listening(bool value) { - set_has_support_listening(); - support_listening_ = value; +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >& +GetCatalogsResp::catalogs() const { + return catalogs_; +} +inline ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >* +GetCatalogsResp::mutable_catalogs() { + return &catalogs_; } -// optional int32 rpc_version = 3; -inline bool UserToBitHandshake::has_rpc_version() const { +// optional .exec.shared.DrillPBError error = 3; +inline bool GetCatalogsResp::has_error() const { return (_has_bits_[0] & 0x00000004u) != 0; } -inline void UserToBitHandshake::set_has_rpc_version() { +inline void GetCatalogsResp::set_has_error() { _has_bits_[0] |= 0x00000004u; } -inline void UserToBitHandshake::clear_has_rpc_version() { +inline void GetCatalogsResp::clear_has_error() { _has_bits_[0] &= ~0x00000004u; } -inline void UserToBitHandshake::clear_rpc_version() { - rpc_version_ = 0; - clear_has_rpc_version(); +inline void GetCatalogsResp::clear_error() { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + clear_has_error(); } -inline ::google::protobuf::int32 UserToBitHandshake::rpc_version() const { - return rpc_version_; +inline const ::exec::shared::DrillPBError& GetCatalogsResp::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; } -inline void UserToBitHandshake::set_rpc_version(::google::protobuf::int32 value) { - set_has_rpc_version(); - rpc_version_ = value; +inline ::exec::shared::DrillPBError* GetCatalogsResp::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; + return error_; +} +inline ::exec::shared::DrillPBError* GetCatalogsResp::release_error() { + clear_has_error(); + ::exec::shared::DrillPBError* temp = error_; + error_ = NULL; + return temp; +} +inline void GetCatalogsResp::set_allocated_error(::exec::shared::DrillPBError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); + } else { + clear_has_error(); + } } -// optional .exec.shared.UserCredentials credentials = 4; -inline bool UserToBitHandshake::has_credentials() const { - return (_has_bits_[0] & 0x00000008u) != 0; +// ------------------------------------------------------------------- + +// GetSchemasReq + +// optional .exec.user.LikeFilter catalog_name_filter = 1; +inline bool GetSchemasReq::has_catalog_name_filter() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void UserToBitHandshake::set_has_credentials() { - _has_bits_[0] |= 0x00000008u; +inline void GetSchemasReq::set_has_catalog_name_filter() { + _has_bits_[0] |= 0x00000001u; } -inline void UserToBitHandshake::clear_has_credentials() { - _has_bits_[0] &= ~0x00000008u; +inline void GetSchemasReq::clear_has_catalog_name_filter() { + _has_bits_[0] &= ~0x00000001u; } -inline void UserToBitHandshake::clear_credentials() { - if (credentials_ != NULL) credentials_->::exec::shared::UserCredentials::Clear(); - clear_has_credentials(); +inline void GetSchemasReq::clear_catalog_name_filter() { + if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_catalog_name_filter(); } -inline const ::exec::shared::UserCredentials& UserToBitHandshake::credentials() const { - return credentials_ != NULL ? *credentials_ : *default_instance_->credentials_; +inline const ::exec::user::LikeFilter& GetSchemasReq::catalog_name_filter() const { + return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; } -inline ::exec::shared::UserCredentials* UserToBitHandshake::mutable_credentials() { - set_has_credentials(); - if (credentials_ == NULL) credentials_ = new ::exec::shared::UserCredentials; - return credentials_; +inline ::exec::user::LikeFilter* GetSchemasReq::mutable_catalog_name_filter() { + set_has_catalog_name_filter(); + if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; + return catalog_name_filter_; } -inline ::exec::shared::UserCredentials* UserToBitHandshake::release_credentials() { - clear_has_credentials(); - ::exec::shared::UserCredentials* temp = credentials_; - credentials_ = NULL; +inline ::exec::user::LikeFilter* GetSchemasReq::release_catalog_name_filter() { + clear_has_catalog_name_filter(); + ::exec::user::LikeFilter* temp = catalog_name_filter_; + catalog_name_filter_ = NULL; return temp; } -inline void UserToBitHandshake::set_allocated_credentials(::exec::shared::UserCredentials* credentials) { - delete credentials_; - credentials_ = credentials; - if (credentials) { - set_has_credentials(); +inline void GetSchemasReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { + delete catalog_name_filter_; + catalog_name_filter_ = catalog_name_filter; + if (catalog_name_filter) { + set_has_catalog_name_filter(); } else { - clear_has_credentials(); + clear_has_catalog_name_filter(); + } +} + +// optional .exec.user.LikeFilter schema_name_filter = 2; +inline bool GetSchemasReq::has_schema_name_filter() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetSchemasReq::set_has_schema_name_filter() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetSchemasReq::clear_has_schema_name_filter() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetSchemasReq::clear_schema_name_filter() { + if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_schema_name_filter(); +} +inline const ::exec::user::LikeFilter& GetSchemasReq::schema_name_filter() const { + return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_; +} +inline ::exec::user::LikeFilter* GetSchemasReq::mutable_schema_name_filter() { + set_has_schema_name_filter(); + if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter; + return schema_name_filter_; +} +inline ::exec::user::LikeFilter* GetSchemasReq::release_schema_name_filter() { + clear_has_schema_name_filter(); + ::exec::user::LikeFilter* temp = schema_name_filter_; + schema_name_filter_ = NULL; + return temp; +} +inline void GetSchemasReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) { + delete schema_name_filter_; + schema_name_filter_ = schema_name_filter; + if (schema_name_filter) { + set_has_schema_name_filter(); + } else { + clear_has_schema_name_filter(); } } -// optional .exec.user.UserProperties properties = 5; -inline bool UserToBitHandshake::has_properties() const { - return (_has_bits_[0] & 0x00000010u) != 0; +// ------------------------------------------------------------------- + +// SchemaMetadata + +// optional string catalog_name = 1; +inline bool SchemaMetadata::has_catalog_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void UserToBitHandshake::set_has_properties() { - _has_bits_[0] |= 0x00000010u; +inline void SchemaMetadata::set_has_catalog_name() { + _has_bits_[0] |= 0x00000001u; } -inline void UserToBitHandshake::clear_has_properties() { - _has_bits_[0] &= ~0x00000010u; +inline void SchemaMetadata::clear_has_catalog_name() { + _has_bits_[0] &= ~0x00000001u; } -inline void UserToBitHandshake::clear_properties() { - if (properties_ != NULL) properties_->::exec::user::UserProperties::Clear(); - clear_has_properties(); +inline void SchemaMetadata::clear_catalog_name() { + if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { + catalog_name_->clear(); + } + clear_has_catalog_name(); } -inline const ::exec::user::UserProperties& UserToBitHandshake::properties() const { - return properties_ != NULL ? *properties_ : *default_instance_->properties_; +inline const ::std::string& SchemaMetadata::catalog_name() const { + return *catalog_name_; } -inline ::exec::user::UserProperties* UserToBitHandshake::mutable_properties() { - set_has_properties(); - if (properties_ == NULL) properties_ = new ::exec::user::UserProperties; - return properties_; +inline void SchemaMetadata::set_catalog_name(const ::std::string& value) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + catalog_name_->assign(value); } -inline ::exec::user::UserProperties* UserToBitHandshake::release_properties() { - clear_has_properties(); - ::exec::user::UserProperties* temp = properties_; - properties_ = NULL; - return temp; +inline void SchemaMetadata::set_catalog_name(const char* value) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + catalog_name_->assign(value); } -inline void UserToBitHandshake::set_allocated_properties(::exec::user::UserProperties* properties) { - delete properties_; - properties_ = properties; - if (properties) { - set_has_properties(); +inline void SchemaMetadata::set_catalog_name(const char* value, size_t size) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + catalog_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* SchemaMetadata::mutable_catalog_name() { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + return catalog_name_; +} +inline ::std::string* SchemaMetadata::release_catalog_name() { + clear_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; } else { - clear_has_properties(); + ::std::string* temp = catalog_name_; + catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; } } - -// optional bool support_complex_types = 6 [default = false]; -inline bool UserToBitHandshake::has_support_complex_types() const { - return (_has_bits_[0] & 0x00000020u) != 0; +inline void SchemaMetadata::set_allocated_catalog_name(::std::string* catalog_name) { + if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_name_; + } + if (catalog_name) { + set_has_catalog_name(); + catalog_name_ = catalog_name; + } else { + clear_has_catalog_name(); + catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -inline void UserToBitHandshake::set_has_support_complex_types() { - _has_bits_[0] |= 0x00000020u; + +// optional string schema_name = 2; +inline bool SchemaMetadata::has_schema_name() const { + return (_has_bits_[0] & 0x00000002u) != 0; } -inline void UserToBitHandshake::clear_has_support_complex_types() { - _has_bits_[0] &= ~0x00000020u; +inline void SchemaMetadata::set_has_schema_name() { + _has_bits_[0] |= 0x00000002u; } -inline void UserToBitHandshake::clear_support_complex_types() { - support_complex_types_ = false; - clear_has_support_complex_types(); +inline void SchemaMetadata::clear_has_schema_name() { + _has_bits_[0] &= ~0x00000002u; } -inline bool UserToBitHandshake::support_complex_types() const { - return support_complex_types_; +inline void SchemaMetadata::clear_schema_name() { + if (schema_name_ != &::google::protobuf::internal::kEmptyString) { + schema_name_->clear(); + } + clear_has_schema_name(); } -inline void UserToBitHandshake::set_support_complex_types(bool value) { - set_has_support_complex_types(); - support_complex_types_ = value; +inline const ::std::string& SchemaMetadata::schema_name() const { + return *schema_name_; } - -// optional bool support_timeout = 7 [default = false]; -inline bool UserToBitHandshake::has_support_timeout() const { - return (_has_bits_[0] & 0x00000040u) != 0; +inline void SchemaMetadata::set_schema_name(const ::std::string& value) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + schema_name_->assign(value); } -inline void UserToBitHandshake::set_has_support_timeout() { - _has_bits_[0] |= 0x00000040u; +inline void SchemaMetadata::set_schema_name(const char* value) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + schema_name_->assign(value); } -inline void UserToBitHandshake::clear_has_support_timeout() { - _has_bits_[0] &= ~0x00000040u; +inline void SchemaMetadata::set_schema_name(const char* value, size_t size) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + schema_name_->assign(reinterpret_cast(value), size); } -inline void UserToBitHandshake::clear_support_timeout() { - support_timeout_ = false; - clear_has_support_timeout(); +inline ::std::string* SchemaMetadata::mutable_schema_name() { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + return schema_name_; } -inline bool UserToBitHandshake::support_timeout() const { - return support_timeout_; +inline ::std::string* SchemaMetadata::release_schema_name() { + clear_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = schema_name_; + schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } } -inline void UserToBitHandshake::set_support_timeout(bool value) { - set_has_support_timeout(); - support_timeout_ = value; +inline void SchemaMetadata::set_allocated_schema_name(::std::string* schema_name) { + if (schema_name_ != &::google::protobuf::internal::kEmptyString) { + delete schema_name_; + } + if (schema_name) { + set_has_schema_name(); + schema_name_ = schema_name; + } else { + clear_has_schema_name(); + schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional .exec.user.RpcEndpointInfos client_infos = 8; -inline bool UserToBitHandshake::has_client_infos() const { - return (_has_bits_[0] & 0x00000080u) != 0; +// optional string owner = 3; +inline bool SchemaMetadata::has_owner() const { + return (_has_bits_[0] & 0x00000004u) != 0; } -inline void UserToBitHandshake::set_has_client_infos() { - _has_bits_[0] |= 0x00000080u; +inline void SchemaMetadata::set_has_owner() { + _has_bits_[0] |= 0x00000004u; } -inline void UserToBitHandshake::clear_has_client_infos() { - _has_bits_[0] &= ~0x00000080u; +inline void SchemaMetadata::clear_has_owner() { + _has_bits_[0] &= ~0x00000004u; } -inline void UserToBitHandshake::clear_client_infos() { - if (client_infos_ != NULL) client_infos_->::exec::user::RpcEndpointInfos::Clear(); - clear_has_client_infos(); +inline void SchemaMetadata::clear_owner() { + if (owner_ != &::google::protobuf::internal::kEmptyString) { + owner_->clear(); + } + clear_has_owner(); } -inline const ::exec::user::RpcEndpointInfos& UserToBitHandshake::client_infos() const { - return client_infos_ != NULL ? *client_infos_ : *default_instance_->client_infos_; +inline const ::std::string& SchemaMetadata::owner() const { + return *owner_; } -inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::mutable_client_infos() { - set_has_client_infos(); - if (client_infos_ == NULL) client_infos_ = new ::exec::user::RpcEndpointInfos; - return client_infos_; +inline void SchemaMetadata::set_owner(const ::std::string& value) { + set_has_owner(); + if (owner_ == &::google::protobuf::internal::kEmptyString) { + owner_ = new ::std::string; + } + owner_->assign(value); } -inline ::exec::user::RpcEndpointInfos* UserToBitHandshake::release_client_infos() { - clear_has_client_infos(); - ::exec::user::RpcEndpointInfos* temp = client_infos_; - client_infos_ = NULL; - return temp; +inline void SchemaMetadata::set_owner(const char* value) { + set_has_owner(); + if (owner_ == &::google::protobuf::internal::kEmptyString) { + owner_ = new ::std::string; + } + owner_->assign(value); } -inline void UserToBitHandshake::set_allocated_client_infos(::exec::user::RpcEndpointInfos* client_infos) { - delete client_infos_; - client_infos_ = client_infos; - if (client_infos) { - set_has_client_infos(); +inline void SchemaMetadata::set_owner(const char* value, size_t size) { + set_has_owner(); + if (owner_ == &::google::protobuf::internal::kEmptyString) { + owner_ = new ::std::string; + } + owner_->assign(reinterpret_cast(value), size); +} +inline ::std::string* SchemaMetadata::mutable_owner() { + set_has_owner(); + if (owner_ == &::google::protobuf::internal::kEmptyString) { + owner_ = new ::std::string; + } + return owner_; +} +inline ::std::string* SchemaMetadata::release_owner() { + clear_has_owner(); + if (owner_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = owner_; + owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void SchemaMetadata::set_allocated_owner(::std::string* owner) { + if (owner_ != &::google::protobuf::internal::kEmptyString) { + delete owner_; + } + if (owner) { + set_has_owner(); + owner_ = owner; } else { - clear_has_client_infos(); + clear_has_owner(); + owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional .exec.user.SaslSupport sasl_support = 9; -inline bool UserToBitHandshake::has_sasl_support() const { - return (_has_bits_[0] & 0x00000100u) != 0; -} -inline void UserToBitHandshake::set_has_sasl_support() { - _has_bits_[0] |= 0x00000100u; -} -inline void UserToBitHandshake::clear_has_sasl_support() { - _has_bits_[0] &= ~0x00000100u; -} -inline void UserToBitHandshake::clear_sasl_support() { - sasl_support_ = 0; - clear_has_sasl_support(); -} -inline ::exec::user::SaslSupport UserToBitHandshake::sasl_support() const { - return static_cast< ::exec::user::SaslSupport >(sasl_support_); +// optional string type = 4; +inline bool SchemaMetadata::has_type() const { + return (_has_bits_[0] & 0x00000008u) != 0; } -inline void UserToBitHandshake::set_sasl_support(::exec::user::SaslSupport value) { - assert(::exec::user::SaslSupport_IsValid(value)); - set_has_sasl_support(); - sasl_support_ = value; +inline void SchemaMetadata::set_has_type() { + _has_bits_[0] |= 0x00000008u; } - -// ------------------------------------------------------------------- - -// RequestResults - -// optional .exec.shared.QueryId query_id = 1; -inline bool RequestResults::has_query_id() const { - return (_has_bits_[0] & 0x00000001u) != 0; +inline void SchemaMetadata::clear_has_type() { + _has_bits_[0] &= ~0x00000008u; } -inline void RequestResults::set_has_query_id() { - _has_bits_[0] |= 0x00000001u; +inline void SchemaMetadata::clear_type() { + if (type_ != &::google::protobuf::internal::kEmptyString) { + type_->clear(); + } + clear_has_type(); } -inline void RequestResults::clear_has_query_id() { - _has_bits_[0] &= ~0x00000001u; +inline const ::std::string& SchemaMetadata::type() const { + return *type_; } -inline void RequestResults::clear_query_id() { - if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear(); - clear_has_query_id(); +inline void SchemaMetadata::set_type(const ::std::string& value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; + } + type_->assign(value); } -inline const ::exec::shared::QueryId& RequestResults::query_id() const { - return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_; +inline void SchemaMetadata::set_type(const char* value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; + } + type_->assign(value); } -inline ::exec::shared::QueryId* RequestResults::mutable_query_id() { - set_has_query_id(); - if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId; - return query_id_; +inline void SchemaMetadata::set_type(const char* value, size_t size) { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; + } + type_->assign(reinterpret_cast(value), size); } -inline ::exec::shared::QueryId* RequestResults::release_query_id() { - clear_has_query_id(); - ::exec::shared::QueryId* temp = query_id_; - query_id_ = NULL; - return temp; +inline ::std::string* SchemaMetadata::mutable_type() { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; + } + return type_; } -inline void RequestResults::set_allocated_query_id(::exec::shared::QueryId* query_id) { - delete query_id_; - query_id_ = query_id; - if (query_id) { - set_has_query_id(); +inline ::std::string* SchemaMetadata::release_type() { + clear_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + return NULL; } else { - clear_has_query_id(); + ::std::string* temp = type_; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; } } - -// optional int32 maximum_responses = 2; -inline bool RequestResults::has_maximum_responses() const { - return (_has_bits_[0] & 0x00000002u) != 0; -} -inline void RequestResults::set_has_maximum_responses() { - _has_bits_[0] |= 0x00000002u; -} -inline void RequestResults::clear_has_maximum_responses() { - _has_bits_[0] &= ~0x00000002u; -} -inline void RequestResults::clear_maximum_responses() { - maximum_responses_ = 0; - clear_has_maximum_responses(); -} -inline ::google::protobuf::int32 RequestResults::maximum_responses() const { - return maximum_responses_; -} -inline void RequestResults::set_maximum_responses(::google::protobuf::int32 value) { - set_has_maximum_responses(); - maximum_responses_ = value; +inline void SchemaMetadata::set_allocated_type(::std::string* type) { + if (type_ != &::google::protobuf::internal::kEmptyString) { + delete type_; + } + if (type) { + set_has_type(); + type_ = type; + } else { + clear_has_type(); + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// ------------------------------------------------------------------- - -// GetQueryPlanFragments - -// required string query = 1; -inline bool GetQueryPlanFragments::has_query() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional string mutable = 5; +inline bool SchemaMetadata::has_mutable_() const { + return (_has_bits_[0] & 0x00000010u) != 0; } -inline void GetQueryPlanFragments::set_has_query() { - _has_bits_[0] |= 0x00000001u; +inline void SchemaMetadata::set_has_mutable_() { + _has_bits_[0] |= 0x00000010u; } -inline void GetQueryPlanFragments::clear_has_query() { - _has_bits_[0] &= ~0x00000001u; +inline void SchemaMetadata::clear_has_mutable_() { + _has_bits_[0] &= ~0x00000010u; } -inline void GetQueryPlanFragments::clear_query() { - if (query_ != &::google::protobuf::internal::kEmptyString) { - query_->clear(); +inline void SchemaMetadata::clear_mutable_() { + if (mutable__ != &::google::protobuf::internal::kEmptyString) { + mutable__->clear(); } - clear_has_query(); + clear_has_mutable_(); } -inline const ::std::string& GetQueryPlanFragments::query() const { - return *query_; +inline const ::std::string& SchemaMetadata::mutable_() const { + return *mutable__; } -inline void GetQueryPlanFragments::set_query(const ::std::string& value) { - set_has_query(); - if (query_ == &::google::protobuf::internal::kEmptyString) { - query_ = new ::std::string; +inline void SchemaMetadata::set_mutable_(const ::std::string& value) { + set_has_mutable_(); + if (mutable__ == &::google::protobuf::internal::kEmptyString) { + mutable__ = new ::std::string; } - query_->assign(value); + mutable__->assign(value); } -inline void GetQueryPlanFragments::set_query(const char* value) { - set_has_query(); - if (query_ == &::google::protobuf::internal::kEmptyString) { - query_ = new ::std::string; +inline void SchemaMetadata::set_mutable_(const char* value) { + set_has_mutable_(); + if (mutable__ == &::google::protobuf::internal::kEmptyString) { + mutable__ = new ::std::string; } - query_->assign(value); + mutable__->assign(value); } -inline void GetQueryPlanFragments::set_query(const char* value, size_t size) { - set_has_query(); - if (query_ == &::google::protobuf::internal::kEmptyString) { - query_ = new ::std::string; +inline void SchemaMetadata::set_mutable_(const char* value, size_t size) { + set_has_mutable_(); + if (mutable__ == &::google::protobuf::internal::kEmptyString) { + mutable__ = new ::std::string; } - query_->assign(reinterpret_cast(value), size); + mutable__->assign(reinterpret_cast(value), size); } -inline ::std::string* GetQueryPlanFragments::mutable_query() { - set_has_query(); - if (query_ == &::google::protobuf::internal::kEmptyString) { - query_ = new ::std::string; +inline ::std::string* SchemaMetadata::mutable_mutable_() { + set_has_mutable_(); + if (mutable__ == &::google::protobuf::internal::kEmptyString) { + mutable__ = new ::std::string; } - return query_; + return mutable__; } -inline ::std::string* GetQueryPlanFragments::release_query() { - clear_has_query(); - if (query_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* SchemaMetadata::release_mutable_() { + clear_has_mutable_(); + if (mutable__ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = query_; - query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = mutable__; + mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void GetQueryPlanFragments::set_allocated_query(::std::string* query) { - if (query_ != &::google::protobuf::internal::kEmptyString) { - delete query_; +inline void SchemaMetadata::set_allocated_mutable_(::std::string* mutable_) { + if (mutable__ != &::google::protobuf::internal::kEmptyString) { + delete mutable__; } - if (query) { - set_has_query(); - query_ = query; + if (mutable_) { + set_has_mutable_(); + mutable__ = mutable_; } else { - clear_has_query(); - query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_mutable_(); + mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional .exec.shared.QueryType type = 2; -inline bool GetQueryPlanFragments::has_type() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// ------------------------------------------------------------------- + +// GetSchemasResp + +// optional .exec.user.RequestStatus status = 1; +inline bool GetSchemasResp::has_status() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void GetSchemasResp::set_has_status() { + _has_bits_[0] |= 0x00000001u; +} +inline void GetSchemasResp::clear_has_status() { + _has_bits_[0] &= ~0x00000001u; +} +inline void GetSchemasResp::clear_status() { + status_ = 0; + clear_has_status(); +} +inline ::exec::user::RequestStatus GetSchemasResp::status() const { + return static_cast< ::exec::user::RequestStatus >(status_); +} +inline void GetSchemasResp::set_status(::exec::user::RequestStatus value) { + assert(::exec::user::RequestStatus_IsValid(value)); + set_has_status(); + status_ = value; +} + +// repeated .exec.user.SchemaMetadata schemas = 2; +inline int GetSchemasResp::schemas_size() const { + return schemas_.size(); } -inline void GetQueryPlanFragments::set_has_type() { - _has_bits_[0] |= 0x00000002u; +inline void GetSchemasResp::clear_schemas() { + schemas_.Clear(); } -inline void GetQueryPlanFragments::clear_has_type() { - _has_bits_[0] &= ~0x00000002u; +inline const ::exec::user::SchemaMetadata& GetSchemasResp::schemas(int index) const { + return schemas_.Get(index); } -inline void GetQueryPlanFragments::clear_type() { - type_ = 1; - clear_has_type(); +inline ::exec::user::SchemaMetadata* GetSchemasResp::mutable_schemas(int index) { + return schemas_.Mutable(index); } -inline ::exec::shared::QueryType GetQueryPlanFragments::type() const { - return static_cast< ::exec::shared::QueryType >(type_); +inline ::exec::user::SchemaMetadata* GetSchemasResp::add_schemas() { + return schemas_.Add(); } -inline void GetQueryPlanFragments::set_type(::exec::shared::QueryType value) { - assert(::exec::shared::QueryType_IsValid(value)); - set_has_type(); - type_ = value; +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >& +GetSchemasResp::schemas() const { + return schemas_; +} +inline ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >* +GetSchemasResp::mutable_schemas() { + return &schemas_; } -// optional bool split_plan = 3 [default = false]; -inline bool GetQueryPlanFragments::has_split_plan() const { +// optional .exec.shared.DrillPBError error = 3; +inline bool GetSchemasResp::has_error() const { return (_has_bits_[0] & 0x00000004u) != 0; } -inline void GetQueryPlanFragments::set_has_split_plan() { +inline void GetSchemasResp::set_has_error() { _has_bits_[0] |= 0x00000004u; } -inline void GetQueryPlanFragments::clear_has_split_plan() { +inline void GetSchemasResp::clear_has_error() { _has_bits_[0] &= ~0x00000004u; } -inline void GetQueryPlanFragments::clear_split_plan() { - split_plan_ = false; - clear_has_split_plan(); +inline void GetSchemasResp::clear_error() { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + clear_has_error(); } -inline bool GetQueryPlanFragments::split_plan() const { - return split_plan_; +inline const ::exec::shared::DrillPBError& GetSchemasResp::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; } -inline void GetQueryPlanFragments::set_split_plan(bool value) { - set_has_split_plan(); - split_plan_ = value; +inline ::exec::shared::DrillPBError* GetSchemasResp::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; + return error_; +} +inline ::exec::shared::DrillPBError* GetSchemasResp::release_error() { + clear_has_error(); + ::exec::shared::DrillPBError* temp = error_; + error_ = NULL; + return temp; +} +inline void GetSchemasResp::set_allocated_error(::exec::shared::DrillPBError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); + } else { + clear_has_error(); + } } // ------------------------------------------------------------------- -// QueryPlanFragments +// GetTablesReq -// required .exec.shared.QueryResult.QueryState status = 1; -inline bool QueryPlanFragments::has_status() const { +// optional .exec.user.LikeFilter catalog_name_filter = 1; +inline bool GetTablesReq::has_catalog_name_filter() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void QueryPlanFragments::set_has_status() { +inline void GetTablesReq::set_has_catalog_name_filter() { _has_bits_[0] |= 0x00000001u; } -inline void QueryPlanFragments::clear_has_status() { +inline void GetTablesReq::clear_has_catalog_name_filter() { _has_bits_[0] &= ~0x00000001u; } -inline void QueryPlanFragments::clear_status() { - status_ = 0; - clear_has_status(); +inline void GetTablesReq::clear_catalog_name_filter() { + if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_catalog_name_filter(); } -inline ::exec::shared::QueryResult_QueryState QueryPlanFragments::status() const { - return static_cast< ::exec::shared::QueryResult_QueryState >(status_); +inline const ::exec::user::LikeFilter& GetTablesReq::catalog_name_filter() const { + return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; } -inline void QueryPlanFragments::set_status(::exec::shared::QueryResult_QueryState value) { - assert(::exec::shared::QueryResult_QueryState_IsValid(value)); - set_has_status(); - status_ = value; +inline ::exec::user::LikeFilter* GetTablesReq::mutable_catalog_name_filter() { + set_has_catalog_name_filter(); + if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; + return catalog_name_filter_; +} +inline ::exec::user::LikeFilter* GetTablesReq::release_catalog_name_filter() { + clear_has_catalog_name_filter(); + ::exec::user::LikeFilter* temp = catalog_name_filter_; + catalog_name_filter_ = NULL; + return temp; +} +inline void GetTablesReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { + delete catalog_name_filter_; + catalog_name_filter_ = catalog_name_filter; + if (catalog_name_filter) { + set_has_catalog_name_filter(); + } else { + clear_has_catalog_name_filter(); + } } -// optional .exec.shared.QueryId query_id = 2; -inline bool QueryPlanFragments::has_query_id() const { +// optional .exec.user.LikeFilter schema_name_filter = 2; +inline bool GetTablesReq::has_schema_name_filter() const { return (_has_bits_[0] & 0x00000002u) != 0; } -inline void QueryPlanFragments::set_has_query_id() { +inline void GetTablesReq::set_has_schema_name_filter() { _has_bits_[0] |= 0x00000002u; } -inline void QueryPlanFragments::clear_has_query_id() { +inline void GetTablesReq::clear_has_schema_name_filter() { _has_bits_[0] &= ~0x00000002u; } -inline void QueryPlanFragments::clear_query_id() { - if (query_id_ != NULL) query_id_->::exec::shared::QueryId::Clear(); - clear_has_query_id(); +inline void GetTablesReq::clear_schema_name_filter() { + if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_schema_name_filter(); } -inline const ::exec::shared::QueryId& QueryPlanFragments::query_id() const { - return query_id_ != NULL ? *query_id_ : *default_instance_->query_id_; +inline const ::exec::user::LikeFilter& GetTablesReq::schema_name_filter() const { + return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_; } -inline ::exec::shared::QueryId* QueryPlanFragments::mutable_query_id() { - set_has_query_id(); - if (query_id_ == NULL) query_id_ = new ::exec::shared::QueryId; - return query_id_; +inline ::exec::user::LikeFilter* GetTablesReq::mutable_schema_name_filter() { + set_has_schema_name_filter(); + if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter; + return schema_name_filter_; } -inline ::exec::shared::QueryId* QueryPlanFragments::release_query_id() { - clear_has_query_id(); - ::exec::shared::QueryId* temp = query_id_; - query_id_ = NULL; +inline ::exec::user::LikeFilter* GetTablesReq::release_schema_name_filter() { + clear_has_schema_name_filter(); + ::exec::user::LikeFilter* temp = schema_name_filter_; + schema_name_filter_ = NULL; return temp; } -inline void QueryPlanFragments::set_allocated_query_id(::exec::shared::QueryId* query_id) { - delete query_id_; - query_id_ = query_id; - if (query_id) { - set_has_query_id(); +inline void GetTablesReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) { + delete schema_name_filter_; + schema_name_filter_ = schema_name_filter; + if (schema_name_filter) { + set_has_schema_name_filter(); } else { - clear_has_query_id(); + clear_has_schema_name_filter(); } } -// repeated .exec.bit.control.PlanFragment fragments = 3; -inline int QueryPlanFragments::fragments_size() const { - return fragments_.size(); +// optional .exec.user.LikeFilter table_name_filter = 3; +inline bool GetTablesReq::has_table_name_filter() const { + return (_has_bits_[0] & 0x00000004u) != 0; } -inline void QueryPlanFragments::clear_fragments() { - fragments_.Clear(); +inline void GetTablesReq::set_has_table_name_filter() { + _has_bits_[0] |= 0x00000004u; } -inline const ::exec::bit::control::PlanFragment& QueryPlanFragments::fragments(int index) const { - return fragments_.Get(index); +inline void GetTablesReq::clear_has_table_name_filter() { + _has_bits_[0] &= ~0x00000004u; } -inline ::exec::bit::control::PlanFragment* QueryPlanFragments::mutable_fragments(int index) { - return fragments_.Mutable(index); +inline void GetTablesReq::clear_table_name_filter() { + if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_table_name_filter(); } -inline ::exec::bit::control::PlanFragment* QueryPlanFragments::add_fragments() { - return fragments_.Add(); +inline const ::exec::user::LikeFilter& GetTablesReq::table_name_filter() const { + return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_; } -inline const ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >& -QueryPlanFragments::fragments() const { - return fragments_; +inline ::exec::user::LikeFilter* GetTablesReq::mutable_table_name_filter() { + set_has_table_name_filter(); + if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter; + return table_name_filter_; } -inline ::google::protobuf::RepeatedPtrField< ::exec::bit::control::PlanFragment >* -QueryPlanFragments::mutable_fragments() { - return &fragments_; +inline ::exec::user::LikeFilter* GetTablesReq::release_table_name_filter() { + clear_has_table_name_filter(); + ::exec::user::LikeFilter* temp = table_name_filter_; + table_name_filter_ = NULL; + return temp; +} +inline void GetTablesReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) { + delete table_name_filter_; + table_name_filter_ = table_name_filter; + if (table_name_filter) { + set_has_table_name_filter(); + } else { + clear_has_table_name_filter(); + } } -// optional .exec.shared.DrillPBError error = 4; -inline bool QueryPlanFragments::has_error() const { - return (_has_bits_[0] & 0x00000008u) != 0; +// repeated string table_type_filter = 4; +inline int GetTablesReq::table_type_filter_size() const { + return table_type_filter_.size(); } -inline void QueryPlanFragments::set_has_error() { - _has_bits_[0] |= 0x00000008u; +inline void GetTablesReq::clear_table_type_filter() { + table_type_filter_.Clear(); } -inline void QueryPlanFragments::clear_has_error() { - _has_bits_[0] &= ~0x00000008u; +inline const ::std::string& GetTablesReq::table_type_filter(int index) const { + return table_type_filter_.Get(index); } -inline void QueryPlanFragments::clear_error() { - if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); - clear_has_error(); +inline ::std::string* GetTablesReq::mutable_table_type_filter(int index) { + return table_type_filter_.Mutable(index); } -inline const ::exec::shared::DrillPBError& QueryPlanFragments::error() const { - return error_ != NULL ? *error_ : *default_instance_->error_; +inline void GetTablesReq::set_table_type_filter(int index, const ::std::string& value) { + table_type_filter_.Mutable(index)->assign(value); } -inline ::exec::shared::DrillPBError* QueryPlanFragments::mutable_error() { - set_has_error(); - if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; - return error_; +inline void GetTablesReq::set_table_type_filter(int index, const char* value) { + table_type_filter_.Mutable(index)->assign(value); +} +inline void GetTablesReq::set_table_type_filter(int index, const char* value, size_t size) { + table_type_filter_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* GetTablesReq::add_table_type_filter() { + return table_type_filter_.Add(); +} +inline void GetTablesReq::add_table_type_filter(const ::std::string& value) { + table_type_filter_.Add()->assign(value); +} +inline void GetTablesReq::add_table_type_filter(const char* value) { + table_type_filter_.Add()->assign(value); } -inline ::exec::shared::DrillPBError* QueryPlanFragments::release_error() { - clear_has_error(); - ::exec::shared::DrillPBError* temp = error_; - error_ = NULL; - return temp; +inline void GetTablesReq::add_table_type_filter(const char* value, size_t size) { + table_type_filter_.Add()->assign(reinterpret_cast(value), size); } -inline void QueryPlanFragments::set_allocated_error(::exec::shared::DrillPBError* error) { - delete error_; - error_ = error; - if (error) { - set_has_error(); - } else { - clear_has_error(); - } +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +GetTablesReq::table_type_filter() const { + return table_type_filter_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +GetTablesReq::mutable_table_type_filter() { + return &table_type_filter_; } // ------------------------------------------------------------------- -// BitToUserHandshake +// TableMetadata -// optional int32 rpc_version = 2; -inline bool BitToUserHandshake::has_rpc_version() const { +// optional string catalog_name = 1; +inline bool TableMetadata::has_catalog_name() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void BitToUserHandshake::set_has_rpc_version() { +inline void TableMetadata::set_has_catalog_name() { _has_bits_[0] |= 0x00000001u; } -inline void BitToUserHandshake::clear_has_rpc_version() { +inline void TableMetadata::clear_has_catalog_name() { _has_bits_[0] &= ~0x00000001u; } -inline void BitToUserHandshake::clear_rpc_version() { - rpc_version_ = 0; - clear_has_rpc_version(); +inline void TableMetadata::clear_catalog_name() { + if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { + catalog_name_->clear(); + } + clear_has_catalog_name(); } -inline ::google::protobuf::int32 BitToUserHandshake::rpc_version() const { - return rpc_version_; +inline const ::std::string& TableMetadata::catalog_name() const { + return *catalog_name_; } -inline void BitToUserHandshake::set_rpc_version(::google::protobuf::int32 value) { - set_has_rpc_version(); - rpc_version_ = value; +inline void TableMetadata::set_catalog_name(const ::std::string& value) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + catalog_name_->assign(value); +} +inline void TableMetadata::set_catalog_name(const char* value) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + catalog_name_->assign(value); +} +inline void TableMetadata::set_catalog_name(const char* value, size_t size) { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + catalog_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* TableMetadata::mutable_catalog_name() { + set_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + catalog_name_ = new ::std::string; + } + return catalog_name_; +} +inline ::std::string* TableMetadata::release_catalog_name() { + clear_has_catalog_name(); + if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = catalog_name_; + catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void TableMetadata::set_allocated_catalog_name(::std::string* catalog_name) { + if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_name_; + } + if (catalog_name) { + set_has_catalog_name(); + catalog_name_ = catalog_name; + } else { + clear_has_catalog_name(); + catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional .exec.user.HandshakeStatus status = 3; -inline bool BitToUserHandshake::has_status() const { +// optional string schema_name = 2; +inline bool TableMetadata::has_schema_name() const { return (_has_bits_[0] & 0x00000002u) != 0; } -inline void BitToUserHandshake::set_has_status() { +inline void TableMetadata::set_has_schema_name() { _has_bits_[0] |= 0x00000002u; } -inline void BitToUserHandshake::clear_has_status() { +inline void TableMetadata::clear_has_schema_name() { _has_bits_[0] &= ~0x00000002u; } -inline void BitToUserHandshake::clear_status() { - status_ = 1; - clear_has_status(); +inline void TableMetadata::clear_schema_name() { + if (schema_name_ != &::google::protobuf::internal::kEmptyString) { + schema_name_->clear(); + } + clear_has_schema_name(); } -inline ::exec::user::HandshakeStatus BitToUserHandshake::status() const { - return static_cast< ::exec::user::HandshakeStatus >(status_); +inline const ::std::string& TableMetadata::schema_name() const { + return *schema_name_; } -inline void BitToUserHandshake::set_status(::exec::user::HandshakeStatus value) { - assert(::exec::user::HandshakeStatus_IsValid(value)); - set_has_status(); - status_ = value; +inline void TableMetadata::set_schema_name(const ::std::string& value) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + schema_name_->assign(value); +} +inline void TableMetadata::set_schema_name(const char* value) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + schema_name_->assign(value); +} +inline void TableMetadata::set_schema_name(const char* value, size_t size) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + schema_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* TableMetadata::mutable_schema_name() { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; + } + return schema_name_; +} +inline ::std::string* TableMetadata::release_schema_name() { + clear_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = schema_name_; + schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void TableMetadata::set_allocated_schema_name(::std::string* schema_name) { + if (schema_name_ != &::google::protobuf::internal::kEmptyString) { + delete schema_name_; + } + if (schema_name) { + set_has_schema_name(); + schema_name_ = schema_name; + } else { + clear_has_schema_name(); + schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional string errorId = 4; -inline bool BitToUserHandshake::has_errorid() const { +// optional string table_name = 3; +inline bool TableMetadata::has_table_name() const { return (_has_bits_[0] & 0x00000004u) != 0; } -inline void BitToUserHandshake::set_has_errorid() { +inline void TableMetadata::set_has_table_name() { _has_bits_[0] |= 0x00000004u; } -inline void BitToUserHandshake::clear_has_errorid() { +inline void TableMetadata::clear_has_table_name() { _has_bits_[0] &= ~0x00000004u; } -inline void BitToUserHandshake::clear_errorid() { - if (errorid_ != &::google::protobuf::internal::kEmptyString) { - errorid_->clear(); +inline void TableMetadata::clear_table_name() { + if (table_name_ != &::google::protobuf::internal::kEmptyString) { + table_name_->clear(); } - clear_has_errorid(); + clear_has_table_name(); } -inline const ::std::string& BitToUserHandshake::errorid() const { - return *errorid_; +inline const ::std::string& TableMetadata::table_name() const { + return *table_name_; } -inline void BitToUserHandshake::set_errorid(const ::std::string& value) { - set_has_errorid(); - if (errorid_ == &::google::protobuf::internal::kEmptyString) { - errorid_ = new ::std::string; +inline void TableMetadata::set_table_name(const ::std::string& value) { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - errorid_->assign(value); + table_name_->assign(value); } -inline void BitToUserHandshake::set_errorid(const char* value) { - set_has_errorid(); - if (errorid_ == &::google::protobuf::internal::kEmptyString) { - errorid_ = new ::std::string; +inline void TableMetadata::set_table_name(const char* value) { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - errorid_->assign(value); + table_name_->assign(value); } -inline void BitToUserHandshake::set_errorid(const char* value, size_t size) { - set_has_errorid(); - if (errorid_ == &::google::protobuf::internal::kEmptyString) { - errorid_ = new ::std::string; +inline void TableMetadata::set_table_name(const char* value, size_t size) { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - errorid_->assign(reinterpret_cast(value), size); + table_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* BitToUserHandshake::mutable_errorid() { - set_has_errorid(); - if (errorid_ == &::google::protobuf::internal::kEmptyString) { - errorid_ = new ::std::string; +inline ::std::string* TableMetadata::mutable_table_name() { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - return errorid_; + return table_name_; } -inline ::std::string* BitToUserHandshake::release_errorid() { - clear_has_errorid(); - if (errorid_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* TableMetadata::release_table_name() { + clear_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = errorid_; - errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = table_name_; + table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void BitToUserHandshake::set_allocated_errorid(::std::string* errorid) { - if (errorid_ != &::google::protobuf::internal::kEmptyString) { - delete errorid_; +inline void TableMetadata::set_allocated_table_name(::std::string* table_name) { + if (table_name_ != &::google::protobuf::internal::kEmptyString) { + delete table_name_; } - if (errorid) { - set_has_errorid(); - errorid_ = errorid; - } else { - clear_has_errorid(); - errorid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + if (table_name) { + set_has_table_name(); + table_name_ = table_name; + } else { + clear_has_table_name(); + table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string errorMessage = 5; -inline bool BitToUserHandshake::has_errormessage() const { +// optional string type = 4; +inline bool TableMetadata::has_type() const { return (_has_bits_[0] & 0x00000008u) != 0; } -inline void BitToUserHandshake::set_has_errormessage() { +inline void TableMetadata::set_has_type() { _has_bits_[0] |= 0x00000008u; } -inline void BitToUserHandshake::clear_has_errormessage() { +inline void TableMetadata::clear_has_type() { _has_bits_[0] &= ~0x00000008u; } -inline void BitToUserHandshake::clear_errormessage() { - if (errormessage_ != &::google::protobuf::internal::kEmptyString) { - errormessage_->clear(); +inline void TableMetadata::clear_type() { + if (type_ != &::google::protobuf::internal::kEmptyString) { + type_->clear(); } - clear_has_errormessage(); + clear_has_type(); } -inline const ::std::string& BitToUserHandshake::errormessage() const { - return *errormessage_; +inline const ::std::string& TableMetadata::type() const { + return *type_; } -inline void BitToUserHandshake::set_errormessage(const ::std::string& value) { - set_has_errormessage(); - if (errormessage_ == &::google::protobuf::internal::kEmptyString) { - errormessage_ = new ::std::string; +inline void TableMetadata::set_type(const ::std::string& value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; } - errormessage_->assign(value); + type_->assign(value); } -inline void BitToUserHandshake::set_errormessage(const char* value) { - set_has_errormessage(); - if (errormessage_ == &::google::protobuf::internal::kEmptyString) { - errormessage_ = new ::std::string; +inline void TableMetadata::set_type(const char* value) { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; } - errormessage_->assign(value); + type_->assign(value); } -inline void BitToUserHandshake::set_errormessage(const char* value, size_t size) { - set_has_errormessage(); - if (errormessage_ == &::google::protobuf::internal::kEmptyString) { - errormessage_ = new ::std::string; +inline void TableMetadata::set_type(const char* value, size_t size) { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; } - errormessage_->assign(reinterpret_cast(value), size); + type_->assign(reinterpret_cast(value), size); } -inline ::std::string* BitToUserHandshake::mutable_errormessage() { - set_has_errormessage(); - if (errormessage_ == &::google::protobuf::internal::kEmptyString) { - errormessage_ = new ::std::string; +inline ::std::string* TableMetadata::mutable_type() { + set_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { + type_ = new ::std::string; } - return errormessage_; + return type_; } -inline ::std::string* BitToUserHandshake::release_errormessage() { - clear_has_errormessage(); - if (errormessage_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* TableMetadata::release_type() { + clear_has_type(); + if (type_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = errormessage_; - errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = type_; + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void BitToUserHandshake::set_allocated_errormessage(::std::string* errormessage) { - if (errormessage_ != &::google::protobuf::internal::kEmptyString) { - delete errormessage_; - } - if (errormessage) { - set_has_errormessage(); - errormessage_ = errormessage; - } else { - clear_has_errormessage(); - errormessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); +inline void TableMetadata::set_allocated_type(::std::string* type) { + if (type_ != &::google::protobuf::internal::kEmptyString) { + delete type_; } -} - -// optional .exec.user.RpcEndpointInfos server_infos = 6; -inline bool BitToUserHandshake::has_server_infos() const { - return (_has_bits_[0] & 0x00000010u) != 0; -} -inline void BitToUserHandshake::set_has_server_infos() { - _has_bits_[0] |= 0x00000010u; -} -inline void BitToUserHandshake::clear_has_server_infos() { - _has_bits_[0] &= ~0x00000010u; -} -inline void BitToUserHandshake::clear_server_infos() { - if (server_infos_ != NULL) server_infos_->::exec::user::RpcEndpointInfos::Clear(); - clear_has_server_infos(); -} -inline const ::exec::user::RpcEndpointInfos& BitToUserHandshake::server_infos() const { - return server_infos_ != NULL ? *server_infos_ : *default_instance_->server_infos_; -} -inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::mutable_server_infos() { - set_has_server_infos(); - if (server_infos_ == NULL) server_infos_ = new ::exec::user::RpcEndpointInfos; - return server_infos_; -} -inline ::exec::user::RpcEndpointInfos* BitToUserHandshake::release_server_infos() { - clear_has_server_infos(); - ::exec::user::RpcEndpointInfos* temp = server_infos_; - server_infos_ = NULL; - return temp; -} -inline void BitToUserHandshake::set_allocated_server_infos(::exec::user::RpcEndpointInfos* server_infos) { - delete server_infos_; - server_infos_ = server_infos; - if (server_infos) { - set_has_server_infos(); + if (type) { + set_has_type(); + type_ = type; } else { - clear_has_server_infos(); + clear_has_type(); + type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// repeated string authenticationMechanisms = 7; -inline int BitToUserHandshake::authenticationmechanisms_size() const { - return authenticationmechanisms_.size(); -} -inline void BitToUserHandshake::clear_authenticationmechanisms() { - authenticationmechanisms_.Clear(); -} -inline const ::std::string& BitToUserHandshake::authenticationmechanisms(int index) const { - return authenticationmechanisms_.Get(index); -} -inline ::std::string* BitToUserHandshake::mutable_authenticationmechanisms(int index) { - return authenticationmechanisms_.Mutable(index); -} -inline void BitToUserHandshake::set_authenticationmechanisms(int index, const ::std::string& value) { - authenticationmechanisms_.Mutable(index)->assign(value); -} -inline void BitToUserHandshake::set_authenticationmechanisms(int index, const char* value) { - authenticationmechanisms_.Mutable(index)->assign(value); -} -inline void BitToUserHandshake::set_authenticationmechanisms(int index, const char* value, size_t size) { - authenticationmechanisms_.Mutable(index)->assign( - reinterpret_cast(value), size); -} -inline ::std::string* BitToUserHandshake::add_authenticationmechanisms() { - return authenticationmechanisms_.Add(); -} -inline void BitToUserHandshake::add_authenticationmechanisms(const ::std::string& value) { - authenticationmechanisms_.Add()->assign(value); -} -inline void BitToUserHandshake::add_authenticationmechanisms(const char* value) { - authenticationmechanisms_.Add()->assign(value); -} -inline void BitToUserHandshake::add_authenticationmechanisms(const char* value, size_t size) { - authenticationmechanisms_.Add()->assign(reinterpret_cast(value), size); -} -inline const ::google::protobuf::RepeatedPtrField< ::std::string>& -BitToUserHandshake::authenticationmechanisms() const { - return authenticationmechanisms_; -} -inline ::google::protobuf::RepeatedPtrField< ::std::string>* -BitToUserHandshake::mutable_authenticationmechanisms() { - return &authenticationmechanisms_; -} - -// repeated .exec.user.RpcType supported_methods = 8; -inline int BitToUserHandshake::supported_methods_size() const { - return supported_methods_.size(); -} -inline void BitToUserHandshake::clear_supported_methods() { - supported_methods_.Clear(); -} -inline ::exec::user::RpcType BitToUserHandshake::supported_methods(int index) const { - return static_cast< ::exec::user::RpcType >(supported_methods_.Get(index)); -} -inline void BitToUserHandshake::set_supported_methods(int index, ::exec::user::RpcType value) { - assert(::exec::user::RpcType_IsValid(value)); - supported_methods_.Set(index, value); -} -inline void BitToUserHandshake::add_supported_methods(::exec::user::RpcType value) { - assert(::exec::user::RpcType_IsValid(value)); - supported_methods_.Add(value); -} -inline const ::google::protobuf::RepeatedField& -BitToUserHandshake::supported_methods() const { - return supported_methods_; -} -inline ::google::protobuf::RepeatedField* -BitToUserHandshake::mutable_supported_methods() { - return &supported_methods_; -} - // ------------------------------------------------------------------- -// LikeFilter +// GetTablesResp -// optional string pattern = 1; -inline bool LikeFilter::has_pattern() const { +// optional .exec.user.RequestStatus status = 1; +inline bool GetTablesResp::has_status() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void LikeFilter::set_has_pattern() { +inline void GetTablesResp::set_has_status() { _has_bits_[0] |= 0x00000001u; } -inline void LikeFilter::clear_has_pattern() { +inline void GetTablesResp::clear_has_status() { _has_bits_[0] &= ~0x00000001u; } -inline void LikeFilter::clear_pattern() { - if (pattern_ != &::google::protobuf::internal::kEmptyString) { - pattern_->clear(); - } - clear_has_pattern(); -} -inline const ::std::string& LikeFilter::pattern() const { - return *pattern_; -} -inline void LikeFilter::set_pattern(const ::std::string& value) { - set_has_pattern(); - if (pattern_ == &::google::protobuf::internal::kEmptyString) { - pattern_ = new ::std::string; - } - pattern_->assign(value); -} -inline void LikeFilter::set_pattern(const char* value) { - set_has_pattern(); - if (pattern_ == &::google::protobuf::internal::kEmptyString) { - pattern_ = new ::std::string; - } - pattern_->assign(value); -} -inline void LikeFilter::set_pattern(const char* value, size_t size) { - set_has_pattern(); - if (pattern_ == &::google::protobuf::internal::kEmptyString) { - pattern_ = new ::std::string; - } - pattern_->assign(reinterpret_cast(value), size); -} -inline ::std::string* LikeFilter::mutable_pattern() { - set_has_pattern(); - if (pattern_ == &::google::protobuf::internal::kEmptyString) { - pattern_ = new ::std::string; - } - return pattern_; +inline void GetTablesResp::clear_status() { + status_ = 0; + clear_has_status(); } -inline ::std::string* LikeFilter::release_pattern() { - clear_has_pattern(); - if (pattern_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = pattern_; - pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline ::exec::user::RequestStatus GetTablesResp::status() const { + return static_cast< ::exec::user::RequestStatus >(status_); } -inline void LikeFilter::set_allocated_pattern(::std::string* pattern) { - if (pattern_ != &::google::protobuf::internal::kEmptyString) { - delete pattern_; - } - if (pattern) { - set_has_pattern(); - pattern_ = pattern; - } else { - clear_has_pattern(); - pattern_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline void GetTablesResp::set_status(::exec::user::RequestStatus value) { + assert(::exec::user::RequestStatus_IsValid(value)); + set_has_status(); + status_ = value; } -// optional string escape = 2; -inline bool LikeFilter::has_escape() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// repeated .exec.user.TableMetadata tables = 2; +inline int GetTablesResp::tables_size() const { + return tables_.size(); } -inline void LikeFilter::set_has_escape() { - _has_bits_[0] |= 0x00000002u; +inline void GetTablesResp::clear_tables() { + tables_.Clear(); } -inline void LikeFilter::clear_has_escape() { - _has_bits_[0] &= ~0x00000002u; +inline const ::exec::user::TableMetadata& GetTablesResp::tables(int index) const { + return tables_.Get(index); } -inline void LikeFilter::clear_escape() { - if (escape_ != &::google::protobuf::internal::kEmptyString) { - escape_->clear(); - } - clear_has_escape(); +inline ::exec::user::TableMetadata* GetTablesResp::mutable_tables(int index) { + return tables_.Mutable(index); } -inline const ::std::string& LikeFilter::escape() const { - return *escape_; +inline ::exec::user::TableMetadata* GetTablesResp::add_tables() { + return tables_.Add(); } -inline void LikeFilter::set_escape(const ::std::string& value) { - set_has_escape(); - if (escape_ == &::google::protobuf::internal::kEmptyString) { - escape_ = new ::std::string; - } - escape_->assign(value); +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >& +GetTablesResp::tables() const { + return tables_; } -inline void LikeFilter::set_escape(const char* value) { - set_has_escape(); - if (escape_ == &::google::protobuf::internal::kEmptyString) { - escape_ = new ::std::string; - } - escape_->assign(value); +inline ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >* +GetTablesResp::mutable_tables() { + return &tables_; } -inline void LikeFilter::set_escape(const char* value, size_t size) { - set_has_escape(); - if (escape_ == &::google::protobuf::internal::kEmptyString) { - escape_ = new ::std::string; - } - escape_->assign(reinterpret_cast(value), size); + +// optional .exec.shared.DrillPBError error = 3; +inline bool GetTablesResp::has_error() const { + return (_has_bits_[0] & 0x00000004u) != 0; } -inline ::std::string* LikeFilter::mutable_escape() { - set_has_escape(); - if (escape_ == &::google::protobuf::internal::kEmptyString) { - escape_ = new ::std::string; - } - return escape_; +inline void GetTablesResp::set_has_error() { + _has_bits_[0] |= 0x00000004u; } -inline ::std::string* LikeFilter::release_escape() { - clear_has_escape(); - if (escape_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = escape_; - escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void GetTablesResp::clear_has_error() { + _has_bits_[0] &= ~0x00000004u; } -inline void LikeFilter::set_allocated_escape(::std::string* escape) { - if (escape_ != &::google::protobuf::internal::kEmptyString) { - delete escape_; - } - if (escape) { - set_has_escape(); - escape_ = escape; +inline void GetTablesResp::clear_error() { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + clear_has_error(); +} +inline const ::exec::shared::DrillPBError& GetTablesResp::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; +} +inline ::exec::shared::DrillPBError* GetTablesResp::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; + return error_; +} +inline ::exec::shared::DrillPBError* GetTablesResp::release_error() { + clear_has_error(); + ::exec::shared::DrillPBError* temp = error_; + error_ = NULL; + return temp; +} +inline void GetTablesResp::set_allocated_error(::exec::shared::DrillPBError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); } else { - clear_has_escape(); - escape_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_error(); } } // ------------------------------------------------------------------- -// GetCatalogsReq +// GetColumnsReq // optional .exec.user.LikeFilter catalog_name_filter = 1; -inline bool GetCatalogsReq::has_catalog_name_filter() const { +inline bool GetColumnsReq::has_catalog_name_filter() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void GetCatalogsReq::set_has_catalog_name_filter() { +inline void GetColumnsReq::set_has_catalog_name_filter() { _has_bits_[0] |= 0x00000001u; } -inline void GetCatalogsReq::clear_has_catalog_name_filter() { +inline void GetColumnsReq::clear_has_catalog_name_filter() { _has_bits_[0] &= ~0x00000001u; } -inline void GetCatalogsReq::clear_catalog_name_filter() { +inline void GetColumnsReq::clear_catalog_name_filter() { if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); clear_has_catalog_name_filter(); } -inline const ::exec::user::LikeFilter& GetCatalogsReq::catalog_name_filter() const { +inline const ::exec::user::LikeFilter& GetColumnsReq::catalog_name_filter() const { return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; } -inline ::exec::user::LikeFilter* GetCatalogsReq::mutable_catalog_name_filter() { +inline ::exec::user::LikeFilter* GetColumnsReq::mutable_catalog_name_filter() { set_has_catalog_name_filter(); if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; return catalog_name_filter_; } -inline ::exec::user::LikeFilter* GetCatalogsReq::release_catalog_name_filter() { +inline ::exec::user::LikeFilter* GetColumnsReq::release_catalog_name_filter() { clear_has_catalog_name_filter(); ::exec::user::LikeFilter* temp = catalog_name_filter_; catalog_name_filter_ = NULL; return temp; } -inline void GetCatalogsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { +inline void GetColumnsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { delete catalog_name_filter_; catalog_name_filter_ = catalog_name_filter; if (catalog_name_filter) { @@ -5270,58 +7818,172 @@ inline void GetCatalogsReq::set_allocated_catalog_name_filter(::exec::user::Like } } +// optional .exec.user.LikeFilter schema_name_filter = 2; +inline bool GetColumnsReq::has_schema_name_filter() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetColumnsReq::set_has_schema_name_filter() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetColumnsReq::clear_has_schema_name_filter() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetColumnsReq::clear_schema_name_filter() { + if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_schema_name_filter(); +} +inline const ::exec::user::LikeFilter& GetColumnsReq::schema_name_filter() const { + return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_; +} +inline ::exec::user::LikeFilter* GetColumnsReq::mutable_schema_name_filter() { + set_has_schema_name_filter(); + if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter; + return schema_name_filter_; +} +inline ::exec::user::LikeFilter* GetColumnsReq::release_schema_name_filter() { + clear_has_schema_name_filter(); + ::exec::user::LikeFilter* temp = schema_name_filter_; + schema_name_filter_ = NULL; + return temp; +} +inline void GetColumnsReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) { + delete schema_name_filter_; + schema_name_filter_ = schema_name_filter; + if (schema_name_filter) { + set_has_schema_name_filter(); + } else { + clear_has_schema_name_filter(); + } +} + +// optional .exec.user.LikeFilter table_name_filter = 3; +inline bool GetColumnsReq::has_table_name_filter() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetColumnsReq::set_has_table_name_filter() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetColumnsReq::clear_has_table_name_filter() { + _has_bits_[0] &= ~0x00000004u; +} +inline void GetColumnsReq::clear_table_name_filter() { + if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_table_name_filter(); +} +inline const ::exec::user::LikeFilter& GetColumnsReq::table_name_filter() const { + return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_; +} +inline ::exec::user::LikeFilter* GetColumnsReq::mutable_table_name_filter() { + set_has_table_name_filter(); + if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter; + return table_name_filter_; +} +inline ::exec::user::LikeFilter* GetColumnsReq::release_table_name_filter() { + clear_has_table_name_filter(); + ::exec::user::LikeFilter* temp = table_name_filter_; + table_name_filter_ = NULL; + return temp; +} +inline void GetColumnsReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) { + delete table_name_filter_; + table_name_filter_ = table_name_filter; + if (table_name_filter) { + set_has_table_name_filter(); + } else { + clear_has_table_name_filter(); + } +} + +// optional .exec.user.LikeFilter column_name_filter = 4; +inline bool GetColumnsReq::has_column_name_filter() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void GetColumnsReq::set_has_column_name_filter() { + _has_bits_[0] |= 0x00000008u; +} +inline void GetColumnsReq::clear_has_column_name_filter() { + _has_bits_[0] &= ~0x00000008u; +} +inline void GetColumnsReq::clear_column_name_filter() { + if (column_name_filter_ != NULL) column_name_filter_->::exec::user::LikeFilter::Clear(); + clear_has_column_name_filter(); +} +inline const ::exec::user::LikeFilter& GetColumnsReq::column_name_filter() const { + return column_name_filter_ != NULL ? *column_name_filter_ : *default_instance_->column_name_filter_; +} +inline ::exec::user::LikeFilter* GetColumnsReq::mutable_column_name_filter() { + set_has_column_name_filter(); + if (column_name_filter_ == NULL) column_name_filter_ = new ::exec::user::LikeFilter; + return column_name_filter_; +} +inline ::exec::user::LikeFilter* GetColumnsReq::release_column_name_filter() { + clear_has_column_name_filter(); + ::exec::user::LikeFilter* temp = column_name_filter_; + column_name_filter_ = NULL; + return temp; +} +inline void GetColumnsReq::set_allocated_column_name_filter(::exec::user::LikeFilter* column_name_filter) { + delete column_name_filter_; + column_name_filter_ = column_name_filter; + if (column_name_filter) { + set_has_column_name_filter(); + } else { + clear_has_column_name_filter(); + } +} + // ------------------------------------------------------------------- -// CatalogMetadata +// ColumnMetadata // optional string catalog_name = 1; -inline bool CatalogMetadata::has_catalog_name() const { +inline bool ColumnMetadata::has_catalog_name() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void CatalogMetadata::set_has_catalog_name() { +inline void ColumnMetadata::set_has_catalog_name() { _has_bits_[0] |= 0x00000001u; } -inline void CatalogMetadata::clear_has_catalog_name() { +inline void ColumnMetadata::clear_has_catalog_name() { _has_bits_[0] &= ~0x00000001u; } -inline void CatalogMetadata::clear_catalog_name() { +inline void ColumnMetadata::clear_catalog_name() { if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { catalog_name_->clear(); } clear_has_catalog_name(); } -inline const ::std::string& CatalogMetadata::catalog_name() const { +inline const ::std::string& ColumnMetadata::catalog_name() const { return *catalog_name_; } -inline void CatalogMetadata::set_catalog_name(const ::std::string& value) { +inline void ColumnMetadata::set_catalog_name(const ::std::string& value) { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } catalog_name_->assign(value); } -inline void CatalogMetadata::set_catalog_name(const char* value) { +inline void ColumnMetadata::set_catalog_name(const char* value) { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } catalog_name_->assign(value); } -inline void CatalogMetadata::set_catalog_name(const char* value, size_t size) { +inline void ColumnMetadata::set_catalog_name(const char* value, size_t size) { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } catalog_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* CatalogMetadata::mutable_catalog_name() { +inline ::std::string* ColumnMetadata::mutable_catalog_name() { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } return catalog_name_; } -inline ::std::string* CatalogMetadata::release_catalog_name() { +inline ::std::string* ColumnMetadata::release_catalog_name() { clear_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; @@ -5331,7 +7993,7 @@ inline ::std::string* CatalogMetadata::release_catalog_name() { return temp; } } -inline void CatalogMetadata::set_allocated_catalog_name(::std::string* catalog_name) { +inline void ColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) { if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { delete catalog_name_; } @@ -5344,751 +8006,727 @@ inline void CatalogMetadata::set_allocated_catalog_name(::std::string* catalog_n } } -// optional string description = 2; -inline bool CatalogMetadata::has_description() const { +// optional string schema_name = 2; +inline bool ColumnMetadata::has_schema_name() const { return (_has_bits_[0] & 0x00000002u) != 0; } -inline void CatalogMetadata::set_has_description() { +inline void ColumnMetadata::set_has_schema_name() { _has_bits_[0] |= 0x00000002u; } -inline void CatalogMetadata::clear_has_description() { +inline void ColumnMetadata::clear_has_schema_name() { _has_bits_[0] &= ~0x00000002u; } -inline void CatalogMetadata::clear_description() { - if (description_ != &::google::protobuf::internal::kEmptyString) { - description_->clear(); +inline void ColumnMetadata::clear_schema_name() { + if (schema_name_ != &::google::protobuf::internal::kEmptyString) { + schema_name_->clear(); } - clear_has_description(); + clear_has_schema_name(); } -inline const ::std::string& CatalogMetadata::description() const { - return *description_; +inline const ::std::string& ColumnMetadata::schema_name() const { + return *schema_name_; } -inline void CatalogMetadata::set_description(const ::std::string& value) { - set_has_description(); - if (description_ == &::google::protobuf::internal::kEmptyString) { - description_ = new ::std::string; +inline void ColumnMetadata::set_schema_name(const ::std::string& value) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; } - description_->assign(value); + schema_name_->assign(value); } -inline void CatalogMetadata::set_description(const char* value) { - set_has_description(); - if (description_ == &::google::protobuf::internal::kEmptyString) { - description_ = new ::std::string; +inline void ColumnMetadata::set_schema_name(const char* value) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; } - description_->assign(value); + schema_name_->assign(value); } -inline void CatalogMetadata::set_description(const char* value, size_t size) { - set_has_description(); - if (description_ == &::google::protobuf::internal::kEmptyString) { - description_ = new ::std::string; +inline void ColumnMetadata::set_schema_name(const char* value, size_t size) { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; } - description_->assign(reinterpret_cast(value), size); + schema_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* CatalogMetadata::mutable_description() { - set_has_description(); - if (description_ == &::google::protobuf::internal::kEmptyString) { - description_ = new ::std::string; +inline ::std::string* ColumnMetadata::mutable_schema_name() { + set_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { + schema_name_ = new ::std::string; } - return description_; + return schema_name_; } -inline ::std::string* CatalogMetadata::release_description() { - clear_has_description(); - if (description_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ColumnMetadata::release_schema_name() { + clear_has_schema_name(); + if (schema_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = description_; - description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = schema_name_; + schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void CatalogMetadata::set_allocated_description(::std::string* description) { - if (description_ != &::google::protobuf::internal::kEmptyString) { - delete description_; +inline void ColumnMetadata::set_allocated_schema_name(::std::string* schema_name) { + if (schema_name_ != &::google::protobuf::internal::kEmptyString) { + delete schema_name_; } - if (description) { - set_has_description(); - description_ = description; + if (schema_name) { + set_has_schema_name(); + schema_name_ = schema_name; } else { - clear_has_description(); - description_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_schema_name(); + schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string connect = 3; -inline bool CatalogMetadata::has_connect() const { +// optional string table_name = 3; +inline bool ColumnMetadata::has_table_name() const { return (_has_bits_[0] & 0x00000004u) != 0; } -inline void CatalogMetadata::set_has_connect() { +inline void ColumnMetadata::set_has_table_name() { _has_bits_[0] |= 0x00000004u; } -inline void CatalogMetadata::clear_has_connect() { +inline void ColumnMetadata::clear_has_table_name() { _has_bits_[0] &= ~0x00000004u; } -inline void CatalogMetadata::clear_connect() { - if (connect_ != &::google::protobuf::internal::kEmptyString) { - connect_->clear(); +inline void ColumnMetadata::clear_table_name() { + if (table_name_ != &::google::protobuf::internal::kEmptyString) { + table_name_->clear(); } - clear_has_connect(); + clear_has_table_name(); } -inline const ::std::string& CatalogMetadata::connect() const { - return *connect_; +inline const ::std::string& ColumnMetadata::table_name() const { + return *table_name_; } -inline void CatalogMetadata::set_connect(const ::std::string& value) { - set_has_connect(); - if (connect_ == &::google::protobuf::internal::kEmptyString) { - connect_ = new ::std::string; +inline void ColumnMetadata::set_table_name(const ::std::string& value) { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - connect_->assign(value); + table_name_->assign(value); } -inline void CatalogMetadata::set_connect(const char* value) { - set_has_connect(); - if (connect_ == &::google::protobuf::internal::kEmptyString) { - connect_ = new ::std::string; +inline void ColumnMetadata::set_table_name(const char* value) { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - connect_->assign(value); + table_name_->assign(value); } -inline void CatalogMetadata::set_connect(const char* value, size_t size) { - set_has_connect(); - if (connect_ == &::google::protobuf::internal::kEmptyString) { - connect_ = new ::std::string; +inline void ColumnMetadata::set_table_name(const char* value, size_t size) { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - connect_->assign(reinterpret_cast(value), size); + table_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* CatalogMetadata::mutable_connect() { - set_has_connect(); - if (connect_ == &::google::protobuf::internal::kEmptyString) { - connect_ = new ::std::string; +inline ::std::string* ColumnMetadata::mutable_table_name() { + set_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { + table_name_ = new ::std::string; } - return connect_; + return table_name_; } -inline ::std::string* CatalogMetadata::release_connect() { - clear_has_connect(); - if (connect_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ColumnMetadata::release_table_name() { + clear_has_table_name(); + if (table_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = connect_; - connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = table_name_; + table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void CatalogMetadata::set_allocated_connect(::std::string* connect) { - if (connect_ != &::google::protobuf::internal::kEmptyString) { - delete connect_; +inline void ColumnMetadata::set_allocated_table_name(::std::string* table_name) { + if (table_name_ != &::google::protobuf::internal::kEmptyString) { + delete table_name_; } - if (connect) { - set_has_connect(); - connect_ = connect; + if (table_name) { + set_has_table_name(); + table_name_ = table_name; + } else { + clear_has_table_name(); + table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string column_name = 4; +inline bool ColumnMetadata::has_column_name() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void ColumnMetadata::set_has_column_name() { + _has_bits_[0] |= 0x00000008u; +} +inline void ColumnMetadata::clear_has_column_name() { + _has_bits_[0] &= ~0x00000008u; +} +inline void ColumnMetadata::clear_column_name() { + if (column_name_ != &::google::protobuf::internal::kEmptyString) { + column_name_->clear(); + } + clear_has_column_name(); +} +inline const ::std::string& ColumnMetadata::column_name() const { + return *column_name_; +} +inline void ColumnMetadata::set_column_name(const ::std::string& value) { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; + } + column_name_->assign(value); +} +inline void ColumnMetadata::set_column_name(const char* value) { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; + } + column_name_->assign(value); +} +inline void ColumnMetadata::set_column_name(const char* value, size_t size) { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; + } + column_name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ColumnMetadata::mutable_column_name() { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; + } + return column_name_; +} +inline ::std::string* ColumnMetadata::release_column_name() { + clear_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = column_name_; + column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void ColumnMetadata::set_allocated_column_name(::std::string* column_name) { + if (column_name_ != &::google::protobuf::internal::kEmptyString) { + delete column_name_; + } + if (column_name) { + set_has_column_name(); + column_name_ = column_name; } else { - clear_has_connect(); - connect_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_column_name(); + column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// ------------------------------------------------------------------- - -// GetCatalogsResp - -// optional .exec.user.RequestStatus status = 1; -inline bool GetCatalogsResp::has_status() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional int32 ordinal_position = 5; +inline bool ColumnMetadata::has_ordinal_position() const { + return (_has_bits_[0] & 0x00000010u) != 0; } -inline void GetCatalogsResp::set_has_status() { - _has_bits_[0] |= 0x00000001u; +inline void ColumnMetadata::set_has_ordinal_position() { + _has_bits_[0] |= 0x00000010u; } -inline void GetCatalogsResp::clear_has_status() { - _has_bits_[0] &= ~0x00000001u; +inline void ColumnMetadata::clear_has_ordinal_position() { + _has_bits_[0] &= ~0x00000010u; } -inline void GetCatalogsResp::clear_status() { - status_ = 0; - clear_has_status(); +inline void ColumnMetadata::clear_ordinal_position() { + ordinal_position_ = 0; + clear_has_ordinal_position(); } -inline ::exec::user::RequestStatus GetCatalogsResp::status() const { - return static_cast< ::exec::user::RequestStatus >(status_); +inline ::google::protobuf::int32 ColumnMetadata::ordinal_position() const { + return ordinal_position_; } -inline void GetCatalogsResp::set_status(::exec::user::RequestStatus value) { - assert(::exec::user::RequestStatus_IsValid(value)); - set_has_status(); - status_ = value; +inline void ColumnMetadata::set_ordinal_position(::google::protobuf::int32 value) { + set_has_ordinal_position(); + ordinal_position_ = value; } -// repeated .exec.user.CatalogMetadata catalogs = 2; -inline int GetCatalogsResp::catalogs_size() const { - return catalogs_.size(); -} -inline void GetCatalogsResp::clear_catalogs() { - catalogs_.Clear(); -} -inline const ::exec::user::CatalogMetadata& GetCatalogsResp::catalogs(int index) const { - return catalogs_.Get(index); -} -inline ::exec::user::CatalogMetadata* GetCatalogsResp::mutable_catalogs(int index) { - return catalogs_.Mutable(index); -} -inline ::exec::user::CatalogMetadata* GetCatalogsResp::add_catalogs() { - return catalogs_.Add(); -} -inline const ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >& -GetCatalogsResp::catalogs() const { - return catalogs_; +// optional string default_value = 6; +inline bool ColumnMetadata::has_default_value() const { + return (_has_bits_[0] & 0x00000020u) != 0; } -inline ::google::protobuf::RepeatedPtrField< ::exec::user::CatalogMetadata >* -GetCatalogsResp::mutable_catalogs() { - return &catalogs_; +inline void ColumnMetadata::set_has_default_value() { + _has_bits_[0] |= 0x00000020u; } - -// optional .exec.shared.DrillPBError error = 3; -inline bool GetCatalogsResp::has_error() const { - return (_has_bits_[0] & 0x00000004u) != 0; +inline void ColumnMetadata::clear_has_default_value() { + _has_bits_[0] &= ~0x00000020u; } -inline void GetCatalogsResp::set_has_error() { - _has_bits_[0] |= 0x00000004u; +inline void ColumnMetadata::clear_default_value() { + if (default_value_ != &::google::protobuf::internal::kEmptyString) { + default_value_->clear(); + } + clear_has_default_value(); } -inline void GetCatalogsResp::clear_has_error() { - _has_bits_[0] &= ~0x00000004u; +inline const ::std::string& ColumnMetadata::default_value() const { + return *default_value_; } -inline void GetCatalogsResp::clear_error() { - if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); - clear_has_error(); +inline void ColumnMetadata::set_default_value(const ::std::string& value) { + set_has_default_value(); + if (default_value_ == &::google::protobuf::internal::kEmptyString) { + default_value_ = new ::std::string; + } + default_value_->assign(value); } -inline const ::exec::shared::DrillPBError& GetCatalogsResp::error() const { - return error_ != NULL ? *error_ : *default_instance_->error_; +inline void ColumnMetadata::set_default_value(const char* value) { + set_has_default_value(); + if (default_value_ == &::google::protobuf::internal::kEmptyString) { + default_value_ = new ::std::string; + } + default_value_->assign(value); } -inline ::exec::shared::DrillPBError* GetCatalogsResp::mutable_error() { - set_has_error(); - if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; - return error_; +inline void ColumnMetadata::set_default_value(const char* value, size_t size) { + set_has_default_value(); + if (default_value_ == &::google::protobuf::internal::kEmptyString) { + default_value_ = new ::std::string; + } + default_value_->assign(reinterpret_cast(value), size); } -inline ::exec::shared::DrillPBError* GetCatalogsResp::release_error() { - clear_has_error(); - ::exec::shared::DrillPBError* temp = error_; - error_ = NULL; - return temp; +inline ::std::string* ColumnMetadata::mutable_default_value() { + set_has_default_value(); + if (default_value_ == &::google::protobuf::internal::kEmptyString) { + default_value_ = new ::std::string; + } + return default_value_; } -inline void GetCatalogsResp::set_allocated_error(::exec::shared::DrillPBError* error) { - delete error_; - error_ = error; - if (error) { - set_has_error(); +inline ::std::string* ColumnMetadata::release_default_value() { + clear_has_default_value(); + if (default_value_ == &::google::protobuf::internal::kEmptyString) { + return NULL; } else { - clear_has_error(); + ::std::string* temp = default_value_; + default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; } } - -// ------------------------------------------------------------------- - -// GetSchemasReq - -// optional .exec.user.LikeFilter catalog_name_filter = 1; -inline bool GetSchemasReq::has_catalog_name_filter() const { - return (_has_bits_[0] & 0x00000001u) != 0; -} -inline void GetSchemasReq::set_has_catalog_name_filter() { - _has_bits_[0] |= 0x00000001u; -} -inline void GetSchemasReq::clear_has_catalog_name_filter() { - _has_bits_[0] &= ~0x00000001u; -} -inline void GetSchemasReq::clear_catalog_name_filter() { - if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_catalog_name_filter(); -} -inline const ::exec::user::LikeFilter& GetSchemasReq::catalog_name_filter() const { - return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; -} -inline ::exec::user::LikeFilter* GetSchemasReq::mutable_catalog_name_filter() { - set_has_catalog_name_filter(); - if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; - return catalog_name_filter_; -} -inline ::exec::user::LikeFilter* GetSchemasReq::release_catalog_name_filter() { - clear_has_catalog_name_filter(); - ::exec::user::LikeFilter* temp = catalog_name_filter_; - catalog_name_filter_ = NULL; - return temp; -} -inline void GetSchemasReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { - delete catalog_name_filter_; - catalog_name_filter_ = catalog_name_filter; - if (catalog_name_filter) { - set_has_catalog_name_filter(); +inline void ColumnMetadata::set_allocated_default_value(::std::string* default_value) { + if (default_value_ != &::google::protobuf::internal::kEmptyString) { + delete default_value_; + } + if (default_value) { + set_has_default_value(); + default_value_ = default_value; } else { - clear_has_catalog_name_filter(); + clear_has_default_value(); + default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional .exec.user.LikeFilter schema_name_filter = 2; -inline bool GetSchemasReq::has_schema_name_filter() const { - return (_has_bits_[0] & 0x00000002u) != 0; -} -inline void GetSchemasReq::set_has_schema_name_filter() { - _has_bits_[0] |= 0x00000002u; -} -inline void GetSchemasReq::clear_has_schema_name_filter() { - _has_bits_[0] &= ~0x00000002u; +// optional bool is_nullable = 7; +inline bool ColumnMetadata::has_is_nullable() const { + return (_has_bits_[0] & 0x00000040u) != 0; } -inline void GetSchemasReq::clear_schema_name_filter() { - if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_schema_name_filter(); +inline void ColumnMetadata::set_has_is_nullable() { + _has_bits_[0] |= 0x00000040u; } -inline const ::exec::user::LikeFilter& GetSchemasReq::schema_name_filter() const { - return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_; +inline void ColumnMetadata::clear_has_is_nullable() { + _has_bits_[0] &= ~0x00000040u; } -inline ::exec::user::LikeFilter* GetSchemasReq::mutable_schema_name_filter() { - set_has_schema_name_filter(); - if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter; - return schema_name_filter_; +inline void ColumnMetadata::clear_is_nullable() { + is_nullable_ = false; + clear_has_is_nullable(); } -inline ::exec::user::LikeFilter* GetSchemasReq::release_schema_name_filter() { - clear_has_schema_name_filter(); - ::exec::user::LikeFilter* temp = schema_name_filter_; - schema_name_filter_ = NULL; - return temp; +inline bool ColumnMetadata::is_nullable() const { + return is_nullable_; } -inline void GetSchemasReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) { - delete schema_name_filter_; - schema_name_filter_ = schema_name_filter; - if (schema_name_filter) { - set_has_schema_name_filter(); - } else { - clear_has_schema_name_filter(); - } +inline void ColumnMetadata::set_is_nullable(bool value) { + set_has_is_nullable(); + is_nullable_ = value; } -// ------------------------------------------------------------------- - -// SchemaMetadata - -// optional string catalog_name = 1; -inline bool SchemaMetadata::has_catalog_name() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional string data_type = 8; +inline bool ColumnMetadata::has_data_type() const { + return (_has_bits_[0] & 0x00000080u) != 0; } -inline void SchemaMetadata::set_has_catalog_name() { - _has_bits_[0] |= 0x00000001u; +inline void ColumnMetadata::set_has_data_type() { + _has_bits_[0] |= 0x00000080u; } -inline void SchemaMetadata::clear_has_catalog_name() { - _has_bits_[0] &= ~0x00000001u; +inline void ColumnMetadata::clear_has_data_type() { + _has_bits_[0] &= ~0x00000080u; } -inline void SchemaMetadata::clear_catalog_name() { - if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { - catalog_name_->clear(); +inline void ColumnMetadata::clear_data_type() { + if (data_type_ != &::google::protobuf::internal::kEmptyString) { + data_type_->clear(); } - clear_has_catalog_name(); + clear_has_data_type(); } -inline const ::std::string& SchemaMetadata::catalog_name() const { - return *catalog_name_; +inline const ::std::string& ColumnMetadata::data_type() const { + return *data_type_; } -inline void SchemaMetadata::set_catalog_name(const ::std::string& value) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; +inline void ColumnMetadata::set_data_type(const ::std::string& value) { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; } - catalog_name_->assign(value); + data_type_->assign(value); } -inline void SchemaMetadata::set_catalog_name(const char* value) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; +inline void ColumnMetadata::set_data_type(const char* value) { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; } - catalog_name_->assign(value); + data_type_->assign(value); } -inline void SchemaMetadata::set_catalog_name(const char* value, size_t size) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; +inline void ColumnMetadata::set_data_type(const char* value, size_t size) { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; } - catalog_name_->assign(reinterpret_cast(value), size); + data_type_->assign(reinterpret_cast(value), size); } -inline ::std::string* SchemaMetadata::mutable_catalog_name() { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; +inline ::std::string* ColumnMetadata::mutable_data_type() { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; } - return catalog_name_; + return data_type_; } -inline ::std::string* SchemaMetadata::release_catalog_name() { - clear_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ColumnMetadata::release_data_type() { + clear_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = catalog_name_; - catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = data_type_; + data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void SchemaMetadata::set_allocated_catalog_name(::std::string* catalog_name) { - if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { - delete catalog_name_; +inline void ColumnMetadata::set_allocated_data_type(::std::string* data_type) { + if (data_type_ != &::google::protobuf::internal::kEmptyString) { + delete data_type_; } - if (catalog_name) { - set_has_catalog_name(); - catalog_name_ = catalog_name; + if (data_type) { + set_has_data_type(); + data_type_ = data_type; } else { - clear_has_catalog_name(); - catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_data_type(); + data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string schema_name = 2; -inline bool SchemaMetadata::has_schema_name() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// optional int32 char_max_length = 9; +inline bool ColumnMetadata::has_char_max_length() const { + return (_has_bits_[0] & 0x00000100u) != 0; } -inline void SchemaMetadata::set_has_schema_name() { - _has_bits_[0] |= 0x00000002u; +inline void ColumnMetadata::set_has_char_max_length() { + _has_bits_[0] |= 0x00000100u; } -inline void SchemaMetadata::clear_has_schema_name() { - _has_bits_[0] &= ~0x00000002u; +inline void ColumnMetadata::clear_has_char_max_length() { + _has_bits_[0] &= ~0x00000100u; } -inline void SchemaMetadata::clear_schema_name() { - if (schema_name_ != &::google::protobuf::internal::kEmptyString) { - schema_name_->clear(); - } - clear_has_schema_name(); +inline void ColumnMetadata::clear_char_max_length() { + char_max_length_ = 0; + clear_has_char_max_length(); } -inline const ::std::string& SchemaMetadata::schema_name() const { - return *schema_name_; +inline ::google::protobuf::int32 ColumnMetadata::char_max_length() const { + return char_max_length_; } -inline void SchemaMetadata::set_schema_name(const ::std::string& value) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - schema_name_->assign(value); +inline void ColumnMetadata::set_char_max_length(::google::protobuf::int32 value) { + set_has_char_max_length(); + char_max_length_ = value; } -inline void SchemaMetadata::set_schema_name(const char* value) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - schema_name_->assign(value); + +// optional int32 char_octet_length = 10; +inline bool ColumnMetadata::has_char_octet_length() const { + return (_has_bits_[0] & 0x00000200u) != 0; } -inline void SchemaMetadata::set_schema_name(const char* value, size_t size) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - schema_name_->assign(reinterpret_cast(value), size); +inline void ColumnMetadata::set_has_char_octet_length() { + _has_bits_[0] |= 0x00000200u; } -inline ::std::string* SchemaMetadata::mutable_schema_name() { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - return schema_name_; +inline void ColumnMetadata::clear_has_char_octet_length() { + _has_bits_[0] &= ~0x00000200u; } -inline ::std::string* SchemaMetadata::release_schema_name() { - clear_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = schema_name_; - schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ColumnMetadata::clear_char_octet_length() { + char_octet_length_ = 0; + clear_has_char_octet_length(); } -inline void SchemaMetadata::set_allocated_schema_name(::std::string* schema_name) { - if (schema_name_ != &::google::protobuf::internal::kEmptyString) { - delete schema_name_; - } - if (schema_name) { - set_has_schema_name(); - schema_name_ = schema_name; - } else { - clear_has_schema_name(); - schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::int32 ColumnMetadata::char_octet_length() const { + return char_octet_length_; +} +inline void ColumnMetadata::set_char_octet_length(::google::protobuf::int32 value) { + set_has_char_octet_length(); + char_octet_length_ = value; } -// optional string owner = 3; -inline bool SchemaMetadata::has_owner() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional int32 numeric_precision = 11; +inline bool ColumnMetadata::has_numeric_precision() const { + return (_has_bits_[0] & 0x00000400u) != 0; } -inline void SchemaMetadata::set_has_owner() { - _has_bits_[0] |= 0x00000004u; +inline void ColumnMetadata::set_has_numeric_precision() { + _has_bits_[0] |= 0x00000400u; } -inline void SchemaMetadata::clear_has_owner() { - _has_bits_[0] &= ~0x00000004u; +inline void ColumnMetadata::clear_has_numeric_precision() { + _has_bits_[0] &= ~0x00000400u; } -inline void SchemaMetadata::clear_owner() { - if (owner_ != &::google::protobuf::internal::kEmptyString) { - owner_->clear(); - } - clear_has_owner(); +inline void ColumnMetadata::clear_numeric_precision() { + numeric_precision_ = 0; + clear_has_numeric_precision(); } -inline const ::std::string& SchemaMetadata::owner() const { - return *owner_; +inline ::google::protobuf::int32 ColumnMetadata::numeric_precision() const { + return numeric_precision_; } -inline void SchemaMetadata::set_owner(const ::std::string& value) { - set_has_owner(); - if (owner_ == &::google::protobuf::internal::kEmptyString) { - owner_ = new ::std::string; - } - owner_->assign(value); +inline void ColumnMetadata::set_numeric_precision(::google::protobuf::int32 value) { + set_has_numeric_precision(); + numeric_precision_ = value; } -inline void SchemaMetadata::set_owner(const char* value) { - set_has_owner(); - if (owner_ == &::google::protobuf::internal::kEmptyString) { - owner_ = new ::std::string; - } - owner_->assign(value); + +// optional int32 numeric_precision_radix = 12; +inline bool ColumnMetadata::has_numeric_precision_radix() const { + return (_has_bits_[0] & 0x00000800u) != 0; } -inline void SchemaMetadata::set_owner(const char* value, size_t size) { - set_has_owner(); - if (owner_ == &::google::protobuf::internal::kEmptyString) { - owner_ = new ::std::string; - } - owner_->assign(reinterpret_cast(value), size); +inline void ColumnMetadata::set_has_numeric_precision_radix() { + _has_bits_[0] |= 0x00000800u; +} +inline void ColumnMetadata::clear_has_numeric_precision_radix() { + _has_bits_[0] &= ~0x00000800u; +} +inline void ColumnMetadata::clear_numeric_precision_radix() { + numeric_precision_radix_ = 0; + clear_has_numeric_precision_radix(); +} +inline ::google::protobuf::int32 ColumnMetadata::numeric_precision_radix() const { + return numeric_precision_radix_; +} +inline void ColumnMetadata::set_numeric_precision_radix(::google::protobuf::int32 value) { + set_has_numeric_precision_radix(); + numeric_precision_radix_ = value; +} + +// optional int32 numeric_scale = 13; +inline bool ColumnMetadata::has_numeric_scale() const { + return (_has_bits_[0] & 0x00001000u) != 0; +} +inline void ColumnMetadata::set_has_numeric_scale() { + _has_bits_[0] |= 0x00001000u; +} +inline void ColumnMetadata::clear_has_numeric_scale() { + _has_bits_[0] &= ~0x00001000u; +} +inline void ColumnMetadata::clear_numeric_scale() { + numeric_scale_ = 0; + clear_has_numeric_scale(); +} +inline ::google::protobuf::int32 ColumnMetadata::numeric_scale() const { + return numeric_scale_; +} +inline void ColumnMetadata::set_numeric_scale(::google::protobuf::int32 value) { + set_has_numeric_scale(); + numeric_scale_ = value; +} + +// optional int32 date_time_precision = 14; +inline bool ColumnMetadata::has_date_time_precision() const { + return (_has_bits_[0] & 0x00002000u) != 0; } -inline ::std::string* SchemaMetadata::mutable_owner() { - set_has_owner(); - if (owner_ == &::google::protobuf::internal::kEmptyString) { - owner_ = new ::std::string; - } - return owner_; +inline void ColumnMetadata::set_has_date_time_precision() { + _has_bits_[0] |= 0x00002000u; } -inline ::std::string* SchemaMetadata::release_owner() { - clear_has_owner(); - if (owner_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = owner_; - owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ColumnMetadata::clear_has_date_time_precision() { + _has_bits_[0] &= ~0x00002000u; } -inline void SchemaMetadata::set_allocated_owner(::std::string* owner) { - if (owner_ != &::google::protobuf::internal::kEmptyString) { - delete owner_; - } - if (owner) { - set_has_owner(); - owner_ = owner; - } else { - clear_has_owner(); - owner_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline void ColumnMetadata::clear_date_time_precision() { + date_time_precision_ = 0; + clear_has_date_time_precision(); +} +inline ::google::protobuf::int32 ColumnMetadata::date_time_precision() const { + return date_time_precision_; +} +inline void ColumnMetadata::set_date_time_precision(::google::protobuf::int32 value) { + set_has_date_time_precision(); + date_time_precision_ = value; } -// optional string type = 4; -inline bool SchemaMetadata::has_type() const { - return (_has_bits_[0] & 0x00000008u) != 0; +// optional string interval_type = 15; +inline bool ColumnMetadata::has_interval_type() const { + return (_has_bits_[0] & 0x00004000u) != 0; } -inline void SchemaMetadata::set_has_type() { - _has_bits_[0] |= 0x00000008u; +inline void ColumnMetadata::set_has_interval_type() { + _has_bits_[0] |= 0x00004000u; } -inline void SchemaMetadata::clear_has_type() { - _has_bits_[0] &= ~0x00000008u; +inline void ColumnMetadata::clear_has_interval_type() { + _has_bits_[0] &= ~0x00004000u; } -inline void SchemaMetadata::clear_type() { - if (type_ != &::google::protobuf::internal::kEmptyString) { - type_->clear(); +inline void ColumnMetadata::clear_interval_type() { + if (interval_type_ != &::google::protobuf::internal::kEmptyString) { + interval_type_->clear(); } - clear_has_type(); + clear_has_interval_type(); } -inline const ::std::string& SchemaMetadata::type() const { - return *type_; +inline const ::std::string& ColumnMetadata::interval_type() const { + return *interval_type_; } -inline void SchemaMetadata::set_type(const ::std::string& value) { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline void ColumnMetadata::set_interval_type(const ::std::string& value) { + set_has_interval_type(); + if (interval_type_ == &::google::protobuf::internal::kEmptyString) { + interval_type_ = new ::std::string; } - type_->assign(value); + interval_type_->assign(value); } -inline void SchemaMetadata::set_type(const char* value) { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline void ColumnMetadata::set_interval_type(const char* value) { + set_has_interval_type(); + if (interval_type_ == &::google::protobuf::internal::kEmptyString) { + interval_type_ = new ::std::string; } - type_->assign(value); + interval_type_->assign(value); } -inline void SchemaMetadata::set_type(const char* value, size_t size) { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline void ColumnMetadata::set_interval_type(const char* value, size_t size) { + set_has_interval_type(); + if (interval_type_ == &::google::protobuf::internal::kEmptyString) { + interval_type_ = new ::std::string; } - type_->assign(reinterpret_cast(value), size); + interval_type_->assign(reinterpret_cast(value), size); } -inline ::std::string* SchemaMetadata::mutable_type() { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline ::std::string* ColumnMetadata::mutable_interval_type() { + set_has_interval_type(); + if (interval_type_ == &::google::protobuf::internal::kEmptyString) { + interval_type_ = new ::std::string; } - return type_; + return interval_type_; } -inline ::std::string* SchemaMetadata::release_type() { - clear_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ColumnMetadata::release_interval_type() { + clear_has_interval_type(); + if (interval_type_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = type_; - type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = interval_type_; + interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void SchemaMetadata::set_allocated_type(::std::string* type) { - if (type_ != &::google::protobuf::internal::kEmptyString) { - delete type_; +inline void ColumnMetadata::set_allocated_interval_type(::std::string* interval_type) { + if (interval_type_ != &::google::protobuf::internal::kEmptyString) { + delete interval_type_; } - if (type) { - set_has_type(); - type_ = type; + if (interval_type) { + set_has_interval_type(); + interval_type_ = interval_type; } else { - clear_has_type(); - type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_interval_type(); + interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string mutable = 5; -inline bool SchemaMetadata::has_mutable_() const { - return (_has_bits_[0] & 0x00000010u) != 0; +// optional int32 interval_precision = 16; +inline bool ColumnMetadata::has_interval_precision() const { + return (_has_bits_[0] & 0x00008000u) != 0; } -inline void SchemaMetadata::set_has_mutable_() { - _has_bits_[0] |= 0x00000010u; +inline void ColumnMetadata::set_has_interval_precision() { + _has_bits_[0] |= 0x00008000u; } -inline void SchemaMetadata::clear_has_mutable_() { - _has_bits_[0] &= ~0x00000010u; +inline void ColumnMetadata::clear_has_interval_precision() { + _has_bits_[0] &= ~0x00008000u; } -inline void SchemaMetadata::clear_mutable_() { - if (mutable__ != &::google::protobuf::internal::kEmptyString) { - mutable__->clear(); - } - clear_has_mutable_(); +inline void ColumnMetadata::clear_interval_precision() { + interval_precision_ = 0; + clear_has_interval_precision(); } -inline const ::std::string& SchemaMetadata::mutable_() const { - return *mutable__; +inline ::google::protobuf::int32 ColumnMetadata::interval_precision() const { + return interval_precision_; } -inline void SchemaMetadata::set_mutable_(const ::std::string& value) { - set_has_mutable_(); - if (mutable__ == &::google::protobuf::internal::kEmptyString) { - mutable__ = new ::std::string; - } - mutable__->assign(value); +inline void ColumnMetadata::set_interval_precision(::google::protobuf::int32 value) { + set_has_interval_precision(); + interval_precision_ = value; } -inline void SchemaMetadata::set_mutable_(const char* value) { - set_has_mutable_(); - if (mutable__ == &::google::protobuf::internal::kEmptyString) { - mutable__ = new ::std::string; - } - mutable__->assign(value); + +// optional int32 column_size = 17; +inline bool ColumnMetadata::has_column_size() const { + return (_has_bits_[0] & 0x00010000u) != 0; } -inline void SchemaMetadata::set_mutable_(const char* value, size_t size) { - set_has_mutable_(); - if (mutable__ == &::google::protobuf::internal::kEmptyString) { - mutable__ = new ::std::string; - } - mutable__->assign(reinterpret_cast(value), size); +inline void ColumnMetadata::set_has_column_size() { + _has_bits_[0] |= 0x00010000u; } -inline ::std::string* SchemaMetadata::mutable_mutable_() { - set_has_mutable_(); - if (mutable__ == &::google::protobuf::internal::kEmptyString) { - mutable__ = new ::std::string; - } - return mutable__; +inline void ColumnMetadata::clear_has_column_size() { + _has_bits_[0] &= ~0x00010000u; } -inline ::std::string* SchemaMetadata::release_mutable_() { - clear_has_mutable_(); - if (mutable__ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = mutable__; - mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ColumnMetadata::clear_column_size() { + column_size_ = 0; + clear_has_column_size(); } -inline void SchemaMetadata::set_allocated_mutable_(::std::string* mutable_) { - if (mutable__ != &::google::protobuf::internal::kEmptyString) { - delete mutable__; - } - if (mutable_) { - set_has_mutable_(); - mutable__ = mutable_; - } else { - clear_has_mutable_(); - mutable__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::int32 ColumnMetadata::column_size() const { + return column_size_; +} +inline void ColumnMetadata::set_column_size(::google::protobuf::int32 value) { + set_has_column_size(); + column_size_ = value; } // ------------------------------------------------------------------- -// GetSchemasResp +// GetColumnsResp // optional .exec.user.RequestStatus status = 1; -inline bool GetSchemasResp::has_status() const { +inline bool GetColumnsResp::has_status() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void GetSchemasResp::set_has_status() { +inline void GetColumnsResp::set_has_status() { _has_bits_[0] |= 0x00000001u; } -inline void GetSchemasResp::clear_has_status() { +inline void GetColumnsResp::clear_has_status() { _has_bits_[0] &= ~0x00000001u; } -inline void GetSchemasResp::clear_status() { +inline void GetColumnsResp::clear_status() { status_ = 0; clear_has_status(); } -inline ::exec::user::RequestStatus GetSchemasResp::status() const { +inline ::exec::user::RequestStatus GetColumnsResp::status() const { return static_cast< ::exec::user::RequestStatus >(status_); } -inline void GetSchemasResp::set_status(::exec::user::RequestStatus value) { +inline void GetColumnsResp::set_status(::exec::user::RequestStatus value) { assert(::exec::user::RequestStatus_IsValid(value)); set_has_status(); status_ = value; } -// repeated .exec.user.SchemaMetadata schemas = 2; -inline int GetSchemasResp::schemas_size() const { - return schemas_.size(); +// repeated .exec.user.ColumnMetadata columns = 2; +inline int GetColumnsResp::columns_size() const { + return columns_.size(); } -inline void GetSchemasResp::clear_schemas() { - schemas_.Clear(); +inline void GetColumnsResp::clear_columns() { + columns_.Clear(); } -inline const ::exec::user::SchemaMetadata& GetSchemasResp::schemas(int index) const { - return schemas_.Get(index); +inline const ::exec::user::ColumnMetadata& GetColumnsResp::columns(int index) const { + return columns_.Get(index); } -inline ::exec::user::SchemaMetadata* GetSchemasResp::mutable_schemas(int index) { - return schemas_.Mutable(index); +inline ::exec::user::ColumnMetadata* GetColumnsResp::mutable_columns(int index) { + return columns_.Mutable(index); } -inline ::exec::user::SchemaMetadata* GetSchemasResp::add_schemas() { - return schemas_.Add(); +inline ::exec::user::ColumnMetadata* GetColumnsResp::add_columns() { + return columns_.Add(); } -inline const ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >& -GetSchemasResp::schemas() const { - return schemas_; +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >& +GetColumnsResp::columns() const { + return columns_; } -inline ::google::protobuf::RepeatedPtrField< ::exec::user::SchemaMetadata >* -GetSchemasResp::mutable_schemas() { - return &schemas_; +inline ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >* +GetColumnsResp::mutable_columns() { + return &columns_; } // optional .exec.shared.DrillPBError error = 3; -inline bool GetSchemasResp::has_error() const { +inline bool GetColumnsResp::has_error() const { return (_has_bits_[0] & 0x00000004u) != 0; } -inline void GetSchemasResp::set_has_error() { +inline void GetColumnsResp::set_has_error() { _has_bits_[0] |= 0x00000004u; } -inline void GetSchemasResp::clear_has_error() { +inline void GetColumnsResp::clear_has_error() { _has_bits_[0] &= ~0x00000004u; } -inline void GetSchemasResp::clear_error() { +inline void GetColumnsResp::clear_error() { if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); clear_has_error(); } -inline const ::exec::shared::DrillPBError& GetSchemasResp::error() const { +inline const ::exec::shared::DrillPBError& GetColumnsResp::error() const { return error_ != NULL ? *error_ : *default_instance_->error_; } -inline ::exec::shared::DrillPBError* GetSchemasResp::mutable_error() { +inline ::exec::shared::DrillPBError* GetColumnsResp::mutable_error() { set_has_error(); if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; return error_; } -inline ::exec::shared::DrillPBError* GetSchemasResp::release_error() { +inline ::exec::shared::DrillPBError* GetColumnsResp::release_error() { clear_has_error(); ::exec::shared::DrillPBError* temp = error_; error_ = NULL; return temp; } -inline void GetSchemasResp::set_allocated_error(::exec::shared::DrillPBError* error) { +inline void GetColumnsResp::set_allocated_error(::exec::shared::DrillPBError* error) { delete error_; error_ = error; if (error) { @@ -6100,218 +8738,130 @@ inline void GetSchemasResp::set_allocated_error(::exec::shared::DrillPBError* er // ------------------------------------------------------------------- -// GetTablesReq +// CreatePreparedStatementReq -// optional .exec.user.LikeFilter catalog_name_filter = 1; -inline bool GetTablesReq::has_catalog_name_filter() const { +// optional string sql_query = 1; +inline bool CreatePreparedStatementReq::has_sql_query() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void GetTablesReq::set_has_catalog_name_filter() { +inline void CreatePreparedStatementReq::set_has_sql_query() { _has_bits_[0] |= 0x00000001u; } -inline void GetTablesReq::clear_has_catalog_name_filter() { +inline void CreatePreparedStatementReq::clear_has_sql_query() { _has_bits_[0] &= ~0x00000001u; } -inline void GetTablesReq::clear_catalog_name_filter() { - if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_catalog_name_filter(); -} -inline const ::exec::user::LikeFilter& GetTablesReq::catalog_name_filter() const { - return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; -} -inline ::exec::user::LikeFilter* GetTablesReq::mutable_catalog_name_filter() { - set_has_catalog_name_filter(); - if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; - return catalog_name_filter_; -} -inline ::exec::user::LikeFilter* GetTablesReq::release_catalog_name_filter() { - clear_has_catalog_name_filter(); - ::exec::user::LikeFilter* temp = catalog_name_filter_; - catalog_name_filter_ = NULL; - return temp; -} -inline void GetTablesReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { - delete catalog_name_filter_; - catalog_name_filter_ = catalog_name_filter; - if (catalog_name_filter) { - set_has_catalog_name_filter(); - } else { - clear_has_catalog_name_filter(); +inline void CreatePreparedStatementReq::clear_sql_query() { + if (sql_query_ != &::google::protobuf::internal::kEmptyString) { + sql_query_->clear(); } + clear_has_sql_query(); } - -// optional .exec.user.LikeFilter schema_name_filter = 2; -inline bool GetTablesReq::has_schema_name_filter() const { - return (_has_bits_[0] & 0x00000002u) != 0; -} -inline void GetTablesReq::set_has_schema_name_filter() { - _has_bits_[0] |= 0x00000002u; -} -inline void GetTablesReq::clear_has_schema_name_filter() { - _has_bits_[0] &= ~0x00000002u; +inline const ::std::string& CreatePreparedStatementReq::sql_query() const { + return *sql_query_; } -inline void GetTablesReq::clear_schema_name_filter() { - if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_schema_name_filter(); +inline void CreatePreparedStatementReq::set_sql_query(const ::std::string& value) { + set_has_sql_query(); + if (sql_query_ == &::google::protobuf::internal::kEmptyString) { + sql_query_ = new ::std::string; + } + sql_query_->assign(value); } -inline const ::exec::user::LikeFilter& GetTablesReq::schema_name_filter() const { - return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_; +inline void CreatePreparedStatementReq::set_sql_query(const char* value) { + set_has_sql_query(); + if (sql_query_ == &::google::protobuf::internal::kEmptyString) { + sql_query_ = new ::std::string; + } + sql_query_->assign(value); } -inline ::exec::user::LikeFilter* GetTablesReq::mutable_schema_name_filter() { - set_has_schema_name_filter(); - if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter; - return schema_name_filter_; +inline void CreatePreparedStatementReq::set_sql_query(const char* value, size_t size) { + set_has_sql_query(); + if (sql_query_ == &::google::protobuf::internal::kEmptyString) { + sql_query_ = new ::std::string; + } + sql_query_->assign(reinterpret_cast(value), size); } -inline ::exec::user::LikeFilter* GetTablesReq::release_schema_name_filter() { - clear_has_schema_name_filter(); - ::exec::user::LikeFilter* temp = schema_name_filter_; - schema_name_filter_ = NULL; - return temp; +inline ::std::string* CreatePreparedStatementReq::mutable_sql_query() { + set_has_sql_query(); + if (sql_query_ == &::google::protobuf::internal::kEmptyString) { + sql_query_ = new ::std::string; + } + return sql_query_; } -inline void GetTablesReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) { - delete schema_name_filter_; - schema_name_filter_ = schema_name_filter; - if (schema_name_filter) { - set_has_schema_name_filter(); +inline ::std::string* CreatePreparedStatementReq::release_sql_query() { + clear_has_sql_query(); + if (sql_query_ == &::google::protobuf::internal::kEmptyString) { + return NULL; } else { - clear_has_schema_name_filter(); + ::std::string* temp = sql_query_; + sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; } } - -// optional .exec.user.LikeFilter table_name_filter = 3; -inline bool GetTablesReq::has_table_name_filter() const { - return (_has_bits_[0] & 0x00000004u) != 0; -} -inline void GetTablesReq::set_has_table_name_filter() { - _has_bits_[0] |= 0x00000004u; -} -inline void GetTablesReq::clear_has_table_name_filter() { - _has_bits_[0] &= ~0x00000004u; -} -inline void GetTablesReq::clear_table_name_filter() { - if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_table_name_filter(); -} -inline const ::exec::user::LikeFilter& GetTablesReq::table_name_filter() const { - return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_; -} -inline ::exec::user::LikeFilter* GetTablesReq::mutable_table_name_filter() { - set_has_table_name_filter(); - if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter; - return table_name_filter_; -} -inline ::exec::user::LikeFilter* GetTablesReq::release_table_name_filter() { - clear_has_table_name_filter(); - ::exec::user::LikeFilter* temp = table_name_filter_; - table_name_filter_ = NULL; - return temp; -} -inline void GetTablesReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) { - delete table_name_filter_; - table_name_filter_ = table_name_filter; - if (table_name_filter) { - set_has_table_name_filter(); +inline void CreatePreparedStatementReq::set_allocated_sql_query(::std::string* sql_query) { + if (sql_query_ != &::google::protobuf::internal::kEmptyString) { + delete sql_query_; + } + if (sql_query) { + set_has_sql_query(); + sql_query_ = sql_query; } else { - clear_has_table_name_filter(); + clear_has_sql_query(); + sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// repeated string table_type_filter = 4; -inline int GetTablesReq::table_type_filter_size() const { - return table_type_filter_.size(); -} -inline void GetTablesReq::clear_table_type_filter() { - table_type_filter_.Clear(); -} -inline const ::std::string& GetTablesReq::table_type_filter(int index) const { - return table_type_filter_.Get(index); -} -inline ::std::string* GetTablesReq::mutable_table_type_filter(int index) { - return table_type_filter_.Mutable(index); -} -inline void GetTablesReq::set_table_type_filter(int index, const ::std::string& value) { - table_type_filter_.Mutable(index)->assign(value); -} -inline void GetTablesReq::set_table_type_filter(int index, const char* value) { - table_type_filter_.Mutable(index)->assign(value); -} -inline void GetTablesReq::set_table_type_filter(int index, const char* value, size_t size) { - table_type_filter_.Mutable(index)->assign( - reinterpret_cast(value), size); -} -inline ::std::string* GetTablesReq::add_table_type_filter() { - return table_type_filter_.Add(); -} -inline void GetTablesReq::add_table_type_filter(const ::std::string& value) { - table_type_filter_.Add()->assign(value); -} -inline void GetTablesReq::add_table_type_filter(const char* value) { - table_type_filter_.Add()->assign(value); -} -inline void GetTablesReq::add_table_type_filter(const char* value, size_t size) { - table_type_filter_.Add()->assign(reinterpret_cast(value), size); -} -inline const ::google::protobuf::RepeatedPtrField< ::std::string>& -GetTablesReq::table_type_filter() const { - return table_type_filter_; -} -inline ::google::protobuf::RepeatedPtrField< ::std::string>* -GetTablesReq::mutable_table_type_filter() { - return &table_type_filter_; -} - // ------------------------------------------------------------------- -// TableMetadata +// ResultColumnMetadata // optional string catalog_name = 1; -inline bool TableMetadata::has_catalog_name() const { +inline bool ResultColumnMetadata::has_catalog_name() const { return (_has_bits_[0] & 0x00000001u) != 0; } -inline void TableMetadata::set_has_catalog_name() { +inline void ResultColumnMetadata::set_has_catalog_name() { _has_bits_[0] |= 0x00000001u; } -inline void TableMetadata::clear_has_catalog_name() { +inline void ResultColumnMetadata::clear_has_catalog_name() { _has_bits_[0] &= ~0x00000001u; } -inline void TableMetadata::clear_catalog_name() { +inline void ResultColumnMetadata::clear_catalog_name() { if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { catalog_name_->clear(); } clear_has_catalog_name(); } -inline const ::std::string& TableMetadata::catalog_name() const { +inline const ::std::string& ResultColumnMetadata::catalog_name() const { return *catalog_name_; } -inline void TableMetadata::set_catalog_name(const ::std::string& value) { +inline void ResultColumnMetadata::set_catalog_name(const ::std::string& value) { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } catalog_name_->assign(value); } -inline void TableMetadata::set_catalog_name(const char* value) { +inline void ResultColumnMetadata::set_catalog_name(const char* value) { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } catalog_name_->assign(value); } -inline void TableMetadata::set_catalog_name(const char* value, size_t size) { +inline void ResultColumnMetadata::set_catalog_name(const char* value, size_t size) { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } catalog_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* TableMetadata::mutable_catalog_name() { +inline ::std::string* ResultColumnMetadata::mutable_catalog_name() { set_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { catalog_name_ = new ::std::string; } return catalog_name_; } -inline ::std::string* TableMetadata::release_catalog_name() { +inline ::std::string* ResultColumnMetadata::release_catalog_name() { clear_has_catalog_name(); if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; @@ -6321,7 +8871,7 @@ inline ::std::string* TableMetadata::release_catalog_name() { return temp; } } -inline void TableMetadata::set_allocated_catalog_name(::std::string* catalog_name) { +inline void ResultColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) { if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { delete catalog_name_; } @@ -6335,53 +8885,53 @@ inline void TableMetadata::set_allocated_catalog_name(::std::string* catalog_nam } // optional string schema_name = 2; -inline bool TableMetadata::has_schema_name() const { +inline bool ResultColumnMetadata::has_schema_name() const { return (_has_bits_[0] & 0x00000002u) != 0; } -inline void TableMetadata::set_has_schema_name() { +inline void ResultColumnMetadata::set_has_schema_name() { _has_bits_[0] |= 0x00000002u; } -inline void TableMetadata::clear_has_schema_name() { +inline void ResultColumnMetadata::clear_has_schema_name() { _has_bits_[0] &= ~0x00000002u; } -inline void TableMetadata::clear_schema_name() { +inline void ResultColumnMetadata::clear_schema_name() { if (schema_name_ != &::google::protobuf::internal::kEmptyString) { schema_name_->clear(); } clear_has_schema_name(); } -inline const ::std::string& TableMetadata::schema_name() const { +inline const ::std::string& ResultColumnMetadata::schema_name() const { return *schema_name_; } -inline void TableMetadata::set_schema_name(const ::std::string& value) { +inline void ResultColumnMetadata::set_schema_name(const ::std::string& value) { set_has_schema_name(); if (schema_name_ == &::google::protobuf::internal::kEmptyString) { schema_name_ = new ::std::string; } schema_name_->assign(value); } -inline void TableMetadata::set_schema_name(const char* value) { +inline void ResultColumnMetadata::set_schema_name(const char* value) { set_has_schema_name(); if (schema_name_ == &::google::protobuf::internal::kEmptyString) { schema_name_ = new ::std::string; } schema_name_->assign(value); } -inline void TableMetadata::set_schema_name(const char* value, size_t size) { +inline void ResultColumnMetadata::set_schema_name(const char* value, size_t size) { set_has_schema_name(); if (schema_name_ == &::google::protobuf::internal::kEmptyString) { schema_name_ = new ::std::string; } schema_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* TableMetadata::mutable_schema_name() { +inline ::std::string* ResultColumnMetadata::mutable_schema_name() { set_has_schema_name(); if (schema_name_ == &::google::protobuf::internal::kEmptyString) { schema_name_ = new ::std::string; } return schema_name_; } -inline ::std::string* TableMetadata::release_schema_name() { +inline ::std::string* ResultColumnMetadata::release_schema_name() { clear_has_schema_name(); if (schema_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; @@ -6391,7 +8941,7 @@ inline ::std::string* TableMetadata::release_schema_name() { return temp; } } -inline void TableMetadata::set_allocated_schema_name(::std::string* schema_name) { +inline void ResultColumnMetadata::set_allocated_schema_name(::std::string* schema_name) { if (schema_name_ != &::google::protobuf::internal::kEmptyString) { delete schema_name_; } @@ -6405,53 +8955,53 @@ inline void TableMetadata::set_allocated_schema_name(::std::string* schema_name) } // optional string table_name = 3; -inline bool TableMetadata::has_table_name() const { +inline bool ResultColumnMetadata::has_table_name() const { return (_has_bits_[0] & 0x00000004u) != 0; } -inline void TableMetadata::set_has_table_name() { +inline void ResultColumnMetadata::set_has_table_name() { _has_bits_[0] |= 0x00000004u; } -inline void TableMetadata::clear_has_table_name() { +inline void ResultColumnMetadata::clear_has_table_name() { _has_bits_[0] &= ~0x00000004u; } -inline void TableMetadata::clear_table_name() { +inline void ResultColumnMetadata::clear_table_name() { if (table_name_ != &::google::protobuf::internal::kEmptyString) { table_name_->clear(); } clear_has_table_name(); } -inline const ::std::string& TableMetadata::table_name() const { +inline const ::std::string& ResultColumnMetadata::table_name() const { return *table_name_; } -inline void TableMetadata::set_table_name(const ::std::string& value) { +inline void ResultColumnMetadata::set_table_name(const ::std::string& value) { set_has_table_name(); if (table_name_ == &::google::protobuf::internal::kEmptyString) { table_name_ = new ::std::string; } table_name_->assign(value); } -inline void TableMetadata::set_table_name(const char* value) { +inline void ResultColumnMetadata::set_table_name(const char* value) { set_has_table_name(); if (table_name_ == &::google::protobuf::internal::kEmptyString) { table_name_ = new ::std::string; } table_name_->assign(value); } -inline void TableMetadata::set_table_name(const char* value, size_t size) { +inline void ResultColumnMetadata::set_table_name(const char* value, size_t size) { set_has_table_name(); if (table_name_ == &::google::protobuf::internal::kEmptyString) { table_name_ = new ::std::string; } table_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* TableMetadata::mutable_table_name() { +inline ::std::string* ResultColumnMetadata::mutable_table_name() { set_has_table_name(); if (table_name_ == &::google::protobuf::internal::kEmptyString) { table_name_ = new ::std::string; } return table_name_; } -inline ::std::string* TableMetadata::release_table_name() { +inline ::std::string* ResultColumnMetadata::release_table_name() { clear_has_table_name(); if (table_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; @@ -6461,7 +9011,7 @@ inline ::std::string* TableMetadata::release_table_name() { return temp; } } -inline void TableMetadata::set_allocated_table_name(::std::string* table_name) { +inline void ResultColumnMetadata::set_allocated_table_name(::std::string* table_name) { if (table_name_ != &::google::protobuf::internal::kEmptyString) { delete table_name_; } @@ -6474,2202 +9024,2517 @@ inline void TableMetadata::set_allocated_table_name(::std::string* table_name) { } } -// optional string type = 4; -inline bool TableMetadata::has_type() const { +// optional string column_name = 4; +inline bool ResultColumnMetadata::has_column_name() const { return (_has_bits_[0] & 0x00000008u) != 0; } -inline void TableMetadata::set_has_type() { +inline void ResultColumnMetadata::set_has_column_name() { _has_bits_[0] |= 0x00000008u; } -inline void TableMetadata::clear_has_type() { +inline void ResultColumnMetadata::clear_has_column_name() { _has_bits_[0] &= ~0x00000008u; } -inline void TableMetadata::clear_type() { - if (type_ != &::google::protobuf::internal::kEmptyString) { - type_->clear(); +inline void ResultColumnMetadata::clear_column_name() { + if (column_name_ != &::google::protobuf::internal::kEmptyString) { + column_name_->clear(); } - clear_has_type(); + clear_has_column_name(); } -inline const ::std::string& TableMetadata::type() const { - return *type_; +inline const ::std::string& ResultColumnMetadata::column_name() const { + return *column_name_; } -inline void TableMetadata::set_type(const ::std::string& value) { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline void ResultColumnMetadata::set_column_name(const ::std::string& value) { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; } - type_->assign(value); + column_name_->assign(value); } -inline void TableMetadata::set_type(const char* value) { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline void ResultColumnMetadata::set_column_name(const char* value) { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; } - type_->assign(value); + column_name_->assign(value); } -inline void TableMetadata::set_type(const char* value, size_t size) { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline void ResultColumnMetadata::set_column_name(const char* value, size_t size) { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; } - type_->assign(reinterpret_cast(value), size); + column_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* TableMetadata::mutable_type() { - set_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { - type_ = new ::std::string; +inline ::std::string* ResultColumnMetadata::mutable_column_name() { + set_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { + column_name_ = new ::std::string; } - return type_; + return column_name_; } -inline ::std::string* TableMetadata::release_type() { - clear_has_type(); - if (type_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ResultColumnMetadata::release_column_name() { + clear_has_column_name(); + if (column_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = type_; - type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = column_name_; + column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void TableMetadata::set_allocated_type(::std::string* type) { - if (type_ != &::google::protobuf::internal::kEmptyString) { - delete type_; +inline void ResultColumnMetadata::set_allocated_column_name(::std::string* column_name) { + if (column_name_ != &::google::protobuf::internal::kEmptyString) { + delete column_name_; } - if (type) { - set_has_type(); - type_ = type; + if (column_name) { + set_has_column_name(); + column_name_ = column_name; } else { - clear_has_type(); - type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_column_name(); + column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string label = 5; +inline bool ResultColumnMetadata::has_label() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void ResultColumnMetadata::set_has_label() { + _has_bits_[0] |= 0x00000010u; +} +inline void ResultColumnMetadata::clear_has_label() { + _has_bits_[0] &= ~0x00000010u; +} +inline void ResultColumnMetadata::clear_label() { + if (label_ != &::google::protobuf::internal::kEmptyString) { + label_->clear(); + } + clear_has_label(); +} +inline const ::std::string& ResultColumnMetadata::label() const { + return *label_; +} +inline void ResultColumnMetadata::set_label(const ::std::string& value) { + set_has_label(); + if (label_ == &::google::protobuf::internal::kEmptyString) { + label_ = new ::std::string; + } + label_->assign(value); +} +inline void ResultColumnMetadata::set_label(const char* value) { + set_has_label(); + if (label_ == &::google::protobuf::internal::kEmptyString) { + label_ = new ::std::string; + } + label_->assign(value); +} +inline void ResultColumnMetadata::set_label(const char* value, size_t size) { + set_has_label(); + if (label_ == &::google::protobuf::internal::kEmptyString) { + label_ = new ::std::string; + } + label_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ResultColumnMetadata::mutable_label() { + set_has_label(); + if (label_ == &::google::protobuf::internal::kEmptyString) { + label_ = new ::std::string; + } + return label_; +} +inline ::std::string* ResultColumnMetadata::release_label() { + clear_has_label(); + if (label_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = label_; + label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void ResultColumnMetadata::set_allocated_label(::std::string* label) { + if (label_ != &::google::protobuf::internal::kEmptyString) { + delete label_; + } + if (label) { + set_has_label(); + label_ = label; + } else { + clear_has_label(); + label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } +} + +// optional string data_type = 6; +inline bool ResultColumnMetadata::has_data_type() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void ResultColumnMetadata::set_has_data_type() { + _has_bits_[0] |= 0x00000020u; +} +inline void ResultColumnMetadata::clear_has_data_type() { + _has_bits_[0] &= ~0x00000020u; +} +inline void ResultColumnMetadata::clear_data_type() { + if (data_type_ != &::google::protobuf::internal::kEmptyString) { + data_type_->clear(); + } + clear_has_data_type(); +} +inline const ::std::string& ResultColumnMetadata::data_type() const { + return *data_type_; +} +inline void ResultColumnMetadata::set_data_type(const ::std::string& value) { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; + } + data_type_->assign(value); +} +inline void ResultColumnMetadata::set_data_type(const char* value) { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; + } + data_type_->assign(value); +} +inline void ResultColumnMetadata::set_data_type(const char* value, size_t size) { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; + } + data_type_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ResultColumnMetadata::mutable_data_type() { + set_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + data_type_ = new ::std::string; + } + return data_type_; +} +inline ::std::string* ResultColumnMetadata::release_data_type() { + clear_has_data_type(); + if (data_type_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = data_type_; + data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void ResultColumnMetadata::set_allocated_data_type(::std::string* data_type) { + if (data_type_ != &::google::protobuf::internal::kEmptyString) { + delete data_type_; + } + if (data_type) { + set_has_data_type(); + data_type_ = data_type; + } else { + clear_has_data_type(); + data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// ------------------------------------------------------------------- - -// GetTablesResp - -// optional .exec.user.RequestStatus status = 1; -inline bool GetTablesResp::has_status() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional bool is_nullable = 7; +inline bool ResultColumnMetadata::has_is_nullable() const { + return (_has_bits_[0] & 0x00000040u) != 0; } -inline void GetTablesResp::set_has_status() { - _has_bits_[0] |= 0x00000001u; +inline void ResultColumnMetadata::set_has_is_nullable() { + _has_bits_[0] |= 0x00000040u; } -inline void GetTablesResp::clear_has_status() { - _has_bits_[0] &= ~0x00000001u; +inline void ResultColumnMetadata::clear_has_is_nullable() { + _has_bits_[0] &= ~0x00000040u; } -inline void GetTablesResp::clear_status() { - status_ = 0; - clear_has_status(); +inline void ResultColumnMetadata::clear_is_nullable() { + is_nullable_ = false; + clear_has_is_nullable(); } -inline ::exec::user::RequestStatus GetTablesResp::status() const { - return static_cast< ::exec::user::RequestStatus >(status_); +inline bool ResultColumnMetadata::is_nullable() const { + return is_nullable_; } -inline void GetTablesResp::set_status(::exec::user::RequestStatus value) { - assert(::exec::user::RequestStatus_IsValid(value)); - set_has_status(); - status_ = value; +inline void ResultColumnMetadata::set_is_nullable(bool value) { + set_has_is_nullable(); + is_nullable_ = value; } -// repeated .exec.user.TableMetadata tables = 2; -inline int GetTablesResp::tables_size() const { - return tables_.size(); -} -inline void GetTablesResp::clear_tables() { - tables_.Clear(); +// optional int32 precision = 8; +inline bool ResultColumnMetadata::has_precision() const { + return (_has_bits_[0] & 0x00000080u) != 0; } -inline const ::exec::user::TableMetadata& GetTablesResp::tables(int index) const { - return tables_.Get(index); +inline void ResultColumnMetadata::set_has_precision() { + _has_bits_[0] |= 0x00000080u; } -inline ::exec::user::TableMetadata* GetTablesResp::mutable_tables(int index) { - return tables_.Mutable(index); +inline void ResultColumnMetadata::clear_has_precision() { + _has_bits_[0] &= ~0x00000080u; } -inline ::exec::user::TableMetadata* GetTablesResp::add_tables() { - return tables_.Add(); +inline void ResultColumnMetadata::clear_precision() { + precision_ = 0; + clear_has_precision(); } -inline const ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >& -GetTablesResp::tables() const { - return tables_; +inline ::google::protobuf::int32 ResultColumnMetadata::precision() const { + return precision_; } -inline ::google::protobuf::RepeatedPtrField< ::exec::user::TableMetadata >* -GetTablesResp::mutable_tables() { - return &tables_; +inline void ResultColumnMetadata::set_precision(::google::protobuf::int32 value) { + set_has_precision(); + precision_ = value; } -// optional .exec.shared.DrillPBError error = 3; -inline bool GetTablesResp::has_error() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional int32 scale = 9; +inline bool ResultColumnMetadata::has_scale() const { + return (_has_bits_[0] & 0x00000100u) != 0; } -inline void GetTablesResp::set_has_error() { - _has_bits_[0] |= 0x00000004u; +inline void ResultColumnMetadata::set_has_scale() { + _has_bits_[0] |= 0x00000100u; } -inline void GetTablesResp::clear_has_error() { - _has_bits_[0] &= ~0x00000004u; +inline void ResultColumnMetadata::clear_has_scale() { + _has_bits_[0] &= ~0x00000100u; } -inline void GetTablesResp::clear_error() { - if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); - clear_has_error(); +inline void ResultColumnMetadata::clear_scale() { + scale_ = 0; + clear_has_scale(); } -inline const ::exec::shared::DrillPBError& GetTablesResp::error() const { - return error_ != NULL ? *error_ : *default_instance_->error_; +inline ::google::protobuf::int32 ResultColumnMetadata::scale() const { + return scale_; } -inline ::exec::shared::DrillPBError* GetTablesResp::mutable_error() { - set_has_error(); - if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; - return error_; +inline void ResultColumnMetadata::set_scale(::google::protobuf::int32 value) { + set_has_scale(); + scale_ = value; } -inline ::exec::shared::DrillPBError* GetTablesResp::release_error() { - clear_has_error(); - ::exec::shared::DrillPBError* temp = error_; - error_ = NULL; - return temp; + +// optional bool signed = 10; +inline bool ResultColumnMetadata::has_signed_() const { + return (_has_bits_[0] & 0x00000200u) != 0; } -inline void GetTablesResp::set_allocated_error(::exec::shared::DrillPBError* error) { - delete error_; - error_ = error; - if (error) { - set_has_error(); - } else { - clear_has_error(); - } +inline void ResultColumnMetadata::set_has_signed_() { + _has_bits_[0] |= 0x00000200u; } - -// ------------------------------------------------------------------- - -// GetColumnsReq - -// optional .exec.user.LikeFilter catalog_name_filter = 1; -inline bool GetColumnsReq::has_catalog_name_filter() const { - return (_has_bits_[0] & 0x00000001u) != 0; +inline void ResultColumnMetadata::clear_has_signed_() { + _has_bits_[0] &= ~0x00000200u; } -inline void GetColumnsReq::set_has_catalog_name_filter() { - _has_bits_[0] |= 0x00000001u; +inline void ResultColumnMetadata::clear_signed_() { + signed__ = false; + clear_has_signed_(); } -inline void GetColumnsReq::clear_has_catalog_name_filter() { - _has_bits_[0] &= ~0x00000001u; +inline bool ResultColumnMetadata::signed_() const { + return signed__; } -inline void GetColumnsReq::clear_catalog_name_filter() { - if (catalog_name_filter_ != NULL) catalog_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_catalog_name_filter(); +inline void ResultColumnMetadata::set_signed_(bool value) { + set_has_signed_(); + signed__ = value; } -inline const ::exec::user::LikeFilter& GetColumnsReq::catalog_name_filter() const { - return catalog_name_filter_ != NULL ? *catalog_name_filter_ : *default_instance_->catalog_name_filter_; + +// optional int32 display_size = 11; +inline bool ResultColumnMetadata::has_display_size() const { + return (_has_bits_[0] & 0x00000400u) != 0; } -inline ::exec::user::LikeFilter* GetColumnsReq::mutable_catalog_name_filter() { - set_has_catalog_name_filter(); - if (catalog_name_filter_ == NULL) catalog_name_filter_ = new ::exec::user::LikeFilter; - return catalog_name_filter_; +inline void ResultColumnMetadata::set_has_display_size() { + _has_bits_[0] |= 0x00000400u; } -inline ::exec::user::LikeFilter* GetColumnsReq::release_catalog_name_filter() { - clear_has_catalog_name_filter(); - ::exec::user::LikeFilter* temp = catalog_name_filter_; - catalog_name_filter_ = NULL; - return temp; +inline void ResultColumnMetadata::clear_has_display_size() { + _has_bits_[0] &= ~0x00000400u; } -inline void GetColumnsReq::set_allocated_catalog_name_filter(::exec::user::LikeFilter* catalog_name_filter) { - delete catalog_name_filter_; - catalog_name_filter_ = catalog_name_filter; - if (catalog_name_filter) { - set_has_catalog_name_filter(); - } else { - clear_has_catalog_name_filter(); - } +inline void ResultColumnMetadata::clear_display_size() { + display_size_ = 0; + clear_has_display_size(); } - -// optional .exec.user.LikeFilter schema_name_filter = 2; -inline bool GetColumnsReq::has_schema_name_filter() const { - return (_has_bits_[0] & 0x00000002u) != 0; +inline ::google::protobuf::int32 ResultColumnMetadata::display_size() const { + return display_size_; } -inline void GetColumnsReq::set_has_schema_name_filter() { - _has_bits_[0] |= 0x00000002u; +inline void ResultColumnMetadata::set_display_size(::google::protobuf::int32 value) { + set_has_display_size(); + display_size_ = value; } -inline void GetColumnsReq::clear_has_schema_name_filter() { - _has_bits_[0] &= ~0x00000002u; + +// optional bool is_aliased = 12; +inline bool ResultColumnMetadata::has_is_aliased() const { + return (_has_bits_[0] & 0x00000800u) != 0; } -inline void GetColumnsReq::clear_schema_name_filter() { - if (schema_name_filter_ != NULL) schema_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_schema_name_filter(); +inline void ResultColumnMetadata::set_has_is_aliased() { + _has_bits_[0] |= 0x00000800u; } -inline const ::exec::user::LikeFilter& GetColumnsReq::schema_name_filter() const { - return schema_name_filter_ != NULL ? *schema_name_filter_ : *default_instance_->schema_name_filter_; +inline void ResultColumnMetadata::clear_has_is_aliased() { + _has_bits_[0] &= ~0x00000800u; } -inline ::exec::user::LikeFilter* GetColumnsReq::mutable_schema_name_filter() { - set_has_schema_name_filter(); - if (schema_name_filter_ == NULL) schema_name_filter_ = new ::exec::user::LikeFilter; - return schema_name_filter_; +inline void ResultColumnMetadata::clear_is_aliased() { + is_aliased_ = false; + clear_has_is_aliased(); } -inline ::exec::user::LikeFilter* GetColumnsReq::release_schema_name_filter() { - clear_has_schema_name_filter(); - ::exec::user::LikeFilter* temp = schema_name_filter_; - schema_name_filter_ = NULL; - return temp; +inline bool ResultColumnMetadata::is_aliased() const { + return is_aliased_; } -inline void GetColumnsReq::set_allocated_schema_name_filter(::exec::user::LikeFilter* schema_name_filter) { - delete schema_name_filter_; - schema_name_filter_ = schema_name_filter; - if (schema_name_filter) { - set_has_schema_name_filter(); - } else { - clear_has_schema_name_filter(); - } +inline void ResultColumnMetadata::set_is_aliased(bool value) { + set_has_is_aliased(); + is_aliased_ = value; } -// optional .exec.user.LikeFilter table_name_filter = 3; -inline bool GetColumnsReq::has_table_name_filter() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional .exec.user.ColumnSearchability searchability = 13; +inline bool ResultColumnMetadata::has_searchability() const { + return (_has_bits_[0] & 0x00001000u) != 0; } -inline void GetColumnsReq::set_has_table_name_filter() { - _has_bits_[0] |= 0x00000004u; +inline void ResultColumnMetadata::set_has_searchability() { + _has_bits_[0] |= 0x00001000u; } -inline void GetColumnsReq::clear_has_table_name_filter() { - _has_bits_[0] &= ~0x00000004u; +inline void ResultColumnMetadata::clear_has_searchability() { + _has_bits_[0] &= ~0x00001000u; } -inline void GetColumnsReq::clear_table_name_filter() { - if (table_name_filter_ != NULL) table_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_table_name_filter(); +inline void ResultColumnMetadata::clear_searchability() { + searchability_ = 0; + clear_has_searchability(); } -inline const ::exec::user::LikeFilter& GetColumnsReq::table_name_filter() const { - return table_name_filter_ != NULL ? *table_name_filter_ : *default_instance_->table_name_filter_; +inline ::exec::user::ColumnSearchability ResultColumnMetadata::searchability() const { + return static_cast< ::exec::user::ColumnSearchability >(searchability_); +} +inline void ResultColumnMetadata::set_searchability(::exec::user::ColumnSearchability value) { + assert(::exec::user::ColumnSearchability_IsValid(value)); + set_has_searchability(); + searchability_ = value; +} + +// optional .exec.user.ColumnUpdatability updatability = 14; +inline bool ResultColumnMetadata::has_updatability() const { + return (_has_bits_[0] & 0x00002000u) != 0; } -inline ::exec::user::LikeFilter* GetColumnsReq::mutable_table_name_filter() { - set_has_table_name_filter(); - if (table_name_filter_ == NULL) table_name_filter_ = new ::exec::user::LikeFilter; - return table_name_filter_; +inline void ResultColumnMetadata::set_has_updatability() { + _has_bits_[0] |= 0x00002000u; } -inline ::exec::user::LikeFilter* GetColumnsReq::release_table_name_filter() { - clear_has_table_name_filter(); - ::exec::user::LikeFilter* temp = table_name_filter_; - table_name_filter_ = NULL; - return temp; +inline void ResultColumnMetadata::clear_has_updatability() { + _has_bits_[0] &= ~0x00002000u; } -inline void GetColumnsReq::set_allocated_table_name_filter(::exec::user::LikeFilter* table_name_filter) { - delete table_name_filter_; - table_name_filter_ = table_name_filter; - if (table_name_filter) { - set_has_table_name_filter(); - } else { - clear_has_table_name_filter(); - } +inline void ResultColumnMetadata::clear_updatability() { + updatability_ = 0; + clear_has_updatability(); } - -// optional .exec.user.LikeFilter column_name_filter = 4; -inline bool GetColumnsReq::has_column_name_filter() const { - return (_has_bits_[0] & 0x00000008u) != 0; +inline ::exec::user::ColumnUpdatability ResultColumnMetadata::updatability() const { + return static_cast< ::exec::user::ColumnUpdatability >(updatability_); } -inline void GetColumnsReq::set_has_column_name_filter() { - _has_bits_[0] |= 0x00000008u; +inline void ResultColumnMetadata::set_updatability(::exec::user::ColumnUpdatability value) { + assert(::exec::user::ColumnUpdatability_IsValid(value)); + set_has_updatability(); + updatability_ = value; } -inline void GetColumnsReq::clear_has_column_name_filter() { - _has_bits_[0] &= ~0x00000008u; + +// optional bool auto_increment = 15; +inline bool ResultColumnMetadata::has_auto_increment() const { + return (_has_bits_[0] & 0x00004000u) != 0; } -inline void GetColumnsReq::clear_column_name_filter() { - if (column_name_filter_ != NULL) column_name_filter_->::exec::user::LikeFilter::Clear(); - clear_has_column_name_filter(); +inline void ResultColumnMetadata::set_has_auto_increment() { + _has_bits_[0] |= 0x00004000u; } -inline const ::exec::user::LikeFilter& GetColumnsReq::column_name_filter() const { - return column_name_filter_ != NULL ? *column_name_filter_ : *default_instance_->column_name_filter_; +inline void ResultColumnMetadata::clear_has_auto_increment() { + _has_bits_[0] &= ~0x00004000u; } -inline ::exec::user::LikeFilter* GetColumnsReq::mutable_column_name_filter() { - set_has_column_name_filter(); - if (column_name_filter_ == NULL) column_name_filter_ = new ::exec::user::LikeFilter; - return column_name_filter_; +inline void ResultColumnMetadata::clear_auto_increment() { + auto_increment_ = false; + clear_has_auto_increment(); } -inline ::exec::user::LikeFilter* GetColumnsReq::release_column_name_filter() { - clear_has_column_name_filter(); - ::exec::user::LikeFilter* temp = column_name_filter_; - column_name_filter_ = NULL; - return temp; +inline bool ResultColumnMetadata::auto_increment() const { + return auto_increment_; } -inline void GetColumnsReq::set_allocated_column_name_filter(::exec::user::LikeFilter* column_name_filter) { - delete column_name_filter_; - column_name_filter_ = column_name_filter; - if (column_name_filter) { - set_has_column_name_filter(); - } else { - clear_has_column_name_filter(); - } +inline void ResultColumnMetadata::set_auto_increment(bool value) { + set_has_auto_increment(); + auto_increment_ = value; } -// ------------------------------------------------------------------- - -// ColumnMetadata - -// optional string catalog_name = 1; -inline bool ColumnMetadata::has_catalog_name() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional bool case_sensitivity = 16; +inline bool ResultColumnMetadata::has_case_sensitivity() const { + return (_has_bits_[0] & 0x00008000u) != 0; } -inline void ColumnMetadata::set_has_catalog_name() { - _has_bits_[0] |= 0x00000001u; +inline void ResultColumnMetadata::set_has_case_sensitivity() { + _has_bits_[0] |= 0x00008000u; } -inline void ColumnMetadata::clear_has_catalog_name() { - _has_bits_[0] &= ~0x00000001u; +inline void ResultColumnMetadata::clear_has_case_sensitivity() { + _has_bits_[0] &= ~0x00008000u; } -inline void ColumnMetadata::clear_catalog_name() { - if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { - catalog_name_->clear(); - } - clear_has_catalog_name(); +inline void ResultColumnMetadata::clear_case_sensitivity() { + case_sensitivity_ = false; + clear_has_case_sensitivity(); } -inline const ::std::string& ColumnMetadata::catalog_name() const { - return *catalog_name_; +inline bool ResultColumnMetadata::case_sensitivity() const { + return case_sensitivity_; } -inline void ColumnMetadata::set_catalog_name(const ::std::string& value) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - catalog_name_->assign(value); +inline void ResultColumnMetadata::set_case_sensitivity(bool value) { + set_has_case_sensitivity(); + case_sensitivity_ = value; } -inline void ColumnMetadata::set_catalog_name(const char* value) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - catalog_name_->assign(value); + +// optional bool sortable = 17; +inline bool ResultColumnMetadata::has_sortable() const { + return (_has_bits_[0] & 0x00010000u) != 0; } -inline void ColumnMetadata::set_catalog_name(const char* value, size_t size) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - catalog_name_->assign(reinterpret_cast(value), size); +inline void ResultColumnMetadata::set_has_sortable() { + _has_bits_[0] |= 0x00010000u; } -inline ::std::string* ColumnMetadata::mutable_catalog_name() { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - return catalog_name_; +inline void ResultColumnMetadata::clear_has_sortable() { + _has_bits_[0] &= ~0x00010000u; } -inline ::std::string* ColumnMetadata::release_catalog_name() { - clear_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = catalog_name_; - catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ResultColumnMetadata::clear_sortable() { + sortable_ = false; + clear_has_sortable(); } -inline void ColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) { - if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { - delete catalog_name_; - } - if (catalog_name) { - set_has_catalog_name(); - catalog_name_ = catalog_name; - } else { - clear_has_catalog_name(); - catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline bool ResultColumnMetadata::sortable() const { + return sortable_; +} +inline void ResultColumnMetadata::set_sortable(bool value) { + set_has_sortable(); + sortable_ = value; } -// optional string schema_name = 2; -inline bool ColumnMetadata::has_schema_name() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// optional string class_name = 18; +inline bool ResultColumnMetadata::has_class_name() const { + return (_has_bits_[0] & 0x00020000u) != 0; } -inline void ColumnMetadata::set_has_schema_name() { - _has_bits_[0] |= 0x00000002u; +inline void ResultColumnMetadata::set_has_class_name() { + _has_bits_[0] |= 0x00020000u; } -inline void ColumnMetadata::clear_has_schema_name() { - _has_bits_[0] &= ~0x00000002u; +inline void ResultColumnMetadata::clear_has_class_name() { + _has_bits_[0] &= ~0x00020000u; } -inline void ColumnMetadata::clear_schema_name() { - if (schema_name_ != &::google::protobuf::internal::kEmptyString) { - schema_name_->clear(); +inline void ResultColumnMetadata::clear_class_name() { + if (class_name_ != &::google::protobuf::internal::kEmptyString) { + class_name_->clear(); } - clear_has_schema_name(); + clear_has_class_name(); } -inline const ::std::string& ColumnMetadata::schema_name() const { - return *schema_name_; +inline const ::std::string& ResultColumnMetadata::class_name() const { + return *class_name_; } -inline void ColumnMetadata::set_schema_name(const ::std::string& value) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; +inline void ResultColumnMetadata::set_class_name(const ::std::string& value) { + set_has_class_name(); + if (class_name_ == &::google::protobuf::internal::kEmptyString) { + class_name_ = new ::std::string; } - schema_name_->assign(value); + class_name_->assign(value); } -inline void ColumnMetadata::set_schema_name(const char* value) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; +inline void ResultColumnMetadata::set_class_name(const char* value) { + set_has_class_name(); + if (class_name_ == &::google::protobuf::internal::kEmptyString) { + class_name_ = new ::std::string; } - schema_name_->assign(value); + class_name_->assign(value); } -inline void ColumnMetadata::set_schema_name(const char* value, size_t size) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; +inline void ResultColumnMetadata::set_class_name(const char* value, size_t size) { + set_has_class_name(); + if (class_name_ == &::google::protobuf::internal::kEmptyString) { + class_name_ = new ::std::string; } - schema_name_->assign(reinterpret_cast(value), size); + class_name_->assign(reinterpret_cast(value), size); } -inline ::std::string* ColumnMetadata::mutable_schema_name() { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; +inline ::std::string* ResultColumnMetadata::mutable_class_name() { + set_has_class_name(); + if (class_name_ == &::google::protobuf::internal::kEmptyString) { + class_name_ = new ::std::string; } - return schema_name_; + return class_name_; } -inline ::std::string* ColumnMetadata::release_schema_name() { - clear_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ResultColumnMetadata::release_class_name() { + clear_has_class_name(); + if (class_name_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = schema_name_; - schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = class_name_; + class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void ColumnMetadata::set_allocated_schema_name(::std::string* schema_name) { - if (schema_name_ != &::google::protobuf::internal::kEmptyString) { - delete schema_name_; +inline void ResultColumnMetadata::set_allocated_class_name(::std::string* class_name) { + if (class_name_ != &::google::protobuf::internal::kEmptyString) { + delete class_name_; } - if (schema_name) { - set_has_schema_name(); - schema_name_ = schema_name; + if (class_name) { + set_has_class_name(); + class_name_ = class_name; } else { - clear_has_schema_name(); - schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_class_name(); + class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string table_name = 3; -inline bool ColumnMetadata::has_table_name() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional bool is_currency = 20; +inline bool ResultColumnMetadata::has_is_currency() const { + return (_has_bits_[0] & 0x00040000u) != 0; } -inline void ColumnMetadata::set_has_table_name() { - _has_bits_[0] |= 0x00000004u; +inline void ResultColumnMetadata::set_has_is_currency() { + _has_bits_[0] |= 0x00040000u; } -inline void ColumnMetadata::clear_has_table_name() { - _has_bits_[0] &= ~0x00000004u; +inline void ResultColumnMetadata::clear_has_is_currency() { + _has_bits_[0] &= ~0x00040000u; } -inline void ColumnMetadata::clear_table_name() { - if (table_name_ != &::google::protobuf::internal::kEmptyString) { - table_name_->clear(); +inline void ResultColumnMetadata::clear_is_currency() { + is_currency_ = false; + clear_has_is_currency(); +} +inline bool ResultColumnMetadata::is_currency() const { + return is_currency_; +} +inline void ResultColumnMetadata::set_is_currency(bool value) { + set_has_is_currency(); + is_currency_ = value; +} + +// ------------------------------------------------------------------- + +// PreparedStatementHandle + +// optional bytes server_info = 1; +inline bool PreparedStatementHandle::has_server_info() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PreparedStatementHandle::set_has_server_info() { + _has_bits_[0] |= 0x00000001u; +} +inline void PreparedStatementHandle::clear_has_server_info() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PreparedStatementHandle::clear_server_info() { + if (server_info_ != &::google::protobuf::internal::kEmptyString) { + server_info_->clear(); } - clear_has_table_name(); + clear_has_server_info(); } -inline const ::std::string& ColumnMetadata::table_name() const { - return *table_name_; +inline const ::std::string& PreparedStatementHandle::server_info() const { + return *server_info_; } -inline void ColumnMetadata::set_table_name(const ::std::string& value) { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; +inline void PreparedStatementHandle::set_server_info(const ::std::string& value) { + set_has_server_info(); + if (server_info_ == &::google::protobuf::internal::kEmptyString) { + server_info_ = new ::std::string; } - table_name_->assign(value); + server_info_->assign(value); } -inline void ColumnMetadata::set_table_name(const char* value) { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; +inline void PreparedStatementHandle::set_server_info(const char* value) { + set_has_server_info(); + if (server_info_ == &::google::protobuf::internal::kEmptyString) { + server_info_ = new ::std::string; } - table_name_->assign(value); + server_info_->assign(value); } -inline void ColumnMetadata::set_table_name(const char* value, size_t size) { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; +inline void PreparedStatementHandle::set_server_info(const void* value, size_t size) { + set_has_server_info(); + if (server_info_ == &::google::protobuf::internal::kEmptyString) { + server_info_ = new ::std::string; } - table_name_->assign(reinterpret_cast(value), size); + server_info_->assign(reinterpret_cast(value), size); } -inline ::std::string* ColumnMetadata::mutable_table_name() { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; +inline ::std::string* PreparedStatementHandle::mutable_server_info() { + set_has_server_info(); + if (server_info_ == &::google::protobuf::internal::kEmptyString) { + server_info_ = new ::std::string; } - return table_name_; + return server_info_; } -inline ::std::string* ColumnMetadata::release_table_name() { - clear_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* PreparedStatementHandle::release_server_info() { + clear_has_server_info(); + if (server_info_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = table_name_; - table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = server_info_; + server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void ColumnMetadata::set_allocated_table_name(::std::string* table_name) { - if (table_name_ != &::google::protobuf::internal::kEmptyString) { - delete table_name_; +inline void PreparedStatementHandle::set_allocated_server_info(::std::string* server_info) { + if (server_info_ != &::google::protobuf::internal::kEmptyString) { + delete server_info_; } - if (table_name) { - set_has_table_name(); - table_name_ = table_name; + if (server_info) { + set_has_server_info(); + server_info_ = server_info; } else { - clear_has_table_name(); - table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_server_info(); + server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional string column_name = 4; -inline bool ColumnMetadata::has_column_name() const { - return (_has_bits_[0] & 0x00000008u) != 0; +// ------------------------------------------------------------------- + +// PreparedStatement + +// repeated .exec.user.ResultColumnMetadata columns = 1; +inline int PreparedStatement::columns_size() const { + return columns_.size(); } -inline void ColumnMetadata::set_has_column_name() { - _has_bits_[0] |= 0x00000008u; +inline void PreparedStatement::clear_columns() { + columns_.Clear(); } -inline void ColumnMetadata::clear_has_column_name() { - _has_bits_[0] &= ~0x00000008u; +inline const ::exec::user::ResultColumnMetadata& PreparedStatement::columns(int index) const { + return columns_.Get(index); } -inline void ColumnMetadata::clear_column_name() { - if (column_name_ != &::google::protobuf::internal::kEmptyString) { - column_name_->clear(); - } - clear_has_column_name(); +inline ::exec::user::ResultColumnMetadata* PreparedStatement::mutable_columns(int index) { + return columns_.Mutable(index); } -inline const ::std::string& ColumnMetadata::column_name() const { - return *column_name_; +inline ::exec::user::ResultColumnMetadata* PreparedStatement::add_columns() { + return columns_.Add(); } -inline void ColumnMetadata::set_column_name(const ::std::string& value) { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - column_name_->assign(value); +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >& +PreparedStatement::columns() const { + return columns_; } -inline void ColumnMetadata::set_column_name(const char* value) { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - column_name_->assign(value); +inline ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >* +PreparedStatement::mutable_columns() { + return &columns_; } -inline void ColumnMetadata::set_column_name(const char* value, size_t size) { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - column_name_->assign(reinterpret_cast(value), size); + +// optional .exec.user.PreparedStatementHandle server_handle = 2; +inline bool PreparedStatement::has_server_handle() const { + return (_has_bits_[0] & 0x00000002u) != 0; } -inline ::std::string* ColumnMetadata::mutable_column_name() { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - return column_name_; +inline void PreparedStatement::set_has_server_handle() { + _has_bits_[0] |= 0x00000002u; } -inline ::std::string* ColumnMetadata::release_column_name() { - clear_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = column_name_; - column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void PreparedStatement::clear_has_server_handle() { + _has_bits_[0] &= ~0x00000002u; } -inline void ColumnMetadata::set_allocated_column_name(::std::string* column_name) { - if (column_name_ != &::google::protobuf::internal::kEmptyString) { - delete column_name_; - } - if (column_name) { - set_has_column_name(); - column_name_ = column_name; +inline void PreparedStatement::clear_server_handle() { + if (server_handle_ != NULL) server_handle_->::exec::user::PreparedStatementHandle::Clear(); + clear_has_server_handle(); +} +inline const ::exec::user::PreparedStatementHandle& PreparedStatement::server_handle() const { + return server_handle_ != NULL ? *server_handle_ : *default_instance_->server_handle_; +} +inline ::exec::user::PreparedStatementHandle* PreparedStatement::mutable_server_handle() { + set_has_server_handle(); + if (server_handle_ == NULL) server_handle_ = new ::exec::user::PreparedStatementHandle; + return server_handle_; +} +inline ::exec::user::PreparedStatementHandle* PreparedStatement::release_server_handle() { + clear_has_server_handle(); + ::exec::user::PreparedStatementHandle* temp = server_handle_; + server_handle_ = NULL; + return temp; +} +inline void PreparedStatement::set_allocated_server_handle(::exec::user::PreparedStatementHandle* server_handle) { + delete server_handle_; + server_handle_ = server_handle; + if (server_handle) { + set_has_server_handle(); } else { - clear_has_column_name(); - column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_server_handle(); } } - -// optional int32 ordinal_position = 5; -inline bool ColumnMetadata::has_ordinal_position() const { - return (_has_bits_[0] & 0x00000010u) != 0; + +// ------------------------------------------------------------------- + +// CreatePreparedStatementResp + +// optional .exec.user.RequestStatus status = 1; +inline bool CreatePreparedStatementResp::has_status() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CreatePreparedStatementResp::set_has_status() { + _has_bits_[0] |= 0x00000001u; +} +inline void CreatePreparedStatementResp::clear_has_status() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CreatePreparedStatementResp::clear_status() { + status_ = 0; + clear_has_status(); +} +inline ::exec::user::RequestStatus CreatePreparedStatementResp::status() const { + return static_cast< ::exec::user::RequestStatus >(status_); } -inline void ColumnMetadata::set_has_ordinal_position() { - _has_bits_[0] |= 0x00000010u; +inline void CreatePreparedStatementResp::set_status(::exec::user::RequestStatus value) { + assert(::exec::user::RequestStatus_IsValid(value)); + set_has_status(); + status_ = value; } -inline void ColumnMetadata::clear_has_ordinal_position() { - _has_bits_[0] &= ~0x00000010u; + +// optional .exec.user.PreparedStatement prepared_statement = 2; +inline bool CreatePreparedStatementResp::has_prepared_statement() const { + return (_has_bits_[0] & 0x00000002u) != 0; } -inline void ColumnMetadata::clear_ordinal_position() { - ordinal_position_ = 0; - clear_has_ordinal_position(); +inline void CreatePreparedStatementResp::set_has_prepared_statement() { + _has_bits_[0] |= 0x00000002u; } -inline ::google::protobuf::int32 ColumnMetadata::ordinal_position() const { - return ordinal_position_; +inline void CreatePreparedStatementResp::clear_has_prepared_statement() { + _has_bits_[0] &= ~0x00000002u; } -inline void ColumnMetadata::set_ordinal_position(::google::protobuf::int32 value) { - set_has_ordinal_position(); - ordinal_position_ = value; +inline void CreatePreparedStatementResp::clear_prepared_statement() { + if (prepared_statement_ != NULL) prepared_statement_->::exec::user::PreparedStatement::Clear(); + clear_has_prepared_statement(); } - -// optional string default_value = 6; -inline bool ColumnMetadata::has_default_value() const { - return (_has_bits_[0] & 0x00000020u) != 0; +inline const ::exec::user::PreparedStatement& CreatePreparedStatementResp::prepared_statement() const { + return prepared_statement_ != NULL ? *prepared_statement_ : *default_instance_->prepared_statement_; } -inline void ColumnMetadata::set_has_default_value() { - _has_bits_[0] |= 0x00000020u; +inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::mutable_prepared_statement() { + set_has_prepared_statement(); + if (prepared_statement_ == NULL) prepared_statement_ = new ::exec::user::PreparedStatement; + return prepared_statement_; } -inline void ColumnMetadata::clear_has_default_value() { - _has_bits_[0] &= ~0x00000020u; +inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::release_prepared_statement() { + clear_has_prepared_statement(); + ::exec::user::PreparedStatement* temp = prepared_statement_; + prepared_statement_ = NULL; + return temp; } -inline void ColumnMetadata::clear_default_value() { - if (default_value_ != &::google::protobuf::internal::kEmptyString) { - default_value_->clear(); +inline void CreatePreparedStatementResp::set_allocated_prepared_statement(::exec::user::PreparedStatement* prepared_statement) { + delete prepared_statement_; + prepared_statement_ = prepared_statement; + if (prepared_statement) { + set_has_prepared_statement(); + } else { + clear_has_prepared_statement(); } - clear_has_default_value(); } -inline const ::std::string& ColumnMetadata::default_value() const { - return *default_value_; + +// optional .exec.shared.DrillPBError error = 3; +inline bool CreatePreparedStatementResp::has_error() const { + return (_has_bits_[0] & 0x00000004u) != 0; } -inline void ColumnMetadata::set_default_value(const ::std::string& value) { - set_has_default_value(); - if (default_value_ == &::google::protobuf::internal::kEmptyString) { - default_value_ = new ::std::string; - } - default_value_->assign(value); +inline void CreatePreparedStatementResp::set_has_error() { + _has_bits_[0] |= 0x00000004u; } -inline void ColumnMetadata::set_default_value(const char* value) { - set_has_default_value(); - if (default_value_ == &::google::protobuf::internal::kEmptyString) { - default_value_ = new ::std::string; - } - default_value_->assign(value); +inline void CreatePreparedStatementResp::clear_has_error() { + _has_bits_[0] &= ~0x00000004u; } -inline void ColumnMetadata::set_default_value(const char* value, size_t size) { - set_has_default_value(); - if (default_value_ == &::google::protobuf::internal::kEmptyString) { - default_value_ = new ::std::string; - } - default_value_->assign(reinterpret_cast(value), size); +inline void CreatePreparedStatementResp::clear_error() { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + clear_has_error(); } -inline ::std::string* ColumnMetadata::mutable_default_value() { - set_has_default_value(); - if (default_value_ == &::google::protobuf::internal::kEmptyString) { - default_value_ = new ::std::string; - } - return default_value_; +inline const ::exec::shared::DrillPBError& CreatePreparedStatementResp::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; } -inline ::std::string* ColumnMetadata::release_default_value() { - clear_has_default_value(); - if (default_value_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = default_value_; - default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; + return error_; } -inline void ColumnMetadata::set_allocated_default_value(::std::string* default_value) { - if (default_value_ != &::google::protobuf::internal::kEmptyString) { - delete default_value_; - } - if (default_value) { - set_has_default_value(); - default_value_ = default_value; +inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::release_error() { + clear_has_error(); + ::exec::shared::DrillPBError* temp = error_; + error_ = NULL; + return temp; +} +inline void CreatePreparedStatementResp::set_allocated_error(::exec::shared::DrillPBError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); } else { - clear_has_default_value(); - default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_error(); } } -// optional bool is_nullable = 7; -inline bool ColumnMetadata::has_is_nullable() const { - return (_has_bits_[0] & 0x00000040u) != 0; +// ------------------------------------------------------------------- + +// GetServerMetaReq + +// ------------------------------------------------------------------- + +// ConvertSupport + +// required .common.MinorType from = 1; +inline bool ConvertSupport::has_from() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void ColumnMetadata::set_has_is_nullable() { - _has_bits_[0] |= 0x00000040u; +inline void ConvertSupport::set_has_from() { + _has_bits_[0] |= 0x00000001u; } -inline void ColumnMetadata::clear_has_is_nullable() { - _has_bits_[0] &= ~0x00000040u; +inline void ConvertSupport::clear_has_from() { + _has_bits_[0] &= ~0x00000001u; } -inline void ColumnMetadata::clear_is_nullable() { - is_nullable_ = false; - clear_has_is_nullable(); +inline void ConvertSupport::clear_from() { + from_ = 0; + clear_has_from(); } -inline bool ColumnMetadata::is_nullable() const { - return is_nullable_; +inline ::common::MinorType ConvertSupport::from() const { + return static_cast< ::common::MinorType >(from_); } -inline void ColumnMetadata::set_is_nullable(bool value) { - set_has_is_nullable(); - is_nullable_ = value; +inline void ConvertSupport::set_from(::common::MinorType value) { + assert(::common::MinorType_IsValid(value)); + set_has_from(); + from_ = value; } -// optional string data_type = 8; -inline bool ColumnMetadata::has_data_type() const { - return (_has_bits_[0] & 0x00000080u) != 0; +// required .common.MinorType to = 2; +inline bool ConvertSupport::has_to() const { + return (_has_bits_[0] & 0x00000002u) != 0; } -inline void ColumnMetadata::set_has_data_type() { - _has_bits_[0] |= 0x00000080u; +inline void ConvertSupport::set_has_to() { + _has_bits_[0] |= 0x00000002u; } -inline void ColumnMetadata::clear_has_data_type() { - _has_bits_[0] &= ~0x00000080u; +inline void ConvertSupport::clear_has_to() { + _has_bits_[0] &= ~0x00000002u; } -inline void ColumnMetadata::clear_data_type() { - if (data_type_ != &::google::protobuf::internal::kEmptyString) { - data_type_->clear(); - } - clear_has_data_type(); +inline void ConvertSupport::clear_to() { + to_ = 0; + clear_has_to(); } -inline const ::std::string& ColumnMetadata::data_type() const { - return *data_type_; +inline ::common::MinorType ConvertSupport::to() const { + return static_cast< ::common::MinorType >(to_); } -inline void ColumnMetadata::set_data_type(const ::std::string& value) { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - data_type_->assign(value); +inline void ConvertSupport::set_to(::common::MinorType value) { + assert(::common::MinorType_IsValid(value)); + set_has_to(); + to_ = value; } -inline void ColumnMetadata::set_data_type(const char* value) { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - data_type_->assign(value); + +// ------------------------------------------------------------------- + +// GetServerMetaResp + +// optional .exec.user.RequestStatus status = 1; +inline bool GetServerMetaResp::has_status() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void ColumnMetadata::set_data_type(const char* value, size_t size) { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - data_type_->assign(reinterpret_cast(value), size); +inline void GetServerMetaResp::set_has_status() { + _has_bits_[0] |= 0x00000001u; } -inline ::std::string* ColumnMetadata::mutable_data_type() { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - return data_type_; +inline void GetServerMetaResp::clear_has_status() { + _has_bits_[0] &= ~0x00000001u; } -inline ::std::string* ColumnMetadata::release_data_type() { - clear_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = data_type_; - data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void GetServerMetaResp::clear_status() { + status_ = 0; + clear_has_status(); } -inline void ColumnMetadata::set_allocated_data_type(::std::string* data_type) { - if (data_type_ != &::google::protobuf::internal::kEmptyString) { - delete data_type_; - } - if (data_type) { - set_has_data_type(); - data_type_ = data_type; +inline ::exec::user::RequestStatus GetServerMetaResp::status() const { + return static_cast< ::exec::user::RequestStatus >(status_); +} +inline void GetServerMetaResp::set_status(::exec::user::RequestStatus value) { + assert(::exec::user::RequestStatus_IsValid(value)); + set_has_status(); + status_ = value; +} + +// optional .exec.user.ServerMeta server_meta = 2; +inline bool GetServerMetaResp::has_server_meta() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void GetServerMetaResp::set_has_server_meta() { + _has_bits_[0] |= 0x00000002u; +} +inline void GetServerMetaResp::clear_has_server_meta() { + _has_bits_[0] &= ~0x00000002u; +} +inline void GetServerMetaResp::clear_server_meta() { + if (server_meta_ != NULL) server_meta_->::exec::user::ServerMeta::Clear(); + clear_has_server_meta(); +} +inline const ::exec::user::ServerMeta& GetServerMetaResp::server_meta() const { + return server_meta_ != NULL ? *server_meta_ : *default_instance_->server_meta_; +} +inline ::exec::user::ServerMeta* GetServerMetaResp::mutable_server_meta() { + set_has_server_meta(); + if (server_meta_ == NULL) server_meta_ = new ::exec::user::ServerMeta; + return server_meta_; +} +inline ::exec::user::ServerMeta* GetServerMetaResp::release_server_meta() { + clear_has_server_meta(); + ::exec::user::ServerMeta* temp = server_meta_; + server_meta_ = NULL; + return temp; +} +inline void GetServerMetaResp::set_allocated_server_meta(::exec::user::ServerMeta* server_meta) { + delete server_meta_; + server_meta_ = server_meta; + if (server_meta) { + set_has_server_meta(); } else { - clear_has_data_type(); - data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_server_meta(); } } -// optional int32 char_max_length = 9; -inline bool ColumnMetadata::has_char_max_length() const { - return (_has_bits_[0] & 0x00000100u) != 0; +// optional .exec.shared.DrillPBError error = 3; +inline bool GetServerMetaResp::has_error() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void GetServerMetaResp::set_has_error() { + _has_bits_[0] |= 0x00000004u; +} +inline void GetServerMetaResp::clear_has_error() { + _has_bits_[0] &= ~0x00000004u; } -inline void ColumnMetadata::set_has_char_max_length() { - _has_bits_[0] |= 0x00000100u; +inline void GetServerMetaResp::clear_error() { + if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); + clear_has_error(); } -inline void ColumnMetadata::clear_has_char_max_length() { - _has_bits_[0] &= ~0x00000100u; +inline const ::exec::shared::DrillPBError& GetServerMetaResp::error() const { + return error_ != NULL ? *error_ : *default_instance_->error_; } -inline void ColumnMetadata::clear_char_max_length() { - char_max_length_ = 0; - clear_has_char_max_length(); +inline ::exec::shared::DrillPBError* GetServerMetaResp::mutable_error() { + set_has_error(); + if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; + return error_; } -inline ::google::protobuf::int32 ColumnMetadata::char_max_length() const { - return char_max_length_; +inline ::exec::shared::DrillPBError* GetServerMetaResp::release_error() { + clear_has_error(); + ::exec::shared::DrillPBError* temp = error_; + error_ = NULL; + return temp; } -inline void ColumnMetadata::set_char_max_length(::google::protobuf::int32 value) { - set_has_char_max_length(); - char_max_length_ = value; +inline void GetServerMetaResp::set_allocated_error(::exec::shared::DrillPBError* error) { + delete error_; + error_ = error; + if (error) { + set_has_error(); + } else { + clear_has_error(); + } } -// optional int32 char_octet_length = 10; -inline bool ColumnMetadata::has_char_octet_length() const { - return (_has_bits_[0] & 0x00000200u) != 0; +// ------------------------------------------------------------------- + +// ServerMeta + +// optional bool all_tables_selectable = 1; +inline bool ServerMeta::has_all_tables_selectable() const { + return (_has_bits_[0] & 0x00000001u) != 0; } -inline void ColumnMetadata::set_has_char_octet_length() { - _has_bits_[0] |= 0x00000200u; +inline void ServerMeta::set_has_all_tables_selectable() { + _has_bits_[0] |= 0x00000001u; } -inline void ColumnMetadata::clear_has_char_octet_length() { - _has_bits_[0] &= ~0x00000200u; +inline void ServerMeta::clear_has_all_tables_selectable() { + _has_bits_[0] &= ~0x00000001u; } -inline void ColumnMetadata::clear_char_octet_length() { - char_octet_length_ = 0; - clear_has_char_octet_length(); +inline void ServerMeta::clear_all_tables_selectable() { + all_tables_selectable_ = false; + clear_has_all_tables_selectable(); } -inline ::google::protobuf::int32 ColumnMetadata::char_octet_length() const { - return char_octet_length_; +inline bool ServerMeta::all_tables_selectable() const { + return all_tables_selectable_; } -inline void ColumnMetadata::set_char_octet_length(::google::protobuf::int32 value) { - set_has_char_octet_length(); - char_octet_length_ = value; +inline void ServerMeta::set_all_tables_selectable(bool value) { + set_has_all_tables_selectable(); + all_tables_selectable_ = value; } -// optional int32 numeric_precision = 11; -inline bool ColumnMetadata::has_numeric_precision() const { - return (_has_bits_[0] & 0x00000400u) != 0; +// optional bool blob_included_in_max_row_size = 2; +inline bool ServerMeta::has_blob_included_in_max_row_size() const { + return (_has_bits_[0] & 0x00000002u) != 0; } -inline void ColumnMetadata::set_has_numeric_precision() { - _has_bits_[0] |= 0x00000400u; +inline void ServerMeta::set_has_blob_included_in_max_row_size() { + _has_bits_[0] |= 0x00000002u; } -inline void ColumnMetadata::clear_has_numeric_precision() { - _has_bits_[0] &= ~0x00000400u; +inline void ServerMeta::clear_has_blob_included_in_max_row_size() { + _has_bits_[0] &= ~0x00000002u; } -inline void ColumnMetadata::clear_numeric_precision() { - numeric_precision_ = 0; - clear_has_numeric_precision(); +inline void ServerMeta::clear_blob_included_in_max_row_size() { + blob_included_in_max_row_size_ = false; + clear_has_blob_included_in_max_row_size(); } -inline ::google::protobuf::int32 ColumnMetadata::numeric_precision() const { - return numeric_precision_; +inline bool ServerMeta::blob_included_in_max_row_size() const { + return blob_included_in_max_row_size_; } -inline void ColumnMetadata::set_numeric_precision(::google::protobuf::int32 value) { - set_has_numeric_precision(); - numeric_precision_ = value; +inline void ServerMeta::set_blob_included_in_max_row_size(bool value) { + set_has_blob_included_in_max_row_size(); + blob_included_in_max_row_size_ = value; } -// optional int32 numeric_precision_radix = 12; -inline bool ColumnMetadata::has_numeric_precision_radix() const { - return (_has_bits_[0] & 0x00000800u) != 0; +// optional bool catalog_at_start = 3; +inline bool ServerMeta::has_catalog_at_start() const { + return (_has_bits_[0] & 0x00000004u) != 0; } -inline void ColumnMetadata::set_has_numeric_precision_radix() { - _has_bits_[0] |= 0x00000800u; +inline void ServerMeta::set_has_catalog_at_start() { + _has_bits_[0] |= 0x00000004u; } -inline void ColumnMetadata::clear_has_numeric_precision_radix() { - _has_bits_[0] &= ~0x00000800u; +inline void ServerMeta::clear_has_catalog_at_start() { + _has_bits_[0] &= ~0x00000004u; } -inline void ColumnMetadata::clear_numeric_precision_radix() { - numeric_precision_radix_ = 0; - clear_has_numeric_precision_radix(); +inline void ServerMeta::clear_catalog_at_start() { + catalog_at_start_ = false; + clear_has_catalog_at_start(); } -inline ::google::protobuf::int32 ColumnMetadata::numeric_precision_radix() const { - return numeric_precision_radix_; +inline bool ServerMeta::catalog_at_start() const { + return catalog_at_start_; } -inline void ColumnMetadata::set_numeric_precision_radix(::google::protobuf::int32 value) { - set_has_numeric_precision_radix(); - numeric_precision_radix_ = value; +inline void ServerMeta::set_catalog_at_start(bool value) { + set_has_catalog_at_start(); + catalog_at_start_ = value; } -// optional int32 numeric_scale = 13; -inline bool ColumnMetadata::has_numeric_scale() const { - return (_has_bits_[0] & 0x00001000u) != 0; -} -inline void ColumnMetadata::set_has_numeric_scale() { - _has_bits_[0] |= 0x00001000u; +// optional string catalog_separator = 4; +inline bool ServerMeta::has_catalog_separator() const { + return (_has_bits_[0] & 0x00000008u) != 0; } -inline void ColumnMetadata::clear_has_numeric_scale() { - _has_bits_[0] &= ~0x00001000u; +inline void ServerMeta::set_has_catalog_separator() { + _has_bits_[0] |= 0x00000008u; } -inline void ColumnMetadata::clear_numeric_scale() { - numeric_scale_ = 0; - clear_has_numeric_scale(); +inline void ServerMeta::clear_has_catalog_separator() { + _has_bits_[0] &= ~0x00000008u; } -inline ::google::protobuf::int32 ColumnMetadata::numeric_scale() const { - return numeric_scale_; +inline void ServerMeta::clear_catalog_separator() { + if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) { + catalog_separator_->clear(); + } + clear_has_catalog_separator(); } -inline void ColumnMetadata::set_numeric_scale(::google::protobuf::int32 value) { - set_has_numeric_scale(); - numeric_scale_ = value; +inline const ::std::string& ServerMeta::catalog_separator() const { + return *catalog_separator_; } - -// optional int32 date_time_precision = 14; -inline bool ColumnMetadata::has_date_time_precision() const { - return (_has_bits_[0] & 0x00002000u) != 0; +inline void ServerMeta::set_catalog_separator(const ::std::string& value) { + set_has_catalog_separator(); + if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) { + catalog_separator_ = new ::std::string; + } + catalog_separator_->assign(value); } -inline void ColumnMetadata::set_has_date_time_precision() { - _has_bits_[0] |= 0x00002000u; +inline void ServerMeta::set_catalog_separator(const char* value) { + set_has_catalog_separator(); + if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) { + catalog_separator_ = new ::std::string; + } + catalog_separator_->assign(value); } -inline void ColumnMetadata::clear_has_date_time_precision() { - _has_bits_[0] &= ~0x00002000u; +inline void ServerMeta::set_catalog_separator(const char* value, size_t size) { + set_has_catalog_separator(); + if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) { + catalog_separator_ = new ::std::string; + } + catalog_separator_->assign(reinterpret_cast(value), size); } -inline void ColumnMetadata::clear_date_time_precision() { - date_time_precision_ = 0; - clear_has_date_time_precision(); +inline ::std::string* ServerMeta::mutable_catalog_separator() { + set_has_catalog_separator(); + if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) { + catalog_separator_ = new ::std::string; + } + return catalog_separator_; } -inline ::google::protobuf::int32 ColumnMetadata::date_time_precision() const { - return date_time_precision_; +inline ::std::string* ServerMeta::release_catalog_separator() { + clear_has_catalog_separator(); + if (catalog_separator_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = catalog_separator_; + catalog_separator_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } } -inline void ColumnMetadata::set_date_time_precision(::google::protobuf::int32 value) { - set_has_date_time_precision(); - date_time_precision_ = value; +inline void ServerMeta::set_allocated_catalog_separator(::std::string* catalog_separator) { + if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_separator_; + } + if (catalog_separator) { + set_has_catalog_separator(); + catalog_separator_ = catalog_separator; + } else { + clear_has_catalog_separator(); + catalog_separator_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional string interval_type = 15; -inline bool ColumnMetadata::has_interval_type() const { - return (_has_bits_[0] & 0x00004000u) != 0; +// optional string catalog_term = 5; +inline bool ServerMeta::has_catalog_term() const { + return (_has_bits_[0] & 0x00000010u) != 0; } -inline void ColumnMetadata::set_has_interval_type() { - _has_bits_[0] |= 0x00004000u; +inline void ServerMeta::set_has_catalog_term() { + _has_bits_[0] |= 0x00000010u; } -inline void ColumnMetadata::clear_has_interval_type() { - _has_bits_[0] &= ~0x00004000u; +inline void ServerMeta::clear_has_catalog_term() { + _has_bits_[0] &= ~0x00000010u; } -inline void ColumnMetadata::clear_interval_type() { - if (interval_type_ != &::google::protobuf::internal::kEmptyString) { - interval_type_->clear(); +inline void ServerMeta::clear_catalog_term() { + if (catalog_term_ != &::google::protobuf::internal::kEmptyString) { + catalog_term_->clear(); } - clear_has_interval_type(); + clear_has_catalog_term(); } -inline const ::std::string& ColumnMetadata::interval_type() const { - return *interval_type_; +inline const ::std::string& ServerMeta::catalog_term() const { + return *catalog_term_; } -inline void ColumnMetadata::set_interval_type(const ::std::string& value) { - set_has_interval_type(); - if (interval_type_ == &::google::protobuf::internal::kEmptyString) { - interval_type_ = new ::std::string; +inline void ServerMeta::set_catalog_term(const ::std::string& value) { + set_has_catalog_term(); + if (catalog_term_ == &::google::protobuf::internal::kEmptyString) { + catalog_term_ = new ::std::string; } - interval_type_->assign(value); + catalog_term_->assign(value); } -inline void ColumnMetadata::set_interval_type(const char* value) { - set_has_interval_type(); - if (interval_type_ == &::google::protobuf::internal::kEmptyString) { - interval_type_ = new ::std::string; +inline void ServerMeta::set_catalog_term(const char* value) { + set_has_catalog_term(); + if (catalog_term_ == &::google::protobuf::internal::kEmptyString) { + catalog_term_ = new ::std::string; } - interval_type_->assign(value); + catalog_term_->assign(value); } -inline void ColumnMetadata::set_interval_type(const char* value, size_t size) { - set_has_interval_type(); - if (interval_type_ == &::google::protobuf::internal::kEmptyString) { - interval_type_ = new ::std::string; +inline void ServerMeta::set_catalog_term(const char* value, size_t size) { + set_has_catalog_term(); + if (catalog_term_ == &::google::protobuf::internal::kEmptyString) { + catalog_term_ = new ::std::string; } - interval_type_->assign(reinterpret_cast(value), size); + catalog_term_->assign(reinterpret_cast(value), size); } -inline ::std::string* ColumnMetadata::mutable_interval_type() { - set_has_interval_type(); - if (interval_type_ == &::google::protobuf::internal::kEmptyString) { - interval_type_ = new ::std::string; +inline ::std::string* ServerMeta::mutable_catalog_term() { + set_has_catalog_term(); + if (catalog_term_ == &::google::protobuf::internal::kEmptyString) { + catalog_term_ = new ::std::string; } - return interval_type_; + return catalog_term_; } -inline ::std::string* ColumnMetadata::release_interval_type() { - clear_has_interval_type(); - if (interval_type_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ServerMeta::release_catalog_term() { + clear_has_catalog_term(); + if (catalog_term_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = interval_type_; - interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = catalog_term_; + catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void ColumnMetadata::set_allocated_interval_type(::std::string* interval_type) { - if (interval_type_ != &::google::protobuf::internal::kEmptyString) { - delete interval_type_; +inline void ServerMeta::set_allocated_catalog_term(::std::string* catalog_term) { + if (catalog_term_ != &::google::protobuf::internal::kEmptyString) { + delete catalog_term_; } - if (interval_type) { - set_has_interval_type(); - interval_type_ = interval_type; + if (catalog_term) { + set_has_catalog_term(); + catalog_term_ = catalog_term; } else { - clear_has_interval_type(); - interval_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_catalog_term(); + catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional int32 interval_precision = 16; -inline bool ColumnMetadata::has_interval_precision() const { - return (_has_bits_[0] & 0x00008000u) != 0; +// repeated .exec.user.CollateSupport collate_support = 6; +inline int ServerMeta::collate_support_size() const { + return collate_support_.size(); } -inline void ColumnMetadata::set_has_interval_precision() { - _has_bits_[0] |= 0x00008000u; +inline void ServerMeta::clear_collate_support() { + collate_support_.Clear(); } -inline void ColumnMetadata::clear_has_interval_precision() { - _has_bits_[0] &= ~0x00008000u; +inline ::exec::user::CollateSupport ServerMeta::collate_support(int index) const { + return static_cast< ::exec::user::CollateSupport >(collate_support_.Get(index)); } -inline void ColumnMetadata::clear_interval_precision() { - interval_precision_ = 0; - clear_has_interval_precision(); +inline void ServerMeta::set_collate_support(int index, ::exec::user::CollateSupport value) { + assert(::exec::user::CollateSupport_IsValid(value)); + collate_support_.Set(index, value); } -inline ::google::protobuf::int32 ColumnMetadata::interval_precision() const { - return interval_precision_; +inline void ServerMeta::add_collate_support(::exec::user::CollateSupport value) { + assert(::exec::user::CollateSupport_IsValid(value)); + collate_support_.Add(value); } -inline void ColumnMetadata::set_interval_precision(::google::protobuf::int32 value) { - set_has_interval_precision(); - interval_precision_ = value; +inline const ::google::protobuf::RepeatedField& +ServerMeta::collate_support() const { + return collate_support_; +} +inline ::google::protobuf::RepeatedField* +ServerMeta::mutable_collate_support() { + return &collate_support_; } -// optional int32 column_size = 17; -inline bool ColumnMetadata::has_column_size() const { - return (_has_bits_[0] & 0x00010000u) != 0; +// optional bool column_aliasing_supported = 7; +inline bool ServerMeta::has_column_aliasing_supported() const { + return (_has_bits_[0] & 0x00000040u) != 0; } -inline void ColumnMetadata::set_has_column_size() { - _has_bits_[0] |= 0x00010000u; +inline void ServerMeta::set_has_column_aliasing_supported() { + _has_bits_[0] |= 0x00000040u; } -inline void ColumnMetadata::clear_has_column_size() { - _has_bits_[0] &= ~0x00010000u; +inline void ServerMeta::clear_has_column_aliasing_supported() { + _has_bits_[0] &= ~0x00000040u; } -inline void ColumnMetadata::clear_column_size() { - column_size_ = 0; - clear_has_column_size(); +inline void ServerMeta::clear_column_aliasing_supported() { + column_aliasing_supported_ = false; + clear_has_column_aliasing_supported(); } -inline ::google::protobuf::int32 ColumnMetadata::column_size() const { - return column_size_; +inline bool ServerMeta::column_aliasing_supported() const { + return column_aliasing_supported_; } -inline void ColumnMetadata::set_column_size(::google::protobuf::int32 value) { - set_has_column_size(); - column_size_ = value; +inline void ServerMeta::set_column_aliasing_supported(bool value) { + set_has_column_aliasing_supported(); + column_aliasing_supported_ = value; } -// ------------------------------------------------------------------- +// repeated .exec.user.ConvertSupport convert_support = 8; +inline int ServerMeta::convert_support_size() const { + return convert_support_.size(); +} +inline void ServerMeta::clear_convert_support() { + convert_support_.Clear(); +} +inline const ::exec::user::ConvertSupport& ServerMeta::convert_support(int index) const { + return convert_support_.Get(index); +} +inline ::exec::user::ConvertSupport* ServerMeta::mutable_convert_support(int index) { + return convert_support_.Mutable(index); +} +inline ::exec::user::ConvertSupport* ServerMeta::add_convert_support() { + return convert_support_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >& +ServerMeta::convert_support() const { + return convert_support_; +} +inline ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport >* +ServerMeta::mutable_convert_support() { + return &convert_support_; +} -// GetColumnsResp +// optional .exec.user.CorrelationNamesSupport correlation_names_support = 9; +inline bool ServerMeta::has_correlation_names_support() const { + return (_has_bits_[0] & 0x00000100u) != 0; +} +inline void ServerMeta::set_has_correlation_names_support() { + _has_bits_[0] |= 0x00000100u; +} +inline void ServerMeta::clear_has_correlation_names_support() { + _has_bits_[0] &= ~0x00000100u; +} +inline void ServerMeta::clear_correlation_names_support() { + correlation_names_support_ = 1; + clear_has_correlation_names_support(); +} +inline ::exec::user::CorrelationNamesSupport ServerMeta::correlation_names_support() const { + return static_cast< ::exec::user::CorrelationNamesSupport >(correlation_names_support_); +} +inline void ServerMeta::set_correlation_names_support(::exec::user::CorrelationNamesSupport value) { + assert(::exec::user::CorrelationNamesSupport_IsValid(value)); + set_has_correlation_names_support(); + correlation_names_support_ = value; +} -// optional .exec.user.RequestStatus status = 1; -inline bool GetColumnsResp::has_status() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// repeated string date_time_functions = 10; +inline int ServerMeta::date_time_functions_size() const { + return date_time_functions_.size(); } -inline void GetColumnsResp::set_has_status() { - _has_bits_[0] |= 0x00000001u; +inline void ServerMeta::clear_date_time_functions() { + date_time_functions_.Clear(); } -inline void GetColumnsResp::clear_has_status() { - _has_bits_[0] &= ~0x00000001u; +inline const ::std::string& ServerMeta::date_time_functions(int index) const { + return date_time_functions_.Get(index); } -inline void GetColumnsResp::clear_status() { - status_ = 0; - clear_has_status(); +inline ::std::string* ServerMeta::mutable_date_time_functions(int index) { + return date_time_functions_.Mutable(index); } -inline ::exec::user::RequestStatus GetColumnsResp::status() const { - return static_cast< ::exec::user::RequestStatus >(status_); +inline void ServerMeta::set_date_time_functions(int index, const ::std::string& value) { + date_time_functions_.Mutable(index)->assign(value); +} +inline void ServerMeta::set_date_time_functions(int index, const char* value) { + date_time_functions_.Mutable(index)->assign(value); +} +inline void ServerMeta::set_date_time_functions(int index, const char* value, size_t size) { + date_time_functions_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* ServerMeta::add_date_time_functions() { + return date_time_functions_.Add(); +} +inline void ServerMeta::add_date_time_functions(const ::std::string& value) { + date_time_functions_.Add()->assign(value); +} +inline void ServerMeta::add_date_time_functions(const char* value) { + date_time_functions_.Add()->assign(value); +} +inline void ServerMeta::add_date_time_functions(const char* value, size_t size) { + date_time_functions_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +ServerMeta::date_time_functions() const { + return date_time_functions_; } -inline void GetColumnsResp::set_status(::exec::user::RequestStatus value) { - assert(::exec::user::RequestStatus_IsValid(value)); - set_has_status(); - status_ = value; +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +ServerMeta::mutable_date_time_functions() { + return &date_time_functions_; } -// repeated .exec.user.ColumnMetadata columns = 2; -inline int GetColumnsResp::columns_size() const { - return columns_.size(); +// repeated .exec.user.DateTimeLiteralsSupport date_time_literals_support = 11; +inline int ServerMeta::date_time_literals_support_size() const { + return date_time_literals_support_.size(); } -inline void GetColumnsResp::clear_columns() { - columns_.Clear(); +inline void ServerMeta::clear_date_time_literals_support() { + date_time_literals_support_.Clear(); } -inline const ::exec::user::ColumnMetadata& GetColumnsResp::columns(int index) const { - return columns_.Get(index); +inline ::exec::user::DateTimeLiteralsSupport ServerMeta::date_time_literals_support(int index) const { + return static_cast< ::exec::user::DateTimeLiteralsSupport >(date_time_literals_support_.Get(index)); } -inline ::exec::user::ColumnMetadata* GetColumnsResp::mutable_columns(int index) { - return columns_.Mutable(index); +inline void ServerMeta::set_date_time_literals_support(int index, ::exec::user::DateTimeLiteralsSupport value) { + assert(::exec::user::DateTimeLiteralsSupport_IsValid(value)); + date_time_literals_support_.Set(index, value); } -inline ::exec::user::ColumnMetadata* GetColumnsResp::add_columns() { - return columns_.Add(); +inline void ServerMeta::add_date_time_literals_support(::exec::user::DateTimeLiteralsSupport value) { + assert(::exec::user::DateTimeLiteralsSupport_IsValid(value)); + date_time_literals_support_.Add(value); } -inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >& -GetColumnsResp::columns() const { - return columns_; +inline const ::google::protobuf::RepeatedField& +ServerMeta::date_time_literals_support() const { + return date_time_literals_support_; } -inline ::google::protobuf::RepeatedPtrField< ::exec::user::ColumnMetadata >* -GetColumnsResp::mutable_columns() { - return &columns_; +inline ::google::protobuf::RepeatedField* +ServerMeta::mutable_date_time_literals_support() { + return &date_time_literals_support_; } -// optional .exec.shared.DrillPBError error = 3; -inline bool GetColumnsResp::has_error() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional .exec.user.GroupBySupport group_by_support = 12; +inline bool ServerMeta::has_group_by_support() const { + return (_has_bits_[0] & 0x00000800u) != 0; } -inline void GetColumnsResp::set_has_error() { - _has_bits_[0] |= 0x00000004u; +inline void ServerMeta::set_has_group_by_support() { + _has_bits_[0] |= 0x00000800u; } -inline void GetColumnsResp::clear_has_error() { - _has_bits_[0] &= ~0x00000004u; +inline void ServerMeta::clear_has_group_by_support() { + _has_bits_[0] &= ~0x00000800u; } -inline void GetColumnsResp::clear_error() { - if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); - clear_has_error(); +inline void ServerMeta::clear_group_by_support() { + group_by_support_ = 1; + clear_has_group_by_support(); } -inline const ::exec::shared::DrillPBError& GetColumnsResp::error() const { - return error_ != NULL ? *error_ : *default_instance_->error_; +inline ::exec::user::GroupBySupport ServerMeta::group_by_support() const { + return static_cast< ::exec::user::GroupBySupport >(group_by_support_); } -inline ::exec::shared::DrillPBError* GetColumnsResp::mutable_error() { - set_has_error(); - if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; - return error_; +inline void ServerMeta::set_group_by_support(::exec::user::GroupBySupport value) { + assert(::exec::user::GroupBySupport_IsValid(value)); + set_has_group_by_support(); + group_by_support_ = value; } -inline ::exec::shared::DrillPBError* GetColumnsResp::release_error() { - clear_has_error(); - ::exec::shared::DrillPBError* temp = error_; - error_ = NULL; - return temp; + +// optional .exec.user.IdentifierCasing identifier_casing = 13; +inline bool ServerMeta::has_identifier_casing() const { + return (_has_bits_[0] & 0x00001000u) != 0; } -inline void GetColumnsResp::set_allocated_error(::exec::shared::DrillPBError* error) { - delete error_; - error_ = error; - if (error) { - set_has_error(); - } else { - clear_has_error(); - } +inline void ServerMeta::set_has_identifier_casing() { + _has_bits_[0] |= 0x00001000u; +} +inline void ServerMeta::clear_has_identifier_casing() { + _has_bits_[0] &= ~0x00001000u; +} +inline void ServerMeta::clear_identifier_casing() { + identifier_casing_ = 0; + clear_has_identifier_casing(); +} +inline ::exec::user::IdentifierCasing ServerMeta::identifier_casing() const { + return static_cast< ::exec::user::IdentifierCasing >(identifier_casing_); +} +inline void ServerMeta::set_identifier_casing(::exec::user::IdentifierCasing value) { + assert(::exec::user::IdentifierCasing_IsValid(value)); + set_has_identifier_casing(); + identifier_casing_ = value; } -// ------------------------------------------------------------------- - -// CreatePreparedStatementReq - -// optional string sql_query = 1; -inline bool CreatePreparedStatementReq::has_sql_query() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional string identifier_quote_string = 14; +inline bool ServerMeta::has_identifier_quote_string() const { + return (_has_bits_[0] & 0x00002000u) != 0; } -inline void CreatePreparedStatementReq::set_has_sql_query() { - _has_bits_[0] |= 0x00000001u; +inline void ServerMeta::set_has_identifier_quote_string() { + _has_bits_[0] |= 0x00002000u; } -inline void CreatePreparedStatementReq::clear_has_sql_query() { - _has_bits_[0] &= ~0x00000001u; +inline void ServerMeta::clear_has_identifier_quote_string() { + _has_bits_[0] &= ~0x00002000u; } -inline void CreatePreparedStatementReq::clear_sql_query() { - if (sql_query_ != &::google::protobuf::internal::kEmptyString) { - sql_query_->clear(); +inline void ServerMeta::clear_identifier_quote_string() { + if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) { + identifier_quote_string_->clear(); } - clear_has_sql_query(); + clear_has_identifier_quote_string(); } -inline const ::std::string& CreatePreparedStatementReq::sql_query() const { - return *sql_query_; +inline const ::std::string& ServerMeta::identifier_quote_string() const { + return *identifier_quote_string_; } -inline void CreatePreparedStatementReq::set_sql_query(const ::std::string& value) { - set_has_sql_query(); - if (sql_query_ == &::google::protobuf::internal::kEmptyString) { - sql_query_ = new ::std::string; +inline void ServerMeta::set_identifier_quote_string(const ::std::string& value) { + set_has_identifier_quote_string(); + if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) { + identifier_quote_string_ = new ::std::string; } - sql_query_->assign(value); + identifier_quote_string_->assign(value); } -inline void CreatePreparedStatementReq::set_sql_query(const char* value) { - set_has_sql_query(); - if (sql_query_ == &::google::protobuf::internal::kEmptyString) { - sql_query_ = new ::std::string; +inline void ServerMeta::set_identifier_quote_string(const char* value) { + set_has_identifier_quote_string(); + if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) { + identifier_quote_string_ = new ::std::string; } - sql_query_->assign(value); + identifier_quote_string_->assign(value); } -inline void CreatePreparedStatementReq::set_sql_query(const char* value, size_t size) { - set_has_sql_query(); - if (sql_query_ == &::google::protobuf::internal::kEmptyString) { - sql_query_ = new ::std::string; +inline void ServerMeta::set_identifier_quote_string(const char* value, size_t size) { + set_has_identifier_quote_string(); + if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) { + identifier_quote_string_ = new ::std::string; } - sql_query_->assign(reinterpret_cast(value), size); + identifier_quote_string_->assign(reinterpret_cast(value), size); } -inline ::std::string* CreatePreparedStatementReq::mutable_sql_query() { - set_has_sql_query(); - if (sql_query_ == &::google::protobuf::internal::kEmptyString) { - sql_query_ = new ::std::string; +inline ::std::string* ServerMeta::mutable_identifier_quote_string() { + set_has_identifier_quote_string(); + if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) { + identifier_quote_string_ = new ::std::string; } - return sql_query_; + return identifier_quote_string_; } -inline ::std::string* CreatePreparedStatementReq::release_sql_query() { - clear_has_sql_query(); - if (sql_query_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ServerMeta::release_identifier_quote_string() { + clear_has_identifier_quote_string(); + if (identifier_quote_string_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = sql_query_; - sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = identifier_quote_string_; + identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void CreatePreparedStatementReq::set_allocated_sql_query(::std::string* sql_query) { - if (sql_query_ != &::google::protobuf::internal::kEmptyString) { - delete sql_query_; +inline void ServerMeta::set_allocated_identifier_quote_string(::std::string* identifier_quote_string) { + if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) { + delete identifier_quote_string_; } - if (sql_query) { - set_has_sql_query(); - sql_query_ = sql_query; + if (identifier_quote_string) { + set_has_identifier_quote_string(); + identifier_quote_string_ = identifier_quote_string; } else { - clear_has_sql_query(); - sql_query_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_identifier_quote_string(); + identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// ------------------------------------------------------------------- +// optional bool like_escape_clause_supported = 15; +inline bool ServerMeta::has_like_escape_clause_supported() const { + return (_has_bits_[0] & 0x00004000u) != 0; +} +inline void ServerMeta::set_has_like_escape_clause_supported() { + _has_bits_[0] |= 0x00004000u; +} +inline void ServerMeta::clear_has_like_escape_clause_supported() { + _has_bits_[0] &= ~0x00004000u; +} +inline void ServerMeta::clear_like_escape_clause_supported() { + like_escape_clause_supported_ = false; + clear_has_like_escape_clause_supported(); +} +inline bool ServerMeta::like_escape_clause_supported() const { + return like_escape_clause_supported_; +} +inline void ServerMeta::set_like_escape_clause_supported(bool value) { + set_has_like_escape_clause_supported(); + like_escape_clause_supported_ = value; +} -// ResultColumnMetadata +// optional uint32 max_binary_literal_length = 16; +inline bool ServerMeta::has_max_binary_literal_length() const { + return (_has_bits_[0] & 0x00008000u) != 0; +} +inline void ServerMeta::set_has_max_binary_literal_length() { + _has_bits_[0] |= 0x00008000u; +} +inline void ServerMeta::clear_has_max_binary_literal_length() { + _has_bits_[0] &= ~0x00008000u; +} +inline void ServerMeta::clear_max_binary_literal_length() { + max_binary_literal_length_ = 0u; + clear_has_max_binary_literal_length(); +} +inline ::google::protobuf::uint32 ServerMeta::max_binary_literal_length() const { + return max_binary_literal_length_; +} +inline void ServerMeta::set_max_binary_literal_length(::google::protobuf::uint32 value) { + set_has_max_binary_literal_length(); + max_binary_literal_length_ = value; +} -// optional string catalog_name = 1; -inline bool ResultColumnMetadata::has_catalog_name() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional uint32 max_catalog_name_length = 17; +inline bool ServerMeta::has_max_catalog_name_length() const { + return (_has_bits_[0] & 0x00010000u) != 0; } -inline void ResultColumnMetadata::set_has_catalog_name() { - _has_bits_[0] |= 0x00000001u; +inline void ServerMeta::set_has_max_catalog_name_length() { + _has_bits_[0] |= 0x00010000u; } -inline void ResultColumnMetadata::clear_has_catalog_name() { - _has_bits_[0] &= ~0x00000001u; +inline void ServerMeta::clear_has_max_catalog_name_length() { + _has_bits_[0] &= ~0x00010000u; } -inline void ResultColumnMetadata::clear_catalog_name() { - if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { - catalog_name_->clear(); - } - clear_has_catalog_name(); +inline void ServerMeta::clear_max_catalog_name_length() { + max_catalog_name_length_ = 0u; + clear_has_max_catalog_name_length(); } -inline const ::std::string& ResultColumnMetadata::catalog_name() const { - return *catalog_name_; +inline ::google::protobuf::uint32 ServerMeta::max_catalog_name_length() const { + return max_catalog_name_length_; } -inline void ResultColumnMetadata::set_catalog_name(const ::std::string& value) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - catalog_name_->assign(value); +inline void ServerMeta::set_max_catalog_name_length(::google::protobuf::uint32 value) { + set_has_max_catalog_name_length(); + max_catalog_name_length_ = value; } -inline void ResultColumnMetadata::set_catalog_name(const char* value) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - catalog_name_->assign(value); + +// optional uint32 max_char_literal_length = 18; +inline bool ServerMeta::has_max_char_literal_length() const { + return (_has_bits_[0] & 0x00020000u) != 0; } -inline void ResultColumnMetadata::set_catalog_name(const char* value, size_t size) { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - catalog_name_->assign(reinterpret_cast(value), size); +inline void ServerMeta::set_has_max_char_literal_length() { + _has_bits_[0] |= 0x00020000u; } -inline ::std::string* ResultColumnMetadata::mutable_catalog_name() { - set_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - catalog_name_ = new ::std::string; - } - return catalog_name_; +inline void ServerMeta::clear_has_max_char_literal_length() { + _has_bits_[0] &= ~0x00020000u; } -inline ::std::string* ResultColumnMetadata::release_catalog_name() { - clear_has_catalog_name(); - if (catalog_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = catalog_name_; - catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ServerMeta::clear_max_char_literal_length() { + max_char_literal_length_ = 0u; + clear_has_max_char_literal_length(); } -inline void ResultColumnMetadata::set_allocated_catalog_name(::std::string* catalog_name) { - if (catalog_name_ != &::google::protobuf::internal::kEmptyString) { - delete catalog_name_; - } - if (catalog_name) { - set_has_catalog_name(); - catalog_name_ = catalog_name; - } else { - clear_has_catalog_name(); - catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::uint32 ServerMeta::max_char_literal_length() const { + return max_char_literal_length_; +} +inline void ServerMeta::set_max_char_literal_length(::google::protobuf::uint32 value) { + set_has_max_char_literal_length(); + max_char_literal_length_ = value; } -// optional string schema_name = 2; -inline bool ResultColumnMetadata::has_schema_name() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// optional uint32 max_column_name_length = 19; +inline bool ServerMeta::has_max_column_name_length() const { + return (_has_bits_[0] & 0x00040000u) != 0; } -inline void ResultColumnMetadata::set_has_schema_name() { - _has_bits_[0] |= 0x00000002u; +inline void ServerMeta::set_has_max_column_name_length() { + _has_bits_[0] |= 0x00040000u; } -inline void ResultColumnMetadata::clear_has_schema_name() { - _has_bits_[0] &= ~0x00000002u; +inline void ServerMeta::clear_has_max_column_name_length() { + _has_bits_[0] &= ~0x00040000u; } -inline void ResultColumnMetadata::clear_schema_name() { - if (schema_name_ != &::google::protobuf::internal::kEmptyString) { - schema_name_->clear(); - } - clear_has_schema_name(); +inline void ServerMeta::clear_max_column_name_length() { + max_column_name_length_ = 0u; + clear_has_max_column_name_length(); } -inline const ::std::string& ResultColumnMetadata::schema_name() const { - return *schema_name_; +inline ::google::protobuf::uint32 ServerMeta::max_column_name_length() const { + return max_column_name_length_; } -inline void ResultColumnMetadata::set_schema_name(const ::std::string& value) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - schema_name_->assign(value); +inline void ServerMeta::set_max_column_name_length(::google::protobuf::uint32 value) { + set_has_max_column_name_length(); + max_column_name_length_ = value; } -inline void ResultColumnMetadata::set_schema_name(const char* value) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - schema_name_->assign(value); + +// optional uint32 max_columns_in_group_by = 20; +inline bool ServerMeta::has_max_columns_in_group_by() const { + return (_has_bits_[0] & 0x00080000u) != 0; } -inline void ResultColumnMetadata::set_schema_name(const char* value, size_t size) { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - schema_name_->assign(reinterpret_cast(value), size); +inline void ServerMeta::set_has_max_columns_in_group_by() { + _has_bits_[0] |= 0x00080000u; } -inline ::std::string* ResultColumnMetadata::mutable_schema_name() { - set_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - schema_name_ = new ::std::string; - } - return schema_name_; +inline void ServerMeta::clear_has_max_columns_in_group_by() { + _has_bits_[0] &= ~0x00080000u; } -inline ::std::string* ResultColumnMetadata::release_schema_name() { - clear_has_schema_name(); - if (schema_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = schema_name_; - schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ServerMeta::clear_max_columns_in_group_by() { + max_columns_in_group_by_ = 0u; + clear_has_max_columns_in_group_by(); +} +inline ::google::protobuf::uint32 ServerMeta::max_columns_in_group_by() const { + return max_columns_in_group_by_; } -inline void ResultColumnMetadata::set_allocated_schema_name(::std::string* schema_name) { - if (schema_name_ != &::google::protobuf::internal::kEmptyString) { - delete schema_name_; - } - if (schema_name) { - set_has_schema_name(); - schema_name_ = schema_name; - } else { - clear_has_schema_name(); - schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline void ServerMeta::set_max_columns_in_group_by(::google::protobuf::uint32 value) { + set_has_max_columns_in_group_by(); + max_columns_in_group_by_ = value; } -// optional string table_name = 3; -inline bool ResultColumnMetadata::has_table_name() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional uint32 max_columns_in_order_by = 21; +inline bool ServerMeta::has_max_columns_in_order_by() const { + return (_has_bits_[0] & 0x00100000u) != 0; } -inline void ResultColumnMetadata::set_has_table_name() { - _has_bits_[0] |= 0x00000004u; +inline void ServerMeta::set_has_max_columns_in_order_by() { + _has_bits_[0] |= 0x00100000u; } -inline void ResultColumnMetadata::clear_has_table_name() { - _has_bits_[0] &= ~0x00000004u; +inline void ServerMeta::clear_has_max_columns_in_order_by() { + _has_bits_[0] &= ~0x00100000u; } -inline void ResultColumnMetadata::clear_table_name() { - if (table_name_ != &::google::protobuf::internal::kEmptyString) { - table_name_->clear(); - } - clear_has_table_name(); +inline void ServerMeta::clear_max_columns_in_order_by() { + max_columns_in_order_by_ = 0u; + clear_has_max_columns_in_order_by(); } -inline const ::std::string& ResultColumnMetadata::table_name() const { - return *table_name_; +inline ::google::protobuf::uint32 ServerMeta::max_columns_in_order_by() const { + return max_columns_in_order_by_; } -inline void ResultColumnMetadata::set_table_name(const ::std::string& value) { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; - } - table_name_->assign(value); +inline void ServerMeta::set_max_columns_in_order_by(::google::protobuf::uint32 value) { + set_has_max_columns_in_order_by(); + max_columns_in_order_by_ = value; } -inline void ResultColumnMetadata::set_table_name(const char* value) { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; - } - table_name_->assign(value); + +// optional uint32 max_columns_in_select = 22; +inline bool ServerMeta::has_max_columns_in_select() const { + return (_has_bits_[0] & 0x00200000u) != 0; } -inline void ResultColumnMetadata::set_table_name(const char* value, size_t size) { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; - } - table_name_->assign(reinterpret_cast(value), size); +inline void ServerMeta::set_has_max_columns_in_select() { + _has_bits_[0] |= 0x00200000u; } -inline ::std::string* ResultColumnMetadata::mutable_table_name() { - set_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - table_name_ = new ::std::string; - } - return table_name_; +inline void ServerMeta::clear_has_max_columns_in_select() { + _has_bits_[0] &= ~0x00200000u; } -inline ::std::string* ResultColumnMetadata::release_table_name() { - clear_has_table_name(); - if (table_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = table_name_; - table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ServerMeta::clear_max_columns_in_select() { + max_columns_in_select_ = 0u; + clear_has_max_columns_in_select(); } -inline void ResultColumnMetadata::set_allocated_table_name(::std::string* table_name) { - if (table_name_ != &::google::protobuf::internal::kEmptyString) { - delete table_name_; - } - if (table_name) { - set_has_table_name(); - table_name_ = table_name; - } else { - clear_has_table_name(); - table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::uint32 ServerMeta::max_columns_in_select() const { + return max_columns_in_select_; +} +inline void ServerMeta::set_max_columns_in_select(::google::protobuf::uint32 value) { + set_has_max_columns_in_select(); + max_columns_in_select_ = value; } -// optional string column_name = 4; -inline bool ResultColumnMetadata::has_column_name() const { - return (_has_bits_[0] & 0x00000008u) != 0; +// optional uint32 max_cursor_name_length = 23; +inline bool ServerMeta::has_max_cursor_name_length() const { + return (_has_bits_[0] & 0x00400000u) != 0; } -inline void ResultColumnMetadata::set_has_column_name() { - _has_bits_[0] |= 0x00000008u; +inline void ServerMeta::set_has_max_cursor_name_length() { + _has_bits_[0] |= 0x00400000u; } -inline void ResultColumnMetadata::clear_has_column_name() { - _has_bits_[0] &= ~0x00000008u; +inline void ServerMeta::clear_has_max_cursor_name_length() { + _has_bits_[0] &= ~0x00400000u; } -inline void ResultColumnMetadata::clear_column_name() { - if (column_name_ != &::google::protobuf::internal::kEmptyString) { - column_name_->clear(); - } - clear_has_column_name(); +inline void ServerMeta::clear_max_cursor_name_length() { + max_cursor_name_length_ = 0u; + clear_has_max_cursor_name_length(); } -inline const ::std::string& ResultColumnMetadata::column_name() const { - return *column_name_; +inline ::google::protobuf::uint32 ServerMeta::max_cursor_name_length() const { + return max_cursor_name_length_; } -inline void ResultColumnMetadata::set_column_name(const ::std::string& value) { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - column_name_->assign(value); +inline void ServerMeta::set_max_cursor_name_length(::google::protobuf::uint32 value) { + set_has_max_cursor_name_length(); + max_cursor_name_length_ = value; } -inline void ResultColumnMetadata::set_column_name(const char* value) { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - column_name_->assign(value); + +// optional uint32 max_logical_lob_size = 24; +inline bool ServerMeta::has_max_logical_lob_size() const { + return (_has_bits_[0] & 0x00800000u) != 0; } -inline void ResultColumnMetadata::set_column_name(const char* value, size_t size) { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - column_name_->assign(reinterpret_cast(value), size); +inline void ServerMeta::set_has_max_logical_lob_size() { + _has_bits_[0] |= 0x00800000u; } -inline ::std::string* ResultColumnMetadata::mutable_column_name() { - set_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - column_name_ = new ::std::string; - } - return column_name_; +inline void ServerMeta::clear_has_max_logical_lob_size() { + _has_bits_[0] &= ~0x00800000u; } -inline ::std::string* ResultColumnMetadata::release_column_name() { - clear_has_column_name(); - if (column_name_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = column_name_; - column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ServerMeta::clear_max_logical_lob_size() { + max_logical_lob_size_ = 0u; + clear_has_max_logical_lob_size(); } -inline void ResultColumnMetadata::set_allocated_column_name(::std::string* column_name) { - if (column_name_ != &::google::protobuf::internal::kEmptyString) { - delete column_name_; - } - if (column_name) { - set_has_column_name(); - column_name_ = column_name; - } else { - clear_has_column_name(); - column_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::uint32 ServerMeta::max_logical_lob_size() const { + return max_logical_lob_size_; +} +inline void ServerMeta::set_max_logical_lob_size(::google::protobuf::uint32 value) { + set_has_max_logical_lob_size(); + max_logical_lob_size_ = value; } -// optional string label = 5; -inline bool ResultColumnMetadata::has_label() const { - return (_has_bits_[0] & 0x00000010u) != 0; +// optional uint32 max_row_size = 25; +inline bool ServerMeta::has_max_row_size() const { + return (_has_bits_[0] & 0x01000000u) != 0; } -inline void ResultColumnMetadata::set_has_label() { - _has_bits_[0] |= 0x00000010u; +inline void ServerMeta::set_has_max_row_size() { + _has_bits_[0] |= 0x01000000u; } -inline void ResultColumnMetadata::clear_has_label() { - _has_bits_[0] &= ~0x00000010u; +inline void ServerMeta::clear_has_max_row_size() { + _has_bits_[0] &= ~0x01000000u; } -inline void ResultColumnMetadata::clear_label() { - if (label_ != &::google::protobuf::internal::kEmptyString) { - label_->clear(); - } - clear_has_label(); +inline void ServerMeta::clear_max_row_size() { + max_row_size_ = 0u; + clear_has_max_row_size(); } -inline const ::std::string& ResultColumnMetadata::label() const { - return *label_; +inline ::google::protobuf::uint32 ServerMeta::max_row_size() const { + return max_row_size_; } -inline void ResultColumnMetadata::set_label(const ::std::string& value) { - set_has_label(); - if (label_ == &::google::protobuf::internal::kEmptyString) { - label_ = new ::std::string; - } - label_->assign(value); +inline void ServerMeta::set_max_row_size(::google::protobuf::uint32 value) { + set_has_max_row_size(); + max_row_size_ = value; } -inline void ResultColumnMetadata::set_label(const char* value) { - set_has_label(); - if (label_ == &::google::protobuf::internal::kEmptyString) { - label_ = new ::std::string; - } - label_->assign(value); + +// optional uint32 max_schema_name_length = 26; +inline bool ServerMeta::has_max_schema_name_length() const { + return (_has_bits_[0] & 0x02000000u) != 0; } -inline void ResultColumnMetadata::set_label(const char* value, size_t size) { - set_has_label(); - if (label_ == &::google::protobuf::internal::kEmptyString) { - label_ = new ::std::string; - } - label_->assign(reinterpret_cast(value), size); +inline void ServerMeta::set_has_max_schema_name_length() { + _has_bits_[0] |= 0x02000000u; } -inline ::std::string* ResultColumnMetadata::mutable_label() { - set_has_label(); - if (label_ == &::google::protobuf::internal::kEmptyString) { - label_ = new ::std::string; - } - return label_; +inline void ServerMeta::clear_has_max_schema_name_length() { + _has_bits_[0] &= ~0x02000000u; } -inline ::std::string* ResultColumnMetadata::release_label() { - clear_has_label(); - if (label_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = label_; - label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ServerMeta::clear_max_schema_name_length() { + max_schema_name_length_ = 0u; + clear_has_max_schema_name_length(); } -inline void ResultColumnMetadata::set_allocated_label(::std::string* label) { - if (label_ != &::google::protobuf::internal::kEmptyString) { - delete label_; - } - if (label) { - set_has_label(); - label_ = label; - } else { - clear_has_label(); - label_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::uint32 ServerMeta::max_schema_name_length() const { + return max_schema_name_length_; +} +inline void ServerMeta::set_max_schema_name_length(::google::protobuf::uint32 value) { + set_has_max_schema_name_length(); + max_schema_name_length_ = value; } -// optional string data_type = 6; -inline bool ResultColumnMetadata::has_data_type() const { - return (_has_bits_[0] & 0x00000020u) != 0; +// optional uint32 max_statement_length = 27; +inline bool ServerMeta::has_max_statement_length() const { + return (_has_bits_[0] & 0x04000000u) != 0; } -inline void ResultColumnMetadata::set_has_data_type() { - _has_bits_[0] |= 0x00000020u; +inline void ServerMeta::set_has_max_statement_length() { + _has_bits_[0] |= 0x04000000u; } -inline void ResultColumnMetadata::clear_has_data_type() { - _has_bits_[0] &= ~0x00000020u; +inline void ServerMeta::clear_has_max_statement_length() { + _has_bits_[0] &= ~0x04000000u; } -inline void ResultColumnMetadata::clear_data_type() { - if (data_type_ != &::google::protobuf::internal::kEmptyString) { - data_type_->clear(); - } - clear_has_data_type(); +inline void ServerMeta::clear_max_statement_length() { + max_statement_length_ = 0u; + clear_has_max_statement_length(); } -inline const ::std::string& ResultColumnMetadata::data_type() const { - return *data_type_; +inline ::google::protobuf::uint32 ServerMeta::max_statement_length() const { + return max_statement_length_; } -inline void ResultColumnMetadata::set_data_type(const ::std::string& value) { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - data_type_->assign(value); +inline void ServerMeta::set_max_statement_length(::google::protobuf::uint32 value) { + set_has_max_statement_length(); + max_statement_length_ = value; } -inline void ResultColumnMetadata::set_data_type(const char* value) { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - data_type_->assign(value); + +// optional uint32 max_statements = 28; +inline bool ServerMeta::has_max_statements() const { + return (_has_bits_[0] & 0x08000000u) != 0; } -inline void ResultColumnMetadata::set_data_type(const char* value, size_t size) { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - data_type_->assign(reinterpret_cast(value), size); +inline void ServerMeta::set_has_max_statements() { + _has_bits_[0] |= 0x08000000u; } -inline ::std::string* ResultColumnMetadata::mutable_data_type() { - set_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - data_type_ = new ::std::string; - } - return data_type_; +inline void ServerMeta::clear_has_max_statements() { + _has_bits_[0] &= ~0x08000000u; } -inline ::std::string* ResultColumnMetadata::release_data_type() { - clear_has_data_type(); - if (data_type_ == &::google::protobuf::internal::kEmptyString) { - return NULL; - } else { - ::std::string* temp = data_type_; - data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - return temp; - } +inline void ServerMeta::clear_max_statements() { + max_statements_ = 0u; + clear_has_max_statements(); } -inline void ResultColumnMetadata::set_allocated_data_type(::std::string* data_type) { - if (data_type_ != &::google::protobuf::internal::kEmptyString) { - delete data_type_; - } - if (data_type) { - set_has_data_type(); - data_type_ = data_type; - } else { - clear_has_data_type(); - data_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); - } +inline ::google::protobuf::uint32 ServerMeta::max_statements() const { + return max_statements_; +} +inline void ServerMeta::set_max_statements(::google::protobuf::uint32 value) { + set_has_max_statements(); + max_statements_ = value; +} + +// optional uint32 max_table_name_length = 29; +inline bool ServerMeta::has_max_table_name_length() const { + return (_has_bits_[0] & 0x10000000u) != 0; +} +inline void ServerMeta::set_has_max_table_name_length() { + _has_bits_[0] |= 0x10000000u; +} +inline void ServerMeta::clear_has_max_table_name_length() { + _has_bits_[0] &= ~0x10000000u; +} +inline void ServerMeta::clear_max_table_name_length() { + max_table_name_length_ = 0u; + clear_has_max_table_name_length(); +} +inline ::google::protobuf::uint32 ServerMeta::max_table_name_length() const { + return max_table_name_length_; +} +inline void ServerMeta::set_max_table_name_length(::google::protobuf::uint32 value) { + set_has_max_table_name_length(); + max_table_name_length_ = value; } -// optional bool is_nullable = 7; -inline bool ResultColumnMetadata::has_is_nullable() const { - return (_has_bits_[0] & 0x00000040u) != 0; +// optional uint32 max_tables_in_select = 30; +inline bool ServerMeta::has_max_tables_in_select() const { + return (_has_bits_[0] & 0x20000000u) != 0; } -inline void ResultColumnMetadata::set_has_is_nullable() { - _has_bits_[0] |= 0x00000040u; +inline void ServerMeta::set_has_max_tables_in_select() { + _has_bits_[0] |= 0x20000000u; } -inline void ResultColumnMetadata::clear_has_is_nullable() { - _has_bits_[0] &= ~0x00000040u; +inline void ServerMeta::clear_has_max_tables_in_select() { + _has_bits_[0] &= ~0x20000000u; } -inline void ResultColumnMetadata::clear_is_nullable() { - is_nullable_ = false; - clear_has_is_nullable(); +inline void ServerMeta::clear_max_tables_in_select() { + max_tables_in_select_ = 0u; + clear_has_max_tables_in_select(); } -inline bool ResultColumnMetadata::is_nullable() const { - return is_nullable_; +inline ::google::protobuf::uint32 ServerMeta::max_tables_in_select() const { + return max_tables_in_select_; } -inline void ResultColumnMetadata::set_is_nullable(bool value) { - set_has_is_nullable(); - is_nullable_ = value; +inline void ServerMeta::set_max_tables_in_select(::google::protobuf::uint32 value) { + set_has_max_tables_in_select(); + max_tables_in_select_ = value; } -// optional int32 precision = 8; -inline bool ResultColumnMetadata::has_precision() const { - return (_has_bits_[0] & 0x00000080u) != 0; +// optional uint32 max_user_name_length = 31; +inline bool ServerMeta::has_max_user_name_length() const { + return (_has_bits_[0] & 0x40000000u) != 0; } -inline void ResultColumnMetadata::set_has_precision() { - _has_bits_[0] |= 0x00000080u; +inline void ServerMeta::set_has_max_user_name_length() { + _has_bits_[0] |= 0x40000000u; } -inline void ResultColumnMetadata::clear_has_precision() { - _has_bits_[0] &= ~0x00000080u; +inline void ServerMeta::clear_has_max_user_name_length() { + _has_bits_[0] &= ~0x40000000u; } -inline void ResultColumnMetadata::clear_precision() { - precision_ = 0; - clear_has_precision(); +inline void ServerMeta::clear_max_user_name_length() { + max_user_name_length_ = 0u; + clear_has_max_user_name_length(); } -inline ::google::protobuf::int32 ResultColumnMetadata::precision() const { - return precision_; +inline ::google::protobuf::uint32 ServerMeta::max_user_name_length() const { + return max_user_name_length_; } -inline void ResultColumnMetadata::set_precision(::google::protobuf::int32 value) { - set_has_precision(); - precision_ = value; +inline void ServerMeta::set_max_user_name_length(::google::protobuf::uint32 value) { + set_has_max_user_name_length(); + max_user_name_length_ = value; } -// optional int32 scale = 9; -inline bool ResultColumnMetadata::has_scale() const { - return (_has_bits_[0] & 0x00000100u) != 0; +// optional .exec.user.NullCollation null_collation = 32; +inline bool ServerMeta::has_null_collation() const { + return (_has_bits_[0] & 0x80000000u) != 0; } -inline void ResultColumnMetadata::set_has_scale() { - _has_bits_[0] |= 0x00000100u; +inline void ServerMeta::set_has_null_collation() { + _has_bits_[0] |= 0x80000000u; } -inline void ResultColumnMetadata::clear_has_scale() { - _has_bits_[0] &= ~0x00000100u; +inline void ServerMeta::clear_has_null_collation() { + _has_bits_[0] &= ~0x80000000u; } -inline void ResultColumnMetadata::clear_scale() { - scale_ = 0; - clear_has_scale(); +inline void ServerMeta::clear_null_collation() { + null_collation_ = 0; + clear_has_null_collation(); } -inline ::google::protobuf::int32 ResultColumnMetadata::scale() const { - return scale_; +inline ::exec::user::NullCollation ServerMeta::null_collation() const { + return static_cast< ::exec::user::NullCollation >(null_collation_); } -inline void ResultColumnMetadata::set_scale(::google::protobuf::int32 value) { - set_has_scale(); - scale_ = value; +inline void ServerMeta::set_null_collation(::exec::user::NullCollation value) { + assert(::exec::user::NullCollation_IsValid(value)); + set_has_null_collation(); + null_collation_ = value; } -// optional bool signed = 10; -inline bool ResultColumnMetadata::has_signed_() const { - return (_has_bits_[0] & 0x00000200u) != 0; +// optional bool null_plus_non_null_equals_null = 33; +inline bool ServerMeta::has_null_plus_non_null_equals_null() const { + return (_has_bits_[1] & 0x00000001u) != 0; } -inline void ResultColumnMetadata::set_has_signed_() { - _has_bits_[0] |= 0x00000200u; +inline void ServerMeta::set_has_null_plus_non_null_equals_null() { + _has_bits_[1] |= 0x00000001u; } -inline void ResultColumnMetadata::clear_has_signed_() { - _has_bits_[0] &= ~0x00000200u; +inline void ServerMeta::clear_has_null_plus_non_null_equals_null() { + _has_bits_[1] &= ~0x00000001u; } -inline void ResultColumnMetadata::clear_signed_() { - signed__ = false; - clear_has_signed_(); +inline void ServerMeta::clear_null_plus_non_null_equals_null() { + null_plus_non_null_equals_null_ = false; + clear_has_null_plus_non_null_equals_null(); } -inline bool ResultColumnMetadata::signed_() const { - return signed__; +inline bool ServerMeta::null_plus_non_null_equals_null() const { + return null_plus_non_null_equals_null_; } -inline void ResultColumnMetadata::set_signed_(bool value) { - set_has_signed_(); - signed__ = value; +inline void ServerMeta::set_null_plus_non_null_equals_null(bool value) { + set_has_null_plus_non_null_equals_null(); + null_plus_non_null_equals_null_ = value; } -// optional int32 display_size = 11; -inline bool ResultColumnMetadata::has_display_size() const { - return (_has_bits_[0] & 0x00000400u) != 0; +// repeated string numeric_functions = 34; +inline int ServerMeta::numeric_functions_size() const { + return numeric_functions_.size(); } -inline void ResultColumnMetadata::set_has_display_size() { - _has_bits_[0] |= 0x00000400u; +inline void ServerMeta::clear_numeric_functions() { + numeric_functions_.Clear(); } -inline void ResultColumnMetadata::clear_has_display_size() { - _has_bits_[0] &= ~0x00000400u; +inline const ::std::string& ServerMeta::numeric_functions(int index) const { + return numeric_functions_.Get(index); } -inline void ResultColumnMetadata::clear_display_size() { - display_size_ = 0; - clear_has_display_size(); +inline ::std::string* ServerMeta::mutable_numeric_functions(int index) { + return numeric_functions_.Mutable(index); } -inline ::google::protobuf::int32 ResultColumnMetadata::display_size() const { - return display_size_; +inline void ServerMeta::set_numeric_functions(int index, const ::std::string& value) { + numeric_functions_.Mutable(index)->assign(value); } -inline void ResultColumnMetadata::set_display_size(::google::protobuf::int32 value) { - set_has_display_size(); - display_size_ = value; +inline void ServerMeta::set_numeric_functions(int index, const char* value) { + numeric_functions_.Mutable(index)->assign(value); } - -// optional bool is_aliased = 12; -inline bool ResultColumnMetadata::has_is_aliased() const { - return (_has_bits_[0] & 0x00000800u) != 0; +inline void ServerMeta::set_numeric_functions(int index, const char* value, size_t size) { + numeric_functions_.Mutable(index)->assign( + reinterpret_cast(value), size); } -inline void ResultColumnMetadata::set_has_is_aliased() { - _has_bits_[0] |= 0x00000800u; +inline ::std::string* ServerMeta::add_numeric_functions() { + return numeric_functions_.Add(); } -inline void ResultColumnMetadata::clear_has_is_aliased() { - _has_bits_[0] &= ~0x00000800u; +inline void ServerMeta::add_numeric_functions(const ::std::string& value) { + numeric_functions_.Add()->assign(value); } -inline void ResultColumnMetadata::clear_is_aliased() { - is_aliased_ = false; - clear_has_is_aliased(); +inline void ServerMeta::add_numeric_functions(const char* value) { + numeric_functions_.Add()->assign(value); } -inline bool ResultColumnMetadata::is_aliased() const { - return is_aliased_; +inline void ServerMeta::add_numeric_functions(const char* value, size_t size) { + numeric_functions_.Add()->assign(reinterpret_cast(value), size); } -inline void ResultColumnMetadata::set_is_aliased(bool value) { - set_has_is_aliased(); - is_aliased_ = value; +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +ServerMeta::numeric_functions() const { + return numeric_functions_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +ServerMeta::mutable_numeric_functions() { + return &numeric_functions_; } -// optional .exec.user.ColumnSearchability searchability = 13; -inline bool ResultColumnMetadata::has_searchability() const { - return (_has_bits_[0] & 0x00001000u) != 0; +// repeated .exec.user.OrderBySupport order_by_support = 35; +inline int ServerMeta::order_by_support_size() const { + return order_by_support_.size(); } -inline void ResultColumnMetadata::set_has_searchability() { - _has_bits_[0] |= 0x00001000u; +inline void ServerMeta::clear_order_by_support() { + order_by_support_.Clear(); } -inline void ResultColumnMetadata::clear_has_searchability() { - _has_bits_[0] &= ~0x00001000u; +inline ::exec::user::OrderBySupport ServerMeta::order_by_support(int index) const { + return static_cast< ::exec::user::OrderBySupport >(order_by_support_.Get(index)); } -inline void ResultColumnMetadata::clear_searchability() { - searchability_ = 0; - clear_has_searchability(); +inline void ServerMeta::set_order_by_support(int index, ::exec::user::OrderBySupport value) { + assert(::exec::user::OrderBySupport_IsValid(value)); + order_by_support_.Set(index, value); } -inline ::exec::user::ColumnSearchability ResultColumnMetadata::searchability() const { - return static_cast< ::exec::user::ColumnSearchability >(searchability_); +inline void ServerMeta::add_order_by_support(::exec::user::OrderBySupport value) { + assert(::exec::user::OrderBySupport_IsValid(value)); + order_by_support_.Add(value); } -inline void ResultColumnMetadata::set_searchability(::exec::user::ColumnSearchability value) { - assert(::exec::user::ColumnSearchability_IsValid(value)); - set_has_searchability(); - searchability_ = value; +inline const ::google::protobuf::RepeatedField& +ServerMeta::order_by_support() const { + return order_by_support_; +} +inline ::google::protobuf::RepeatedField* +ServerMeta::mutable_order_by_support() { + return &order_by_support_; } -// optional .exec.user.ColumnUpdatability updatability = 14; -inline bool ResultColumnMetadata::has_updatability() const { - return (_has_bits_[0] & 0x00002000u) != 0; +// repeated .exec.user.OuterJoinSupport outer_join_support = 36; +inline int ServerMeta::outer_join_support_size() const { + return outer_join_support_.size(); } -inline void ResultColumnMetadata::set_has_updatability() { - _has_bits_[0] |= 0x00002000u; +inline void ServerMeta::clear_outer_join_support() { + outer_join_support_.Clear(); } -inline void ResultColumnMetadata::clear_has_updatability() { - _has_bits_[0] &= ~0x00002000u; +inline ::exec::user::OuterJoinSupport ServerMeta::outer_join_support(int index) const { + return static_cast< ::exec::user::OuterJoinSupport >(outer_join_support_.Get(index)); } -inline void ResultColumnMetadata::clear_updatability() { - updatability_ = 0; - clear_has_updatability(); +inline void ServerMeta::set_outer_join_support(int index, ::exec::user::OuterJoinSupport value) { + assert(::exec::user::OuterJoinSupport_IsValid(value)); + outer_join_support_.Set(index, value); } -inline ::exec::user::ColumnUpdatability ResultColumnMetadata::updatability() const { - return static_cast< ::exec::user::ColumnUpdatability >(updatability_); +inline void ServerMeta::add_outer_join_support(::exec::user::OuterJoinSupport value) { + assert(::exec::user::OuterJoinSupport_IsValid(value)); + outer_join_support_.Add(value); } -inline void ResultColumnMetadata::set_updatability(::exec::user::ColumnUpdatability value) { - assert(::exec::user::ColumnUpdatability_IsValid(value)); - set_has_updatability(); - updatability_ = value; +inline const ::google::protobuf::RepeatedField& +ServerMeta::outer_join_support() const { + return outer_join_support_; +} +inline ::google::protobuf::RepeatedField* +ServerMeta::mutable_outer_join_support() { + return &outer_join_support_; } -// optional bool auto_increment = 15; -inline bool ResultColumnMetadata::has_auto_increment() const { - return (_has_bits_[0] & 0x00004000u) != 0; +// optional .exec.user.IdentifierCasing quoted_identifier_casing = 37; +inline bool ServerMeta::has_quoted_identifier_casing() const { + return (_has_bits_[1] & 0x00000010u) != 0; } -inline void ResultColumnMetadata::set_has_auto_increment() { - _has_bits_[0] |= 0x00004000u; +inline void ServerMeta::set_has_quoted_identifier_casing() { + _has_bits_[1] |= 0x00000010u; } -inline void ResultColumnMetadata::clear_has_auto_increment() { - _has_bits_[0] &= ~0x00004000u; +inline void ServerMeta::clear_has_quoted_identifier_casing() { + _has_bits_[1] &= ~0x00000010u; } -inline void ResultColumnMetadata::clear_auto_increment() { - auto_increment_ = false; - clear_has_auto_increment(); +inline void ServerMeta::clear_quoted_identifier_casing() { + quoted_identifier_casing_ = 0; + clear_has_quoted_identifier_casing(); } -inline bool ResultColumnMetadata::auto_increment() const { - return auto_increment_; +inline ::exec::user::IdentifierCasing ServerMeta::quoted_identifier_casing() const { + return static_cast< ::exec::user::IdentifierCasing >(quoted_identifier_casing_); } -inline void ResultColumnMetadata::set_auto_increment(bool value) { - set_has_auto_increment(); - auto_increment_ = value; +inline void ServerMeta::set_quoted_identifier_casing(::exec::user::IdentifierCasing value) { + assert(::exec::user::IdentifierCasing_IsValid(value)); + set_has_quoted_identifier_casing(); + quoted_identifier_casing_ = value; } -// optional bool case_sensitivity = 16; -inline bool ResultColumnMetadata::has_case_sensitivity() const { - return (_has_bits_[0] & 0x00008000u) != 0; +// optional bool read_only = 38; +inline bool ServerMeta::has_read_only() const { + return (_has_bits_[1] & 0x00000020u) != 0; } -inline void ResultColumnMetadata::set_has_case_sensitivity() { - _has_bits_[0] |= 0x00008000u; +inline void ServerMeta::set_has_read_only() { + _has_bits_[1] |= 0x00000020u; } -inline void ResultColumnMetadata::clear_has_case_sensitivity() { - _has_bits_[0] &= ~0x00008000u; +inline void ServerMeta::clear_has_read_only() { + _has_bits_[1] &= ~0x00000020u; } -inline void ResultColumnMetadata::clear_case_sensitivity() { - case_sensitivity_ = false; - clear_has_case_sensitivity(); +inline void ServerMeta::clear_read_only() { + read_only_ = false; + clear_has_read_only(); } -inline bool ResultColumnMetadata::case_sensitivity() const { - return case_sensitivity_; +inline bool ServerMeta::read_only() const { + return read_only_; } -inline void ResultColumnMetadata::set_case_sensitivity(bool value) { - set_has_case_sensitivity(); - case_sensitivity_ = value; +inline void ServerMeta::set_read_only(bool value) { + set_has_read_only(); + read_only_ = value; } -// optional bool sortable = 17; -inline bool ResultColumnMetadata::has_sortable() const { - return (_has_bits_[0] & 0x00010000u) != 0; +// optional string schema_term = 39; +inline bool ServerMeta::has_schema_term() const { + return (_has_bits_[1] & 0x00000040u) != 0; } -inline void ResultColumnMetadata::set_has_sortable() { - _has_bits_[0] |= 0x00010000u; +inline void ServerMeta::set_has_schema_term() { + _has_bits_[1] |= 0x00000040u; } -inline void ResultColumnMetadata::clear_has_sortable() { - _has_bits_[0] &= ~0x00010000u; +inline void ServerMeta::clear_has_schema_term() { + _has_bits_[1] &= ~0x00000040u; } -inline void ResultColumnMetadata::clear_sortable() { - sortable_ = false; - clear_has_sortable(); +inline void ServerMeta::clear_schema_term() { + if (schema_term_ != &::google::protobuf::internal::kEmptyString) { + schema_term_->clear(); + } + clear_has_schema_term(); } -inline bool ResultColumnMetadata::sortable() const { - return sortable_; +inline const ::std::string& ServerMeta::schema_term() const { + return *schema_term_; } -inline void ResultColumnMetadata::set_sortable(bool value) { - set_has_sortable(); - sortable_ = value; +inline void ServerMeta::set_schema_term(const ::std::string& value) { + set_has_schema_term(); + if (schema_term_ == &::google::protobuf::internal::kEmptyString) { + schema_term_ = new ::std::string; + } + schema_term_->assign(value); +} +inline void ServerMeta::set_schema_term(const char* value) { + set_has_schema_term(); + if (schema_term_ == &::google::protobuf::internal::kEmptyString) { + schema_term_ = new ::std::string; + } + schema_term_->assign(value); +} +inline void ServerMeta::set_schema_term(const char* value, size_t size) { + set_has_schema_term(); + if (schema_term_ == &::google::protobuf::internal::kEmptyString) { + schema_term_ = new ::std::string; + } + schema_term_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ServerMeta::mutable_schema_term() { + set_has_schema_term(); + if (schema_term_ == &::google::protobuf::internal::kEmptyString) { + schema_term_ = new ::std::string; + } + return schema_term_; +} +inline ::std::string* ServerMeta::release_schema_term() { + clear_has_schema_term(); + if (schema_term_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = schema_term_; + schema_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void ServerMeta::set_allocated_schema_term(::std::string* schema_term) { + if (schema_term_ != &::google::protobuf::internal::kEmptyString) { + delete schema_term_; + } + if (schema_term) { + set_has_schema_term(); + schema_term_ = schema_term; + } else { + clear_has_schema_term(); + schema_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + } } -// optional string class_name = 18; -inline bool ResultColumnMetadata::has_class_name() const { - return (_has_bits_[0] & 0x00020000u) != 0; +// optional string search_escape_string = 40; +inline bool ServerMeta::has_search_escape_string() const { + return (_has_bits_[1] & 0x00000080u) != 0; } -inline void ResultColumnMetadata::set_has_class_name() { - _has_bits_[0] |= 0x00020000u; +inline void ServerMeta::set_has_search_escape_string() { + _has_bits_[1] |= 0x00000080u; } -inline void ResultColumnMetadata::clear_has_class_name() { - _has_bits_[0] &= ~0x00020000u; +inline void ServerMeta::clear_has_search_escape_string() { + _has_bits_[1] &= ~0x00000080u; } -inline void ResultColumnMetadata::clear_class_name() { - if (class_name_ != &::google::protobuf::internal::kEmptyString) { - class_name_->clear(); +inline void ServerMeta::clear_search_escape_string() { + if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) { + search_escape_string_->clear(); } - clear_has_class_name(); + clear_has_search_escape_string(); } -inline const ::std::string& ResultColumnMetadata::class_name() const { - return *class_name_; +inline const ::std::string& ServerMeta::search_escape_string() const { + return *search_escape_string_; } -inline void ResultColumnMetadata::set_class_name(const ::std::string& value) { - set_has_class_name(); - if (class_name_ == &::google::protobuf::internal::kEmptyString) { - class_name_ = new ::std::string; +inline void ServerMeta::set_search_escape_string(const ::std::string& value) { + set_has_search_escape_string(); + if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) { + search_escape_string_ = new ::std::string; } - class_name_->assign(value); + search_escape_string_->assign(value); } -inline void ResultColumnMetadata::set_class_name(const char* value) { - set_has_class_name(); - if (class_name_ == &::google::protobuf::internal::kEmptyString) { - class_name_ = new ::std::string; +inline void ServerMeta::set_search_escape_string(const char* value) { + set_has_search_escape_string(); + if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) { + search_escape_string_ = new ::std::string; } - class_name_->assign(value); + search_escape_string_->assign(value); } -inline void ResultColumnMetadata::set_class_name(const char* value, size_t size) { - set_has_class_name(); - if (class_name_ == &::google::protobuf::internal::kEmptyString) { - class_name_ = new ::std::string; +inline void ServerMeta::set_search_escape_string(const char* value, size_t size) { + set_has_search_escape_string(); + if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) { + search_escape_string_ = new ::std::string; } - class_name_->assign(reinterpret_cast(value), size); + search_escape_string_->assign(reinterpret_cast(value), size); } -inline ::std::string* ResultColumnMetadata::mutable_class_name() { - set_has_class_name(); - if (class_name_ == &::google::protobuf::internal::kEmptyString) { - class_name_ = new ::std::string; +inline ::std::string* ServerMeta::mutable_search_escape_string() { + set_has_search_escape_string(); + if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) { + search_escape_string_ = new ::std::string; } - return class_name_; + return search_escape_string_; } -inline ::std::string* ResultColumnMetadata::release_class_name() { - clear_has_class_name(); - if (class_name_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ServerMeta::release_search_escape_string() { + clear_has_search_escape_string(); + if (search_escape_string_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = class_name_; - class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = search_escape_string_; + search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void ResultColumnMetadata::set_allocated_class_name(::std::string* class_name) { - if (class_name_ != &::google::protobuf::internal::kEmptyString) { - delete class_name_; +inline void ServerMeta::set_allocated_search_escape_string(::std::string* search_escape_string) { + if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) { + delete search_escape_string_; } - if (class_name) { - set_has_class_name(); - class_name_ = class_name; + if (search_escape_string) { + set_has_search_escape_string(); + search_escape_string_ = search_escape_string; } else { - clear_has_class_name(); - class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_search_escape_string(); + search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional bool is_currency = 20; -inline bool ResultColumnMetadata::has_is_currency() const { - return (_has_bits_[0] & 0x00040000u) != 0; -} -inline void ResultColumnMetadata::set_has_is_currency() { - _has_bits_[0] |= 0x00040000u; +// optional bool select_for_update_supported = 41; +inline bool ServerMeta::has_select_for_update_supported() const { + return (_has_bits_[1] & 0x00000100u) != 0; } -inline void ResultColumnMetadata::clear_has_is_currency() { - _has_bits_[0] &= ~0x00040000u; +inline void ServerMeta::set_has_select_for_update_supported() { + _has_bits_[1] |= 0x00000100u; } -inline void ResultColumnMetadata::clear_is_currency() { - is_currency_ = false; - clear_has_is_currency(); +inline void ServerMeta::clear_has_select_for_update_supported() { + _has_bits_[1] &= ~0x00000100u; } -inline bool ResultColumnMetadata::is_currency() const { - return is_currency_; +inline void ServerMeta::clear_select_for_update_supported() { + select_for_update_supported_ = false; + clear_has_select_for_update_supported(); } -inline void ResultColumnMetadata::set_is_currency(bool value) { - set_has_is_currency(); - is_currency_ = value; +inline bool ServerMeta::select_for_update_supported() const { + return select_for_update_supported_; +} +inline void ServerMeta::set_select_for_update_supported(bool value) { + set_has_select_for_update_supported(); + select_for_update_supported_ = value; } -// ------------------------------------------------------------------- - -// PreparedStatementHandle - -// optional bytes server_info = 1; -inline bool PreparedStatementHandle::has_server_info() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// optional string special_characters = 42; +inline bool ServerMeta::has_special_characters() const { + return (_has_bits_[1] & 0x00000200u) != 0; } -inline void PreparedStatementHandle::set_has_server_info() { - _has_bits_[0] |= 0x00000001u; +inline void ServerMeta::set_has_special_characters() { + _has_bits_[1] |= 0x00000200u; } -inline void PreparedStatementHandle::clear_has_server_info() { - _has_bits_[0] &= ~0x00000001u; +inline void ServerMeta::clear_has_special_characters() { + _has_bits_[1] &= ~0x00000200u; } -inline void PreparedStatementHandle::clear_server_info() { - if (server_info_ != &::google::protobuf::internal::kEmptyString) { - server_info_->clear(); +inline void ServerMeta::clear_special_characters() { + if (special_characters_ != &::google::protobuf::internal::kEmptyString) { + special_characters_->clear(); } - clear_has_server_info(); + clear_has_special_characters(); } -inline const ::std::string& PreparedStatementHandle::server_info() const { - return *server_info_; +inline const ::std::string& ServerMeta::special_characters() const { + return *special_characters_; } -inline void PreparedStatementHandle::set_server_info(const ::std::string& value) { - set_has_server_info(); - if (server_info_ == &::google::protobuf::internal::kEmptyString) { - server_info_ = new ::std::string; +inline void ServerMeta::set_special_characters(const ::std::string& value) { + set_has_special_characters(); + if (special_characters_ == &::google::protobuf::internal::kEmptyString) { + special_characters_ = new ::std::string; } - server_info_->assign(value); + special_characters_->assign(value); } -inline void PreparedStatementHandle::set_server_info(const char* value) { - set_has_server_info(); - if (server_info_ == &::google::protobuf::internal::kEmptyString) { - server_info_ = new ::std::string; +inline void ServerMeta::set_special_characters(const char* value) { + set_has_special_characters(); + if (special_characters_ == &::google::protobuf::internal::kEmptyString) { + special_characters_ = new ::std::string; } - server_info_->assign(value); + special_characters_->assign(value); } -inline void PreparedStatementHandle::set_server_info(const void* value, size_t size) { - set_has_server_info(); - if (server_info_ == &::google::protobuf::internal::kEmptyString) { - server_info_ = new ::std::string; +inline void ServerMeta::set_special_characters(const char* value, size_t size) { + set_has_special_characters(); + if (special_characters_ == &::google::protobuf::internal::kEmptyString) { + special_characters_ = new ::std::string; } - server_info_->assign(reinterpret_cast(value), size); + special_characters_->assign(reinterpret_cast(value), size); } -inline ::std::string* PreparedStatementHandle::mutable_server_info() { - set_has_server_info(); - if (server_info_ == &::google::protobuf::internal::kEmptyString) { - server_info_ = new ::std::string; +inline ::std::string* ServerMeta::mutable_special_characters() { + set_has_special_characters(); + if (special_characters_ == &::google::protobuf::internal::kEmptyString) { + special_characters_ = new ::std::string; } - return server_info_; + return special_characters_; } -inline ::std::string* PreparedStatementHandle::release_server_info() { - clear_has_server_info(); - if (server_info_ == &::google::protobuf::internal::kEmptyString) { +inline ::std::string* ServerMeta::release_special_characters() { + clear_has_special_characters(); + if (special_characters_ == &::google::protobuf::internal::kEmptyString) { return NULL; } else { - ::std::string* temp = server_info_; - server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::std::string* temp = special_characters_; + special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); return temp; } } -inline void PreparedStatementHandle::set_allocated_server_info(::std::string* server_info) { - if (server_info_ != &::google::protobuf::internal::kEmptyString) { - delete server_info_; +inline void ServerMeta::set_allocated_special_characters(::std::string* special_characters) { + if (special_characters_ != &::google::protobuf::internal::kEmptyString) { + delete special_characters_; } - if (server_info) { - set_has_server_info(); - server_info_ = server_info; + if (special_characters) { + set_has_special_characters(); + special_characters_ = special_characters; } else { - clear_has_server_info(); - server_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + clear_has_special_characters(); + special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// ------------------------------------------------------------------- - -// PreparedStatement - -// repeated .exec.user.ResultColumnMetadata columns = 1; -inline int PreparedStatement::columns_size() const { - return columns_.size(); +// repeated string sql_keywords = 43; +inline int ServerMeta::sql_keywords_size() const { + return sql_keywords_.size(); } -inline void PreparedStatement::clear_columns() { - columns_.Clear(); +inline void ServerMeta::clear_sql_keywords() { + sql_keywords_.Clear(); } -inline const ::exec::user::ResultColumnMetadata& PreparedStatement::columns(int index) const { - return columns_.Get(index); +inline const ::std::string& ServerMeta::sql_keywords(int index) const { + return sql_keywords_.Get(index); } -inline ::exec::user::ResultColumnMetadata* PreparedStatement::mutable_columns(int index) { - return columns_.Mutable(index); +inline ::std::string* ServerMeta::mutable_sql_keywords(int index) { + return sql_keywords_.Mutable(index); } -inline ::exec::user::ResultColumnMetadata* PreparedStatement::add_columns() { - return columns_.Add(); +inline void ServerMeta::set_sql_keywords(int index, const ::std::string& value) { + sql_keywords_.Mutable(index)->assign(value); } -inline const ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >& -PreparedStatement::columns() const { - return columns_; +inline void ServerMeta::set_sql_keywords(int index, const char* value) { + sql_keywords_.Mutable(index)->assign(value); } -inline ::google::protobuf::RepeatedPtrField< ::exec::user::ResultColumnMetadata >* -PreparedStatement::mutable_columns() { - return &columns_; +inline void ServerMeta::set_sql_keywords(int index, const char* value, size_t size) { + sql_keywords_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* ServerMeta::add_sql_keywords() { + return sql_keywords_.Add(); +} +inline void ServerMeta::add_sql_keywords(const ::std::string& value) { + sql_keywords_.Add()->assign(value); +} +inline void ServerMeta::add_sql_keywords(const char* value) { + sql_keywords_.Add()->assign(value); +} +inline void ServerMeta::add_sql_keywords(const char* value, size_t size) { + sql_keywords_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +ServerMeta::sql_keywords() const { + return sql_keywords_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +ServerMeta::mutable_sql_keywords() { + return &sql_keywords_; } -// optional .exec.user.PreparedStatementHandle server_handle = 2; -inline bool PreparedStatement::has_server_handle() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// repeated string string_functions = 44; +inline int ServerMeta::string_functions_size() const { + return string_functions_.size(); } -inline void PreparedStatement::set_has_server_handle() { - _has_bits_[0] |= 0x00000002u; +inline void ServerMeta::clear_string_functions() { + string_functions_.Clear(); } -inline void PreparedStatement::clear_has_server_handle() { - _has_bits_[0] &= ~0x00000002u; +inline const ::std::string& ServerMeta::string_functions(int index) const { + return string_functions_.Get(index); } -inline void PreparedStatement::clear_server_handle() { - if (server_handle_ != NULL) server_handle_->::exec::user::PreparedStatementHandle::Clear(); - clear_has_server_handle(); +inline ::std::string* ServerMeta::mutable_string_functions(int index) { + return string_functions_.Mutable(index); } -inline const ::exec::user::PreparedStatementHandle& PreparedStatement::server_handle() const { - return server_handle_ != NULL ? *server_handle_ : *default_instance_->server_handle_; +inline void ServerMeta::set_string_functions(int index, const ::std::string& value) { + string_functions_.Mutable(index)->assign(value); } -inline ::exec::user::PreparedStatementHandle* PreparedStatement::mutable_server_handle() { - set_has_server_handle(); - if (server_handle_ == NULL) server_handle_ = new ::exec::user::PreparedStatementHandle; - return server_handle_; +inline void ServerMeta::set_string_functions(int index, const char* value) { + string_functions_.Mutable(index)->assign(value); } -inline ::exec::user::PreparedStatementHandle* PreparedStatement::release_server_handle() { - clear_has_server_handle(); - ::exec::user::PreparedStatementHandle* temp = server_handle_; - server_handle_ = NULL; - return temp; +inline void ServerMeta::set_string_functions(int index, const char* value, size_t size) { + string_functions_.Mutable(index)->assign( + reinterpret_cast(value), size); } -inline void PreparedStatement::set_allocated_server_handle(::exec::user::PreparedStatementHandle* server_handle) { - delete server_handle_; - server_handle_ = server_handle; - if (server_handle) { - set_has_server_handle(); - } else { - clear_has_server_handle(); - } +inline ::std::string* ServerMeta::add_string_functions() { + return string_functions_.Add(); +} +inline void ServerMeta::add_string_functions(const ::std::string& value) { + string_functions_.Add()->assign(value); +} +inline void ServerMeta::add_string_functions(const char* value) { + string_functions_.Add()->assign(value); +} +inline void ServerMeta::add_string_functions(const char* value, size_t size) { + string_functions_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +ServerMeta::string_functions() const { + return string_functions_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +ServerMeta::mutable_string_functions() { + return &string_functions_; } -// ------------------------------------------------------------------- - -// CreatePreparedStatementResp +// repeated .exec.user.SubQuerySupport subquery_support = 45; +inline int ServerMeta::subquery_support_size() const { + return subquery_support_.size(); +} +inline void ServerMeta::clear_subquery_support() { + subquery_support_.Clear(); +} +inline ::exec::user::SubQuerySupport ServerMeta::subquery_support(int index) const { + return static_cast< ::exec::user::SubQuerySupport >(subquery_support_.Get(index)); +} +inline void ServerMeta::set_subquery_support(int index, ::exec::user::SubQuerySupport value) { + assert(::exec::user::SubQuerySupport_IsValid(value)); + subquery_support_.Set(index, value); +} +inline void ServerMeta::add_subquery_support(::exec::user::SubQuerySupport value) { + assert(::exec::user::SubQuerySupport_IsValid(value)); + subquery_support_.Add(value); +} +inline const ::google::protobuf::RepeatedField& +ServerMeta::subquery_support() const { + return subquery_support_; +} +inline ::google::protobuf::RepeatedField* +ServerMeta::mutable_subquery_support() { + return &subquery_support_; +} -// optional .exec.user.RequestStatus status = 1; -inline bool CreatePreparedStatementResp::has_status() const { - return (_has_bits_[0] & 0x00000001u) != 0; +// repeated string system_functions = 46; +inline int ServerMeta::system_functions_size() const { + return system_functions_.size(); } -inline void CreatePreparedStatementResp::set_has_status() { - _has_bits_[0] |= 0x00000001u; +inline void ServerMeta::clear_system_functions() { + system_functions_.Clear(); } -inline void CreatePreparedStatementResp::clear_has_status() { - _has_bits_[0] &= ~0x00000001u; +inline const ::std::string& ServerMeta::system_functions(int index) const { + return system_functions_.Get(index); } -inline void CreatePreparedStatementResp::clear_status() { - status_ = 0; - clear_has_status(); +inline ::std::string* ServerMeta::mutable_system_functions(int index) { + return system_functions_.Mutable(index); } -inline ::exec::user::RequestStatus CreatePreparedStatementResp::status() const { - return static_cast< ::exec::user::RequestStatus >(status_); +inline void ServerMeta::set_system_functions(int index, const ::std::string& value) { + system_functions_.Mutable(index)->assign(value); } -inline void CreatePreparedStatementResp::set_status(::exec::user::RequestStatus value) { - assert(::exec::user::RequestStatus_IsValid(value)); - set_has_status(); - status_ = value; +inline void ServerMeta::set_system_functions(int index, const char* value) { + system_functions_.Mutable(index)->assign(value); +} +inline void ServerMeta::set_system_functions(int index, const char* value, size_t size) { + system_functions_.Mutable(index)->assign( + reinterpret_cast(value), size); +} +inline ::std::string* ServerMeta::add_system_functions() { + return system_functions_.Add(); +} +inline void ServerMeta::add_system_functions(const ::std::string& value) { + system_functions_.Add()->assign(value); +} +inline void ServerMeta::add_system_functions(const char* value) { + system_functions_.Add()->assign(value); +} +inline void ServerMeta::add_system_functions(const char* value, size_t size) { + system_functions_.Add()->assign(reinterpret_cast(value), size); +} +inline const ::google::protobuf::RepeatedPtrField< ::std::string>& +ServerMeta::system_functions() const { + return system_functions_; +} +inline ::google::protobuf::RepeatedPtrField< ::std::string>* +ServerMeta::mutable_system_functions() { + return &system_functions_; } -// optional .exec.user.PreparedStatement prepared_statement = 2; -inline bool CreatePreparedStatementResp::has_prepared_statement() const { - return (_has_bits_[0] & 0x00000002u) != 0; +// optional string table_term = 47; +inline bool ServerMeta::has_table_term() const { + return (_has_bits_[1] & 0x00004000u) != 0; } -inline void CreatePreparedStatementResp::set_has_prepared_statement() { - _has_bits_[0] |= 0x00000002u; +inline void ServerMeta::set_has_table_term() { + _has_bits_[1] |= 0x00004000u; } -inline void CreatePreparedStatementResp::clear_has_prepared_statement() { - _has_bits_[0] &= ~0x00000002u; +inline void ServerMeta::clear_has_table_term() { + _has_bits_[1] &= ~0x00004000u; } -inline void CreatePreparedStatementResp::clear_prepared_statement() { - if (prepared_statement_ != NULL) prepared_statement_->::exec::user::PreparedStatement::Clear(); - clear_has_prepared_statement(); +inline void ServerMeta::clear_table_term() { + if (table_term_ != &::google::protobuf::internal::kEmptyString) { + table_term_->clear(); + } + clear_has_table_term(); } -inline const ::exec::user::PreparedStatement& CreatePreparedStatementResp::prepared_statement() const { - return prepared_statement_ != NULL ? *prepared_statement_ : *default_instance_->prepared_statement_; +inline const ::std::string& ServerMeta::table_term() const { + return *table_term_; } -inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::mutable_prepared_statement() { - set_has_prepared_statement(); - if (prepared_statement_ == NULL) prepared_statement_ = new ::exec::user::PreparedStatement; - return prepared_statement_; +inline void ServerMeta::set_table_term(const ::std::string& value) { + set_has_table_term(); + if (table_term_ == &::google::protobuf::internal::kEmptyString) { + table_term_ = new ::std::string; + } + table_term_->assign(value); } -inline ::exec::user::PreparedStatement* CreatePreparedStatementResp::release_prepared_statement() { - clear_has_prepared_statement(); - ::exec::user::PreparedStatement* temp = prepared_statement_; - prepared_statement_ = NULL; - return temp; +inline void ServerMeta::set_table_term(const char* value) { + set_has_table_term(); + if (table_term_ == &::google::protobuf::internal::kEmptyString) { + table_term_ = new ::std::string; + } + table_term_->assign(value); } -inline void CreatePreparedStatementResp::set_allocated_prepared_statement(::exec::user::PreparedStatement* prepared_statement) { - delete prepared_statement_; - prepared_statement_ = prepared_statement; - if (prepared_statement) { - set_has_prepared_statement(); +inline void ServerMeta::set_table_term(const char* value, size_t size) { + set_has_table_term(); + if (table_term_ == &::google::protobuf::internal::kEmptyString) { + table_term_ = new ::std::string; + } + table_term_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ServerMeta::mutable_table_term() { + set_has_table_term(); + if (table_term_ == &::google::protobuf::internal::kEmptyString) { + table_term_ = new ::std::string; + } + return table_term_; +} +inline ::std::string* ServerMeta::release_table_term() { + clear_has_table_term(); + if (table_term_ == &::google::protobuf::internal::kEmptyString) { + return NULL; } else { - clear_has_prepared_statement(); + ::std::string* temp = table_term_; + table_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} +inline void ServerMeta::set_allocated_table_term(::std::string* table_term) { + if (table_term_ != &::google::protobuf::internal::kEmptyString) { + delete table_term_; + } + if (table_term) { + set_has_table_term(); + table_term_ = table_term; + } else { + clear_has_table_term(); + table_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); } } -// optional .exec.shared.DrillPBError error = 3; -inline bool CreatePreparedStatementResp::has_error() const { - return (_has_bits_[0] & 0x00000004u) != 0; +// optional bool transaction_supported = 48; +inline bool ServerMeta::has_transaction_supported() const { + return (_has_bits_[1] & 0x00008000u) != 0; } -inline void CreatePreparedStatementResp::set_has_error() { - _has_bits_[0] |= 0x00000004u; +inline void ServerMeta::set_has_transaction_supported() { + _has_bits_[1] |= 0x00008000u; } -inline void CreatePreparedStatementResp::clear_has_error() { - _has_bits_[0] &= ~0x00000004u; +inline void ServerMeta::clear_has_transaction_supported() { + _has_bits_[1] &= ~0x00008000u; } -inline void CreatePreparedStatementResp::clear_error() { - if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear(); - clear_has_error(); +inline void ServerMeta::clear_transaction_supported() { + transaction_supported_ = false; + clear_has_transaction_supported(); } -inline const ::exec::shared::DrillPBError& CreatePreparedStatementResp::error() const { - return error_ != NULL ? *error_ : *default_instance_->error_; +inline bool ServerMeta::transaction_supported() const { + return transaction_supported_; } -inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::mutable_error() { - set_has_error(); - if (error_ == NULL) error_ = new ::exec::shared::DrillPBError; - return error_; +inline void ServerMeta::set_transaction_supported(bool value) { + set_has_transaction_supported(); + transaction_supported_ = value; } -inline ::exec::shared::DrillPBError* CreatePreparedStatementResp::release_error() { - clear_has_error(); - ::exec::shared::DrillPBError* temp = error_; - error_ = NULL; - return temp; + +// repeated .exec.user.UnionSupport union_support = 49; +inline int ServerMeta::union_support_size() const { + return union_support_.size(); } -inline void CreatePreparedStatementResp::set_allocated_error(::exec::shared::DrillPBError* error) { - delete error_; - error_ = error; - if (error) { - set_has_error(); - } else { - clear_has_error(); - } +inline void ServerMeta::clear_union_support() { + union_support_.Clear(); +} +inline ::exec::user::UnionSupport ServerMeta::union_support(int index) const { + return static_cast< ::exec::user::UnionSupport >(union_support_.Get(index)); +} +inline void ServerMeta::set_union_support(int index, ::exec::user::UnionSupport value) { + assert(::exec::user::UnionSupport_IsValid(value)); + union_support_.Set(index, value); +} +inline void ServerMeta::add_union_support(::exec::user::UnionSupport value) { + assert(::exec::user::UnionSupport_IsValid(value)); + union_support_.Add(value); +} +inline const ::google::protobuf::RepeatedField& +ServerMeta::union_support() const { + return union_support_; +} +inline ::google::protobuf::RepeatedField* +ServerMeta::mutable_union_support() { + return &union_support_; } // ------------------------------------------------------------------- @@ -8893,6 +11758,46 @@ template <> inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::ColumnUpdatability>() { return ::exec::user::ColumnUpdatability_descriptor(); } +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::CollateSupport>() { + return ::exec::user::CollateSupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::CorrelationNamesSupport>() { + return ::exec::user::CorrelationNamesSupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::DateTimeLiteralsSupport>() { + return ::exec::user::DateTimeLiteralsSupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::GroupBySupport>() { + return ::exec::user::GroupBySupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::IdentifierCasing>() { + return ::exec::user::IdentifierCasing_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::NullCollation>() { + return ::exec::user::NullCollation_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::OrderBySupport>() { + return ::exec::user::OrderBySupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::OuterJoinSupport>() { + return ::exec::user::OuterJoinSupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::SubQuerySupport>() { + return ::exec::user::SubQuerySupport_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::exec::user::UnionSupport>() { + return ::exec::user::UnionSupport_descriptor(); +} } // namespace google } // namespace protobuf -- cgit v1.2.3