| # |
| # Autogenerated by Thrift Compiler (0.10.0) |
| # |
| # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| # |
| # options string: py |
| # |
| |
| from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException |
| from thrift.protocol.TProtocol import TProtocolException |
| import sys |
| import logging |
| from .ttypes import * |
| from thrift.Thrift import TProcessor |
| from thrift.transport import TTransport |
| |
| |
| 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 GetPrimaryKeys(self, req): |
| """ |
| Parameters: |
| - req |
| """ |
| pass |
| |
| def GetCrossReference(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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = OpenSession_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = CloseSession_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetInfo_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = ExecuteStatement_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetTypeInfo_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetCatalogs_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetSchemas_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetTables_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetTableTypes_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetColumns_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetFunctions_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "GetFunctions failed: unknown result") |
| |
| def GetPrimaryKeys(self, req): |
| """ |
| Parameters: |
| - req |
| """ |
| self.send_GetPrimaryKeys(req) |
| return self.recv_GetPrimaryKeys() |
| |
| def send_GetPrimaryKeys(self, req): |
| self._oprot.writeMessageBegin('GetPrimaryKeys', TMessageType.CALL, self._seqid) |
| args = GetPrimaryKeys_args() |
| args.req = req |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_GetPrimaryKeys(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetPrimaryKeys_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "GetPrimaryKeys failed: unknown result") |
| |
| def GetCrossReference(self, req): |
| """ |
| Parameters: |
| - req |
| """ |
| self.send_GetCrossReference(req) |
| return self.recv_GetCrossReference() |
| |
| def send_GetCrossReference(self, req): |
| self._oprot.writeMessageBegin('GetCrossReference', TMessageType.CALL, self._seqid) |
| args = GetCrossReference_args() |
| args.req = req |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_GetCrossReference(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetCrossReference_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "GetCrossReference 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetOperationStatus_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = CancelOperation_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = CloseOperation_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetResultSetMetadata_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = FetchResults_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetDelegationToken_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = CancelDelegationToken_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = RenewDelegationToken_result() |
| result.read(iprot) |
| 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): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = GetLog_result() |
| result.read(iprot) |
| 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["GetPrimaryKeys"] = Processor.process_GetPrimaryKeys |
| self._processMap["GetCrossReference"] = Processor.process_GetCrossReference |
| 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() |
| try: |
| result.success = self._handler.OpenSession(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("OpenSession", msg_type, 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() |
| try: |
| result.success = self._handler.CloseSession(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("CloseSession", msg_type, 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() |
| try: |
| result.success = self._handler.GetInfo(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetInfo", msg_type, 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() |
| try: |
| result.success = self._handler.ExecuteStatement(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("ExecuteStatement", msg_type, 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() |
| try: |
| result.success = self._handler.GetTypeInfo(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetTypeInfo", msg_type, 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() |
| try: |
| result.success = self._handler.GetCatalogs(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetCatalogs", msg_type, 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() |
| try: |
| result.success = self._handler.GetSchemas(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetSchemas", msg_type, 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() |
| try: |
| result.success = self._handler.GetTables(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetTables", msg_type, 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() |
| try: |
| result.success = self._handler.GetTableTypes(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetTableTypes", msg_type, 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() |
| try: |
| result.success = self._handler.GetColumns(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetColumns", msg_type, 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() |
| try: |
| result.success = self._handler.GetFunctions(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetFunctions", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_GetPrimaryKeys(self, seqid, iprot, oprot): |
| args = GetPrimaryKeys_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = GetPrimaryKeys_result() |
| try: |
| result.success = self._handler.GetPrimaryKeys(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetPrimaryKeys", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_GetCrossReference(self, seqid, iprot, oprot): |
| args = GetCrossReference_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = GetCrossReference_result() |
| try: |
| result.success = self._handler.GetCrossReference(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetCrossReference", msg_type, 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() |
| try: |
| result.success = self._handler.GetOperationStatus(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetOperationStatus", msg_type, 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() |
| try: |
| result.success = self._handler.CancelOperation(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("CancelOperation", msg_type, 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() |
| try: |
| result.success = self._handler.CloseOperation(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("CloseOperation", msg_type, 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() |
| try: |
| result.success = self._handler.GetResultSetMetadata(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetResultSetMetadata", msg_type, 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() |
| try: |
| result.success = self._handler.FetchResults(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("FetchResults", msg_type, 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() |
| try: |
| result.success = self._handler.GetDelegationToken(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetDelegationToken", msg_type, 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() |
| try: |
| result.success = self._handler.CancelDelegationToken(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("CancelDelegationToken", msg_type, 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() |
| try: |
| result.success = self._handler.RenewDelegationToken(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("RenewDelegationToken", msg_type, 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() |
| try: |
| result.success = self._handler.GetLog(args.req) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("GetLog", msg_type, 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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 GetPrimaryKeys_args(object): |
| """ |
| Attributes: |
| - req |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'req', (TGetPrimaryKeysReq, TGetPrimaryKeysReq.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, req=None,): |
| self.req = req |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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 = TGetPrimaryKeysReq() |
| self.req.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('GetPrimaryKeys_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__.items()] |
| 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 GetPrimaryKeys_result(object): |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (TGetPrimaryKeysResp, TGetPrimaryKeysResp.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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 = TGetPrimaryKeysResp() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('GetPrimaryKeys_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__.items()] |
| 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 GetCrossReference_args(object): |
| """ |
| Attributes: |
| - req |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.STRUCT, 'req', (TGetCrossReferenceReq, TGetCrossReferenceReq.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, req=None,): |
| self.req = req |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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 = TGetCrossReferenceReq() |
| self.req.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('GetCrossReference_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__.items()] |
| 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 GetCrossReference_result(object): |
| """ |
| Attributes: |
| - success |
| """ |
| |
| thrift_spec = ( |
| (0, TType.STRUCT, 'success', (TGetCrossReferenceResp, TGetCrossReferenceResp.thrift_spec), None, ), # 0 |
| ) |
| |
| def __init__(self, success=None,): |
| self.success = success |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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 = TGetCrossReferenceResp() |
| self.success.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('GetCrossReference_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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (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._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(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__.items()] |
| 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) |
