service/src/gen/thrift/gen-cpp/TCLIService.h

/**
 * Autogenerated by Thrift Compiler (0.9.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#ifndef TCLIService_H
#define TCLIService_H

#include <thrift/TDispatchProcessor.h>
#include "TCLIService_types.h"

namespace apache { namespace hive { namespace service { namespace cli { namespace thrift {

class TCLIServiceIf {
 public:
  virtual ~TCLIServiceIf() {}
  virtual void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req) = 0;
  virtual void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req) = 0;
  virtual void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req) = 0;
  virtual void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req) = 0;
  virtual void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req) = 0;
  virtual void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req) = 0;
  virtual void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req) = 0;
  virtual void GetTables(TGetTablesResp& _return, const TGetTablesReq& req) = 0;
  virtual void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req) = 0;
  virtual void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req) = 0;
  virtual void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req) = 0;
  virtual void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req) = 0;
  virtual void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req) = 0;
  virtual void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) = 0;
  virtual void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) = 0;
  virtual void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) = 0;
  virtual void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) = 0;
  virtual void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) = 0;
  virtual void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) = 0;
};

class TCLIServiceIfFactory {
 public:
  typedef TCLIServiceIf Handler;

  virtual ~TCLIServiceIfFactory() {}

  virtual TCLIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
  virtual void releaseHandler(TCLIServiceIf* /* handler */) = 0;
};

class TCLIServiceIfSingletonFactory : virtual public TCLIServiceIfFactory {
 public:
  TCLIServiceIfSingletonFactory(const boost::shared_ptr<TCLIServiceIf>& iface) : iface_(iface) {}
  virtual ~TCLIServiceIfSingletonFactory() {}

  virtual TCLIServiceIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
    return iface_.get();
  }
  virtual void releaseHandler(TCLIServiceIf* /* handler */) {}

 protected:
  boost::shared_ptr<TCLIServiceIf> iface_;
};

class TCLIServiceNull : virtual public TCLIServiceIf {
 public:
  virtual ~TCLIServiceNull() {}
  void OpenSession(TOpenSessionResp& /* _return */, const TOpenSessionReq& /* req */) {
    return;
  }
  void CloseSession(TCloseSessionResp& /* _return */, const TCloseSessionReq& /* req */) {
    return;
  }
  void GetInfo(TGetInfoResp& /* _return */, const TGetInfoReq& /* req */) {
    return;
  }
  void ExecuteStatement(TExecuteStatementResp& /* _return */, const TExecuteStatementReq& /* req */) {
    return;
  }
  void GetTypeInfo(TGetTypeInfoResp& /* _return */, const TGetTypeInfoReq& /* req */) {
    return;
  }
  void GetCatalogs(TGetCatalogsResp& /* _return */, const TGetCatalogsReq& /* req */) {
    return;
  }
  void GetSchemas(TGetSchemasResp& /* _return */, const TGetSchemasReq& /* req */) {
    return;
  }
  void GetTables(TGetTablesResp& /* _return */, const TGetTablesReq& /* req */) {
    return;
  }
  void GetTableTypes(TGetTableTypesResp& /* _return */, const TGetTableTypesReq& /* req */) {
    return;
  }
  void GetColumns(TGetColumnsResp& /* _return */, const TGetColumnsReq& /* req */) {
    return;
  }
  void GetFunctions(TGetFunctionsResp& /* _return */, const TGetFunctionsReq& /* req */) {
    return;
  }
  void GetOperationStatus(TGetOperationStatusResp& /* _return */, const TGetOperationStatusReq& /* req */) {
    return;
  }
  void CancelOperation(TCancelOperationResp& /* _return */, const TCancelOperationReq& /* req */) {
    return;
  }
  void CloseOperation(TCloseOperationResp& /* _return */, const TCloseOperationReq& /* req */) {
    return;
  }
  void GetResultSetMetadata(TGetResultSetMetadataResp& /* _return */, const TGetResultSetMetadataReq& /* req */) {
    return;
  }
  void FetchResults(TFetchResultsResp& /* _return */, const TFetchResultsReq& /* req */) {
    return;
  }
  void GetDelegationToken(TGetDelegationTokenResp& /* _return */, const TGetDelegationTokenReq& /* req */) {
    return;
  }
  void CancelDelegationToken(TCancelDelegationTokenResp& /* _return */, const TCancelDelegationTokenReq& /* req */) {
    return;
  }
  void RenewDelegationToken(TRenewDelegationTokenResp& /* _return */, const TRenewDelegationTokenReq& /* req */) {
    return;
  }
};

typedef struct _TCLIService_OpenSession_args__isset {
  _TCLIService_OpenSession_args__isset() : req(false) {}
  bool req;
} _TCLIService_OpenSession_args__isset;

class TCLIService_OpenSession_args {
 public:

  TCLIService_OpenSession_args() {
  }

  virtual ~TCLIService_OpenSession_args() throw() {}

  TOpenSessionReq req;

  _TCLIService_OpenSession_args__isset __isset;

