http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py index 13f77bc..4b08329 100644 --- a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py +++ b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ThriftHiveMetastore.py @@ -1445,6 +1445,111 @@ class Iface(fb303.FacebookService.Iface): """ pass + def create_ischema(self, schema): + """ + Parameters: + - schema + """ + pass + + def alter_ischema(self, schemaName, newSchema): + """ + Parameters: + - schemaName + - newSchema + """ + pass + + def get_ischema(self, schemaName): + """ + Parameters: + - schemaName + """ + pass + + def drop_ischema(self, schemaName): + """ + Parameters: + - schemaName + """ + pass + + def add_schema_version(self, schemaVersion): + """ + Parameters: + - schemaVersion + """ + pass + + def get_schema_version(self, schemaName, version): + """ + Parameters: + - schemaName + - version + """ + pass + + def get_schema_latest_version(self, schemaName): + """ + Parameters: + - schemaName + """ + pass + + def get_schema_all_versions(self, schemaName): + """ + Parameters: + - schemaName + """ + pass + + def drop_schema_version(self, schemaName, version): + """ + Parameters: + - schemaName + - version + """ + pass + + def get_schemas_by_cols(self, rqst): + """ + Parameters: + - rqst + """ + pass + + def map_schema_version_to_serde(self, schemaName, version, serdeName): + """ + Parameters: + - schemaName + - version + - serdeName + """ + pass + + def set_schema_version_state(self, schemaName, version, state): + """ + Parameters: + - schemaName + - version + - state + """ + pass + + def add_serde(self, serde): + """ + Parameters: + - serde + """ + pass + + def get_serde(self, serdeName): + """ + Parameters: + - serdeName + """ + pass + class Client(fb303.FacebookService.Client, Iface): """ @@ -8046,6 +8151,500 @@ class Client(fb303.FacebookService.Client, Iface): raise result.o4 raise TApplicationException(TApplicationException.MISSING_RESULT, "create_or_drop_wm_trigger_to_pool_mapping failed: unknown result") + def create_ischema(self, schema): + """ + Parameters: + - schema + """ + self.send_create_ischema(schema) + self.recv_create_ischema() + + def send_create_ischema(self, schema): + self._oprot.writeMessageBegin('create_ischema', TMessageType.CALL, self._seqid) + args = create_ischema_args() + args.schema = schema + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_create_ischema(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = create_ischema_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + return + + def alter_ischema(self, schemaName, newSchema): + """ + Parameters: + - schemaName + - newSchema + """ + self.send_alter_ischema(schemaName, newSchema) + self.recv_alter_ischema() + + def send_alter_ischema(self, schemaName, newSchema): + self._oprot.writeMessageBegin('alter_ischema', TMessageType.CALL, self._seqid) + args = alter_ischema_args() + args.schemaName = schemaName + args.newSchema = newSchema + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_alter_ischema(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = alter_ischema_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + return + + def get_ischema(self, schemaName): + """ + Parameters: + - schemaName + """ + self.send_get_ischema(schemaName) + return self.recv_get_ischema() + + def send_get_ischema(self, schemaName): + self._oprot.writeMessageBegin('get_ischema', TMessageType.CALL, self._seqid) + args = get_ischema_args() + args.schemaName = schemaName + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_ischema(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_ischema_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_ischema failed: unknown result") + + def drop_ischema(self, schemaName): + """ + Parameters: + - schemaName + """ + self.send_drop_ischema(schemaName) + self.recv_drop_ischema() + + def send_drop_ischema(self, schemaName): + self._oprot.writeMessageBegin('drop_ischema', TMessageType.CALL, self._seqid) + args = drop_ischema_args() + args.schemaName = schemaName + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_ischema(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = drop_ischema_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + return + + def add_schema_version(self, schemaVersion): + """ + Parameters: + - schemaVersion + """ + self.send_add_schema_version(schemaVersion) + self.recv_add_schema_version() + + def send_add_schema_version(self, schemaVersion): + self._oprot.writeMessageBegin('add_schema_version', TMessageType.CALL, self._seqid) + args = add_schema_version_args() + args.schemaVersion = schemaVersion + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_add_schema_version(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = add_schema_version_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + return + + def get_schema_version(self, schemaName, version): + """ + Parameters: + - schemaName + - version + """ + self.send_get_schema_version(schemaName, version) + return self.recv_get_schema_version() + + def send_get_schema_version(self, schemaName, version): + self._oprot.writeMessageBegin('get_schema_version', TMessageType.CALL, self._seqid) + args = get_schema_version_args() + args.schemaName = schemaName + args.version = version + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_schema_version(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_schema_version_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_schema_version failed: unknown result") + + def get_schema_latest_version(self, schemaName): + """ + Parameters: + - schemaName + """ + self.send_get_schema_latest_version(schemaName) + return self.recv_get_schema_latest_version() + + def send_get_schema_latest_version(self, schemaName): + self._oprot.writeMessageBegin('get_schema_latest_version', TMessageType.CALL, self._seqid) + args = get_schema_latest_version_args() + args.schemaName = schemaName + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_schema_latest_version(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_schema_latest_version_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_schema_latest_version failed: unknown result") + + def get_schema_all_versions(self, schemaName): + """ + Parameters: + - schemaName + """ + self.send_get_schema_all_versions(schemaName) + return self.recv_get_schema_all_versions() + + def send_get_schema_all_versions(self, schemaName): + self._oprot.writeMessageBegin('get_schema_all_versions', TMessageType.CALL, self._seqid) + args = get_schema_all_versions_args() + args.schemaName = schemaName + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_schema_all_versions(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_schema_all_versions_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_schema_all_versions failed: unknown result") + + def drop_schema_version(self, schemaName, version): + """ + Parameters: + - schemaName + - version + """ + self.send_drop_schema_version(schemaName, version) + self.recv_drop_schema_version() + + def send_drop_schema_version(self, schemaName, version): + self._oprot.writeMessageBegin('drop_schema_version', TMessageType.CALL, self._seqid) + args = drop_schema_version_args() + args.schemaName = schemaName + args.version = version + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_drop_schema_version(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = drop_schema_version_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + return + + def get_schemas_by_cols(self, rqst): + """ + Parameters: + - rqst + """ + self.send_get_schemas_by_cols(rqst) + return self.recv_get_schemas_by_cols() + + def send_get_schemas_by_cols(self, rqst): + self._oprot.writeMessageBegin('get_schemas_by_cols', TMessageType.CALL, self._seqid) + args = get_schemas_by_cols_args() + args.rqst = rqst + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_schemas_by_cols(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_schemas_by_cols_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_schemas_by_cols failed: unknown result") + + def map_schema_version_to_serde(self, schemaName, version, serdeName): + """ + Parameters: + - schemaName + - version + - serdeName + """ + self.send_map_schema_version_to_serde(schemaName, version, serdeName) + self.recv_map_schema_version_to_serde() + + def send_map_schema_version_to_serde(self, schemaName, version, serdeName): + self._oprot.writeMessageBegin('map_schema_version_to_serde', TMessageType.CALL, self._seqid) + args = map_schema_version_to_serde_args() + args.schemaName = schemaName + args.version = version + args.serdeName = serdeName + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_map_schema_version_to_serde(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = map_schema_version_to_serde_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + return + + def set_schema_version_state(self, schemaName, version, state): + """ + Parameters: + - schemaName + - version + - state + """ + self.send_set_schema_version_state(schemaName, version, state) + self.recv_set_schema_version_state() + + def send_set_schema_version_state(self, schemaName, version, state): + self._oprot.writeMessageBegin('set_schema_version_state', TMessageType.CALL, self._seqid) + args = set_schema_version_state_args() + args.schemaName = schemaName + args.version = version + args.state = state + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_set_schema_version_state(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = set_schema_version_state_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + if result.o3 is not None: + raise result.o3 + return + + def add_serde(self, serde): + """ + Parameters: + - serde + """ + self.send_add_serde(serde) + self.recv_add_serde() + + def send_add_serde(self, serde): + self._oprot.writeMessageBegin('add_serde', TMessageType.CALL, self._seqid) + args = add_serde_args() + args.serde = serde + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_add_serde(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = add_serde_result() + result.read(iprot) + iprot.readMessageEnd() + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + return + + def get_serde(self, serdeName): + """ + Parameters: + - serdeName + """ + self.send_get_serde(serdeName) + return self.recv_get_serde() + + def send_get_serde(self, serdeName): + self._oprot.writeMessageBegin('get_serde', TMessageType.CALL, self._seqid) + args = get_serde_args() + args.serdeName = serdeName + args.write(self._oprot) + self._oprot.writeMessageEnd() + self._oprot.trans.flush() + + def recv_get_serde(self): + iprot = self._iprot + (fname, mtype, rseqid) = iprot.readMessageBegin() + if mtype == TMessageType.EXCEPTION: + x = TApplicationException() + x.read(iprot) + iprot.readMessageEnd() + raise x + result = get_serde_result() + result.read(iprot) + iprot.readMessageEnd() + if result.success is not None: + return result.success + if result.o1 is not None: + raise result.o1 + if result.o2 is not None: + raise result.o2 + raise TApplicationException(TApplicationException.MISSING_RESULT, "get_serde failed: unknown result") + class Processor(fb303.FacebookService.Processor, Iface, TProcessor): def __init__(self, handler): @@ -8233,6 +8832,20 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor): self._processMap["create_or_update_wm_mapping"] = Processor.process_create_or_update_wm_mapping self._processMap["drop_wm_mapping"] = Processor.process_drop_wm_mapping self._processMap["create_or_drop_wm_trigger_to_pool_mapping"] = Processor.process_create_or_drop_wm_trigger_to_pool_mapping + self._processMap["create_ischema"] = Processor.process_create_ischema + self._processMap["alter_ischema"] = Processor.process_alter_ischema + self._processMap["get_ischema"] = Processor.process_get_ischema + self._processMap["drop_ischema"] = Processor.process_drop_ischema + self._processMap["add_schema_version"] = Processor.process_add_schema_version + self._processMap["get_schema_version"] = Processor.process_get_schema_version + self._processMap["get_schema_latest_version"] = Processor.process_get_schema_latest_version + self._processMap["get_schema_all_versions"] = Processor.process_get_schema_all_versions + self._processMap["drop_schema_version"] = Processor.process_drop_schema_version + self._processMap["get_schemas_by_cols"] = Processor.process_get_schemas_by_cols + self._processMap["map_schema_version_to_serde"] = Processor.process_map_schema_version_to_serde + self._processMap["set_schema_version_state"] = Processor.process_set_schema_version_state + self._processMap["add_serde"] = Processor.process_add_serde + self._processMap["get_serde"] = Processor.process_get_serde def process(self, iprot, oprot): (name, type, seqid) = iprot.readMessageBegin() @@ -12752,6 +13365,365 @@ class Processor(fb303.FacebookService.Processor, Iface, TProcessor): oprot.writeMessageEnd() oprot.trans.flush() + def process_create_ischema(self, seqid, iprot, oprot): + args = create_ischema_args() + args.read(iprot) + iprot.readMessageEnd() + result = create_ischema_result() + try: + self._handler.create_ischema(args.schema) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except AlreadyExistsException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except NoSuchObjectException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("create_ischema", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_alter_ischema(self, seqid, iprot, oprot): + args = alter_ischema_args() + args.read(iprot) + iprot.readMessageEnd() + result = alter_ischema_result() + try: + self._handler.alter_ischema(args.schemaName, args.newSchema) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("alter_ischema", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_ischema(self, seqid, iprot, oprot): + args = get_ischema_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_ischema_result() + try: + result.success = self._handler.get_ischema(args.schemaName) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_ischema", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_drop_ischema(self, seqid, iprot, oprot): + args = drop_ischema_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_ischema_result() + try: + self._handler.drop_ischema(args.schemaName) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except InvalidOperationException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("drop_ischema", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_add_schema_version(self, seqid, iprot, oprot): + args = add_schema_version_args() + args.read(iprot) + iprot.readMessageEnd() + result = add_schema_version_result() + try: + self._handler.add_schema_version(args.schemaVersion) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except AlreadyExistsException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except NoSuchObjectException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("add_schema_version", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_schema_version(self, seqid, iprot, oprot): + args = get_schema_version_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_schema_version_result() + try: + result.success = self._handler.get_schema_version(args.schemaName, args.version) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_schema_version", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_schema_latest_version(self, seqid, iprot, oprot): + args = get_schema_latest_version_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_schema_latest_version_result() + try: + result.success = self._handler.get_schema_latest_version(args.schemaName) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_schema_latest_version", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_schema_all_versions(self, seqid, iprot, oprot): + args = get_schema_all_versions_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_schema_all_versions_result() + try: + result.success = self._handler.get_schema_all_versions(args.schemaName) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_schema_all_versions", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_drop_schema_version(self, seqid, iprot, oprot): + args = drop_schema_version_args() + args.read(iprot) + iprot.readMessageEnd() + result = drop_schema_version_result() + try: + self._handler.drop_schema_version(args.schemaName, args.version) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("drop_schema_version", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_schemas_by_cols(self, seqid, iprot, oprot): + args = get_schemas_by_cols_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_schemas_by_cols_result() + try: + result.success = self._handler.get_schemas_by_cols(args.rqst) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except MetaException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_schemas_by_cols", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_map_schema_version_to_serde(self, seqid, iprot, oprot): + args = map_schema_version_to_serde_args() + args.read(iprot) + iprot.readMessageEnd() + result = map_schema_version_to_serde_result() + try: + self._handler.map_schema_version_to_serde(args.schemaName, args.version, args.serdeName) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("map_schema_version_to_serde", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_set_schema_version_state(self, seqid, iprot, oprot): + args = set_schema_version_state_args() + args.read(iprot) + iprot.readMessageEnd() + result = set_schema_version_state_result() + try: + self._handler.set_schema_version_state(args.schemaName, args.version, args.state) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except InvalidOperationException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except MetaException as o3: + msg_type = TMessageType.REPLY + result.o3 = o3 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("set_schema_version_state", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_add_serde(self, seqid, iprot, oprot): + args = add_serde_args() + args.read(iprot) + iprot.readMessageEnd() + result = add_serde_result() + try: + self._handler.add_serde(args.serde) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except AlreadyExistsException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("add_serde", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + + def process_get_serde(self, seqid, iprot, oprot): + args = get_serde_args() + args.read(iprot) + iprot.readMessageEnd() + result = get_serde_result() + try: + result.success = self._handler.get_serde(args.serdeName) + msg_type = TMessageType.REPLY + except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): + raise + except NoSuchObjectException as o1: + msg_type = TMessageType.REPLY + result.o1 = o1 + except MetaException as o2: + msg_type = TMessageType.REPLY + result.o2 = o2 + except Exception as ex: + msg_type = TMessageType.EXCEPTION + logging.exception(ex) + result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') + oprot.writeMessageBegin("get_serde", msg_type, seqid) + result.write(oprot) + oprot.writeMessageEnd() + oprot.trans.flush() + # HELPER FUNCTIONS AND STRUCTURES @@ -13638,10 +14610,10 @@ class get_databases_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype725, _size722) = iprot.readListBegin() - for _i726 in xrange(_size722): - _elem727 = iprot.readString() - self.success.append(_elem727) + (_etype739, _size736) = iprot.readListBegin() + for _i740 in xrange(_size736): + _elem741 = iprot.readString() + self.success.append(_elem741) iprot.readListEnd() else: iprot.skip(ftype) @@ -13664,8 +14636,8 @@ class get_databases_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter728 in self.success: - oprot.writeString(iter728) + for iter742 in self.success: + oprot.writeString(iter742) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -13770,10 +14742,10 @@ class get_all_databases_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype732, _size729) = iprot.readListBegin() - for _i733 in xrange(_size729): - _elem734 = iprot.readString() - self.success.append(_elem734) + (_etype746, _size743) = iprot.readListBegin() + for _i747 in xrange(_size743): + _elem748 = iprot.readString() + self.success.append(_elem748) iprot.readListEnd() else: iprot.skip(ftype) @@ -13796,8 +14768,8 @@ class get_all_databases_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter735 in self.success: - oprot.writeString(iter735) + for iter749 in self.success: + oprot.writeString(iter749) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14567,12 +15539,12 @@ class get_type_all_result: if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype737, _vtype738, _size736 ) = iprot.readMapBegin() - for _i740 in xrange(_size736): - _key741 = iprot.readString() - _val742 = Type() - _val742.read(iprot) - self.success[_key741] = _val742 + (_ktype751, _vtype752, _size750 ) = iprot.readMapBegin() + for _i754 in xrange(_size750): + _key755 = iprot.readString() + _val756 = Type() + _val756.read(iprot) + self.success[_key755] = _val756 iprot.readMapEnd() else: iprot.skip(ftype) @@ -14595,9 +15567,9 @@ class get_type_all_result: if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success)) - for kiter743,viter744 in self.success.items(): - oprot.writeString(kiter743) - viter744.write(oprot) + for kiter757,viter758 in self.success.items(): + oprot.writeString(kiter757) + viter758.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o2 is not None: @@ -14740,11 +15712,11 @@ class get_fields_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype748, _size745) = iprot.readListBegin() - for _i749 in xrange(_size745): - _elem750 = FieldSchema() - _elem750.read(iprot) - self.success.append(_elem750) + (_etype762, _size759) = iprot.readListBegin() + for _i763 in xrange(_size759): + _elem764 = FieldSchema() + _elem764.read(iprot) + self.success.append(_elem764) iprot.readListEnd() else: iprot.skip(ftype) @@ -14779,8 +15751,8 @@ class get_fields_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter751 in self.success: - iter751.write(oprot) + for iter765 in self.success: + iter765.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -14947,11 +15919,11 @@ class get_fields_with_environment_context_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype755, _size752) = iprot.readListBegin() - for _i756 in xrange(_size752): - _elem757 = FieldSchema() - _elem757.read(iprot) - self.success.append(_elem757) + (_etype769, _size766) = iprot.readListBegin() + for _i770 in xrange(_size766): + _elem771 = FieldSchema() + _elem771.read(iprot) + self.success.append(_elem771) iprot.readListEnd() else: iprot.skip(ftype) @@ -14986,8 +15958,8 @@ class get_fields_with_environment_context_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter758 in self.success: - iter758.write(oprot) + for iter772 in self.success: + iter772.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15140,11 +16112,11 @@ class get_schema_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype762, _size759) = iprot.readListBegin() - for _i763 in xrange(_size759): - _elem764 = FieldSchema() - _elem764.read(iprot) - self.success.append(_elem764) + (_etype776, _size773) = iprot.readListBegin() + for _i777 in xrange(_size773): + _elem778 = FieldSchema() + _elem778.read(iprot) + self.success.append(_elem778) iprot.readListEnd() else: iprot.skip(ftype) @@ -15179,8 +16151,8 @@ class get_schema_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter765 in self.success: - iter765.write(oprot) + for iter779 in self.success: + iter779.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15347,11 +16319,11 @@ class get_schema_with_environment_context_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype769, _size766) = iprot.readListBegin() - for _i770 in xrange(_size766): - _elem771 = FieldSchema() - _elem771.read(iprot) - self.success.append(_elem771) + (_etype783, _size780) = iprot.readListBegin() + for _i784 in xrange(_size780): + _elem785 = FieldSchema() + _elem785.read(iprot) + self.success.append(_elem785) iprot.readListEnd() else: iprot.skip(ftype) @@ -15386,8 +16358,8 @@ class get_schema_with_environment_context_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter772 in self.success: - iter772.write(oprot) + for iter786 in self.success: + iter786.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -15834,44 +16806,44 @@ class create_table_with_constraints_args: elif fid == 2: if ftype == TType.LIST: self.primaryKeys = [] - (_etype776, _size773) = iprot.readListBegin() - for _i777 in xrange(_size773): - _elem778 = SQLPrimaryKey() - _elem778.read(iprot) - self.primaryKeys.append(_elem778) + (_etype790, _size787) = iprot.readListBegin() + for _i791 in xrange(_size787): + _elem792 = SQLPrimaryKey() + _elem792.read(iprot) + self.primaryKeys.append(_elem792) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 3: if ftype == TType.LIST: self.foreignKeys = [] - (_etype782, _size779) = iprot.readListBegin() - for _i783 in xrange(_size779): - _elem784 = SQLForeignKey() - _elem784.read(iprot) - self.foreignKeys.append(_elem784) + (_etype796, _size793) = iprot.readListBegin() + for _i797 in xrange(_size793): + _elem798 = SQLForeignKey() + _elem798.read(iprot) + self.foreignKeys.append(_elem798) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 4: if ftype == TType.LIST: self.uniqueConstraints = [] - (_etype788, _size785) = iprot.readListBegin() - for _i789 in xrange(_size785): - _elem790 = SQLUniqueConstraint() - _elem790.read(iprot) - self.uniqueConstraints.append(_elem790) + (_etype802, _size799) = iprot.readListBegin() + for _i803 in xrange(_size799): + _elem804 = SQLUniqueConstraint() + _elem804.read(iprot) + self.uniqueConstraints.append(_elem804) iprot.readListEnd() else: iprot.skip(ftype) elif fid == 5: if ftype == TType.LIST: self.notNullConstraints = [] - (_etype794, _size791) = iprot.readListBegin() - for _i795 in xrange(_size791): - _elem796 = SQLNotNullConstraint() - _elem796.read(iprot) - self.notNullConstraints.append(_elem796) + (_etype808, _size805) = iprot.readListBegin() + for _i809 in xrange(_size805): + _elem810 = SQLNotNullConstraint() + _elem810.read(iprot) + self.notNullConstraints.append(_elem810) iprot.readListEnd() else: iprot.skip(ftype) @@ -15892,29 +16864,29 @@ class create_table_with_constraints_args: if self.primaryKeys is not None: oprot.writeFieldBegin('primaryKeys', TType.LIST, 2) oprot.writeListBegin(TType.STRUCT, len(self.primaryKeys)) - for iter797 in self.primaryKeys: - iter797.write(oprot) + for iter811 in self.primaryKeys: + iter811.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.foreignKeys is not None: oprot.writeFieldBegin('foreignKeys', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.foreignKeys)) - for iter798 in self.foreignKeys: - iter798.write(oprot) + for iter812 in self.foreignKeys: + iter812.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.uniqueConstraints is not None: oprot.writeFieldBegin('uniqueConstraints', TType.LIST, 4) oprot.writeListBegin(TType.STRUCT, len(self.uniqueConstraints)) - for iter799 in self.uniqueConstraints: - iter799.write(oprot) + for iter813 in self.uniqueConstraints: + iter813.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.notNullConstraints is not None: oprot.writeFieldBegin('notNullConstraints', TType.LIST, 5) oprot.writeListBegin(TType.STRUCT, len(self.notNullConstraints)) - for iter800 in self.notNullConstraints: - iter800.write(oprot) + for iter814 in self.notNullConstraints: + iter814.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17180,10 +18152,10 @@ class truncate_table_args: elif fid == 3: if ftype == TType.LIST: self.partNames = [] - (_etype804, _size801) = iprot.readListBegin() - for _i805 in xrange(_size801): - _elem806 = iprot.readString() - self.partNames.append(_elem806) + (_etype818, _size815) = iprot.readListBegin() + for _i819 in xrange(_size815): + _elem820 = iprot.readString() + self.partNames.append(_elem820) iprot.readListEnd() else: iprot.skip(ftype) @@ -17208,8 +18180,8 @@ class truncate_table_args: if self.partNames is not None: oprot.writeFieldBegin('partNames', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.partNames)) - for iter807 in self.partNames: - oprot.writeString(iter807) + for iter821 in self.partNames: + oprot.writeString(iter821) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17409,10 +18381,10 @@ class get_tables_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype811, _size808) = iprot.readListBegin() - for _i812 in xrange(_size808): - _elem813 = iprot.readString() - self.success.append(_elem813) + (_etype825, _size822) = iprot.readListBegin() + for _i826 in xrange(_size822): + _elem827 = iprot.readString() + self.success.append(_elem827) iprot.readListEnd() else: iprot.skip(ftype) @@ -17435,8 +18407,8 @@ class get_tables_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter814 in self.success: - oprot.writeString(iter814) + for iter828 in self.success: + oprot.writeString(iter828) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17586,10 +18558,10 @@ class get_tables_by_type_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype818, _size815) = iprot.readListBegin() - for _i819 in xrange(_size815): - _elem820 = iprot.readString() - self.success.append(_elem820) + (_etype832, _size829) = iprot.readListBegin() + for _i833 in xrange(_size829): + _elem834 = iprot.readString() + self.success.append(_elem834) iprot.readListEnd() else: iprot.skip(ftype) @@ -17612,8 +18584,8 @@ class get_tables_by_type_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter821 in self.success: - oprot.writeString(iter821) + for iter835 in self.success: + oprot.writeString(iter835) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17737,10 +18709,10 @@ class get_materialized_views_for_rewriting_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype825, _size822) = iprot.readListBegin() - for _i826 in xrange(_size822): - _elem827 = iprot.readString() - self.success.append(_elem827) + (_etype839, _size836) = iprot.readListBegin() + for _i840 in xrange(_size836): + _elem841 = iprot.readString() + self.success.append(_elem841) iprot.readListEnd() else: iprot.skip(ftype) @@ -17763,8 +18735,8 @@ class get_materialized_views_for_rewriting_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter828 in self.success: - oprot.writeString(iter828) + for iter842 in self.success: + oprot.writeString(iter842) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -17837,10 +18809,10 @@ class get_table_meta_args: elif fid == 3: if ftype == TType.LIST: self.tbl_types = [] - (_etype832, _size829) = iprot.readListBegin() - for _i833 in xrange(_size829): - _elem834 = iprot.readString() - self.tbl_types.append(_elem834) + (_etype846, _size843) = iprot.readListBegin() + for _i847 in xrange(_size843): + _elem848 = iprot.readString() + self.tbl_types.append(_elem848) iprot.readListEnd() else: iprot.skip(ftype) @@ -17865,8 +18837,8 @@ class get_table_meta_args: if self.tbl_types is not None: oprot.writeFieldBegin('tbl_types', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.tbl_types)) - for iter835 in self.tbl_types: - oprot.writeString(iter835) + for iter849 in self.tbl_types: + oprot.writeString(iter849) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -17922,11 +18894,11 @@ class get_table_meta_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype839, _size836) = iprot.readListBegin() - for _i840 in xrange(_size836): - _elem841 = TableMeta() - _elem841.read(iprot) - self.success.append(_elem841) + (_etype853, _size850) = iprot.readListBegin() + for _i854 in xrange(_size850): + _elem855 = TableMeta() + _elem855.read(iprot) + self.success.append(_elem855) iprot.readListEnd() else: iprot.skip(ftype) @@ -17949,8 +18921,8 @@ class get_table_meta_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter842 in self.success: - iter842.write(oprot) + for iter856 in self.success: + iter856.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18074,10 +19046,10 @@ class get_all_tables_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype846, _size843) = iprot.readListBegin() - for _i847 in xrange(_size843): - _elem848 = iprot.readString() - self.success.append(_elem848) + (_etype860, _size857) = iprot.readListBegin() + for _i861 in xrange(_size857): + _elem862 = iprot.readString() + self.success.append(_elem862) iprot.readListEnd() else: iprot.skip(ftype) @@ -18100,8 +19072,8 @@ class get_all_tables_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter849 in self.success: - oprot.writeString(iter849) + for iter863 in self.success: + oprot.writeString(iter863) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -18337,10 +19309,10 @@ class get_table_objects_by_name_args: elif fid == 2: if ftype == TType.LIST: self.tbl_names = [] - (_etype853, _size850) = iprot.readListBegin() - for _i854 in xrange(_size850): - _elem855 = iprot.readString() - self.tbl_names.append(_elem855) + (_etype867, _size864) = iprot.readListBegin() + for _i868 in xrange(_size864): + _elem869 = iprot.readString() + self.tbl_names.append(_elem869) iprot.readListEnd() else: iprot.skip(ftype) @@ -18361,8 +19333,8 @@ class get_table_objects_by_name_args: if self.tbl_names is not None: oprot.writeFieldBegin('tbl_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tbl_names)) - for iter856 in self.tbl_names: - oprot.writeString(iter856) + for iter870 in self.tbl_names: + oprot.writeString(iter870) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18414,11 +19386,11 @@ class get_table_objects_by_name_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype860, _size857) = iprot.readListBegin() - for _i861 in xrange(_size857): - _elem862 = Table() - _elem862.read(iprot) - self.success.append(_elem862) + (_etype874, _size871) = iprot.readListBegin() + for _i875 in xrange(_size871): + _elem876 = Table() + _elem876.read(iprot) + self.success.append(_elem876) iprot.readListEnd() else: iprot.skip(ftype) @@ -18435,8 +19407,8 @@ class get_table_objects_by_name_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter863 in self.success: - iter863.write(oprot) + for iter877 in self.success: + iter877.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18828,10 +19800,10 @@ class get_materialization_invalidation_info_args: elif fid == 2: if ftype == TType.LIST: self.tbl_names = [] - (_etype867, _size864) = iprot.readListBegin() - for _i868 in xrange(_size864): - _elem869 = iprot.readString() - self.tbl_names.append(_elem869) + (_etype881, _size878) = iprot.readListBegin() + for _i882 in xrange(_size878): + _elem883 = iprot.readString() + self.tbl_names.append(_elem883) iprot.readListEnd() else: iprot.skip(ftype) @@ -18852,8 +19824,8 @@ class get_materialization_invalidation_info_args: if self.tbl_names is not None: oprot.writeFieldBegin('tbl_names', TType.LIST, 2) oprot.writeListBegin(TType.STRING, len(self.tbl_names)) - for iter870 in self.tbl_names: - oprot.writeString(iter870) + for iter884 in self.tbl_names: + oprot.writeString(iter884) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -18914,12 +19886,12 @@ class get_materialization_invalidation_info_result: if fid == 0: if ftype == TType.MAP: self.success = {} - (_ktype872, _vtype873, _size871 ) = iprot.readMapBegin() - for _i875 in xrange(_size871): - _key876 = iprot.readString() - _val877 = Materialization() - _val877.read(iprot) - self.success[_key876] = _val877 + (_ktype886, _vtype887, _size885 ) = iprot.readMapBegin() + for _i889 in xrange(_size885): + _key890 = iprot.readString() + _val891 = Materialization() + _val891.read(iprot) + self.success[_key890] = _val891 iprot.readMapEnd() else: iprot.skip(ftype) @@ -18954,9 +19926,9 @@ class get_materialization_invalidation_info_result: if self.success is not None: oprot.writeFieldBegin('success', TType.MAP, 0) oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success)) - for kiter878,viter879 in self.success.items(): - oprot.writeString(kiter878) - viter879.write(oprot) + for kiter892,viter893 in self.success.items(): + oprot.writeString(kiter892) + viter893.write(oprot) oprot.writeMapEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -19122,10 +20094,10 @@ class get_table_names_by_filter_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype883, _size880) = iprot.readListBegin() - for _i884 in xrange(_size880): - _elem885 = iprot.readString() - self.success.append(_elem885) + (_etype897, _size894) = iprot.readListBegin() + for _i898 in xrange(_size894): + _elem899 = iprot.readString() + self.success.append(_elem899) iprot.readListEnd() else: iprot.skip(ftype) @@ -19160,8 +20132,8 @@ class get_table_names_by_filter_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter886 in self.success: - oprot.writeString(iter886) + for iter900 in self.success: + oprot.writeString(iter900) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -20131,11 +21103,11 @@ class add_partitions_args: if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype890, _size887) = iprot.readListBegin() - for _i891 in xrange(_size887): - _elem892 = Partition() - _elem892.read(iprot) - self.new_parts.append(_elem892) + (_etype904, _size901) = iprot.readListBegin() + for _i905 in xrange(_size901): + _elem906 = Partition() + _elem906.read(iprot) + self.new_parts.append(_elem906) iprot.readListEnd() else: iprot.skip(ftype) @@ -20152,8 +21124,8 @@ class add_partitions_args: if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter893 in self.new_parts: - iter893.write(oprot) + for iter907 in self.new_parts: + iter907.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20311,11 +21283,11 @@ class add_partitions_pspec_args: if fid == 1: if ftype == TType.LIST: self.new_parts = [] - (_etype897, _size894) = iprot.readListBegin() - for _i898 in xrange(_size894): - _elem899 = PartitionSpec() - _elem899.read(iprot) - self.new_parts.append(_elem899) + (_etype911, _size908) = iprot.readListBegin() + for _i912 in xrange(_size908): + _elem913 = PartitionSpec() + _elem913.read(iprot) + self.new_parts.append(_elem913) iprot.readListEnd() else: iprot.skip(ftype) @@ -20332,8 +21304,8 @@ class add_partitions_pspec_args: if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 1) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter900 in self.new_parts: - iter900.write(oprot) + for iter914 in self.new_parts: + iter914.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20507,10 +21479,10 @@ class append_partition_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype904, _size901) = iprot.readListBegin() - for _i905 in xrange(_size901): - _elem906 = iprot.readString() - self.part_vals.append(_elem906) + (_etype918, _size915) = iprot.readListBegin() + for _i919 in xrange(_size915): + _elem920 = iprot.readString() + self.part_vals.append(_elem920) iprot.readListEnd() else: iprot.skip(ftype) @@ -20535,8 +21507,8 @@ class append_partition_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter907 in self.part_vals: - oprot.writeString(iter907) + for iter921 in self.part_vals: + oprot.writeString(iter921) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -20889,10 +21861,10 @@ class append_partition_with_environment_context_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype911, _size908) = iprot.readListBegin() - for _i912 in xrange(_size908): - _elem913 = iprot.readString() - self.part_vals.append(_elem913) + (_etype925, _size922) = iprot.readListBegin() + for _i926 in xrange(_size922): + _elem927 = iprot.readString() + self.part_vals.append(_elem927) iprot.readListEnd() else: iprot.skip(ftype) @@ -20923,8 +21895,8 @@ class append_partition_with_environment_context_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter914 in self.part_vals: - oprot.writeString(iter914) + for iter928 in self.part_vals: + oprot.writeString(iter928) oprot.writeListEnd() oprot.writeFieldEnd() if self.environment_context is not None: @@ -21519,10 +22491,10 @@ class drop_partition_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype918, _size915) = iprot.readListBegin() - for _i919 in xrange(_size915): - _elem920 = iprot.readString() - self.part_vals.append(_elem920) + (_etype932, _size929) = iprot.readListBegin() + for _i933 in xrange(_size929): + _elem934 = iprot.readString() + self.part_vals.append(_elem934) iprot.readListEnd() else: iprot.skip(ftype) @@ -21552,8 +22524,8 @@ class drop_partition_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter921 in self.part_vals: - oprot.writeString(iter921) + for iter935 in self.part_vals: + oprot.writeString(iter935) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -21726,10 +22698,10 @@ class drop_partition_with_environment_context_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype925, _size922) = iprot.readListBegin() - for _i926 in xrange(_size922): - _elem927 = iprot.readString() - self.part_vals.append(_elem927) + (_etype939, _size936) = iprot.readListBegin() + for _i940 in xrange(_size936): + _elem941 = iprot.readString() + self.part_vals.append(_elem941) iprot.readListEnd() else: iprot.skip(ftype) @@ -21765,8 +22737,8 @@ class drop_partition_with_environment_context_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter928 in self.part_vals: - oprot.writeString(iter928) + for iter942 in self.part_vals: + oprot.writeString(iter942) oprot.writeListEnd() oprot.writeFieldEnd() if self.deleteData is not None: @@ -22503,10 +23475,10 @@ class get_partition_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype932, _size929) = iprot.readListBegin() - for _i933 in xrange(_size929): - _elem934 = iprot.readString() - self.part_vals.append(_elem934) + (_etype946, _size943) = iprot.readListBegin() + for _i947 in xrange(_size943): + _elem948 = iprot.readString() + self.part_vals.append(_elem948) iprot.readListEnd() else: iprot.skip(ftype) @@ -22531,8 +23503,8 @@ class get_partition_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter935 in self.part_vals: - oprot.writeString(iter935) + for iter949 in self.part_vals: + oprot.writeString(iter949) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -22691,11 +23663,11 @@ class exchange_partition_args: if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype937, _vtype938, _size936 ) = iprot.readMapBegin() - for _i940 in xrange(_size936): - _key941 = iprot.readString() - _val942 = iprot.readString() - self.partitionSpecs[_key941] = _val942 + (_ktype951, _vtype952, _size950 ) = iprot.readMapBegin() + for _i954 in xrange(_size950): + _key955 = iprot.readString() + _val956 = iprot.readString() + self.partitionSpecs[_key955] = _val956 iprot.readMapEnd() else: iprot.skip(ftype) @@ -22732,9 +23704,9 @@ class exchange_partition_args: if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter943,viter944 in self.partitionSpecs.items(): - oprot.writeString(kiter943) - oprot.writeString(viter944) + for kiter957,viter958 in self.partitionSpecs.items(): + oprot.writeString(kiter957) + oprot.writeString(viter958) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -22939,11 +23911,11 @@ class exchange_partitions_args: if fid == 1: if ftype == TType.MAP: self.partitionSpecs = {} - (_ktype946, _vtype947, _size945 ) = iprot.readMapBegin() - for _i949 in xrange(_size945): - _key950 = iprot.readString() - _val951 = iprot.readString() - self.partitionSpecs[_key950] = _val951 + (_ktype960, _vtype961, _size959 ) = iprot.readMapBegin() + for _i963 in xrange(_size959): + _key964 = iprot.readString() + _val965 = iprot.readString() + self.partitionSpecs[_key964] = _val965 iprot.readMapEnd() else: iprot.skip(ftype) @@ -22980,9 +23952,9 @@ class exchange_partitions_args: if self.partitionSpecs is not None: oprot.writeFieldBegin('partitionSpecs', TType.MAP, 1) oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.partitionSpecs)) - for kiter952,viter953 in self.partitionSpecs.items(): - oprot.writeString(kiter952) - oprot.writeString(viter953) + for kiter966,viter967 in self.partitionSpecs.items(): + oprot.writeString(kiter966) + oprot.writeString(viter967) oprot.writeMapEnd() oprot.writeFieldEnd() if self.source_db is not None: @@ -23065,11 +24037,11 @@ class exchange_partitions_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype957, _size954) = iprot.readListBegin() - for _i958 in xrange(_size954): - _elem959 = Partition() - _elem959.read(iprot) - self.success.append(_elem959) + (_etype971, _size968) = iprot.readListBegin() + for _i972 in xrange(_size968): + _elem973 = Partition() + _elem973.read(iprot) + self.success.append(_elem973) iprot.readListEnd() else: iprot.skip(ftype) @@ -23110,8 +24082,8 @@ class exchange_partitions_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter960 in self.success: - iter960.write(oprot) + for iter974 in self.success: + iter974.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23205,10 +24177,10 @@ class get_partition_with_auth_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype964, _size961) = iprot.readListBegin() - for _i965 in xrange(_size961): - _elem966 = iprot.readString() - self.part_vals.append(_elem966) + (_etype978, _size975) = iprot.readListBegin() + for _i979 in xrange(_size975): + _elem980 = iprot.readString() + self.part_vals.append(_elem980) iprot.readListEnd() else: iprot.skip(ftype) @@ -23220,10 +24192,10 @@ class get_partition_with_auth_args: elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype970, _size967) = iprot.readListBegin() - for _i971 in xrange(_size967): - _elem972 = iprot.readString() - self.group_names.append(_elem972) + (_etype984, _size981) = iprot.readListBegin() + for _i985 in xrange(_size981): + _elem986 = iprot.readString() + self.group_names.append(_elem986) iprot.readListEnd() else: iprot.skip(ftype) @@ -23248,8 +24220,8 @@ class get_partition_with_auth_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter973 in self.part_vals: - oprot.writeString(iter973) + for iter987 in self.part_vals: + oprot.writeString(iter987) oprot.writeListEnd() oprot.writeFieldEnd() if self.user_name is not None: @@ -23259,8 +24231,8 @@ class get_partition_with_auth_args: if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter974 in self.group_names: - oprot.writeString(iter974) + for iter988 in self.group_names: + oprot.writeString(iter988) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -23689,11 +24661,11 @@ class get_partitions_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype978, _size975) = iprot.readListBegin() - for _i979 in xrange(_size975): - _elem980 = Partition() - _elem980.read(iprot) - self.success.append(_elem980) + (_etype992, _size989) = iprot.readListBegin() + for _i993 in xrange(_size989): + _elem994 = Partition() + _elem994.read(iprot) + self.success.append(_elem994) iprot.readListEnd() else: iprot.skip(ftype) @@ -23722,8 +24694,8 @@ class get_partitions_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter981 in self.success: - iter981.write(oprot) + for iter995 in self.success: + iter995.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -23817,10 +24789,10 @@ class get_partitions_with_auth_args: elif fid == 5: if ftype == TType.LIST: self.group_names = [] - (_etype985, _size982) = iprot.readListBegin() - for _i986 in xrange(_size982): - _elem987 = iprot.readString() - self.group_names.append(_elem987) + (_etype999, _size996) = iprot.readListBegin() + for _i1000 in xrange(_size996): + _elem1001 = iprot.readString() + self.group_names.append(_elem1001) iprot.readListEnd() else: iprot.skip(ftype) @@ -23853,8 +24825,8 @@ class get_partitions_with_auth_args: if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 5) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter988 in self.group_names: - oprot.writeString(iter988) + for iter1002 in self.group_names: + oprot.writeString(iter1002) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -23915,11 +24887,11 @@ class get_partitions_with_auth_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype992, _size989) = iprot.readListBegin() - for _i993 in xrange(_size989): - _elem994 = Partition() - _elem994.read(iprot) - self.success.append(_elem994) + (_etype1006, _size1003) = iprot.readListBegin() + for _i1007 in xrange(_size1003): + _elem1008 = Partition() + _elem1008.read(iprot) + self.success.append(_elem1008) iprot.readListEnd() else: iprot.skip(ftype) @@ -23948,8 +24920,8 @@ class get_partitions_with_auth_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter995 in self.success: - iter995.write(oprot) + for iter1009 in self.success: + iter1009.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24107,11 +25079,11 @@ class get_partitions_pspec_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype999, _size996) = iprot.readListBegin() - for _i1000 in xrange(_size996): - _elem1001 = PartitionSpec() - _elem1001.read(iprot) - self.success.append(_elem1001) + (_etype1013, _size1010) = iprot.readListBegin() + for _i1014 in xrange(_size1010): + _elem1015 = PartitionSpec() + _elem1015.read(iprot) + self.success.append(_elem1015) iprot.readListEnd() else: iprot.skip(ftype) @@ -24140,8 +25112,8 @@ class get_partitions_pspec_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1002 in self.success: - iter1002.write(oprot) + for iter1016 in self.success: + iter1016.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24299,10 +25271,10 @@ class get_partition_names_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1006, _size1003) = iprot.readListBegin() - for _i1007 in xrange(_size1003): - _elem1008 = iprot.readString() - self.success.append(_elem1008) + (_etype1020, _size1017) = iprot.readListBegin() + for _i1021 in xrange(_size1017): + _elem1022 = iprot.readString() + self.success.append(_elem1022) iprot.readListEnd() else: iprot.skip(ftype) @@ -24331,8 +25303,8 @@ class get_partition_names_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1009 in self.success: - oprot.writeString(iter1009) + for iter1023 in self.success: + oprot.writeString(iter1023) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24572,10 +25544,10 @@ class get_partitions_ps_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1013, _size1010) = iprot.readListBegin() - for _i1014 in xrange(_size1010): - _elem1015 = iprot.readString() - self.part_vals.append(_elem1015) + (_etype1027, _size1024) = iprot.readListBegin() + for _i1028 in xrange(_size1024): + _elem1029 = iprot.readString() + self.part_vals.append(_elem1029) iprot.readListEnd() else: iprot.skip(ftype) @@ -24605,8 +25577,8 @@ class get_partitions_ps_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1016 in self.part_vals: - oprot.writeString(iter1016) + for iter1030 in self.part_vals: + oprot.writeString(iter1030) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -24670,11 +25642,11 @@ class get_partitions_ps_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1020, _size1017) = iprot.readListBegin() - for _i1021 in xrange(_size1017): - _elem1022 = Partition() - _elem1022.read(iprot) - self.success.append(_elem1022) + (_etype1034, _size1031) = iprot.readListBegin() + for _i1035 in xrange(_size1031): + _elem1036 = Partition() + _elem1036.read(iprot) + self.success.append(_elem1036) iprot.readListEnd() else: iprot.skip(ftype) @@ -24703,8 +25675,8 @@ class get_partitions_ps_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1023 in self.success: - iter1023.write(oprot) + for iter1037 in self.success: + iter1037.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -24791,10 +25763,10 @@ class get_partitions_ps_with_auth_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1027, _size1024) = iprot.readListBegin() - for _i1028 in xrange(_size1024): - _elem1029 = iprot.readString() - self.part_vals.append(_elem1029) + (_etype1041, _size1038) = iprot.readListBegin() + for _i1042 in xrange(_size1038): + _elem1043 = iprot.readString() + self.part_vals.append(_elem1043) iprot.readListEnd() else: iprot.skip(ftype) @@ -24811,10 +25783,10 @@ class get_partitions_ps_with_auth_args: elif fid == 6: if ftype == TType.LIST: self.group_names = [] - (_etype1033, _size1030) = iprot.readListBegin() - for _i1034 in xrange(_size1030): - _elem1035 = iprot.readString() - self.group_names.append(_elem1035) + (_etype1047, _size1044) = iprot.readListBegin() + for _i1048 in xrange(_size1044): + _elem1049 = iprot.readString() + self.group_names.append(_elem1049) iprot.readListEnd() else: iprot.skip(ftype) @@ -24839,8 +25811,8 @@ class get_partitions_ps_with_auth_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1036 in self.part_vals: - oprot.writeString(iter1036) + for iter1050 in self.part_vals: + oprot.writeString(iter1050) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -24854,8 +25826,8 @@ class get_partitions_ps_with_auth_args: if self.group_names is not None: oprot.writeFieldBegin('group_names', TType.LIST, 6) oprot.writeListBegin(TType.STRING, len(self.group_names)) - for iter1037 in self.group_names: - oprot.writeString(iter1037) + for iter1051 in self.group_names: + oprot.writeString(iter1051) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -24917,11 +25889,11 @@ class get_partitions_ps_with_auth_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1041, _size1038) = iprot.readListBegin() - for _i1042 in xrange(_size1038): - _elem1043 = Partition() - _elem1043.read(iprot) - self.success.append(_elem1043) + (_etype1055, _size1052) = iprot.readListBegin() + for _i1056 in xrange(_size1052): + _elem1057 = Partition() + _elem1057.read(iprot) + self.success.append(_elem1057) iprot.readListEnd() else: iprot.skip(ftype) @@ -24950,8 +25922,8 @@ class get_partitions_ps_with_auth_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1044 in self.success: - iter1044.write(oprot) + for iter1058 in self.success: + iter1058.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25032,10 +26004,10 @@ class get_partition_names_ps_args: elif fid == 3: if ftype == TType.LIST: self.part_vals = [] - (_etype1048, _size1045) = iprot.readListBegin() - for _i1049 in xrange(_size1045): - _elem1050 = iprot.readString() - self.part_vals.append(_elem1050) + (_etype1062, _size1059) = iprot.readListBegin() + for _i1063 in xrange(_size1059): + _elem1064 = iprot.readString() + self.part_vals.append(_elem1064) iprot.readListEnd() else: iprot.skip(ftype) @@ -25065,8 +26037,8 @@ class get_partition_names_ps_args: if self.part_vals is not None: oprot.writeFieldBegin('part_vals', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.part_vals)) - for iter1051 in self.part_vals: - oprot.writeString(iter1051) + for iter1065 in self.part_vals: + oprot.writeString(iter1065) oprot.writeListEnd() oprot.writeFieldEnd() if self.max_parts is not None: @@ -25130,10 +26102,10 @@ class get_partition_names_ps_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1055, _size1052) = iprot.readListBegin() - for _i1056 in xrange(_size1052): - _elem1057 = iprot.readString() - self.success.append(_elem1057) + (_etype1069, _size1066) = iprot.readListBegin() + for _i1070 in xrange(_size1066): + _elem1071 = iprot.readString() + self.success.append(_elem1071) iprot.readListEnd() else: iprot.skip(ftype) @@ -25162,8 +26134,8 @@ class get_partition_names_ps_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRING, len(self.success)) - for iter1058 in self.success: - oprot.writeString(iter1058) + for iter1072 in self.success: + oprot.writeString(iter1072) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25334,11 +26306,11 @@ class get_partitions_by_filter_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1062, _size1059) = iprot.readListBegin() - for _i1063 in xrange(_size1059): - _elem1064 = Partition() - _elem1064.read(iprot) - self.success.append(_elem1064) + (_etype1076, _size1073) = iprot.readListBegin() + for _i1077 in xrange(_size1073): + _elem1078 = Partition() + _elem1078.read(iprot) + self.success.append(_elem1078) iprot.readListEnd() else: iprot.skip(ftype) @@ -25367,8 +26339,8 @@ class get_partitions_by_filter_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1065 in self.success: - iter1065.write(oprot) + for iter1079 in self.success: + iter1079.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25539,11 +26511,11 @@ class get_part_specs_by_filter_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1069, _size1066) = iprot.readListBegin() - for _i1070 in xrange(_size1066): - _elem1071 = PartitionSpec() - _elem1071.read(iprot) - self.success.append(_elem1071) + (_etype1083, _size1080) = iprot.readListBegin() + for _i1084 in xrange(_size1080): + _elem1085 = PartitionSpec() + _elem1085.read(iprot) + self.success.append(_elem1085) iprot.readListEnd() else: iprot.skip(ftype) @@ -25572,8 +26544,8 @@ class get_part_specs_by_filter_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1072 in self.success: - iter1072.write(oprot) + for iter1086 in self.success: + iter1086.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -25993,10 +26965,10 @@ class get_partitions_by_names_args: elif fid == 3: if ftype == TType.LIST: self.names = [] - (_etype1076, _size1073) = iprot.readListBegin() - for _i1077 in xrange(_size1073): - _elem1078 = iprot.readString() - self.names.append(_elem1078) + (_etype1090, _size1087) = iprot.readListBegin() + for _i1091 in xrange(_size1087): + _elem1092 = iprot.readString() + self.names.append(_elem1092) iprot.readListEnd() else: iprot.skip(ftype) @@ -26021,8 +26993,8 @@ class get_partitions_by_names_args: if self.names is not None: oprot.writeFieldBegin('names', TType.LIST, 3) oprot.writeListBegin(TType.STRING, len(self.names)) - for iter1079 in self.names: - oprot.writeString(iter1079) + for iter1093 in self.names: + oprot.writeString(iter1093) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -26081,11 +27053,11 @@ class get_partitions_by_names_result: if fid == 0: if ftype == TType.LIST: self.success = [] - (_etype1083, _size1080) = iprot.readListBegin() - for _i1084 in xrange(_size1080): - _elem1085 = Partition() - _elem1085.read(iprot) - self.success.append(_elem1085) + (_etype1097, _size1094) = iprot.readListBegin() + for _i1098 in xrange(_size1094): + _elem1099 = Partition() + _elem1099.read(iprot) + self.success.append(_elem1099) iprot.readListEnd() else: iprot.skip(ftype) @@ -26114,8 +27086,8 @@ class get_partitions_by_names_result: if self.success is not None: oprot.writeFieldBegin('success', TType.LIST, 0) oprot.writeListBegin(TType.STRUCT, len(self.success)) - for iter1086 in self.success: - iter1086.write(oprot) + for iter1100 in self.success: + iter1100.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() if self.o1 is not None: @@ -26365,11 +27337,11 @@ class alter_partitions_args: elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1090, _size1087) = iprot.readListBegin() - for _i1091 in xrange(_size1087): - _elem1092 = Partition() - _elem1092.read(iprot) - self.new_parts.append(_elem1092) + (_etype1104, _size1101) = iprot.readListBegin() + for _i1105 in xrange(_size1101): + _elem1106 = Partition() + _elem1106.read(iprot) + self.new_parts.append(_elem1106) iprot.readListEnd() else: iprot.skip(ftype) @@ -26394,8 +27366,8 @@ class alter_partitions_args: if self.new_parts is not None: oprot.writeFieldBegin('new_parts', TType.LIST, 3) oprot.writeListBegin(TType.STRUCT, len(self.new_parts)) - for iter1093 in self.new_parts: - iter1093.write(oprot) + for iter1107 in self.new_parts: + iter1107.write(oprot) oprot.writeListEnd() oprot.writeFieldEnd() oprot.writeFieldStop() @@ -26548,11 +27520,11 @@ class alter_partitions_with_environment_context_args: elif fid == 3: if ftype == TType.LIST: self.new_parts = [] - (_etype1097, _size1094) = iprot.readListBegin() - for _i1098 in xrange(_size1094): - _elem1099 = Partition() - _elem1099.read(iprot) - self.new_parts.append(_elem1099) + (_
<TRUNCATED>