text: #
  # Autogenerated by Thrift Compiler (0.9.0)
  #
  # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  #
  #  options string: py:new_style
  #
  
  from thrift.Thrift import TType, TMessageType, TException, TApplicationException
  from ttypes import *
  from thrift.Thrift import TProcessor
  from thrift.transport import TTransport
  from thrift.protocol import TBinaryProtocol, TProtocol
  try:
    from thrift.protocol import fastbinary
  except:
    fastbinary = None
  
  
  class Iface(object):
    def OpenSession(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def CloseSession(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetInfo(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def ExecuteStatement(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetTypeInfo(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetCatalogs(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetSchemas(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetTables(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetTableTypes(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetColumns(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetFunctions(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetOperationStatus(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def CancelOperation(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def CloseOperation(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetResultSetMetadata(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def FetchResults(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetDelegationToken(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def CancelDelegationToken(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def RenewDelegationToken(self, req):
      """
      Parameters:
       - req
      """
      pass
  
    def GetLog(self, req):
      """
      Parameters:
       - req
      """
      pass
  
  
  class Client(Iface):
    def __init__(self, iprot, oprot=None):
      self._iprot = self._oprot = iprot
      if oprot is not None:
        self._oprot = oprot
      self._seqid = 0
  
    def OpenSession(self, req):
      """
      Parameters:
       - req
      """
      self.send_OpenSession(req)
      return self.recv_OpenSession()
  
    def send_OpenSession(self, req):
      self._oprot.writeMessageBegin('OpenSession', TMessageType.CALL, self._seqid)
      args = OpenSession_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_OpenSession(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = OpenSession_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "OpenSession failed: unknown result");
  
    def CloseSession(self, req):
      """
      Parameters:
       - req
      """
      self.send_CloseSession(req)
      return self.recv_CloseSession()
  
    def send_CloseSession(self, req):
      self._oprot.writeMessageBegin('CloseSession', TMessageType.CALL, self._seqid)
      args = CloseSession_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_CloseSession(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = CloseSession_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "CloseSession failed: unknown result");
  
    def GetInfo(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetInfo(req)
      return self.recv_GetInfo()
  
    def send_GetInfo(self, req):
      self._oprot.writeMessageBegin('GetInfo', TMessageType.CALL, self._seqid)
      args = GetInfo_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetInfo(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetInfo_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetInfo failed: unknown result");
  
    def ExecuteStatement(self, req):
      """
      Parameters:
       - req
      """
      self.send_ExecuteStatement(req)
      return self.recv_ExecuteStatement()
  
    def send_ExecuteStatement(self, req):
      self._oprot.writeMessageBegin('ExecuteStatement', TMessageType.CALL, self._seqid)
      args = ExecuteStatement_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_ExecuteStatement(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = ExecuteStatement_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "ExecuteStatement failed: unknown result");
  
    def GetTypeInfo(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetTypeInfo(req)
      return self.recv_GetTypeInfo()
  
    def send_GetTypeInfo(self, req):
      self._oprot.writeMessageBegin('GetTypeInfo', TMessageType.CALL, self._seqid)
      args = GetTypeInfo_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetTypeInfo(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetTypeInfo_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetTypeInfo failed: unknown result");
  
    def GetCatalogs(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetCatalogs(req)
      return self.recv_GetCatalogs()
  
    def send_GetCatalogs(self, req):
      self._oprot.writeMessageBegin('GetCatalogs', TMessageType.CALL, self._seqid)
      args = GetCatalogs_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetCatalogs(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetCatalogs_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetCatalogs failed: unknown result");
  
    def GetSchemas(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetSchemas(req)
      return self.recv_GetSchemas()
  
    def send_GetSchemas(self, req):
      self._oprot.writeMessageBegin('GetSchemas', TMessageType.CALL, self._seqid)
      args = GetSchemas_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetSchemas(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetSchemas_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetSchemas failed: unknown result");
  
    def GetTables(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetTables(req)
      return self.recv_GetTables()
  
    def send_GetTables(self, req):
      self._oprot.writeMessageBegin('GetTables', TMessageType.CALL, self._seqid)
      args = GetTables_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetTables(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetTables_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetTables failed: unknown result");
  
    def GetTableTypes(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetTableTypes(req)
      return self.recv_GetTableTypes()
  
    def send_GetTableTypes(self, req):
      self._oprot.writeMessageBegin('GetTableTypes', TMessageType.CALL, self._seqid)
      args = GetTableTypes_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetTableTypes(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetTableTypes_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetTableTypes failed: unknown result");
  
    def GetColumns(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetColumns(req)
      return self.recv_GetColumns()
  
    def send_GetColumns(self, req):
      self._oprot.writeMessageBegin('GetColumns', TMessageType.CALL, self._seqid)
      args = GetColumns_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetColumns(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetColumns_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetColumns failed: unknown result");
  
    def GetFunctions(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetFunctions(req)
      return self.recv_GetFunctions()
  
    def send_GetFunctions(self, req):
      self._oprot.writeMessageBegin('GetFunctions', TMessageType.CALL, self._seqid)
      args = GetFunctions_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetFunctions(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetFunctions_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetFunctions failed: unknown result");
  
    def GetOperationStatus(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetOperationStatus(req)
      return self.recv_GetOperationStatus()
  
    def send_GetOperationStatus(self, req):
      self._oprot.writeMessageBegin('GetOperationStatus', TMessageType.CALL, self._seqid)
      args = GetOperationStatus_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetOperationStatus(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetOperationStatus_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetOperationStatus failed: unknown result");
  
    def CancelOperation(self, req):
      """
      Parameters:
       - req
      """
      self.send_CancelOperation(req)
      return self.recv_CancelOperation()
  
    def send_CancelOperation(self, req):
      self._oprot.writeMessageBegin('CancelOperation', TMessageType.CALL, self._seqid)
      args = CancelOperation_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_CancelOperation(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = CancelOperation_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "CancelOperation failed: unknown result");
  
    def CloseOperation(self, req):
      """
      Parameters:
       - req
      """
      self.send_CloseOperation(req)
      return self.recv_CloseOperation()
  
    def send_CloseOperation(self, req):
      self._oprot.writeMessageBegin('CloseOperation', TMessageType.CALL, self._seqid)
      args = CloseOperation_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_CloseOperation(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = CloseOperation_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "CloseOperation failed: unknown result");
  
    def GetResultSetMetadata(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetResultSetMetadata(req)
      return self.recv_GetResultSetMetadata()
  
    def send_GetResultSetMetadata(self, req):
      self._oprot.writeMessageBegin('GetResultSetMetadata', TMessageType.CALL, self._seqid)
      args = GetResultSetMetadata_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetResultSetMetadata(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetResultSetMetadata_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetResultSetMetadata failed: unknown result");
  
    def FetchResults(self, req):
      """
      Parameters:
       - req
      """
      self.send_FetchResults(req)
      return self.recv_FetchResults()
  
    def send_FetchResults(self, req):
      self._oprot.writeMessageBegin('FetchResults', TMessageType.CALL, self._seqid)
      args = FetchResults_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_FetchResults(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = FetchResults_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "FetchResults failed: unknown result");
  
    def GetDelegationToken(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetDelegationToken(req)
      return self.recv_GetDelegationToken()
  
    def send_GetDelegationToken(self, req):
      self._oprot.writeMessageBegin('GetDelegationToken', TMessageType.CALL, self._seqid)
      args = GetDelegationToken_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetDelegationToken(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetDelegationToken_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetDelegationToken failed: unknown result");
  
    def CancelDelegationToken(self, req):
      """
      Parameters:
       - req
      """
      self.send_CancelDelegationToken(req)
      return self.recv_CancelDelegationToken()
  
    def send_CancelDelegationToken(self, req):
      self._oprot.writeMessageBegin('CancelDelegationToken', TMessageType.CALL, self._seqid)
      args = CancelDelegationToken_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_CancelDelegationToken(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = CancelDelegationToken_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "CancelDelegationToken failed: unknown result");
  
    def RenewDelegationToken(self, req):
      """
      Parameters:
       - req
      """
      self.send_RenewDelegationToken(req)
      return self.recv_RenewDelegationToken()
  
    def send_RenewDelegationToken(self, req):
      self._oprot.writeMessageBegin('RenewDelegationToken', TMessageType.CALL, self._seqid)
      args = RenewDelegationToken_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_RenewDelegationToken(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = RenewDelegationToken_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "RenewDelegationToken failed: unknown result");
  
    def GetLog(self, req):
      """
      Parameters:
       - req
      """
      self.send_GetLog(req)
      return self.recv_GetLog()
  
    def send_GetLog(self, req):
      self._oprot.writeMessageBegin('GetLog', TMessageType.CALL, self._seqid)
      args = GetLog_args()
      args.req = req
      args.write(self._oprot)
      self._oprot.writeMessageEnd()
      self._oprot.trans.flush()
  
    def recv_GetLog(self, ):
      (fname, mtype, rseqid) = self._iprot.readMessageBegin()
      if mtype == TMessageType.EXCEPTION:
        x = TApplicationException()
        x.read(self._iprot)
        self._iprot.readMessageEnd()
        raise x
      result = GetLog_result()
      result.read(self._iprot)
      self._iprot.readMessageEnd()
      if result.success is not None:
        return result.success
      raise TApplicationException(TApplicationException.MISSING_RESULT, "GetLog failed: unknown result");
  
  
  class Processor(Iface, TProcessor):
    def __init__(self, handler):
      self._handler = handler
      self._processMap = {}
      self._processMap["OpenSession"] = Processor.process_OpenSession
      self._processMap["CloseSession"] = Processor.process_CloseSession
      self._processMap["GetInfo"] = Processor.process_GetInfo
      self._processMap["ExecuteStatement"] = Processor.process_ExecuteStatement
      self._processMap["GetTypeInfo"] = Processor.process_GetTypeInfo
      self._processMap["GetCatalogs"] = Processor.process_GetCatalogs
      self._processMap["GetSchemas"] = Processor.process_GetSchemas
      self._processMap["GetTables"] = Processor.process_GetTables
      self._processMap["GetTableTypes"] = Processor.process_GetTableTypes
      self._processMap["GetColumns"] = Processor.process_GetColumns
      self._processMap["GetFunctions"] = Processor.process_GetFunctions
      self._processMap["GetOperationStatus"] = Processor.process_GetOperationStatus
      self._processMap["CancelOperation"] = Processor.process_CancelOperation
      self._processMap["CloseOperation"] = Processor.process_CloseOperation
      self._processMap["GetResultSetMetadata"] = Processor.process_GetResultSetMetadata
      self._processMap["FetchResults"] = Processor.process_FetchResults
      self._processMap["GetDelegationToken"] = Processor.process_GetDelegationToken
      self._processMap["CancelDelegationToken"] = Processor.process_CancelDelegationToken
      self._processMap["RenewDelegationToken"] = Processor.process_RenewDelegationToken
      self._processMap["GetLog"] = Processor.process_GetLog
  
    def process(self, iprot, oprot):
      (name, type, seqid) = iprot.readMessageBegin()
      if name not in self._processMap:
        iprot.skip(TType.STRUCT)
        iprot.readMessageEnd()
        x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
        oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
        x.write(oprot)
        oprot.writeMessageEnd()
        oprot.trans.flush()
        return
      else:
        self._processMap[name](self, seqid, iprot, oprot)
      return True
  
    def process_OpenSession(self, seqid, iprot, oprot):
      args = OpenSession_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = OpenSession_result()
      result.success = self._handler.OpenSession(args.req)
      oprot.writeMessageBegin("OpenSession", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_CloseSession(self, seqid, iprot, oprot):
      args = CloseSession_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = CloseSession_result()
      result.success = self._handler.CloseSession(args.req)
      oprot.writeMessageBegin("CloseSession", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetInfo(self, seqid, iprot, oprot):
      args = GetInfo_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetInfo_result()
      result.success = self._handler.GetInfo(args.req)
      oprot.writeMessageBegin("GetInfo", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_ExecuteStatement(self, seqid, iprot, oprot):
      args = ExecuteStatement_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = ExecuteStatement_result()
      result.success = self._handler.ExecuteStatement(args.req)
      oprot.writeMessageBegin("ExecuteStatement", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetTypeInfo(self, seqid, iprot, oprot):
      args = GetTypeInfo_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetTypeInfo_result()
      result.success = self._handler.GetTypeInfo(args.req)
      oprot.writeMessageBegin("GetTypeInfo", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetCatalogs(self, seqid, iprot, oprot):
      args = GetCatalogs_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetCatalogs_result()
      result.success = self._handler.GetCatalogs(args.req)
      oprot.writeMessageBegin("GetCatalogs", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetSchemas(self, seqid, iprot, oprot):
      args = GetSchemas_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetSchemas_result()
      result.success = self._handler.GetSchemas(args.req)
      oprot.writeMessageBegin("GetSchemas", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetTables(self, seqid, iprot, oprot):
      args = GetTables_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetTables_result()
      result.success = self._handler.GetTables(args.req)
      oprot.writeMessageBegin("GetTables", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetTableTypes(self, seqid, iprot, oprot):
      args = GetTableTypes_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetTableTypes_result()
      result.success = self._handler.GetTableTypes(args.req)
      oprot.writeMessageBegin("GetTableTypes", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetColumns(self, seqid, iprot, oprot):
      args = GetColumns_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetColumns_result()
      result.success = self._handler.GetColumns(args.req)
      oprot.writeMessageBegin("GetColumns", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetFunctions(self, seqid, iprot, oprot):
      args = GetFunctions_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetFunctions_result()
      result.success = self._handler.GetFunctions(args.req)
      oprot.writeMessageBegin("GetFunctions", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetOperationStatus(self, seqid, iprot, oprot):
      args = GetOperationStatus_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetOperationStatus_result()
      result.success = self._handler.GetOperationStatus(args.req)
      oprot.writeMessageBegin("GetOperationStatus", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_CancelOperation(self, seqid, iprot, oprot):
      args = CancelOperation_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = CancelOperation_result()
      result.success = self._handler.CancelOperation(args.req)
      oprot.writeMessageBegin("CancelOperation", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_CloseOperation(self, seqid, iprot, oprot):
      args = CloseOperation_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = CloseOperation_result()
      result.success = self._handler.CloseOperation(args.req)
      oprot.writeMessageBegin("CloseOperation", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetResultSetMetadata(self, seqid, iprot, oprot):
      args = GetResultSetMetadata_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetResultSetMetadata_result()
      result.success = self._handler.GetResultSetMetadata(args.req)
      oprot.writeMessageBegin("GetResultSetMetadata", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_FetchResults(self, seqid, iprot, oprot):
      args = FetchResults_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = FetchResults_result()
      result.success = self._handler.FetchResults(args.req)
      oprot.writeMessageBegin("FetchResults", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetDelegationToken(self, seqid, iprot, oprot):
      args = GetDelegationToken_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetDelegationToken_result()
      result.success = self._handler.GetDelegationToken(args.req)
      oprot.writeMessageBegin("GetDelegationToken", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_CancelDelegationToken(self, seqid, iprot, oprot):
      args = CancelDelegationToken_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = CancelDelegationToken_result()
      result.success = self._handler.CancelDelegationToken(args.req)
      oprot.writeMessageBegin("CancelDelegationToken", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_RenewDelegationToken(self, seqid, iprot, oprot):
      args = RenewDelegationToken_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = RenewDelegationToken_result()
      result.success = self._handler.RenewDelegationToken(args.req)
      oprot.writeMessageBegin("RenewDelegationToken", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
    def process_GetLog(self, seqid, iprot, oprot):
      args = GetLog_args()
      args.read(iprot)
      iprot.readMessageEnd()
      result = GetLog_result()
      result.success = self._handler.GetLog(args.req)
      oprot.writeMessageBegin("GetLog", TMessageType.REPLY, seqid)
      result.write(oprot)
      oprot.writeMessageEnd()
      oprot.trans.flush()
  
  
  # HELPER FUNCTIONS AND STRUCTURES
  
  class OpenSession_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TOpenSessionReq, TOpenSessionReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TOpenSessionReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('OpenSession_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class OpenSession_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TOpenSessionResp, TOpenSessionResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TOpenSessionResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('OpenSession_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CloseSession_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TCloseSessionReq, TCloseSessionReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TCloseSessionReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CloseSession_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CloseSession_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TCloseSessionResp, TCloseSessionResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TCloseSessionResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CloseSession_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetInfo_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetInfoReq, TGetInfoReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetInfoReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetInfo_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetInfo_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetInfoResp, TGetInfoResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetInfoResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetInfo_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class ExecuteStatement_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TExecuteStatementReq, TExecuteStatementReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TExecuteStatementReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('ExecuteStatement_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class ExecuteStatement_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TExecuteStatementResp, TExecuteStatementResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TExecuteStatementResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('ExecuteStatement_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetTypeInfo_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetTypeInfoReq, TGetTypeInfoReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetTypeInfoReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetTypeInfo_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetTypeInfo_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetTypeInfoResp, TGetTypeInfoResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetTypeInfoResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetTypeInfo_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetCatalogs_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetCatalogsReq, TGetCatalogsReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetCatalogsReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetCatalogs_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetCatalogs_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetCatalogsResp, TGetCatalogsResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetCatalogsResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetCatalogs_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetSchemas_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetSchemasReq, TGetSchemasReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetSchemasReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetSchemas_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetSchemas_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetSchemasResp, TGetSchemasResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetSchemasResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetSchemas_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetTables_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetTablesReq, TGetTablesReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetTablesReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetTables_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetTables_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetTablesResp, TGetTablesResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetTablesResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetTables_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetTableTypes_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetTableTypesReq, TGetTableTypesReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetTableTypesReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetTableTypes_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetTableTypes_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetTableTypesResp, TGetTableTypesResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetTableTypesResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetTableTypes_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetColumns_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetColumnsReq, TGetColumnsReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetColumnsReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetColumns_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetColumns_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetColumnsResp, TGetColumnsResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetColumnsResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetColumns_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetFunctions_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetFunctionsReq, TGetFunctionsReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetFunctionsReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetFunctions_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetFunctions_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetFunctionsResp, TGetFunctionsResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetFunctionsResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetFunctions_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetOperationStatus_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetOperationStatusReq, TGetOperationStatusReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetOperationStatusReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetOperationStatus_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetOperationStatus_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetOperationStatusResp, TGetOperationStatusResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetOperationStatusResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetOperationStatus_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CancelOperation_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TCancelOperationReq, TCancelOperationReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TCancelOperationReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CancelOperation_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CancelOperation_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TCancelOperationResp, TCancelOperationResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TCancelOperationResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CancelOperation_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CloseOperation_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TCloseOperationReq, TCloseOperationReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TCloseOperationReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CloseOperation_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CloseOperation_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TCloseOperationResp, TCloseOperationResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TCloseOperationResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CloseOperation_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetResultSetMetadata_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetResultSetMetadataReq, TGetResultSetMetadataReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetResultSetMetadataReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetResultSetMetadata_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetResultSetMetadata_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetResultSetMetadataResp, TGetResultSetMetadataResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetResultSetMetadataResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetResultSetMetadata_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class FetchResults_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TFetchResultsReq, TFetchResultsReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TFetchResultsReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('FetchResults_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class FetchResults_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TFetchResultsResp, TFetchResultsResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TFetchResultsResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('FetchResults_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetDelegationToken_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetDelegationTokenReq, TGetDelegationTokenReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetDelegationTokenReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetDelegationToken_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetDelegationToken_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetDelegationTokenResp, TGetDelegationTokenResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetDelegationTokenResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetDelegationToken_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CancelDelegationToken_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TCancelDelegationTokenReq, TCancelDelegationTokenReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TCancelDelegationTokenReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CancelDelegationToken_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class CancelDelegationToken_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TCancelDelegationTokenResp, TCancelDelegationTokenResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TCancelDelegationTokenResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('CancelDelegationToken_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class RenewDelegationToken_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TRenewDelegationTokenReq, TRenewDelegationTokenReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TRenewDelegationTokenReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('RenewDelegationToken_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class RenewDelegationToken_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TRenewDelegationTokenResp, TRenewDelegationTokenResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TRenewDelegationTokenResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('RenewDelegationToken_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetLog_args(object):
    """
    Attributes:
     - req
    """
  
    thrift_spec = (
      None, # 0
      (1, TType.STRUCT, 'req', (TGetLogReq, TGetLogReq.thrift_spec), None, ), # 1
    )
  
    def __init__(self, req=None,):
      self.req = req
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 1:
          if ftype == TType.STRUCT:
            self.req = TGetLogReq()
            self.req.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetLog_args')
      if self.req is not None:
        oprot.writeFieldBegin('req', TType.STRUCT, 1)
        self.req.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  
  class GetLog_result(object):
    """
    Attributes:
     - success
    """
  
    thrift_spec = (
      (0, TType.STRUCT, 'success', (TGetLogResp, TGetLogResp.thrift_spec), None, ), # 0
    )
  
    def __init__(self, success=None,):
      self.success = success
  
    def read(self, iprot):
      if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
        fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
        return
      iprot.readStructBegin()
      while True:
        (fname, ftype, fid) = iprot.readFieldBegin()
        if ftype == TType.STOP:
          break
        if fid == 0:
          if ftype == TType.STRUCT:
            self.success = TGetLogResp()
            self.success.read(iprot)
          else:
            iprot.skip(ftype)
        else:
          iprot.skip(ftype)
        iprot.readFieldEnd()
      iprot.readStructEnd()
  
    def write(self, oprot):
      if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
        oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
        return
      oprot.writeStructBegin('GetLog_result')
      if self.success is not None:
        oprot.writeFieldBegin('success', TType.STRUCT, 0)
        self.success.write(oprot)
        oprot.writeFieldEnd()
      oprot.writeFieldStop()
      oprot.writeStructEnd()
  
    def validate(self):
      return
  
  
    def __repr__(self):
      L = ['%s=%r' % (key, value)
        for key, value in self.__dict__.iteritems()]
      return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
  
    def __eq__(self, other):
      return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
  
    def __ne__(self, other):
      return not (self == other)
  