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

9 files changed, 8034 insertions, 883 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 <stdio.h>
 #include <stdlib.h>
 #include <boost/thread.hpp>
+#include <boost/algorithm/string/join.hpp>
 #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; i<fields->size(); 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<std::string>& 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"<<std::endl;
         return false;    }
@@ -365,14 +372,77 @@ int main(int argc, char* argv[]) {
             props.setProperty(USERPROP_PASSWORD, password);
         }
 
-        props.setProperty("someRandomProperty", "someRandomValue");
-
         if(client.connect(connectStr.c_str(), &props)!=Drill::CONN_SUCCESS){
             std::cerr<< "Failed to connect with error: "<< client.getError() << " (Using:"<<connectStr<<")"<<std::endl;
             return -1;
         }
         std::cout<< "Connected!\n" << std::endl;
-        if(api=="sync"){
+        if(api=="meta") {
+        	Drill::Metadata* metadata = client.getMetadata();
+        	if (metadata) {
+        		std::cout << "Connector:" << std::endl;
+        		std::cout << "\tname:" << metadata->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<exec::shared::QueryResult_QueryState, status_t> 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<std::string>(qid.part1()) +std::string(":") + boost::lexical_cast<std::string>(qid.part2())+std::string("] ");
 }
 
+// Convertion helper
+struct ToRpcType: public std::unary_function<google::protobuf::int32, exec::user::RpcType> {
+	exec::user::RpcType operator() (google::protobuf::int32 i) const {
+		return static_cast<exec::user::RpcType>(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<b2u.authenticationmechanisms_size(); i++) {
             std::string mechanism = b2u.authenticationmechanisms(i);
             boost::algorithm::to_lower(mechanism);
@@ -1324,6 +1334,44 @@ status_t DrillClientImpl::processColumnsResult(AllocatedBufferPtr allocatedBuffe
     return ret;
 }
 
+status_t DrillClientImpl::processServerMetaResult(AllocatedBufferPtr allocatedBuffer, const rpc::InBoundRpcMessage& msg ){
+    DRILL_MT_LOG(DRILL_LOG(LOG_DEBUG) << "Processing GetServerMetaResp with coordination id:" << msg.m_coord_id << std::endl;)
+    status_t ret=QRY_SUCCESS;
+
+    // make sure to deallocate buffer
+    boost::shared_ptr<AllocatedBuffer> deallocationGuard(allocatedBuffer);
+    boost::lock_guard<boost::mutex> 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<int,DrillClientQueryHandle*>::const_iterator it=this->m_queryHandles.find(msg.m_coord_id);
+    if(it!=this->m_queryHandles.end()){
+        DrillClientServerMetaHandle* pHandle=static_cast<DrillClientServerMetaHandle*>((*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<ServerMetaContext*>(ctx);
+			if (err) {
+				context->m_status = QRY_FAILURE;
+			} else {
+				context->m_status = QRY_SUCCESS;
+				context->m_serverMeta.CopyFrom(*serverMeta);
+			}
+
+			{
+				boost::lock_guard<boost::mutex> 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<DrillClientServerMetaHandle*(int32_t)> factory = boost::bind(
+	            boost::factory<DrillClientServerMetaHandle*>(),
+	            boost::ref(*this),
+	            _1,
+				ServerMetaContext::listener,
+	            &ctx);
+	// Getting a query handle, and make sure to free when done
+	boost::shared_ptr<DrillClientServerMetaHandle> handle = boost::shared_ptr<DrillClientServerMetaHandle>(
+					sendMsg(factory, exec::user::GET_SERVER_META, req),
+					boost::bind(&DrillClientImpl::freeQueryResources, this, _1));
+	{
+		boost::unique_lock<boost::mutex> 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 DrillClientBaseHandle<pfnQueryResultsListen
         m_pSchemaListener(NULL) {
     };
 
-    ~DrillClientQueryResult(){
+    virtual ~DrillClientQueryResult(){
         this->clearAndDestroy();
     };
 
@@ -307,6 +307,18 @@ class DrillClientPrepareHandle: public DrillClientBaseHandle<pfnPreparedStatemen
     ::exec::user::PreparedStatementHandle m_preparedStatementHandle;
 };
 
+typedef status_t (*pfnServerMetaListener)(void* ctx, const exec::user::ServerMeta* serverMeta, DrillClientError* err);
+class DrillClientServerMetaHandle: public DrillClientBaseHandle<pfnServerMetaListener, const exec::user::ServerMeta*> {
+    public:
+	DrillClientServerMetaHandle(DrillClientImpl& client, int32_t coordId, pfnServerMetaListener listener, void* listenerCtx):
+    	DrillClientBaseHandle<pfnServerMetaListener, const exec::user::ServerMeta*>(client, coordId, "server meta", listener, listenerCtx) {
+    };
+
+    private:
+    friend class DrillClientImpl;
+
+};
+
 template<typename Listener, typename MetaType, typename MetaImpl, typename MetadataResult>
 class DrillClientMetadataResult: public DrillClientBaseHandle<Listener, const DrillCollection<MetaType>*> {
 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<exec::user::RpcType> m_supportedMethods;
         bool m_bIsConnected;
 
         std::vector<std::string> 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<std::string> Drill::meta::DrillMetadata::s_sqlKeywords = boost::assign::list_of
+static const std::vector<std::string> 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<std::string> Drill::meta::DrillMetadata::s_sqlKeywords = boost
 		("UESCAPE")("UNNEST")("UPSERT")("USE")("VARBINARY")("VAR_POP")("VAR_SAMP")("WIDTH_BUCKET")
 		("WINDOW")("WITHIN")("WITHOUT");
 
-const std::vector<std::string> 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<std::string> 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<std::string> 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<std::string> s_stringFunctions = boost::assign::list_of
+		("CONCAT")("INSERT")("LCASE")("LENGTH")("LOCATE")("LTRIM")("RTRIM")("SUBSTRING")("UCASE");
 
-const std::vector<std::string> Drill::meta::DrillMetadata::s_systemFunctions = boost::assign::list_of
-		("DATABASE")("IFNULL")("USER");
+static const std::vector<std::string> s_systemFunctions;
 
-const std::string Drill::meta::DrillMetadata::s_tableTerm("table");
+static const std::string s_tableTerm("table");
 
-const std::vector<std::string> 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<std::string> s_dateTimeFunctions = boost::assign::list_of
+		("CURDATE")("CURTIME")("NOW")("QUARTER");
 
-namespace Drill {
-namespace meta {
-namespace {
-using boost::assign::list_of;
+static const std::vector<exec::user::DateTimeLiteralsSupport> 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<exec::user::OrderBySupport> s_orderBySupport = boost::assign::list_of
+		(exec::user::OB_UNRELATED)(exec::user::OB_EXPRESSION);
+
+static const std::vector<exec::user::OuterJoinSupport> s_outerJoinSupport = boost::assign::list_of
+		(exec::user::OJ_LEFT)(exec::user::OJ_RIGHT)(exec::user::OJ_FULL);
+
+static const std::vector<exec::user::SubQuerySupport> 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<exec::user::UnionSupport> 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<google::protobuf::int32>& collateSupportList) {
+	Drill::meta::CollateSupport result(Drill::meta::C_NONE);
+
+	for(google::protobuf::RepeatedField<google::protobuf::int32>::const_iterator it = collateSupportList.begin();
+		it != collateSupportList.end();
+		++it) {
+		switch(static_cast<exec::user::CollateSupport>(*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<google::protobuf::int32>& dateTimeLiteralsSupportList) {
+	Drill::meta::DateTimeLiteralSupport result(Drill::meta::DL_NONE);
+
+	for(google::protobuf::RepeatedField<google::protobuf::int32>::const_iterator it = dateTimeLiteralsSupportList.begin();
+			it != dateTimeLiteralsSupportList.end();
+			++it) {
+			switch(static_cast<exec::user::DateTimeLiteralsSupport>(*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<google::protobuf::int32>& outerJoinSupportList) {
+	Drill::meta::OuterJoinSupport result(Drill::meta::OJ_NONE);
+
+	for(google::protobuf::RepeatedField<google::protobuf::int32>::const_iterator it = outerJoinSupportList.begin();
+			it != outerJoinSupportList.end();
+			++it) {
+			switch(static_cast<exec::user::OuterJoinSupport>(*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<google::protobuf::int32>& subQuerySupportList) {
+	Drill::meta::SubQuerySupport result(Drill::meta::SQ_NONE);
+
+	for(google::protobuf::RepeatedField<google::protobuf::int32>::const_iterator it = subQuerySupportList.begin();
+			it != subQuerySupportList.end();
+			++it) {
+			switch(static_cast<exec::user::SubQuerySupport>(*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<FromTo> 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<google::protobuf::int32>& unionSupportList) {
+	Drill::meta::UnionSupport result(Drill::meta::U_NONE);
+
+	for(google::protobuf::RepeatedField<google::protobuf::int32>::const_iterator it = unionSupportList.begin();
+			it != unionSupportList.end();
+			++it) {
+			switch(static_cast<exec::user::UnionSupport>(*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<google::protobuf::int32>& orderBySupportList) {
+	for(google::protobuf::RepeatedField<google::protobuf::int32>::const_iterator it = orderBySupportList.begin();
+			it != orderBySupportList.end();
+			++it) {
+			switch(static_cast<exec::user::OrderBySupport>(*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 <boost/ref.hpp>
+#include <boost/unordered_set.hpp>
 
 #include "drill/common.hpp"
 #include "drill/drillClient.hpp"
@@ -159,6 +160,25 @@ namespace meta {
 		boost::reference_wrapper<const ::exec::user::ColumnMetadata> 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<exec::user::ConvertSupport, ConvertSupportHasher, ConvertSupportEqualTo> 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<std::string> s_sqlKeywords;
-        static const std::vector<std::string> s_numericFunctions;
-        static const std::string s_schemaTerm;
-        static const std::string s_searchEscapeString;
-        static const std::string s_specialCharacters;
-        static const std::vector<std::string> s_stringFunctions;
-        static const std::vector<std::string> s_systemFunctions;
-        static const std::string s_tableTerm;
-        static const std::vector<std::string> 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<std::string>* 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<std::string>& 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<std::string>& 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<std::string>& getStringFunctions() const { return s_stringFunctions; }
-        meta::SubQuerySupport getSubQuerySupport() const { return SQ_CORRELATED
-                | SQ_IN_COMPARISON
-                | SQ_IN_EXISTS
-                | SQ_IN_QUANTIFIED;
-        }
-        const std::vector<std::string>& getSystemFunctions() const { return s_systemFunctions; }
-        const std::string& getTableTerm() const { return s_tableTerm; }
-        const std::vector<std::string>& 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<std::string>& 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<std::string>& 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<std::string>& getStringFunctions() const { return m_stringFunctions; }
+        meta::SubQuerySupport getSubQuerySupport() const { return m_subQuerySupport; }
+        const std::vector<std::string>& getSystemFunctions() const { return m_systemFunctions; }
+        const std::string& getTableTerm() const { return m_tableTerm; }
+        const std::vector<std::string>& 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<std::string> 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<std::string> 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<std::string> m_sqlKeywords;
+        std::vector<std::string> m_stringFunctions;
+		Drill::meta::SubQuerySupport m_subQuerySupport;
+        std::vector<std::string> 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 {
@@ -690,6 +832,14 @@ void protobuf_RegisterTypes(const ::std::string&) {
   ::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;
+  }
+}
+
 
 // ===================================================================
 
@@ -10995,6 +11422,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<const GetServerMetaReq*>(
+      &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<const ConvertSupport*>(
+      &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<const GetServerMetaResp*>(
+      &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<const ServerMeta*>(
+      &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
 const int RunQuery::kResultsModeFieldNumber;
 const int RunQuery::kTypeFieldNumber;
 const int RunQuery::kPlanFieldNumber;
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 <google/protobuf/generated_enum_reflection.h>
 #include <google/protobuf/unknown_field_set.h>
 #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>(
     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>(
+    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>(
+    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>(
+    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>(
+    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>(
+    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>(
+    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>(
+    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>(
+    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>(
+    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>(
+    UnionSupport_descriptor(), name, value);
+}
 // ===================================================================
 
 class Property : public ::google::protobuf::Message {
@@ -3545,6 +3776,917 @@ class CreatePreparedStatementResp : public ::google::protobuf::Message {
 };
 // -------------------------------------------------------------------
 
+class GetServerMetaReq : public ::google::protobuf::Message {
+ public:
+  GetServerMetaReq();
+  virtual ~GetServerMetaReq();
+
+  GetServerMetaReq(const GetServerMetaReq& from);
+
+  inline GetServerMetaReq& operator=(const GetServerMetaReq& 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 GetServerMetaReq& default_instance();
+
+  void Swap(GetServerMetaReq* other);
+
+  // implements Message ----------------------------------------------
+
+  GetServerMetaReq* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetServerMetaReq& from);
+  void MergeFrom(const GetServerMetaReq& 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 -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:exec.user.GetServerMetaReq)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[1];
+
+  friend void  protobuf_AddDesc_User_2eproto();
+  friend void protobuf_AssignDesc_User_2eproto();
+  friend void protobuf_ShutdownFile_User_2eproto();
+
+  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_from();
+  inline void clear_has_from();
+  inline void set_has_to();
+  inline void clear_has_to();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  int from_;
+  int to_;
+
+  mutable int _cached_size_;
+  ::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 ConvertSupport* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class GetServerMetaResp : public ::google::protobuf::Message {
+ public:
+  GetServerMetaResp();
+  virtual ~GetServerMetaResp();
+
+  GetServerMetaResp(const GetServerMetaResp& from);
+
+  inline GetServerMetaResp& operator=(const GetServerMetaResp& 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 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<int>& collate_support() const;
+  inline ::google::protobuf::RepeatedField<int>* 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<int>& date_time_literals_support() const;
+  inline ::google::protobuf::RepeatedField<int>* 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<int>& order_by_support() const;
+  inline ::google::protobuf::RepeatedField<int>* 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<int>& outer_join_support() const;
+  inline ::google::protobuf::RepeatedField<int>* 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<int>& subquery_support() const;
+  inline ::google::protobuf::RepeatedField<int>* 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<int>& union_support() const;
+  inline ::google::protobuf::RepeatedField<int>* 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<int> collate_support_;
+  ::google::protobuf::RepeatedPtrField< ::exec::user::ConvertSupport > convert_support_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> date_time_functions_;
+  ::google::protobuf::RepeatedField<int> 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<int> order_by_support_;
+  ::google::protobuf::RepeatedField<int> 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<int> subquery_support_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> system_functions_;
+  ::std::string* table_term_;
+  ::google::protobuf::RepeatedField<int> 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();
@@ -8674,6 +9816,1729 @@ inline void CreatePreparedStatementResp::set_allocated_error(::exec::shared::Dri
 
 // -------------------------------------------------------------------
 
+// GetServerMetaReq
+
+// -------------------------------------------------------------------
+
+// ConvertSupport
+
+// required .common.MinorType from = 1;
+inline bool ConvertSupport::has_from() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ConvertSupport::set_has_from() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ConvertSupport::clear_has_from() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ConvertSupport::clear_from() {
+  from_ = 0;
+  clear_has_from();
+}
+inline ::common::MinorType ConvertSupport::from() const {
+  return static_cast< ::common::MinorType >(from_);
+}
+inline void ConvertSupport::set_from(::common::MinorType value) {
+  assert(::common::MinorType_IsValid(value));
+  set_has_from();
+  from_ = value;
+}
+
+// required .common.MinorType to = 2;
+inline bool ConvertSupport::has_to() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ConvertSupport::set_has_to() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ConvertSupport::clear_has_to() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ConvertSupport::clear_to() {
+  to_ = 0;
+  clear_has_to();
+}
+inline ::common::MinorType ConvertSupport::to() const {
+  return static_cast< ::common::MinorType >(to_);
+}
+inline void ConvertSupport::set_to(::common::MinorType value) {
+  assert(::common::MinorType_IsValid(value));
+  set_has_to();
+  to_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// GetServerMetaResp
+
+// optional .exec.user.RequestStatus status = 1;
+inline bool GetServerMetaResp::has_status() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetServerMetaResp::set_has_status() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetServerMetaResp::clear_has_status() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetServerMetaResp::clear_status() {
+  status_ = 0;
+  clear_has_status();
+}
+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_server_meta();
+  }
+}
+
+// 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 GetServerMetaResp::clear_error() {
+  if (error_ != NULL) error_->::exec::shared::DrillPBError::Clear();
+  clear_has_error();
+}
+inline const ::exec::shared::DrillPBError& GetServerMetaResp::error() const {
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+}
+inline ::exec::shared::DrillPBError* GetServerMetaResp::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::exec::shared::DrillPBError;
+  return error_;
+}
+inline ::exec::shared::DrillPBError* GetServerMetaResp::release_error() {
+  clear_has_error();
+  ::exec::shared::DrillPBError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void GetServerMetaResp::set_allocated_error(::exec::shared::DrillPBError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+// -------------------------------------------------------------------
+
+// ServerMeta
+
+// optional bool all_tables_selectable = 1;
+inline bool ServerMeta::has_all_tables_selectable() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ServerMeta::set_has_all_tables_selectable() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ServerMeta::clear_has_all_tables_selectable() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ServerMeta::clear_all_tables_selectable() {
+  all_tables_selectable_ = false;
+  clear_has_all_tables_selectable();
+}
+inline bool ServerMeta::all_tables_selectable() const {
+  return all_tables_selectable_;
+}
+inline void ServerMeta::set_all_tables_selectable(bool value) {
+  set_has_all_tables_selectable();
+  all_tables_selectable_ = value;
+}
+
+// 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 ServerMeta::set_has_blob_included_in_max_row_size() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ServerMeta::clear_has_blob_included_in_max_row_size() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+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 bool ServerMeta::blob_included_in_max_row_size() const {
+  return blob_included_in_max_row_size_;
+}
+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 bool catalog_at_start = 3;
+inline bool ServerMeta::has_catalog_at_start() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ServerMeta::set_has_catalog_at_start() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ServerMeta::clear_has_catalog_at_start() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ServerMeta::clear_catalog_at_start() {
+  catalog_at_start_ = false;
+  clear_has_catalog_at_start();
+}
+inline bool ServerMeta::catalog_at_start() const {
+  return catalog_at_start_;
+}
+inline void ServerMeta::set_catalog_at_start(bool value) {
+  set_has_catalog_at_start();
+  catalog_at_start_ = value;
+}
+
+// optional string catalog_separator = 4;
+inline bool ServerMeta::has_catalog_separator() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ServerMeta::set_has_catalog_separator() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ServerMeta::clear_has_catalog_separator() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ServerMeta::clear_catalog_separator() {
+  if (catalog_separator_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_separator_->clear();
+  }
+  clear_has_catalog_separator();
+}
+inline const ::std::string& ServerMeta::catalog_separator() const {
+  return *catalog_separator_;
+}
+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 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 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<const char*>(value), size);
+}
+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 ::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 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 catalog_term = 5;
+inline bool ServerMeta::has_catalog_term() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ServerMeta::set_has_catalog_term() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ServerMeta::clear_has_catalog_term() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ServerMeta::clear_catalog_term() {
+  if (catalog_term_ != &::google::protobuf::internal::kEmptyString) {
+    catalog_term_->clear();
+  }
+  clear_has_catalog_term();
+}
+inline const ::std::string& ServerMeta::catalog_term() const {
+  return *catalog_term_;
+}
+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;
+  }
+  catalog_term_->assign(value);
+}
+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;
+  }
+  catalog_term_->assign(value);
+}
+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;
+  }
+  catalog_term_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ServerMeta::mutable_catalog_term() {
+  set_has_catalog_term();
+  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
+    catalog_term_ = new ::std::string;
+  }
+  return catalog_term_;
+}
+inline ::std::string* ServerMeta::release_catalog_term() {
+  clear_has_catalog_term();
+  if (catalog_term_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = catalog_term_;
+    catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ServerMeta::set_allocated_catalog_term(::std::string* catalog_term) {
+  if (catalog_term_ != &::google::protobuf::internal::kEmptyString) {
+    delete catalog_term_;
+  }
+  if (catalog_term) {
+    set_has_catalog_term();
+    catalog_term_ = catalog_term;
+  } else {
+    clear_has_catalog_term();
+    catalog_term_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// repeated .exec.user.CollateSupport collate_support = 6;
+inline int ServerMeta::collate_support_size() const {
+  return collate_support_.size();
+}
+inline void ServerMeta::clear_collate_support() {
+  collate_support_.Clear();
+}
+inline ::exec::user::CollateSupport ServerMeta::collate_support(int index) const {
+  return static_cast< ::exec::user::CollateSupport >(collate_support_.Get(index));
+}
+inline void ServerMeta::set_collate_support(int index, ::exec::user::CollateSupport value) {
+  assert(::exec::user::CollateSupport_IsValid(value));
+  collate_support_.Set(index, value);
+}
+inline void ServerMeta::add_collate_support(::exec::user::CollateSupport value) {
+  assert(::exec::user::CollateSupport_IsValid(value));
+  collate_support_.Add(value);
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ServerMeta::collate_support() const {
+  return collate_support_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ServerMeta::mutable_collate_support() {
+  return &collate_support_;
+}
+
+// optional bool column_aliasing_supported = 7;
+inline bool ServerMeta::has_column_aliasing_supported() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ServerMeta::set_has_column_aliasing_supported() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ServerMeta::clear_has_column_aliasing_supported() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ServerMeta::clear_column_aliasing_supported() {
+  column_aliasing_supported_ = false;
+  clear_has_column_aliasing_supported();
+}
+inline bool ServerMeta::column_aliasing_supported() const {
+  return column_aliasing_supported_;
+}
+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_;
+}
+
+// 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;
+}
+
+// repeated string date_time_functions = 10;
+inline int ServerMeta::date_time_functions_size() const {
+  return date_time_functions_.size();
+}
+inline void ServerMeta::clear_date_time_functions() {
+  date_time_functions_.Clear();
+}
+inline const ::std::string& ServerMeta::date_time_functions(int index) const {
+  return date_time_functions_.Get(index);
+}
+inline ::std::string* ServerMeta::mutable_date_time_functions(int index) {
+  return date_time_functions_.Mutable(index);
+}
+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<const char*>(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<const char*>(value), size);
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+ServerMeta::date_time_functions() const {
+  return date_time_functions_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+ServerMeta::mutable_date_time_functions() {
+  return &date_time_functions_;
+}
+
+// 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 ServerMeta::clear_date_time_literals_support() {
+  date_time_literals_support_.Clear();
+}
+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 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 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::RepeatedField<int>&
+ServerMeta::date_time_literals_support() const {
+  return date_time_literals_support_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ServerMeta::mutable_date_time_literals_support() {
+  return &date_time_literals_support_;
+}
+
+// optional .exec.user.GroupBySupport group_by_support = 12;
+inline bool ServerMeta::has_group_by_support() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ServerMeta::set_has_group_by_support() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ServerMeta::clear_has_group_by_support() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ServerMeta::clear_group_by_support() {
+  group_by_support_ = 1;
+  clear_has_group_by_support();
+}
+inline ::exec::user::GroupBySupport ServerMeta::group_by_support() const {
+  return static_cast< ::exec::user::GroupBySupport >(group_by_support_);
+}
+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;
+}
+
+// optional .exec.user.IdentifierCasing identifier_casing = 13;
+inline bool ServerMeta::has_identifier_casing() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+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;
+}
+
+// optional string identifier_quote_string = 14;
+inline bool ServerMeta::has_identifier_quote_string() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ServerMeta::set_has_identifier_quote_string() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ServerMeta::clear_has_identifier_quote_string() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ServerMeta::clear_identifier_quote_string() {
+  if (identifier_quote_string_ != &::google::protobuf::internal::kEmptyString) {
+    identifier_quote_string_->clear();
+  }
+  clear_has_identifier_quote_string();
+}
+inline const ::std::string& ServerMeta::identifier_quote_string() const {
+  return *identifier_quote_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;
+  }
+  identifier_quote_string_->assign(value);
+}
+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;
+  }
+  identifier_quote_string_->assign(value);
+}
+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;
+  }
+  identifier_quote_string_->assign(reinterpret_cast<const char*>(value), size);
+}
+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 identifier_quote_string_;
+}
+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 = identifier_quote_string_;
+    identifier_quote_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+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 (identifier_quote_string) {
+    set_has_identifier_quote_string();
+    identifier_quote_string_ = identifier_quote_string;
+  } else {
+    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;
+}
+
+// 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 uint32 max_catalog_name_length = 17;
+inline bool ServerMeta::has_max_catalog_name_length() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void ServerMeta::set_has_max_catalog_name_length() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void ServerMeta::clear_has_max_catalog_name_length() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void ServerMeta::clear_max_catalog_name_length() {
+  max_catalog_name_length_ = 0u;
+  clear_has_max_catalog_name_length();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_catalog_name_length() const {
+  return max_catalog_name_length_;
+}
+inline void ServerMeta::set_max_catalog_name_length(::google::protobuf::uint32 value) {
+  set_has_max_catalog_name_length();
+  max_catalog_name_length_ = 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 ServerMeta::set_has_max_char_literal_length() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void ServerMeta::clear_has_max_char_literal_length() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void ServerMeta::clear_max_char_literal_length() {
+  max_char_literal_length_ = 0u;
+  clear_has_max_char_literal_length();
+}
+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 uint32 max_column_name_length = 19;
+inline bool ServerMeta::has_max_column_name_length() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void ServerMeta::set_has_max_column_name_length() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void ServerMeta::clear_has_max_column_name_length() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void ServerMeta::clear_max_column_name_length() {
+  max_column_name_length_ = 0u;
+  clear_has_max_column_name_length();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_column_name_length() const {
+  return max_column_name_length_;
+}
+inline void ServerMeta::set_max_column_name_length(::google::protobuf::uint32 value) {
+  set_has_max_column_name_length();
+  max_column_name_length_ = 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 ServerMeta::set_has_max_columns_in_group_by() {
+  _has_bits_[0] |= 0x00080000u;
+}
+inline void ServerMeta::clear_has_max_columns_in_group_by() {
+  _has_bits_[0] &= ~0x00080000u;
+}
+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 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 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 ServerMeta::set_has_max_columns_in_order_by() {
+  _has_bits_[0] |= 0x00100000u;
+}
+inline void ServerMeta::clear_has_max_columns_in_order_by() {
+  _has_bits_[0] &= ~0x00100000u;
+}
+inline void ServerMeta::clear_max_columns_in_order_by() {
+  max_columns_in_order_by_ = 0u;
+  clear_has_max_columns_in_order_by();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_columns_in_order_by() const {
+  return max_columns_in_order_by_;
+}
+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;
+}
+
+// optional uint32 max_columns_in_select = 22;
+inline bool ServerMeta::has_max_columns_in_select() const {
+  return (_has_bits_[0] & 0x00200000u) != 0;
+}
+inline void ServerMeta::set_has_max_columns_in_select() {
+  _has_bits_[0] |= 0x00200000u;
+}
+inline void ServerMeta::clear_has_max_columns_in_select() {
+  _has_bits_[0] &= ~0x00200000u;
+}
+inline void ServerMeta::clear_max_columns_in_select() {
+  max_columns_in_select_ = 0u;
+  clear_has_max_columns_in_select();
+}
+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 uint32 max_cursor_name_length = 23;
+inline bool ServerMeta::has_max_cursor_name_length() const {
+  return (_has_bits_[0] & 0x00400000u) != 0;
+}
+inline void ServerMeta::set_has_max_cursor_name_length() {
+  _has_bits_[0] |= 0x00400000u;
+}
+inline void ServerMeta::clear_has_max_cursor_name_length() {
+  _has_bits_[0] &= ~0x00400000u;
+}
+inline void ServerMeta::clear_max_cursor_name_length() {
+  max_cursor_name_length_ = 0u;
+  clear_has_max_cursor_name_length();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_cursor_name_length() const {
+  return max_cursor_name_length_;
+}
+inline void ServerMeta::set_max_cursor_name_length(::google::protobuf::uint32 value) {
+  set_has_max_cursor_name_length();
+  max_cursor_name_length_ = 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 ServerMeta::set_has_max_logical_lob_size() {
+  _has_bits_[0] |= 0x00800000u;
+}
+inline void ServerMeta::clear_has_max_logical_lob_size() {
+  _has_bits_[0] &= ~0x00800000u;
+}
+inline void ServerMeta::clear_max_logical_lob_size() {
+  max_logical_lob_size_ = 0u;
+  clear_has_max_logical_lob_size();
+}
+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 uint32 max_row_size = 25;
+inline bool ServerMeta::has_max_row_size() const {
+  return (_has_bits_[0] & 0x01000000u) != 0;
+}
+inline void ServerMeta::set_has_max_row_size() {
+  _has_bits_[0] |= 0x01000000u;
+}
+inline void ServerMeta::clear_has_max_row_size() {
+  _has_bits_[0] &= ~0x01000000u;
+}
+inline void ServerMeta::clear_max_row_size() {
+  max_row_size_ = 0u;
+  clear_has_max_row_size();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_row_size() const {
+  return max_row_size_;
+}
+inline void ServerMeta::set_max_row_size(::google::protobuf::uint32 value) {
+  set_has_max_row_size();
+  max_row_size_ = 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 ServerMeta::set_has_max_schema_name_length() {
+  _has_bits_[0] |= 0x02000000u;
+}
+inline void ServerMeta::clear_has_max_schema_name_length() {
+  _has_bits_[0] &= ~0x02000000u;
+}
+inline void ServerMeta::clear_max_schema_name_length() {
+  max_schema_name_length_ = 0u;
+  clear_has_max_schema_name_length();
+}
+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 uint32 max_statement_length = 27;
+inline bool ServerMeta::has_max_statement_length() const {
+  return (_has_bits_[0] & 0x04000000u) != 0;
+}
+inline void ServerMeta::set_has_max_statement_length() {
+  _has_bits_[0] |= 0x04000000u;
+}
+inline void ServerMeta::clear_has_max_statement_length() {
+  _has_bits_[0] &= ~0x04000000u;
+}
+inline void ServerMeta::clear_max_statement_length() {
+  max_statement_length_ = 0u;
+  clear_has_max_statement_length();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_statement_length() const {
+  return max_statement_length_;
+}
+inline void ServerMeta::set_max_statement_length(::google::protobuf::uint32 value) {
+  set_has_max_statement_length();
+  max_statement_length_ = value;
+}
+
+// optional uint32 max_statements = 28;
+inline bool ServerMeta::has_max_statements() const {
+  return (_has_bits_[0] & 0x08000000u) != 0;
+}
+inline void ServerMeta::set_has_max_statements() {
+  _has_bits_[0] |= 0x08000000u;
+}
+inline void ServerMeta::clear_has_max_statements() {
+  _has_bits_[0] &= ~0x08000000u;
+}
+inline void ServerMeta::clear_max_statements() {
+  max_statements_ = 0u;
+  clear_has_max_statements();
+}
+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 uint32 max_tables_in_select = 30;
+inline bool ServerMeta::has_max_tables_in_select() const {
+  return (_has_bits_[0] & 0x20000000u) != 0;
+}
+inline void ServerMeta::set_has_max_tables_in_select() {
+  _has_bits_[0] |= 0x20000000u;
+}
+inline void ServerMeta::clear_has_max_tables_in_select() {
+  _has_bits_[0] &= ~0x20000000u;
+}
+inline void ServerMeta::clear_max_tables_in_select() {
+  max_tables_in_select_ = 0u;
+  clear_has_max_tables_in_select();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_tables_in_select() const {
+  return max_tables_in_select_;
+}
+inline void ServerMeta::set_max_tables_in_select(::google::protobuf::uint32 value) {
+  set_has_max_tables_in_select();
+  max_tables_in_select_ = value;
+}
+
+// optional uint32 max_user_name_length = 31;
+inline bool ServerMeta::has_max_user_name_length() const {
+  return (_has_bits_[0] & 0x40000000u) != 0;
+}
+inline void ServerMeta::set_has_max_user_name_length() {
+  _has_bits_[0] |= 0x40000000u;
+}
+inline void ServerMeta::clear_has_max_user_name_length() {
+  _has_bits_[0] &= ~0x40000000u;
+}
+inline void ServerMeta::clear_max_user_name_length() {
+  max_user_name_length_ = 0u;
+  clear_has_max_user_name_length();
+}
+inline ::google::protobuf::uint32 ServerMeta::max_user_name_length() const {
+  return max_user_name_length_;
+}
+inline void ServerMeta::set_max_user_name_length(::google::protobuf::uint32 value) {
+  set_has_max_user_name_length();
+  max_user_name_length_ = value;
+}
+
+// optional .exec.user.NullCollation null_collation = 32;
+inline bool ServerMeta::has_null_collation() const {
+  return (_has_bits_[0] & 0x80000000u) != 0;
+}
+inline void ServerMeta::set_has_null_collation() {
+  _has_bits_[0] |= 0x80000000u;
+}
+inline void ServerMeta::clear_has_null_collation() {
+  _has_bits_[0] &= ~0x80000000u;
+}
+inline void ServerMeta::clear_null_collation() {
+  null_collation_ = 0;
+  clear_has_null_collation();
+}
+inline ::exec::user::NullCollation ServerMeta::null_collation() const {
+  return static_cast< ::exec::user::NullCollation >(null_collation_);
+}
+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 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 ServerMeta::set_has_null_plus_non_null_equals_null() {
+  _has_bits_[1] |= 0x00000001u;
+}
+inline void ServerMeta::clear_has_null_plus_non_null_equals_null() {
+  _has_bits_[1] &= ~0x00000001u;
+}
+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 ServerMeta::null_plus_non_null_equals_null() const {
+  return null_plus_non_null_equals_null_;
+}
+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;
+}
+
+// repeated string numeric_functions = 34;
+inline int ServerMeta::numeric_functions_size() const {
+  return numeric_functions_.size();
+}
+inline void ServerMeta::clear_numeric_functions() {
+  numeric_functions_.Clear();
+}
+inline const ::std::string& ServerMeta::numeric_functions(int index) const {
+  return numeric_functions_.Get(index);
+}
+inline ::std::string* ServerMeta::mutable_numeric_functions(int index) {
+  return numeric_functions_.Mutable(index);
+}
+inline void ServerMeta::set_numeric_functions(int index, const ::std::string& value) {
+  numeric_functions_.Mutable(index)->assign(value);
+}
+inline void ServerMeta::set_numeric_functions(int index, const char* value) {
+  numeric_functions_.Mutable(index)->assign(value);
+}
+inline void ServerMeta::set_numeric_functions(int index, const char* value, size_t size) {
+  numeric_functions_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ServerMeta::add_numeric_functions() {
+  return numeric_functions_.Add();
+}
+inline void ServerMeta::add_numeric_functions(const ::std::string& value) {
+  numeric_functions_.Add()->assign(value);
+}
+inline void ServerMeta::add_numeric_functions(const char* value) {
+  numeric_functions_.Add()->assign(value);
+}
+inline void ServerMeta::add_numeric_functions(const char* value, size_t size) {
+  numeric_functions_.Add()->assign(reinterpret_cast<const char*>(value), size);
+}
+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_;
+}
+
+// repeated .exec.user.OrderBySupport order_by_support = 35;
+inline int ServerMeta::order_by_support_size() const {
+  return order_by_support_.size();
+}
+inline void ServerMeta::clear_order_by_support() {
+  order_by_support_.Clear();
+}
+inline ::exec::user::OrderBySupport ServerMeta::order_by_support(int index) const {
+  return static_cast< ::exec::user::OrderBySupport >(order_by_support_.Get(index));
+}
+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 void ServerMeta::add_order_by_support(::exec::user::OrderBySupport value) {
+  assert(::exec::user::OrderBySupport_IsValid(value));
+  order_by_support_.Add(value);
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ServerMeta::order_by_support() const {
+  return order_by_support_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ServerMeta::mutable_order_by_support() {
+  return &order_by_support_;
+}
+
+// repeated .exec.user.OuterJoinSupport outer_join_support = 36;
+inline int ServerMeta::outer_join_support_size() const {
+  return outer_join_support_.size();
+}
+inline void ServerMeta::clear_outer_join_support() {
+  outer_join_support_.Clear();
+}
+inline ::exec::user::OuterJoinSupport ServerMeta::outer_join_support(int index) const {
+  return static_cast< ::exec::user::OuterJoinSupport >(outer_join_support_.Get(index));
+}
+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 void ServerMeta::add_outer_join_support(::exec::user::OuterJoinSupport value) {
+  assert(::exec::user::OuterJoinSupport_IsValid(value));
+  outer_join_support_.Add(value);
+}
+inline const ::google::protobuf::RepeatedField<int>&
+ServerMeta::outer_join_support() const {
+  return outer_join_support_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ServerMeta::mutable_outer_join_support() {
+  return &outer_join_support_;
+}
+
+// optional .exec.user.IdentifierCasing quoted_identifier_casing = 37;
+inline bool ServerMeta::has_quoted_identifier_casing() const {
+  return (_has_bits_[1] & 0x00000010u) != 0;
+}
+inline void ServerMeta::set_has_quoted_identifier_casing() {
+  _has_bits_[1] |= 0x00000010u;
+}
+inline void ServerMeta::clear_has_quoted_identifier_casing() {
+  _has_bits_[1] &= ~0x00000010u;
+}
+inline void ServerMeta::clear_quoted_identifier_casing() {
+  quoted_identifier_casing_ = 0;
+  clear_has_quoted_identifier_casing();
+}
+inline ::exec::user::IdentifierCasing ServerMeta::quoted_identifier_casing() const {
+  return static_cast< ::exec::user::IdentifierCasing >(quoted_identifier_casing_);
+}
+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 read_only = 38;
+inline bool ServerMeta::has_read_only() const {
+  return (_has_bits_[1] & 0x00000020u) != 0;
+}
+inline void ServerMeta::set_has_read_only() {
+  _has_bits_[1] |= 0x00000020u;
+}
+inline void ServerMeta::clear_has_read_only() {
+  _has_bits_[1] &= ~0x00000020u;
+}
+inline void ServerMeta::clear_read_only() {
+  read_only_ = false;
+  clear_has_read_only();
+}
+inline bool ServerMeta::read_only() const {
+  return read_only_;
+}
+inline void ServerMeta::set_read_only(bool value) {
+  set_has_read_only();
+  read_only_ = value;
+}
+
+// optional string schema_term = 39;
+inline bool ServerMeta::has_schema_term() const {
+  return (_has_bits_[1] & 0x00000040u) != 0;
+}
+inline void ServerMeta::set_has_schema_term() {
+  _has_bits_[1] |= 0x00000040u;
+}
+inline void ServerMeta::clear_has_schema_term() {
+  _has_bits_[1] &= ~0x00000040u;
+}
+inline void ServerMeta::clear_schema_term() {
+  if (schema_term_ != &::google::protobuf::internal::kEmptyString) {
+    schema_term_->clear();
+  }
+  clear_has_schema_term();
+}
+inline const ::std::string& ServerMeta::schema_term() const {
+  return *schema_term_;
+}
+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<const char*>(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 search_escape_string = 40;
+inline bool ServerMeta::has_search_escape_string() const {
+  return (_has_bits_[1] & 0x00000080u) != 0;
+}
+inline void ServerMeta::set_has_search_escape_string() {
+  _has_bits_[1] |= 0x00000080u;
+}
+inline void ServerMeta::clear_has_search_escape_string() {
+  _has_bits_[1] &= ~0x00000080u;
+}
+inline void ServerMeta::clear_search_escape_string() {
+  if (search_escape_string_ != &::google::protobuf::internal::kEmptyString) {
+    search_escape_string_->clear();
+  }
+  clear_has_search_escape_string();
+}
+inline const ::std::string& ServerMeta::search_escape_string() const {
+  return *search_escape_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;
+  }
+  search_escape_string_->assign(value);
+}
+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;
+  }
+  search_escape_string_->assign(value);
+}
+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;
+  }
+  search_escape_string_->assign(reinterpret_cast<const char*>(value), size);
+}
+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 search_escape_string_;
+}
+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 = search_escape_string_;
+    search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+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 (search_escape_string) {
+    set_has_search_escape_string();
+    search_escape_string_ = search_escape_string;
+  } else {
+    clear_has_search_escape_string();
+    search_escape_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional bool select_for_update_supported = 41;
+inline bool ServerMeta::has_select_for_update_supported() const {
+  return (_has_bits_[1] & 0x00000100u) != 0;
+}
+inline void ServerMeta::set_has_select_for_update_supported() {
+  _has_bits_[1] |= 0x00000100u;
+}
+inline void ServerMeta::clear_has_select_for_update_supported() {
+  _has_bits_[1] &= ~0x00000100u;
+}
+inline void ServerMeta::clear_select_for_update_supported() {
+  select_for_update_supported_ = false;
+  clear_has_select_for_update_supported();
+}
+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;
+}
+
+// optional string special_characters = 42;
+inline bool ServerMeta::has_special_characters() const {
+  return (_has_bits_[1] & 0x00000200u) != 0;
+}
+inline void ServerMeta::set_has_special_characters() {
+  _has_bits_[1] |= 0x00000200u;
+}
+inline void ServerMeta::clear_has_special_characters() {
+  _has_bits_[1] &= ~0x00000200u;
+}
+inline void ServerMeta::clear_special_characters() {
+  if (special_characters_ != &::google::protobuf::internal::kEmptyString) {
+    special_characters_->clear();
+  }
+  clear_has_special_characters();
+}
+inline const ::std::string& ServerMeta::special_characters() const {
+  return *special_characters_;
+}
+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;
+  }
+  special_characters_->assign(value);
+}
+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;
+  }
+  special_characters_->assign(value);
+}
+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;
+  }
+  special_characters_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* ServerMeta::mutable_special_characters() {
+  set_has_special_characters();
+  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
+    special_characters_ = new ::std::string;
+  }
+  return special_characters_;
+}
+inline ::std::string* ServerMeta::release_special_characters() {
+  clear_has_special_characters();
+  if (special_characters_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = special_characters_;
+    special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void ServerMeta::set_allocated_special_characters(::std::string* special_characters) {
+  if (special_characters_ != &::google::protobuf::internal::kEmptyString) {
+    delete special_characters_;
+  }
+  if (special_characters) {
+    set_has_special_characters();
+    special_characters_ = special_characters;
+  } else {
+    clear_has_special_characters();
+    special_characters_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// repeated string sql_keywords = 43;
+inline int ServerMeta::sql_keywords_size() const {
+  return sql_keywords_.size();
+}
+inline void ServerMeta::clear_sql_keywords() {
+  sql_keywords_.Clear();
+}
+inline const ::std::string& ServerMeta::sql_keywords(int index) const {
+  return sql_keywords_.Get(index);
+}
+inline ::std::string* ServerMeta::mutable_sql_keywords(int index) {
+  return sql_keywords_.Mutable(index);
+}
+inline void ServerMeta::set_sql_keywords(int index, const ::std::string& value) {
+  sql_keywords_.Mutable(index)->assign(value);
+}
+inline void ServerMeta::set_sql_keywords(int index, const char* value) {
+  sql_keywords_.Mutable(index)->assign(value);
+}
+inline void ServerMeta::set_sql_keywords(int index, const char* value, size_t size) {
+  sql_keywords_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(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<const char*>(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_;
+}
+
+// repeated string string_functions = 44;
+inline int ServerMeta::string_functions_size() const {
+  return string_functions_.size();
+}
+inline void ServerMeta::clear_string_functions() {
+  string_functions_.Clear();
+}
+inline const ::std::string& ServerMeta::string_functions(int index) const {
+  return string_functions_.Get(index);
+}
+inline ::std::string* ServerMeta::mutable_string_functions(int index) {
+  return string_functions_.Mutable(index);
+}
+inline void ServerMeta::set_string_functions(int index, const ::std::string& value) {
+  string_functions_.Mutable(index)->assign(value);
+}
+inline void ServerMeta::set_string_functions(int index, const char* value) {
+  string_functions_.Mutable(index)->assign(value);
+}
+inline void ServerMeta::set_string_functions(int index, const char* value, size_t size) {
+  string_functions_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+}
+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<const char*>(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_;
+}
+
+// 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<int>&
+ServerMeta::subquery_support() const {
+  return subquery_support_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ServerMeta::mutable_subquery_support() {
+  return &subquery_support_;
+}
+
+// repeated string system_functions = 46;
+inline int ServerMeta::system_functions_size() const {
+  return system_functions_.size();
+}
+inline void ServerMeta::clear_system_functions() {
+  system_functions_.Clear();
+}
+inline const ::std::string& ServerMeta::system_functions(int index) const {
+  return system_functions_.Get(index);
+}
+inline ::std::string* ServerMeta::mutable_system_functions(int index) {
+  return system_functions_.Mutable(index);
+}
+inline void ServerMeta::set_system_functions(int index, const ::std::string& value) {
+  system_functions_.Mutable(index)->assign(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<const char*>(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<const char*>(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 string table_term = 47;
+inline bool ServerMeta::has_table_term() const {
+  return (_has_bits_[1] & 0x00004000u) != 0;
+}
+inline void ServerMeta::set_has_table_term() {
+  _has_bits_[1] |= 0x00004000u;
+}
+inline void ServerMeta::clear_has_table_term() {
+  _has_bits_[1] &= ~0x00004000u;
+}
+inline void ServerMeta::clear_table_term() {
+  if (table_term_ != &::google::protobuf::internal::kEmptyString) {
+    table_term_->clear();
+  }
+  clear_has_table_term();
+}
+inline const ::std::string& ServerMeta::table_term() const {
+  return *table_term_;
+}
+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 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 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<const char*>(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 {
+    ::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 bool transaction_supported = 48;
+inline bool ServerMeta::has_transaction_supported() const {
+  return (_has_bits_[1] & 0x00008000u) != 0;
+}
+inline void ServerMeta::set_has_transaction_supported() {
+  _has_bits_[1] |= 0x00008000u;
+}
+inline void ServerMeta::clear_has_transaction_supported() {
+  _has_bits_[1] &= ~0x00008000u;
+}
+inline void ServerMeta::clear_transaction_supported() {
+  transaction_supported_ = false;
+  clear_has_transaction_supported();
+}
+inline bool ServerMeta::transaction_supported() const {
+  return transaction_supported_;
+}
+inline void ServerMeta::set_transaction_supported(bool value) {
+  set_has_transaction_supported();
+  transaction_supported_ = value;
+}
+
+// repeated .exec.user.UnionSupport union_support = 49;
+inline int ServerMeta::union_support_size() const {
+  return union_support_.size();
+}
+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<int>&
+ServerMeta::union_support() const {
+  return union_support_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+ServerMeta::mutable_union_support() {
+  return &union_support_;
+}
+
+// -------------------------------------------------------------------
+
 // RunQuery
 
 // optional .exec.user.QueryResultsMode results_mode = 1;
@@ -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