  void __set_req(const TOpenSessionReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_OpenSession_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_OpenSession_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_OpenSession_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_OpenSession_pargs {
 public:


  virtual ~TCLIService_OpenSession_pargs() throw() {}

  const TOpenSessionReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_OpenSession_result__isset {
  _TCLIService_OpenSession_result__isset() : success(false) {}
  bool success;
} _TCLIService_OpenSession_result__isset;

class TCLIService_OpenSession_result {
 public:

  TCLIService_OpenSession_result() {
  }

  virtual ~TCLIService_OpenSession_result() throw() {}

  TOpenSessionResp success;

  _TCLIService_OpenSession_result__isset __isset;

  void __set_success(const TOpenSessionResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_OpenSession_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_OpenSession_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_OpenSession_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_OpenSession_presult__isset {
  _TCLIService_OpenSession_presult__isset() : success(false) {}
  bool success;
} _TCLIService_OpenSession_presult__isset;

class TCLIService_OpenSession_presult {
 public:


  virtual ~TCLIService_OpenSession_presult() throw() {}

  TOpenSessionResp* success;

  _TCLIService_OpenSession_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CloseSession_args__isset {
  _TCLIService_CloseSession_args__isset() : req(false) {}
  bool req;
} _TCLIService_CloseSession_args__isset;

class TCLIService_CloseSession_args {
 public:

  TCLIService_CloseSession_args() {
  }

  virtual ~TCLIService_CloseSession_args() throw() {}

  TCloseSessionReq req;

  _TCLIService_CloseSession_args__isset __isset;

  void __set_req(const TCloseSessionReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_CloseSession_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CloseSession_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CloseSession_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_CloseSession_pargs {
 public:


  virtual ~TCLIService_CloseSession_pargs() throw() {}

  const TCloseSessionReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CloseSession_result__isset {
  _TCLIService_CloseSession_result__isset() : success(false) {}
  bool success;
} _TCLIService_CloseSession_result__isset;

class TCLIService_CloseSession_result {
 public:

  TCLIService_CloseSession_result() {
  }

  virtual ~TCLIService_CloseSession_result() throw() {}

  TCloseSessionResp success;

  _TCLIService_CloseSession_result__isset __isset;

  void __set_success(const TCloseSessionResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_CloseSession_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CloseSession_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CloseSession_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CloseSession_presult__isset {
  _TCLIService_CloseSession_presult__isset() : success(false) {}
  bool success;
} _TCLIService_CloseSession_presult__isset;

class TCLIService_CloseSession_presult {
 public:


  virtual ~TCLIService_CloseSession_presult() throw() {}

  TCloseSessionResp* success;

  _TCLIService_CloseSession_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetInfo_args__isset {
  _TCLIService_GetInfo_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetInfo_args__isset;

class TCLIService_GetInfo_args {
 public:

  TCLIService_GetInfo_args() {
  }

  virtual ~TCLIService_GetInfo_args() throw() {}

  TGetInfoReq req;

  _TCLIService_GetInfo_args__isset __isset;

  void __set_req(const TGetInfoReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetInfo_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetInfo_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetInfo_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetInfo_pargs {
 public:


  virtual ~TCLIService_GetInfo_pargs() throw() {}

  const TGetInfoReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetInfo_result__isset {
  _TCLIService_GetInfo_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetInfo_result__isset;

class TCLIService_GetInfo_result {
 public:

  TCLIService_GetInfo_result() {
  }

  virtual ~TCLIService_GetInfo_result() throw() {}

  TGetInfoResp success;

  _TCLIService_GetInfo_result__isset __isset;

  void __set_success(const TGetInfoResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetInfo_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetInfo_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetInfo_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetInfo_presult__isset {
  _TCLIService_GetInfo_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetInfo_presult__isset;

class TCLIService_GetInfo_presult {
 public:


  virtual ~TCLIService_GetInfo_presult() throw() {}

  TGetInfoResp* success;

  _TCLIService_GetInfo_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_ExecuteStatement_args__isset {
  _TCLIService_ExecuteStatement_args__isset() : req(false) {}
  bool req;
} _TCLIService_ExecuteStatement_args__isset;

class TCLIService_ExecuteStatement_args {
 public:

  TCLIService_ExecuteStatement_args() {
  }

  virtual ~TCLIService_ExecuteStatement_args() throw() {}

  TExecuteStatementReq req;

  _TCLIService_ExecuteStatement_args__isset __isset;

  void __set_req(const TExecuteStatementReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_ExecuteStatement_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_ExecuteStatement_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_ExecuteStatement_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_ExecuteStatement_pargs {
 public:


  virtual ~TCLIService_ExecuteStatement_pargs() throw() {}

  const TExecuteStatementReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_ExecuteStatement_result__isset {
  _TCLIService_ExecuteStatement_result__isset() : success(false) {}
  bool success;
} _TCLIService_ExecuteStatement_result__isset;

class TCLIService_ExecuteStatement_result {
 public:

  TCLIService_ExecuteStatement_result() {
  }

  virtual ~TCLIService_ExecuteStatement_result() throw() {}

  TExecuteStatementResp success;

  _TCLIService_ExecuteStatement_result__isset __isset;

  void __set_success(const TExecuteStatementResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_ExecuteStatement_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_ExecuteStatement_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_ExecuteStatement_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_ExecuteStatement_presult__isset {
  _TCLIService_ExecuteStatement_presult__isset() : success(false) {}
  bool success;
} _TCLIService_ExecuteStatement_presult__isset;

class TCLIService_ExecuteStatement_presult {
 public:


  virtual ~TCLIService_ExecuteStatement_presult() throw() {}

  TExecuteStatementResp* success;

  _TCLIService_ExecuteStatement_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetTypeInfo_args__isset {
  _TCLIService_GetTypeInfo_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetTypeInfo_args__isset;

class TCLIService_GetTypeInfo_args {
 public:

  TCLIService_GetTypeInfo_args() {
  }

  virtual ~TCLIService_GetTypeInfo_args() throw() {}

  TGetTypeInfoReq req;

  _TCLIService_GetTypeInfo_args__isset __isset;

  void __set_req(const TGetTypeInfoReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetTypeInfo_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetTypeInfo_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetTypeInfo_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetTypeInfo_pargs {
 public:


  virtual ~TCLIService_GetTypeInfo_pargs() throw() {}

  const TGetTypeInfoReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTypeInfo_result__isset {
  _TCLIService_GetTypeInfo_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetTypeInfo_result__isset;

class TCLIService_GetTypeInfo_result {
 public:

  TCLIService_GetTypeInfo_result() {
  }

  virtual ~TCLIService_GetTypeInfo_result() throw() {}

  TGetTypeInfoResp success;

  _TCLIService_GetTypeInfo_result__isset __isset;

  void __set_success(const TGetTypeInfoResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetTypeInfo_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetTypeInfo_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetTypeInfo_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTypeInfo_presult__isset {
  _TCLIService_GetTypeInfo_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetTypeInfo_presult__isset;

class TCLIService_GetTypeInfo_presult {
 public:


  virtual ~TCLIService_GetTypeInfo_presult() throw() {}

  TGetTypeInfoResp* success;

  _TCLIService_GetTypeInfo_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetCatalogs_args__isset {
  _TCLIService_GetCatalogs_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetCatalogs_args__isset;

class TCLIService_GetCatalogs_args {
 public:

  TCLIService_GetCatalogs_args() {
  }

  virtual ~TCLIService_GetCatalogs_args() throw() {}

  TGetCatalogsReq req;

  _TCLIService_GetCatalogs_args__isset __isset;

  void __set_req(const TGetCatalogsReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetCatalogs_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetCatalogs_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetCatalogs_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetCatalogs_pargs {
 public:


  virtual ~TCLIService_GetCatalogs_pargs() throw() {}

  const TGetCatalogsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetCatalogs_result__isset {
  _TCLIService_GetCatalogs_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetCatalogs_result__isset;

class TCLIService_GetCatalogs_result {
 public:

  TCLIService_GetCatalogs_result() {
  }

  virtual ~TCLIService_GetCatalogs_result() throw() {}

  TGetCatalogsResp success;

  _TCLIService_GetCatalogs_result__isset __isset;

  void __set_success(const TGetCatalogsResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetCatalogs_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetCatalogs_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetCatalogs_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetCatalogs_presult__isset {
  _TCLIService_GetCatalogs_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetCatalogs_presult__isset;

class TCLIService_GetCatalogs_presult {
 public:


  virtual ~TCLIService_GetCatalogs_presult() throw() {}

  TGetCatalogsResp* success;

  _TCLIService_GetCatalogs_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetSchemas_args__isset {
  _TCLIService_GetSchemas_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetSchemas_args__isset;

class TCLIService_GetSchemas_args {
 public:

  TCLIService_GetSchemas_args() {
  }

  virtual ~TCLIService_GetSchemas_args() throw() {}

  TGetSchemasReq req;

  _TCLIService_GetSchemas_args__isset __isset;

  void __set_req(const TGetSchemasReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetSchemas_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetSchemas_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetSchemas_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetSchemas_pargs {
 public:


  virtual ~TCLIService_GetSchemas_pargs() throw() {}

  const TGetSchemasReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetSchemas_result__isset {
  _TCLIService_GetSchemas_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetSchemas_result__isset;

class TCLIService_GetSchemas_result {
 public:

  TCLIService_GetSchemas_result() {
  }

  virtual ~TCLIService_GetSchemas_result() throw() {}

  TGetSchemasResp success;

  _TCLIService_GetSchemas_result__isset __isset;

  void __set_success(const TGetSchemasResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetSchemas_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetSchemas_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetSchemas_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetSchemas_presult__isset {
  _TCLIService_GetSchemas_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetSchemas_presult__isset;

class TCLIService_GetSchemas_presult {
 public:


  virtual ~TCLIService_GetSchemas_presult() throw() {}

  TGetSchemasResp* success;

  _TCLIService_GetSchemas_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetTables_args__isset {
  _TCLIService_GetTables_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetTables_args__isset;

class TCLIService_GetTables_args {
 public:

  TCLIService_GetTables_args() {
  }

  virtual ~TCLIService_GetTables_args() throw() {}

  TGetTablesReq req;

  _TCLIService_GetTables_args__isset __isset;

  void __set_req(const TGetTablesReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetTables_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetTables_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetTables_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetTables_pargs {
 public:


  virtual ~TCLIService_GetTables_pargs() throw() {}

  const TGetTablesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTables_result__isset {
  _TCLIService_GetTables_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetTables_result__isset;

class TCLIService_GetTables_result {
 public:

  TCLIService_GetTables_result() {
  }

  virtual ~TCLIService_GetTables_result() throw() {}

  TGetTablesResp success;

  _TCLIService_GetTables_result__isset __isset;

  void __set_success(const TGetTablesResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetTables_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetTables_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetTables_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTables_presult__isset {
  _TCLIService_GetTables_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetTables_presult__isset;

class TCLIService_GetTables_presult {
 public:


  virtual ~TCLIService_GetTables_presult() throw() {}

  TGetTablesResp* success;

  _TCLIService_GetTables_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetTableTypes_args__isset {
  _TCLIService_GetTableTypes_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetTableTypes_args__isset;

class TCLIService_GetTableTypes_args {
 public:

  TCLIService_GetTableTypes_args() {
  }

  virtual ~TCLIService_GetTableTypes_args() throw() {}

  TGetTableTypesReq req;

  _TCLIService_GetTableTypes_args__isset __isset;

  void __set_req(const TGetTableTypesReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetTableTypes_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetTableTypes_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetTableTypes_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetTableTypes_pargs {
 public:


  virtual ~TCLIService_GetTableTypes_pargs() throw() {}

  const TGetTableTypesReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTableTypes_result__isset {
  _TCLIService_GetTableTypes_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetTableTypes_result__isset;

class TCLIService_GetTableTypes_result {
 public:

  TCLIService_GetTableTypes_result() {
  }

  virtual ~TCLIService_GetTableTypes_result() throw() {}

  TGetTableTypesResp success;

  _TCLIService_GetTableTypes_result__isset __isset;

  void __set_success(const TGetTableTypesResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetTableTypes_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetTableTypes_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetTableTypes_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetTableTypes_presult__isset {
  _TCLIService_GetTableTypes_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetTableTypes_presult__isset;

class TCLIService_GetTableTypes_presult {
 public:


  virtual ~TCLIService_GetTableTypes_presult() throw() {}

  TGetTableTypesResp* success;

  _TCLIService_GetTableTypes_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetColumns_args__isset {
  _TCLIService_GetColumns_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetColumns_args__isset;

class TCLIService_GetColumns_args {
 public:

  TCLIService_GetColumns_args() {
  }

  virtual ~TCLIService_GetColumns_args() throw() {}

  TGetColumnsReq req;

  _TCLIService_GetColumns_args__isset __isset;

  void __set_req(const TGetColumnsReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetColumns_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetColumns_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetColumns_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetColumns_pargs {
 public:


  virtual ~TCLIService_GetColumns_pargs() throw() {}

  const TGetColumnsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetColumns_result__isset {
  _TCLIService_GetColumns_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetColumns_result__isset;

class TCLIService_GetColumns_result {
 public:

  TCLIService_GetColumns_result() {
  }

  virtual ~TCLIService_GetColumns_result() throw() {}

  TGetColumnsResp success;

  _TCLIService_GetColumns_result__isset __isset;

  void __set_success(const TGetColumnsResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetColumns_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetColumns_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetColumns_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetColumns_presult__isset {
  _TCLIService_GetColumns_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetColumns_presult__isset;

class TCLIService_GetColumns_presult {
 public:


  virtual ~TCLIService_GetColumns_presult() throw() {}

  TGetColumnsResp* success;

  _TCLIService_GetColumns_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetFunctions_args__isset {
  _TCLIService_GetFunctions_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetFunctions_args__isset;

class TCLIService_GetFunctions_args {
 public:

  TCLIService_GetFunctions_args() {
  }

  virtual ~TCLIService_GetFunctions_args() throw() {}

  TGetFunctionsReq req;

  _TCLIService_GetFunctions_args__isset __isset;

  void __set_req(const TGetFunctionsReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetFunctions_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetFunctions_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetFunctions_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetFunctions_pargs {
 public:


  virtual ~TCLIService_GetFunctions_pargs() throw() {}

  const TGetFunctionsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetFunctions_result__isset {
  _TCLIService_GetFunctions_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetFunctions_result__isset;

class TCLIService_GetFunctions_result {
 public:

  TCLIService_GetFunctions_result() {
  }

  virtual ~TCLIService_GetFunctions_result() throw() {}

  TGetFunctionsResp success;

  _TCLIService_GetFunctions_result__isset __isset;

  void __set_success(const TGetFunctionsResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetFunctions_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetFunctions_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetFunctions_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetFunctions_presult__isset {
  _TCLIService_GetFunctions_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetFunctions_presult__isset;

class TCLIService_GetFunctions_presult {
 public:


  virtual ~TCLIService_GetFunctions_presult() throw() {}

  TGetFunctionsResp* success;

  _TCLIService_GetFunctions_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetOperationStatus_args__isset {
  _TCLIService_GetOperationStatus_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetOperationStatus_args__isset;

class TCLIService_GetOperationStatus_args {
 public:

  TCLIService_GetOperationStatus_args() {
  }

  virtual ~TCLIService_GetOperationStatus_args() throw() {}

  TGetOperationStatusReq req;

  _TCLIService_GetOperationStatus_args__isset __isset;

  void __set_req(const TGetOperationStatusReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetOperationStatus_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetOperationStatus_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetOperationStatus_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetOperationStatus_pargs {
 public:


  virtual ~TCLIService_GetOperationStatus_pargs() throw() {}

  const TGetOperationStatusReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetOperationStatus_result__isset {
  _TCLIService_GetOperationStatus_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetOperationStatus_result__isset;

class TCLIService_GetOperationStatus_result {
 public:

  TCLIService_GetOperationStatus_result() {
  }

  virtual ~TCLIService_GetOperationStatus_result() throw() {}

  TGetOperationStatusResp success;

  _TCLIService_GetOperationStatus_result__isset __isset;

  void __set_success(const TGetOperationStatusResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetOperationStatus_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetOperationStatus_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetOperationStatus_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetOperationStatus_presult__isset {
  _TCLIService_GetOperationStatus_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetOperationStatus_presult__isset;

class TCLIService_GetOperationStatus_presult {
 public:


  virtual ~TCLIService_GetOperationStatus_presult() throw() {}

  TGetOperationStatusResp* success;

  _TCLIService_GetOperationStatus_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CancelOperation_args__isset {
  _TCLIService_CancelOperation_args__isset() : req(false) {}
  bool req;
} _TCLIService_CancelOperation_args__isset;

class TCLIService_CancelOperation_args {
 public:

  TCLIService_CancelOperation_args() {
  }

  virtual ~TCLIService_CancelOperation_args() throw() {}

  TCancelOperationReq req;

  _TCLIService_CancelOperation_args__isset __isset;

  void __set_req(const TCancelOperationReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_CancelOperation_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CancelOperation_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CancelOperation_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_CancelOperation_pargs {
 public:


  virtual ~TCLIService_CancelOperation_pargs() throw() {}

  const TCancelOperationReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CancelOperation_result__isset {
  _TCLIService_CancelOperation_result__isset() : success(false) {}
  bool success;
} _TCLIService_CancelOperation_result__isset;

class TCLIService_CancelOperation_result {
 public:

  TCLIService_CancelOperation_result() {
  }

  virtual ~TCLIService_CancelOperation_result() throw() {}

  TCancelOperationResp success;

  _TCLIService_CancelOperation_result__isset __isset;

  void __set_success(const TCancelOperationResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_CancelOperation_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CancelOperation_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CancelOperation_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CancelOperation_presult__isset {
  _TCLIService_CancelOperation_presult__isset() : success(false) {}
  bool success;
} _TCLIService_CancelOperation_presult__isset;

class TCLIService_CancelOperation_presult {
 public:


  virtual ~TCLIService_CancelOperation_presult() throw() {}

  TCancelOperationResp* success;

  _TCLIService_CancelOperation_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CloseOperation_args__isset {
  _TCLIService_CloseOperation_args__isset() : req(false) {}
  bool req;
} _TCLIService_CloseOperation_args__isset;

class TCLIService_CloseOperation_args {
 public:

  TCLIService_CloseOperation_args() {
  }

  virtual ~TCLIService_CloseOperation_args() throw() {}

  TCloseOperationReq req;

  _TCLIService_CloseOperation_args__isset __isset;

  void __set_req(const TCloseOperationReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_CloseOperation_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CloseOperation_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CloseOperation_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_CloseOperation_pargs {
 public:


  virtual ~TCLIService_CloseOperation_pargs() throw() {}

  const TCloseOperationReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CloseOperation_result__isset {
  _TCLIService_CloseOperation_result__isset() : success(false) {}
  bool success;
} _TCLIService_CloseOperation_result__isset;

class TCLIService_CloseOperation_result {
 public:

  TCLIService_CloseOperation_result() {
  }

  virtual ~TCLIService_CloseOperation_result() throw() {}

  TCloseOperationResp success;

  _TCLIService_CloseOperation_result__isset __isset;

  void __set_success(const TCloseOperationResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_CloseOperation_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CloseOperation_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CloseOperation_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CloseOperation_presult__isset {
  _TCLIService_CloseOperation_presult__isset() : success(false) {}
  bool success;
} _TCLIService_CloseOperation_presult__isset;

class TCLIService_CloseOperation_presult {
 public:


  virtual ~TCLIService_CloseOperation_presult() throw() {}

  TCloseOperationResp* success;

  _TCLIService_CloseOperation_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetResultSetMetadata_args__isset {
  _TCLIService_GetResultSetMetadata_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetResultSetMetadata_args__isset;

class TCLIService_GetResultSetMetadata_args {
 public:

  TCLIService_GetResultSetMetadata_args() {
  }

  virtual ~TCLIService_GetResultSetMetadata_args() throw() {}

  TGetResultSetMetadataReq req;

  _TCLIService_GetResultSetMetadata_args__isset __isset;

  void __set_req(const TGetResultSetMetadataReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetResultSetMetadata_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetResultSetMetadata_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetResultSetMetadata_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetResultSetMetadata_pargs {
 public:


  virtual ~TCLIService_GetResultSetMetadata_pargs() throw() {}

  const TGetResultSetMetadataReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetResultSetMetadata_result__isset {
  _TCLIService_GetResultSetMetadata_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetResultSetMetadata_result__isset;

class TCLIService_GetResultSetMetadata_result {
 public:

  TCLIService_GetResultSetMetadata_result() {
  }

  virtual ~TCLIService_GetResultSetMetadata_result() throw() {}

  TGetResultSetMetadataResp success;

  _TCLIService_GetResultSetMetadata_result__isset __isset;

  void __set_success(const TGetResultSetMetadataResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetResultSetMetadata_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetResultSetMetadata_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetResultSetMetadata_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetResultSetMetadata_presult__isset {
  _TCLIService_GetResultSetMetadata_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetResultSetMetadata_presult__isset;

class TCLIService_GetResultSetMetadata_presult {
 public:


  virtual ~TCLIService_GetResultSetMetadata_presult() throw() {}

  TGetResultSetMetadataResp* success;

  _TCLIService_GetResultSetMetadata_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_FetchResults_args__isset {
  _TCLIService_FetchResults_args__isset() : req(false) {}
  bool req;
} _TCLIService_FetchResults_args__isset;

class TCLIService_FetchResults_args {
 public:

  TCLIService_FetchResults_args() {
  }

  virtual ~TCLIService_FetchResults_args() throw() {}

  TFetchResultsReq req;

  _TCLIService_FetchResults_args__isset __isset;

  void __set_req(const TFetchResultsReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_FetchResults_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_FetchResults_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_FetchResults_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_FetchResults_pargs {
 public:


  virtual ~TCLIService_FetchResults_pargs() throw() {}

  const TFetchResultsReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_FetchResults_result__isset {
  _TCLIService_FetchResults_result__isset() : success(false) {}
  bool success;
} _TCLIService_FetchResults_result__isset;

class TCLIService_FetchResults_result {
 public:

  TCLIService_FetchResults_result() {
  }

  virtual ~TCLIService_FetchResults_result() throw() {}

  TFetchResultsResp success;

  _TCLIService_FetchResults_result__isset __isset;

  void __set_success(const TFetchResultsResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_FetchResults_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_FetchResults_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_FetchResults_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_FetchResults_presult__isset {
  _TCLIService_FetchResults_presult__isset() : success(false) {}
  bool success;
} _TCLIService_FetchResults_presult__isset;

class TCLIService_FetchResults_presult {
 public:


  virtual ~TCLIService_FetchResults_presult() throw() {}

  TFetchResultsResp* success;

  _TCLIService_FetchResults_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_GetDelegationToken_args__isset {
  _TCLIService_GetDelegationToken_args__isset() : req(false) {}
  bool req;
} _TCLIService_GetDelegationToken_args__isset;

class TCLIService_GetDelegationToken_args {
 public:

  TCLIService_GetDelegationToken_args() {
  }

  virtual ~TCLIService_GetDelegationToken_args() throw() {}

  TGetDelegationTokenReq req;

  _TCLIService_GetDelegationToken_args__isset __isset;

  void __set_req(const TGetDelegationTokenReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_GetDelegationToken_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetDelegationToken_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetDelegationToken_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_GetDelegationToken_pargs {
 public:


  virtual ~TCLIService_GetDelegationToken_pargs() throw() {}

  const TGetDelegationTokenReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetDelegationToken_result__isset {
  _TCLIService_GetDelegationToken_result__isset() : success(false) {}
  bool success;
} _TCLIService_GetDelegationToken_result__isset;

class TCLIService_GetDelegationToken_result {
 public:

  TCLIService_GetDelegationToken_result() {
  }

  virtual ~TCLIService_GetDelegationToken_result() throw() {}

  TGetDelegationTokenResp success;

  _TCLIService_GetDelegationToken_result__isset __isset;

  void __set_success(const TGetDelegationTokenResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_GetDelegationToken_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_GetDelegationToken_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_GetDelegationToken_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_GetDelegationToken_presult__isset {
  _TCLIService_GetDelegationToken_presult__isset() : success(false) {}
  bool success;
} _TCLIService_GetDelegationToken_presult__isset;

class TCLIService_GetDelegationToken_presult {
 public:


  virtual ~TCLIService_GetDelegationToken_presult() throw() {}

  TGetDelegationTokenResp* success;

  _TCLIService_GetDelegationToken_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_CancelDelegationToken_args__isset {
  _TCLIService_CancelDelegationToken_args__isset() : req(false) {}
  bool req;
} _TCLIService_CancelDelegationToken_args__isset;

class TCLIService_CancelDelegationToken_args {
 public:

  TCLIService_CancelDelegationToken_args() {
  }

  virtual ~TCLIService_CancelDelegationToken_args() throw() {}

  TCancelDelegationTokenReq req;

  _TCLIService_CancelDelegationToken_args__isset __isset;

  void __set_req(const TCancelDelegationTokenReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_CancelDelegationToken_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CancelDelegationToken_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CancelDelegationToken_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_CancelDelegationToken_pargs {
 public:


  virtual ~TCLIService_CancelDelegationToken_pargs() throw() {}

  const TCancelDelegationTokenReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CancelDelegationToken_result__isset {
  _TCLIService_CancelDelegationToken_result__isset() : success(false) {}
  bool success;
} _TCLIService_CancelDelegationToken_result__isset;

class TCLIService_CancelDelegationToken_result {
 public:

  TCLIService_CancelDelegationToken_result() {
  }

  virtual ~TCLIService_CancelDelegationToken_result() throw() {}

  TCancelDelegationTokenResp success;

  _TCLIService_CancelDelegationToken_result__isset __isset;

  void __set_success(const TCancelDelegationTokenResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_CancelDelegationToken_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_CancelDelegationToken_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_CancelDelegationToken_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_CancelDelegationToken_presult__isset {
  _TCLIService_CancelDelegationToken_presult__isset() : success(false) {}
  bool success;
} _TCLIService_CancelDelegationToken_presult__isset;

class TCLIService_CancelDelegationToken_presult {
 public:


  virtual ~TCLIService_CancelDelegationToken_presult() throw() {}

  TCancelDelegationTokenResp* success;

  _TCLIService_CancelDelegationToken_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _TCLIService_RenewDelegationToken_args__isset {
  _TCLIService_RenewDelegationToken_args__isset() : req(false) {}
  bool req;
} _TCLIService_RenewDelegationToken_args__isset;

class TCLIService_RenewDelegationToken_args {
 public:

  TCLIService_RenewDelegationToken_args() {
  }

  virtual ~TCLIService_RenewDelegationToken_args() throw() {}

  TRenewDelegationTokenReq req;

  _TCLIService_RenewDelegationToken_args__isset __isset;

  void __set_req(const TRenewDelegationTokenReq& val) {
    req = val;
  }

  bool operator == (const TCLIService_RenewDelegationToken_args & rhs) const
  {
    if (!(req == rhs.req))
      return false;
    return true;
  }
  bool operator != (const TCLIService_RenewDelegationToken_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_RenewDelegationToken_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class TCLIService_RenewDelegationToken_pargs {
 public:


  virtual ~TCLIService_RenewDelegationToken_pargs() throw() {}

  const TRenewDelegationTokenReq* req;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_RenewDelegationToken_result__isset {
  _TCLIService_RenewDelegationToken_result__isset() : success(false) {}
  bool success;
} _TCLIService_RenewDelegationToken_result__isset;

class TCLIService_RenewDelegationToken_result {
 public:

  TCLIService_RenewDelegationToken_result() {
  }

  virtual ~TCLIService_RenewDelegationToken_result() throw() {}

  TRenewDelegationTokenResp success;

  _TCLIService_RenewDelegationToken_result__isset __isset;

  void __set_success(const TRenewDelegationTokenResp& val) {
    success = val;
  }

  bool operator == (const TCLIService_RenewDelegationToken_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const TCLIService_RenewDelegationToken_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const TCLIService_RenewDelegationToken_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _TCLIService_RenewDelegationToken_presult__isset {
  _TCLIService_RenewDelegationToken_presult__isset() : success(false) {}
  bool success;
} _TCLIService_RenewDelegationToken_presult__isset;

class TCLIService_RenewDelegationToken_presult {
 public:


  virtual ~TCLIService_RenewDelegationToken_presult() throw() {}

  TRenewDelegationTokenResp* success;

  _TCLIService_RenewDelegationToken_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

class TCLIServiceClient : virtual public TCLIServiceIf {
 public:
  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
    piprot_(prot),
    poprot_(prot) {
    iprot_ = prot.get();
    oprot_ = prot.get();
  }
  TCLIServiceClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
    piprot_(iprot),
    poprot_(oprot) {
    iprot_ = iprot.get();
    oprot_ = oprot.get();
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req);
  void send_OpenSession(const TOpenSessionReq& req);
  void recv_OpenSession(TOpenSessionResp& _return);
  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req);
  void send_CloseSession(const TCloseSessionReq& req);
  void recv_CloseSession(TCloseSessionResp& _return);
  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req);
  void send_GetInfo(const TGetInfoReq& req);
  void recv_GetInfo(TGetInfoResp& _return);
  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req);
  void send_ExecuteStatement(const TExecuteStatementReq& req);
  void recv_ExecuteStatement(TExecuteStatementResp& _return);
  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req);
  void send_GetTypeInfo(const TGetTypeInfoReq& req);
  void recv_GetTypeInfo(TGetTypeInfoResp& _return);
  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req);
  void send_GetCatalogs(const TGetCatalogsReq& req);
  void recv_GetCatalogs(TGetCatalogsResp& _return);
  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req);
  void send_GetSchemas(const TGetSchemasReq& req);
  void recv_GetSchemas(TGetSchemasResp& _return);
  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req);
  void send_GetTables(const TGetTablesReq& req);
  void recv_GetTables(TGetTablesResp& _return);
  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req);
  void send_GetTableTypes(const TGetTableTypesReq& req);
  void recv_GetTableTypes(TGetTableTypesResp& _return);
  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req);
  void send_GetColumns(const TGetColumnsReq& req);
  void recv_GetColumns(TGetColumnsResp& _return);
  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req);
  void send_GetFunctions(const TGetFunctionsReq& req);
  void recv_GetFunctions(TGetFunctionsResp& _return);
  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req);
  void send_GetOperationStatus(const TGetOperationStatusReq& req);
  void recv_GetOperationStatus(TGetOperationStatusResp& _return);
  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req);
  void send_CancelOperation(const TCancelOperationReq& req);
  void recv_CancelOperation(TCancelOperationResp& _return);
  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req);
  void send_CloseOperation(const TCloseOperationReq& req);
  void recv_CloseOperation(TCloseOperationResp& _return);
  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req);
  void send_GetResultSetMetadata(const TGetResultSetMetadataReq& req);
  void recv_GetResultSetMetadata(TGetResultSetMetadataResp& _return);
  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req);
  void send_FetchResults(const TFetchResultsReq& req);
  void recv_FetchResults(TFetchResultsResp& _return);
  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req);
  void send_GetDelegationToken(const TGetDelegationTokenReq& req);
  void recv_GetDelegationToken(TGetDelegationTokenResp& _return);
  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req);
  void send_CancelDelegationToken(const TCancelDelegationTokenReq& req);
  void recv_CancelDelegationToken(TCancelDelegationTokenResp& _return);
  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req);
  void send_RenewDelegationToken(const TRenewDelegationTokenReq& req);
  void recv_RenewDelegationToken(TRenewDelegationTokenResp& _return);
 protected:
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
  ::apache::thrift::protocol::TProtocol* iprot_;
  ::apache::thrift::protocol::TProtocol* oprot_;
};

class TCLIServiceProcessor : public ::apache::thrift::TDispatchProcessor {
 protected:
  boost::shared_ptr<TCLIServiceIf> iface_;
  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
 private:
  typedef  void (TCLIServiceProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
  typedef std::map<std::string, ProcessFunction> ProcessMap;
  ProcessMap processMap_;
  void process_OpenSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CloseSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_ExecuteStatement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTypeInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetCatalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetSchemas(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetTableTypes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetFunctions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetOperationStatus(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CancelOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CloseOperation(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetResultSetMetadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_FetchResults(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_GetDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_CancelDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_RenewDelegationToken(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  TCLIServiceProcessor(boost::shared_ptr<TCLIServiceIf> iface) :
    iface_(iface) {
    processMap_["OpenSession"] = &TCLIServiceProcessor::process_OpenSession;
    processMap_["CloseSession"] = &TCLIServiceProcessor::process_CloseSession;
    processMap_["GetInfo"] = &TCLIServiceProcessor::process_GetInfo;
    processMap_["ExecuteStatement"] = &TCLIServiceProcessor::process_ExecuteStatement;
    processMap_["GetTypeInfo"] = &TCLIServiceProcessor::process_GetTypeInfo;
    processMap_["GetCatalogs"] = &TCLIServiceProcessor::process_GetCatalogs;
    processMap_["GetSchemas"] = &TCLIServiceProcessor::process_GetSchemas;
    processMap_["GetTables"] = &TCLIServiceProcessor::process_GetTables;
    processMap_["GetTableTypes"] = &TCLIServiceProcessor::process_GetTableTypes;
    processMap_["GetColumns"] = &TCLIServiceProcessor::process_GetColumns;
    processMap_["GetFunctions"] = &TCLIServiceProcessor::process_GetFunctions;
    processMap_["GetOperationStatus"] = &TCLIServiceProcessor::process_GetOperationStatus;
    processMap_["CancelOperation"] = &TCLIServiceProcessor::process_CancelOperation;
    processMap_["CloseOperation"] = &TCLIServiceProcessor::process_CloseOperation;
    processMap_["GetResultSetMetadata"] = &TCLIServiceProcessor::process_GetResultSetMetadata;
    processMap_["FetchResults"] = &TCLIServiceProcessor::process_FetchResults;
    processMap_["GetDelegationToken"] = &TCLIServiceProcessor::process_GetDelegationToken;
    processMap_["CancelDelegationToken"] = &TCLIServiceProcessor::process_CancelDelegationToken;
    processMap_["RenewDelegationToken"] = &TCLIServiceProcessor::process_RenewDelegationToken;
  }

  virtual ~TCLIServiceProcessor() {}
};

class TCLIServiceProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  TCLIServiceProcessorFactory(const ::boost::shared_ptr< TCLIServiceIfFactory >& handlerFactory) :
      handlerFactory_(handlerFactory) {}

  ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);

 protected:
  ::boost::shared_ptr< TCLIServiceIfFactory > handlerFactory_;
};

class TCLIServiceMultiface : virtual public TCLIServiceIf {
 public:
  TCLIServiceMultiface(std::vector<boost::shared_ptr<TCLIServiceIf> >& ifaces) : ifaces_(ifaces) {
  }
  virtual ~TCLIServiceMultiface() {}
 protected:
  std::vector<boost::shared_ptr<TCLIServiceIf> > ifaces_;
  TCLIServiceMultiface() {}
  void add(boost::shared_ptr<TCLIServiceIf> iface) {
    ifaces_.push_back(iface);
  }
 public:
  void OpenSession(TOpenSessionResp& _return, const TOpenSessionReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->OpenSession(_return, req);
    }
    ifaces_[i]->OpenSession(_return, req);
    return;
  }

  void CloseSession(TCloseSessionResp& _return, const TCloseSessionReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CloseSession(_return, req);
    }
    ifaces_[i]->CloseSession(_return, req);
    return;
  }

  void GetInfo(TGetInfoResp& _return, const TGetInfoReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetInfo(_return, req);
    }
    ifaces_[i]->GetInfo(_return, req);
    return;
  }

  void ExecuteStatement(TExecuteStatementResp& _return, const TExecuteStatementReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->ExecuteStatement(_return, req);
    }
    ifaces_[i]->ExecuteStatement(_return, req);
    return;
  }

  void GetTypeInfo(TGetTypeInfoResp& _return, const TGetTypeInfoReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTypeInfo(_return, req);
    }
    ifaces_[i]->GetTypeInfo(_return, req);
    return;
  }

  void GetCatalogs(TGetCatalogsResp& _return, const TGetCatalogsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetCatalogs(_return, req);
    }
    ifaces_[i]->GetCatalogs(_return, req);
    return;
  }

  void GetSchemas(TGetSchemasResp& _return, const TGetSchemasReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetSchemas(_return, req);
    }
    ifaces_[i]->GetSchemas(_return, req);
    return;
  }

  void GetTables(TGetTablesResp& _return, const TGetTablesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTables(_return, req);
    }
    ifaces_[i]->GetTables(_return, req);
    return;
  }

  void GetTableTypes(TGetTableTypesResp& _return, const TGetTableTypesReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetTableTypes(_return, req);
    }
    ifaces_[i]->GetTableTypes(_return, req);
    return;
  }

  void GetColumns(TGetColumnsResp& _return, const TGetColumnsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetColumns(_return, req);
    }
    ifaces_[i]->GetColumns(_return, req);
    return;
  }

  void GetFunctions(TGetFunctionsResp& _return, const TGetFunctionsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetFunctions(_return, req);
    }
    ifaces_[i]->GetFunctions(_return, req);
    return;
  }

  void GetOperationStatus(TGetOperationStatusResp& _return, const TGetOperationStatusReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetOperationStatus(_return, req);
    }
    ifaces_[i]->GetOperationStatus(_return, req);
    return;
  }

  void CancelOperation(TCancelOperationResp& _return, const TCancelOperationReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CancelOperation(_return, req);
    }
    ifaces_[i]->CancelOperation(_return, req);
    return;
  }

  void CloseOperation(TCloseOperationResp& _return, const TCloseOperationReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CloseOperation(_return, req);
    }
    ifaces_[i]->CloseOperation(_return, req);
    return;
  }

  void GetResultSetMetadata(TGetResultSetMetadataResp& _return, const TGetResultSetMetadataReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetResultSetMetadata(_return, req);
    }
    ifaces_[i]->GetResultSetMetadata(_return, req);
    return;
  }

  void FetchResults(TFetchResultsResp& _return, const TFetchResultsReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->FetchResults(_return, req);
    }
    ifaces_[i]->FetchResults(_return, req);
    return;
  }

  void GetDelegationToken(TGetDelegationTokenResp& _return, const TGetDelegationTokenReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->GetDelegationToken(_return, req);
    }
    ifaces_[i]->GetDelegationToken(_return, req);
    return;
  }

  void CancelDelegationToken(TCancelDelegationTokenResp& _return, const TCancelDelegationTokenReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->CancelDelegationToken(_return, req);
    }
    ifaces_[i]->CancelDelegationToken(_return, req);
    return;
  }

  void RenewDelegationToken(TRenewDelegationTokenResp& _return, const TRenewDelegationTokenReq& req) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->RenewDelegationToken(_return, req);
    }
    ifaces_[i]->RenewDelegationToken(_return, req);
    return;
  }

};

}}}}} // namespace

#endif