http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py index e5f3e6c..25b1f22 100644 --- a/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py +++ b/standalone-metastore/src/gen/thrift/gen-py/hive_metastore/ttypes.py @@ -211,6 +211,100 @@ class EventRequestType: "DELETE": 3, } +class SerdeType: + HIVE = 1 + SCHEMA_REGISTRY = 2 + + _VALUES_TO_NAMES = { + 1: "HIVE", + 2: "SCHEMA_REGISTRY", + } + + _NAMES_TO_VALUES = { + "HIVE": 1, + "SCHEMA_REGISTRY": 2, + } + +class SchemaType: + HIVE = 1 + AVRO = 2 + + _VALUES_TO_NAMES = { + 1: "HIVE", + 2: "AVRO", + } + + _NAMES_TO_VALUES = { + "HIVE": 1, + "AVRO": 2, + } + +class SchemaCompatibility: + NONE = 1 + BACKWARD = 2 + FORWARD = 3 + BOTH = 4 + + _VALUES_TO_NAMES = { + 1: "NONE", + 2: "BACKWARD", + 3: "FORWARD", + 4: "BOTH", + } + + _NAMES_TO_VALUES = { + "NONE": 1, + "BACKWARD": 2, + "FORWARD": 3, + "BOTH": 4, + } + +class SchemaValidation: + LATEST = 1 + ALL = 2 + + _VALUES_TO_NAMES = { + 1: "LATEST", + 2: "ALL", + } + + _NAMES_TO_VALUES = { + "LATEST": 1, + "ALL": 2, + } + +class SchemaVersionState: + INITIATED = 1 + START_REVIEW = 2 + CHANGES_REQUIRED = 3 + REVIEWED = 4 + ENABLED = 5 + DISABLED = 6 + ARCHIVED = 7 + DELETED = 8 + + _VALUES_TO_NAMES = { + 1: "INITIATED", + 2: "START_REVIEW", + 3: "CHANGES_REQUIRED", + 4: "REVIEWED", + 5: "ENABLED", + 6: "DISABLED", + 7: "ARCHIVED", + 8: "DELETED", + } + + _NAMES_TO_VALUES = { + "INITIATED": 1, + "START_REVIEW": 2, + "CHANGES_REQUIRED": 3, + "REVIEWED": 4, + "ENABLED": 5, + "DISABLED": 6, + "ARCHIVED": 7, + "DELETED": 8, + } + class FunctionType: JAVA = 1 @@ -2897,6 +2991,10 @@ class SerDeInfo: - name - serializationLib - parameters + - description + - serializerClass + - deserializerClass + - serdeType """ thrift_spec = ( @@ -2904,12 +3002,20 @@ class SerDeInfo: (1, TType.STRING, 'name', None, None, ), # 1 (2, TType.STRING, 'serializationLib', None, None, ), # 2 (3, TType.MAP, 'parameters', (TType.STRING,None,TType.STRING,None), None, ), # 3 + (4, TType.STRING, 'description', None, None, ), # 4 + (5, TType.STRING, 'serializerClass', None, None, ), # 5 + (6, TType.STRING, 'deserializerClass', None, None, ), # 6 + (7, TType.I32, 'serdeType', None, None, ), # 7 ) - def __init__(self, name=None, serializationLib=None, parameters=None,): + def __init__(self, name=None, serializationLib=None, parameters=None, description=None, serializerClass=None, deserializerClass=None, serdeType=None,): self.name = name self.serializationLib = serializationLib self.parameters = parameters + self.description = description + self.serializerClass = serializerClass + self.deserializerClass = deserializerClass + self.serdeType = serdeType def read(self, iprot): if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: @@ -2941,6 +3047,26 @@ class SerDeInfo: iprot.readMapEnd() else: iprot.skip(ftype) + elif fid == 4: + if ftype == TType.STRING: + self.description = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 5: + if ftype == TType.STRING: + self.serializerClass = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 6: + if ftype == TType.STRING: + self.deserializerClass = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 7: + if ftype == TType.I32: + self.serdeType = iprot.readI32() + else: + iprot.skip(ftype) else: iprot.skip(ftype) iprot.readFieldEnd() @@ -2967,6 +3093,22 @@ class SerDeInfo: oprot.writeString(viter100) oprot.writeMapEnd() oprot.writeFieldEnd() + if self.description is not None: + oprot.writeFieldBegin('description', TType.STRING, 4) + oprot.writeString(self.description) + oprot.writeFieldEnd() + if self.serializerClass is not None: + oprot.writeFieldBegin('serializerClass', TType.STRING, 5) + oprot.writeString(self.serializerClass) + oprot.writeFieldEnd() + if self.deserializerClass is not None: + oprot.writeFieldBegin('deserializerClass', TType.STRING, 6) + oprot.writeString(self.deserializerClass) + oprot.writeFieldEnd() + if self.serdeType is not None: + oprot.writeFieldBegin('serdeType', TType.I32, 7) + oprot.writeI32(self.serdeType) + oprot.writeFieldEnd() oprot.writeFieldStop() oprot.writeStructEnd() @@ -2979,6 +3121,10 @@ class SerDeInfo: value = (value * 31) ^ hash(self.name) value = (value * 31) ^ hash(self.serializationLib) value = (value * 31) ^ hash(self.parameters) + value = (value * 31) ^ hash(self.description) + value = (value * 31) ^ hash(self.serializerClass) + value = (value * 31) ^ hash(self.deserializerClass) + value = (value * 31) ^ hash(self.serdeType) return value def __repr__(self): @@ -17668,6 +17814,597 @@ class WMCreateOrDropTriggerToPoolMappingResponse: def __ne__(self, other): return not (self == other) +class ISchema: + """ + Attributes: + - schemaType + - name + - dbName + - compatibility + - validationLevel + - canEvolve + - schemaGroup + - description + """ + + thrift_spec = ( + None, # 0 + (1, TType.I32, 'schemaType', None, None, ), # 1 + (2, TType.STRING, 'name', None, None, ), # 2 + (3, TType.STRING, 'dbName', None, None, ), # 3 + (4, TType.I32, 'compatibility', None, None, ), # 4 + (5, TType.I32, 'validationLevel', None, None, ), # 5 + (6, TType.BOOL, 'canEvolve', None, None, ), # 6 + (7, TType.STRING, 'schemaGroup', None, None, ), # 7 + (8, TType.STRING, 'description', None, None, ), # 8 + ) + + def __init__(self, schemaType=None, name=None, dbName=None, compatibility=None, validationLevel=None, canEvolve=None, schemaGroup=None, description=None,): + self.schemaType = schemaType + self.name = name + self.dbName = dbName + self.compatibility = compatibility + self.validationLevel = validationLevel + self.canEvolve = canEvolve + self.schemaGroup = schemaGroup + self.description = description + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.I32: + self.schemaType = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.dbName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.I32: + self.compatibility = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 5: + if ftype == TType.I32: + self.validationLevel = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 6: + if ftype == TType.BOOL: + self.canEvolve = iprot.readBool() + else: + iprot.skip(ftype) + elif fid == 7: + if ftype == TType.STRING: + self.schemaGroup = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 8: + if ftype == TType.STRING: + self.description = iprot.readString() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('ISchema') + if self.schemaType is not None: + oprot.writeFieldBegin('schemaType', TType.I32, 1) + oprot.writeI32(self.schemaType) + oprot.writeFieldEnd() + if self.name is not None: + oprot.writeFieldBegin('name', TType.STRING, 2) + oprot.writeString(self.name) + oprot.writeFieldEnd() + if self.dbName is not None: + oprot.writeFieldBegin('dbName', TType.STRING, 3) + oprot.writeString(self.dbName) + oprot.writeFieldEnd() + if self.compatibility is not None: + oprot.writeFieldBegin('compatibility', TType.I32, 4) + oprot.writeI32(self.compatibility) + oprot.writeFieldEnd() + if self.validationLevel is not None: + oprot.writeFieldBegin('validationLevel', TType.I32, 5) + oprot.writeI32(self.validationLevel) + oprot.writeFieldEnd() + if self.canEvolve is not None: + oprot.writeFieldBegin('canEvolve', TType.BOOL, 6) + oprot.writeBool(self.canEvolve) + oprot.writeFieldEnd() + if self.schemaGroup is not None: + oprot.writeFieldBegin('schemaGroup', TType.STRING, 7) + oprot.writeString(self.schemaGroup) + oprot.writeFieldEnd() + if self.description is not None: + oprot.writeFieldBegin('description', TType.STRING, 8) + oprot.writeString(self.description) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.schemaType) + value = (value * 31) ^ hash(self.name) + value = (value * 31) ^ hash(self.dbName) + value = (value * 31) ^ hash(self.compatibility) + value = (value * 31) ^ hash(self.validationLevel) + value = (value * 31) ^ hash(self.canEvolve) + value = (value * 31) ^ hash(self.schemaGroup) + value = (value * 31) ^ hash(self.description) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class SchemaVersion: + """ + Attributes: + - schemaName + - version + - createdAt + - cols + - state + - description + - schemaText + - fingerprint + - name + - serDe + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'schemaName', None, None, ), # 1 + (2, TType.I32, 'version', None, None, ), # 2 + (3, TType.I64, 'createdAt', None, None, ), # 3 + (4, TType.LIST, 'cols', (TType.STRUCT,(FieldSchema, FieldSchema.thrift_spec)), None, ), # 4 + (5, TType.I32, 'state', None, None, ), # 5 + (6, TType.STRING, 'description', None, None, ), # 6 + (7, TType.STRING, 'schemaText', None, None, ), # 7 + (8, TType.STRING, 'fingerprint', None, None, ), # 8 + (9, TType.STRING, 'name', None, None, ), # 9 + (10, TType.STRUCT, 'serDe', (SerDeInfo, SerDeInfo.thrift_spec), None, ), # 10 + ) + + def __init__(self, schemaName=None, version=None, createdAt=None, cols=None, state=None, description=None, schemaText=None, fingerprint=None, name=None, serDe=None,): + self.schemaName = schemaName + self.version = version + self.createdAt = createdAt + self.cols = cols + self.state = state + self.description = description + self.schemaText = schemaText + self.fingerprint = fingerprint + self.name = name + self.serDe = serDe + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRING: + self.schemaName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I32: + self.version = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.I64: + self.createdAt = iprot.readI64() + else: + iprot.skip(ftype) + elif fid == 4: + if ftype == TType.LIST: + self.cols = [] + (_etype725, _size722) = iprot.readListBegin() + for _i726 in xrange(_size722): + _elem727 = FieldSchema() + _elem727.read(iprot) + self.cols.append(_elem727) + iprot.readListEnd() + else: + iprot.skip(ftype) + elif fid == 5: + if ftype == TType.I32: + self.state = iprot.readI32() + else: + iprot.skip(ftype) + elif fid == 6: + if ftype == TType.STRING: + self.description = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 7: + if ftype == TType.STRING: + self.schemaText = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 8: + if ftype == TType.STRING: + self.fingerprint = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 9: + if ftype == TType.STRING: + self.name = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 10: + if ftype == TType.STRUCT: + self.serDe = SerDeInfo() + self.serDe.read(iprot) + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('SchemaVersion') + if self.schemaName is not None: + oprot.writeFieldBegin('schemaName', TType.STRING, 1) + oprot.writeString(self.schemaName) + oprot.writeFieldEnd() + if self.version is not None: + oprot.writeFieldBegin('version', TType.I32, 2) + oprot.writeI32(self.version) + oprot.writeFieldEnd() + if self.createdAt is not None: + oprot.writeFieldBegin('createdAt', TType.I64, 3) + oprot.writeI64(self.createdAt) + oprot.writeFieldEnd() + if self.cols is not None: + oprot.writeFieldBegin('cols', TType.LIST, 4) + oprot.writeListBegin(TType.STRUCT, len(self.cols)) + for iter728 in self.cols: + iter728.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + if self.state is not None: + oprot.writeFieldBegin('state', TType.I32, 5) + oprot.writeI32(self.state) + oprot.writeFieldEnd() + if self.description is not None: + oprot.writeFieldBegin('description', TType.STRING, 6) + oprot.writeString(self.description) + oprot.writeFieldEnd() + if self.schemaText is not None: + oprot.writeFieldBegin('schemaText', TType.STRING, 7) + oprot.writeString(self.schemaText) + oprot.writeFieldEnd() + if self.fingerprint is not None: + oprot.writeFieldBegin('fingerprint', TType.STRING, 8) + oprot.writeString(self.fingerprint) + oprot.writeFieldEnd() + if self.name is not None: + oprot.writeFieldBegin('name', TType.STRING, 9) + oprot.writeString(self.name) + oprot.writeFieldEnd() + if self.serDe is not None: + oprot.writeFieldBegin('serDe', TType.STRUCT, 10) + self.serDe.write(oprot) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.schemaName) + value = (value * 31) ^ hash(self.version) + value = (value * 31) ^ hash(self.createdAt) + value = (value * 31) ^ hash(self.cols) + value = (value * 31) ^ hash(self.state) + value = (value * 31) ^ hash(self.description) + value = (value * 31) ^ hash(self.schemaText) + value = (value * 31) ^ hash(self.fingerprint) + value = (value * 31) ^ hash(self.name) + value = (value * 31) ^ hash(self.serDe) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class FindSchemasByColsRqst: + """ + Attributes: + - colName + - colNamespace + - type + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'colName', None, None, ), # 1 + (2, TType.STRING, 'colNamespace', None, None, ), # 2 + (3, TType.STRING, 'type', None, None, ), # 3 + ) + + def __init__(self, colName=None, colNamespace=None, type=None,): + self.colName = colName + self.colNamespace = colNamespace + self.type = type + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRING: + self.colName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.STRING: + self.colNamespace = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 3: + if ftype == TType.STRING: + self.type = iprot.readString() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('FindSchemasByColsRqst') + if self.colName is not None: + oprot.writeFieldBegin('colName', TType.STRING, 1) + oprot.writeString(self.colName) + oprot.writeFieldEnd() + if self.colNamespace is not None: + oprot.writeFieldBegin('colNamespace', TType.STRING, 2) + oprot.writeString(self.colNamespace) + oprot.writeFieldEnd() + if self.type is not None: + oprot.writeFieldBegin('type', TType.STRING, 3) + oprot.writeString(self.type) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.colName) + value = (value * 31) ^ hash(self.colNamespace) + value = (value * 31) ^ hash(self.type) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class FindSchemasByColsRespEntry: + """ + Attributes: + - schemaName + - version + """ + + thrift_spec = ( + None, # 0 + (1, TType.STRING, 'schemaName', None, None, ), # 1 + (2, TType.I32, 'version', None, None, ), # 2 + ) + + def __init__(self, schemaName=None, version=None,): + self.schemaName = schemaName + self.version = version + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.STRING: + self.schemaName = iprot.readString() + else: + iprot.skip(ftype) + elif fid == 2: + if ftype == TType.I32: + self.version = iprot.readI32() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('FindSchemasByColsRespEntry') + if self.schemaName is not None: + oprot.writeFieldBegin('schemaName', TType.STRING, 1) + oprot.writeString(self.schemaName) + oprot.writeFieldEnd() + if self.version is not None: + oprot.writeFieldBegin('version', TType.I32, 2) + oprot.writeI32(self.version) + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.schemaName) + value = (value * 31) ^ hash(self.version) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + +class FindSchemasByColsResp: + """ + Attributes: + - schemaVersions + """ + + thrift_spec = ( + None, # 0 + (1, TType.LIST, 'schemaVersions', (TType.STRUCT,(FindSchemasByColsRespEntry, FindSchemasByColsRespEntry.thrift_spec)), None, ), # 1 + ) + + def __init__(self, schemaVersions=None,): + self.schemaVersions = schemaVersions + + def read(self, iprot): + if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None: + fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec)) + return + iprot.readStructBegin() + while True: + (fname, ftype, fid) = iprot.readFieldBegin() + if ftype == TType.STOP: + break + if fid == 1: + if ftype == TType.LIST: + self.schemaVersions = [] + (_etype732, _size729) = iprot.readListBegin() + for _i733 in xrange(_size729): + _elem734 = FindSchemasByColsRespEntry() + _elem734.read(iprot) + self.schemaVersions.append(_elem734) + iprot.readListEnd() + else: + iprot.skip(ftype) + else: + iprot.skip(ftype) + iprot.readFieldEnd() + iprot.readStructEnd() + + def write(self, oprot): + if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None: + oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec))) + return + oprot.writeStructBegin('FindSchemasByColsResp') + if self.schemaVersions is not None: + oprot.writeFieldBegin('schemaVersions', TType.LIST, 1) + oprot.writeListBegin(TType.STRUCT, len(self.schemaVersions)) + for iter735 in self.schemaVersions: + iter735.write(oprot) + oprot.writeListEnd() + oprot.writeFieldEnd() + oprot.writeFieldStop() + oprot.writeStructEnd() + + def validate(self): + return + + + def __hash__(self): + value = 17 + value = (value * 31) ^ hash(self.schemaVersions) + return value + + def __repr__(self): + L = ['%s=%r' % (key, value) + for key, value in self.__dict__.iteritems()] + return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) + + def __eq__(self, other): + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __ne__(self, other): + return not (self == other) + class MetaException(TException): """ Attributes:
http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb b/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb index afcec9e..db80271 100644 --- a/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb +++ b/standalone-metastore/src/gen/thrift/gen-rb/hive_metastore_types.rb @@ -98,6 +98,49 @@ module EventRequestType VALID_VALUES = Set.new([INSERT, UPDATE, DELETE]).freeze end +module SerdeType + HIVE = 1 + SCHEMA_REGISTRY = 2 + VALUE_MAP = {1 => "HIVE", 2 => "SCHEMA_REGISTRY"} + VALID_VALUES = Set.new([HIVE, SCHEMA_REGISTRY]).freeze +end + +module SchemaType + HIVE = 1 + AVRO = 2 + VALUE_MAP = {1 => "HIVE", 2 => "AVRO"} + VALID_VALUES = Set.new([HIVE, AVRO]).freeze +end + +module SchemaCompatibility + NONE = 1 + BACKWARD = 2 + FORWARD = 3 + BOTH = 4 + VALUE_MAP = {1 => "NONE", 2 => "BACKWARD", 3 => "FORWARD", 4 => "BOTH"} + VALID_VALUES = Set.new([NONE, BACKWARD, FORWARD, BOTH]).freeze +end + +module SchemaValidation + LATEST = 1 + ALL = 2 + VALUE_MAP = {1 => "LATEST", 2 => "ALL"} + VALID_VALUES = Set.new([LATEST, ALL]).freeze +end + +module SchemaVersionState + INITIATED = 1 + START_REVIEW = 2 + CHANGES_REQUIRED = 3 + REVIEWED = 4 + ENABLED = 5 + DISABLED = 6 + ARCHIVED = 7 + DELETED = 8 + VALUE_MAP = {1 => "INITIATED", 2 => "START_REVIEW", 3 => "CHANGES_REQUIRED", 4 => "REVIEWED", 5 => "ENABLED", 6 => "DISABLED", 7 => "ARCHIVED", 8 => "DELETED"} + VALID_VALUES = Set.new([INITIATED, START_REVIEW, CHANGES_REQUIRED, REVIEWED, ENABLED, DISABLED, ARCHIVED, DELETED]).freeze +end + module FunctionType JAVA = 1 VALUE_MAP = {1 => "JAVA"} @@ -701,16 +744,27 @@ class SerDeInfo NAME = 1 SERIALIZATIONLIB = 2 PARAMETERS = 3 + DESCRIPTION = 4 + SERIALIZERCLASS = 5 + DESERIALIZERCLASS = 6 + SERDETYPE = 7 FIELDS = { NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}, SERIALIZATIONLIB => {:type => ::Thrift::Types::STRING, :name => 'serializationLib'}, - PARAMETERS => {:type => ::Thrift::Types::MAP, :name => 'parameters', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}} + PARAMETERS => {:type => ::Thrift::Types::MAP, :name => 'parameters', :key => {:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}}, + DESCRIPTION => {:type => ::Thrift::Types::STRING, :name => 'description', :optional => true}, + SERIALIZERCLASS => {:type => ::Thrift::Types::STRING, :name => 'serializerClass', :optional => true}, + DESERIALIZERCLASS => {:type => ::Thrift::Types::STRING, :name => 'deserializerClass', :optional => true}, + SERDETYPE => {:type => ::Thrift::Types::I32, :name => 'serdeType', :optional => true, :enum_class => ::SerdeType} } def struct_fields; FIELDS; end def validate + unless @serdeType.nil? || ::SerdeType::VALID_VALUES.include?(@serdeType) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field serdeType!') + end end ::Thrift::Struct.generate_accessors self @@ -4040,6 +4094,136 @@ class WMCreateOrDropTriggerToPoolMappingResponse ::Thrift::Struct.generate_accessors self end +class ISchema + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMATYPE = 1 + NAME = 2 + DBNAME = 3 + COMPATIBILITY = 4 + VALIDATIONLEVEL = 5 + CANEVOLVE = 6 + SCHEMAGROUP = 7 + DESCRIPTION = 8 + + FIELDS = { + SCHEMATYPE => {:type => ::Thrift::Types::I32, :name => 'schemaType', :enum_class => ::SchemaType}, + NAME => {:type => ::Thrift::Types::STRING, :name => 'name'}, + DBNAME => {:type => ::Thrift::Types::STRING, :name => 'dbName'}, + COMPATIBILITY => {:type => ::Thrift::Types::I32, :name => 'compatibility', :enum_class => ::SchemaCompatibility}, + VALIDATIONLEVEL => {:type => ::Thrift::Types::I32, :name => 'validationLevel', :enum_class => ::SchemaValidation}, + CANEVOLVE => {:type => ::Thrift::Types::BOOL, :name => 'canEvolve'}, + SCHEMAGROUP => {:type => ::Thrift::Types::STRING, :name => 'schemaGroup', :optional => true}, + DESCRIPTION => {:type => ::Thrift::Types::STRING, :name => 'description', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + unless @schemaType.nil? || ::SchemaType::VALID_VALUES.include?(@schemaType) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field schemaType!') + end + unless @compatibility.nil? || ::SchemaCompatibility::VALID_VALUES.include?(@compatibility) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field compatibility!') + end + unless @validationLevel.nil? || ::SchemaValidation::VALID_VALUES.include?(@validationLevel) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field validationLevel!') + end + end + + ::Thrift::Struct.generate_accessors self +end + +class SchemaVersion + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + VERSION = 2 + CREATEDAT = 3 + COLS = 4 + STATE = 5 + DESCRIPTION = 6 + SCHEMATEXT = 7 + FINGERPRINT = 8 + NAME = 9 + SERDE = 10 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + VERSION => {:type => ::Thrift::Types::I32, :name => 'version'}, + CREATEDAT => {:type => ::Thrift::Types::I64, :name => 'createdAt'}, + COLS => {:type => ::Thrift::Types::LIST, :name => 'cols', :element => {:type => ::Thrift::Types::STRUCT, :class => ::FieldSchema}}, + STATE => {:type => ::Thrift::Types::I32, :name => 'state', :optional => true, :enum_class => ::SchemaVersionState}, + DESCRIPTION => {:type => ::Thrift::Types::STRING, :name => 'description', :optional => true}, + SCHEMATEXT => {:type => ::Thrift::Types::STRING, :name => 'schemaText', :optional => true}, + FINGERPRINT => {:type => ::Thrift::Types::STRING, :name => 'fingerprint', :optional => true}, + NAME => {:type => ::Thrift::Types::STRING, :name => 'name', :optional => true}, + SERDE => {:type => ::Thrift::Types::STRUCT, :name => 'serDe', :class => ::SerDeInfo, :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + unless @state.nil? || ::SchemaVersionState::VALID_VALUES.include?(@state) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field state!') + end + end + + ::Thrift::Struct.generate_accessors self +end + +class FindSchemasByColsRqst + include ::Thrift::Struct, ::Thrift::Struct_Union + COLNAME = 1 + COLNAMESPACE = 2 + TYPE = 3 + + FIELDS = { + COLNAME => {:type => ::Thrift::Types::STRING, :name => 'colName', :optional => true}, + COLNAMESPACE => {:type => ::Thrift::Types::STRING, :name => 'colNamespace', :optional => true}, + TYPE => {:type => ::Thrift::Types::STRING, :name => 'type', :optional => true} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class FindSchemasByColsRespEntry + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + VERSION = 2 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + VERSION => {:type => ::Thrift::Types::I32, :name => 'version'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + +class FindSchemasByColsResp + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMAVERSIONS = 1 + + FIELDS = { + SCHEMAVERSIONS => {:type => ::Thrift::Types::LIST, :name => 'schemaVersions', :element => {:type => ::Thrift::Types::STRUCT, :class => ::FindSchemasByColsRespEntry}} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self +end + class MetaException < ::Thrift::Exception include ::Thrift::Struct, ::Thrift::Struct_Union def initialize(message=nil) http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb b/standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb index a788c08..16e8e4c 100644 --- a/standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb +++ b/standalone-metastore/src/gen/thrift/gen-rb/thrift_hive_metastore.rb @@ -3061,6 +3061,239 @@ module ThriftHiveMetastore raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'create_or_drop_wm_trigger_to_pool_mapping failed: unknown result') end + def create_ischema(schema) + send_create_ischema(schema) + recv_create_ischema() + end + + def send_create_ischema(schema) + send_message('create_ischema', Create_ischema_args, :schema => schema) + end + + def recv_create_ischema() + result = receive_message(Create_ischema_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + return + end + + def alter_ischema(schemaName, newSchema) + send_alter_ischema(schemaName, newSchema) + recv_alter_ischema() + end + + def send_alter_ischema(schemaName, newSchema) + send_message('alter_ischema', Alter_ischema_args, :schemaName => schemaName, :newSchema => newSchema) + end + + def recv_alter_ischema() + result = receive_message(Alter_ischema_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + return + end + + def get_ischema(schemaName) + send_get_ischema(schemaName) + return recv_get_ischema() + end + + def send_get_ischema(schemaName) + send_message('get_ischema', Get_ischema_args, :schemaName => schemaName) + end + + def recv_get_ischema() + result = receive_message(Get_ischema_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_ischema failed: unknown result') + end + + def drop_ischema(schemaName) + send_drop_ischema(schemaName) + recv_drop_ischema() + end + + def send_drop_ischema(schemaName) + send_message('drop_ischema', Drop_ischema_args, :schemaName => schemaName) + end + + def recv_drop_ischema() + result = receive_message(Drop_ischema_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + return + end + + def add_schema_version(schemaVersion) + send_add_schema_version(schemaVersion) + recv_add_schema_version() + end + + def send_add_schema_version(schemaVersion) + send_message('add_schema_version', Add_schema_version_args, :schemaVersion => schemaVersion) + end + + def recv_add_schema_version() + result = receive_message(Add_schema_version_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + return + end + + def get_schema_version(schemaName, version) + send_get_schema_version(schemaName, version) + return recv_get_schema_version() + end + + def send_get_schema_version(schemaName, version) + send_message('get_schema_version', Get_schema_version_args, :schemaName => schemaName, :version => version) + end + + def recv_get_schema_version() + result = receive_message(Get_schema_version_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_schema_version failed: unknown result') + end + + def get_schema_latest_version(schemaName) + send_get_schema_latest_version(schemaName) + return recv_get_schema_latest_version() + end + + def send_get_schema_latest_version(schemaName) + send_message('get_schema_latest_version', Get_schema_latest_version_args, :schemaName => schemaName) + end + + def recv_get_schema_latest_version() + result = receive_message(Get_schema_latest_version_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_schema_latest_version failed: unknown result') + end + + def get_schema_all_versions(schemaName) + send_get_schema_all_versions(schemaName) + return recv_get_schema_all_versions() + end + + def send_get_schema_all_versions(schemaName) + send_message('get_schema_all_versions', Get_schema_all_versions_args, :schemaName => schemaName) + end + + def recv_get_schema_all_versions() + result = receive_message(Get_schema_all_versions_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_schema_all_versions failed: unknown result') + end + + def drop_schema_version(schemaName, version) + send_drop_schema_version(schemaName, version) + recv_drop_schema_version() + end + + def send_drop_schema_version(schemaName, version) + send_message('drop_schema_version', Drop_schema_version_args, :schemaName => schemaName, :version => version) + end + + def recv_drop_schema_version() + result = receive_message(Drop_schema_version_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + return + end + + def get_schemas_by_cols(rqst) + send_get_schemas_by_cols(rqst) + return recv_get_schemas_by_cols() + end + + def send_get_schemas_by_cols(rqst) + send_message('get_schemas_by_cols', Get_schemas_by_cols_args, :rqst => rqst) + end + + def recv_get_schemas_by_cols() + result = receive_message(Get_schemas_by_cols_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_schemas_by_cols failed: unknown result') + end + + def map_schema_version_to_serde(schemaName, version, serdeName) + send_map_schema_version_to_serde(schemaName, version, serdeName) + recv_map_schema_version_to_serde() + end + + def send_map_schema_version_to_serde(schemaName, version, serdeName) + send_message('map_schema_version_to_serde', Map_schema_version_to_serde_args, :schemaName => schemaName, :version => version, :serdeName => serdeName) + end + + def recv_map_schema_version_to_serde() + result = receive_message(Map_schema_version_to_serde_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + return + end + + def set_schema_version_state(schemaName, version, state) + send_set_schema_version_state(schemaName, version, state) + recv_set_schema_version_state() + end + + def send_set_schema_version_state(schemaName, version, state) + send_message('set_schema_version_state', Set_schema_version_state_args, :schemaName => schemaName, :version => version, :state => state) + end + + def recv_set_schema_version_state() + result = receive_message(Set_schema_version_state_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise result.o3 unless result.o3.nil? + return + end + + def add_serde(serde) + send_add_serde(serde) + recv_add_serde() + end + + def send_add_serde(serde) + send_message('add_serde', Add_serde_args, :serde => serde) + end + + def recv_add_serde() + result = receive_message(Add_serde_result) + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + return + end + + def get_serde(serdeName) + send_get_serde(serdeName) + return recv_get_serde() + end + + def send_get_serde(serdeName) + send_message('get_serde', Get_serde_args, :serdeName => serdeName) + end + + def recv_get_serde() + result = receive_message(Get_serde_result) + return result.success unless result.success.nil? + raise result.o1 unless result.o1.nil? + raise result.o2 unless result.o2.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'get_serde failed: unknown result') + end + end class Processor < ::FacebookService::Processor @@ -5343,6 +5576,194 @@ module ThriftHiveMetastore write_result(result, oprot, 'create_or_drop_wm_trigger_to_pool_mapping', seqid) end + def process_create_ischema(seqid, iprot, oprot) + args = read_args(iprot, Create_ischema_args) + result = Create_ischema_result.new() + begin + @handler.create_ischema(args.schema) + rescue ::AlreadyExistsException => o1 + result.o1 = o1 + rescue ::NoSuchObjectException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'create_ischema', seqid) + end + + def process_alter_ischema(seqid, iprot, oprot) + args = read_args(iprot, Alter_ischema_args) + result = Alter_ischema_result.new() + begin + @handler.alter_ischema(args.schemaName, args.newSchema) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'alter_ischema', seqid) + end + + def process_get_ischema(seqid, iprot, oprot) + args = read_args(iprot, Get_ischema_args) + result = Get_ischema_result.new() + begin + result.success = @handler.get_ischema(args.schemaName) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'get_ischema', seqid) + end + + def process_drop_ischema(seqid, iprot, oprot) + args = read_args(iprot, Drop_ischema_args) + result = Drop_ischema_result.new() + begin + @handler.drop_ischema(args.schemaName) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::InvalidOperationException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'drop_ischema', seqid) + end + + def process_add_schema_version(seqid, iprot, oprot) + args = read_args(iprot, Add_schema_version_args) + result = Add_schema_version_result.new() + begin + @handler.add_schema_version(args.schemaVersion) + rescue ::AlreadyExistsException => o1 + result.o1 = o1 + rescue ::NoSuchObjectException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'add_schema_version', seqid) + end + + def process_get_schema_version(seqid, iprot, oprot) + args = read_args(iprot, Get_schema_version_args) + result = Get_schema_version_result.new() + begin + result.success = @handler.get_schema_version(args.schemaName, args.version) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'get_schema_version', seqid) + end + + def process_get_schema_latest_version(seqid, iprot, oprot) + args = read_args(iprot, Get_schema_latest_version_args) + result = Get_schema_latest_version_result.new() + begin + result.success = @handler.get_schema_latest_version(args.schemaName) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'get_schema_latest_version', seqid) + end + + def process_get_schema_all_versions(seqid, iprot, oprot) + args = read_args(iprot, Get_schema_all_versions_args) + result = Get_schema_all_versions_result.new() + begin + result.success = @handler.get_schema_all_versions(args.schemaName) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'get_schema_all_versions', seqid) + end + + def process_drop_schema_version(seqid, iprot, oprot) + args = read_args(iprot, Drop_schema_version_args) + result = Drop_schema_version_result.new() + begin + @handler.drop_schema_version(args.schemaName, args.version) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'drop_schema_version', seqid) + end + + def process_get_schemas_by_cols(seqid, iprot, oprot) + args = read_args(iprot, Get_schemas_by_cols_args) + result = Get_schemas_by_cols_result.new() + begin + result.success = @handler.get_schemas_by_cols(args.rqst) + rescue ::MetaException => o1 + result.o1 = o1 + end + write_result(result, oprot, 'get_schemas_by_cols', seqid) + end + + def process_map_schema_version_to_serde(seqid, iprot, oprot) + args = read_args(iprot, Map_schema_version_to_serde_args) + result = Map_schema_version_to_serde_result.new() + begin + @handler.map_schema_version_to_serde(args.schemaName, args.version, args.serdeName) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'map_schema_version_to_serde', seqid) + end + + def process_set_schema_version_state(seqid, iprot, oprot) + args = read_args(iprot, Set_schema_version_state_args) + result = Set_schema_version_state_result.new() + begin + @handler.set_schema_version_state(args.schemaName, args.version, args.state) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::InvalidOperationException => o2 + result.o2 = o2 + rescue ::MetaException => o3 + result.o3 = o3 + end + write_result(result, oprot, 'set_schema_version_state', seqid) + end + + def process_add_serde(seqid, iprot, oprot) + args = read_args(iprot, Add_serde_args) + result = Add_serde_result.new() + begin + @handler.add_serde(args.serde) + rescue ::AlreadyExistsException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'add_serde', seqid) + end + + def process_get_serde(seqid, iprot, oprot) + args = read_args(iprot, Get_serde_args) + result = Get_serde_result.new() + begin + result.success = @handler.get_serde(args.serdeName) + rescue ::NoSuchObjectException => o1 + result.o1 = o1 + rescue ::MetaException => o2 + result.o2 = o2 + end + write_result(result, oprot, 'get_serde', seqid) + end + end # HELPER FUNCTIONS AND STRUCTURES @@ -12186,5 +12607,516 @@ module ThriftHiveMetastore ::Thrift::Struct.generate_accessors self end + class Create_ischema_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMA = 1 + + FIELDS = { + SCHEMA => {:type => ::Thrift::Types::STRUCT, :name => 'schema', :class => ::ISchema} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Create_ischema_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = -1 + O3 = 3 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::AlreadyExistsException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::NoSuchObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Alter_ischema_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + NEWSCHEMA = 2 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + NEWSCHEMA => {:type => ::Thrift::Types::STRUCT, :name => 'newSchema', :class => ::ISchema} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Alter_ischema_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_ischema_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_ischema_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::ISchema}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_ischema_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_ischema_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::InvalidOperationException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Add_schema_version_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMAVERSION = 1 + + FIELDS = { + SCHEMAVERSION => {:type => ::Thrift::Types::STRUCT, :name => 'schemaVersion', :class => ::SchemaVersion} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Add_schema_version_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::AlreadyExistsException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::NoSuchObjectException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schema_version_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + VERSION = 2 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + VERSION => {:type => ::Thrift::Types::I32, :name => 'version'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schema_version_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::SchemaVersion}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schema_latest_version_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schema_latest_version_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::SchemaVersion}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schema_all_versions_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schema_all_versions_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRUCT, :class => ::SchemaVersion}}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_schema_version_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + VERSION = 2 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + VERSION => {:type => ::Thrift::Types::I32, :name => 'version'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Drop_schema_version_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schemas_by_cols_args + include ::Thrift::Struct, ::Thrift::Struct_Union + RQST = 1 + + FIELDS = { + RQST => {:type => ::Thrift::Types::STRUCT, :name => 'rqst', :class => ::FindSchemasByColsRqst} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_schemas_by_cols_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::FindSchemasByColsResp}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Map_schema_version_to_serde_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + VERSION = 2 + SERDENAME = 3 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + VERSION => {:type => ::Thrift::Types::I32, :name => 'version'}, + SERDENAME => {:type => ::Thrift::Types::STRING, :name => 'serdeName'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Map_schema_version_to_serde_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Set_schema_version_state_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SCHEMANAME = 1 + VERSION = 2 + STATE = 3 + + FIELDS = { + SCHEMANAME => {:type => ::Thrift::Types::STRING, :name => 'schemaName'}, + VERSION => {:type => ::Thrift::Types::I32, :name => 'version'}, + STATE => {:type => ::Thrift::Types::I32, :name => 'state', :enum_class => ::SchemaVersionState} + } + + def struct_fields; FIELDS; end + + def validate + unless @state.nil? || ::SchemaVersionState::VALID_VALUES.include?(@state) + raise ::Thrift::ProtocolException.new(::Thrift::ProtocolException::UNKNOWN, 'Invalid value of field state!') + end + end + + ::Thrift::Struct.generate_accessors self + end + + class Set_schema_version_state_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + O3 = 3 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::InvalidOperationException}, + O3 => {:type => ::Thrift::Types::STRUCT, :name => 'o3', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Add_serde_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SERDE = 1 + + FIELDS = { + SERDE => {:type => ::Thrift::Types::STRUCT, :name => 'serde', :class => ::SerDeInfo} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Add_serde_result + include ::Thrift::Struct, ::Thrift::Struct_Union + O1 = 1 + O2 = 2 + + FIELDS = { + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::AlreadyExistsException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_serde_args + include ::Thrift::Struct, ::Thrift::Struct_Union + SERDENAME = 1 + + FIELDS = { + SERDENAME => {:type => ::Thrift::Types::STRING, :name => 'serdeName'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class Get_serde_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + O1 = 1 + O2 = 2 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRUCT, :name => 'success', :class => ::SerDeInfo}, + O1 => {:type => ::Thrift::Types::STRUCT, :name => 'o1', :class => ::NoSuchObjectException}, + O2 => {:type => ::Thrift::Types::STRUCT, :name => 'o2', :class => ::MetaException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + end http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java index a6bae3b..1f511a6 100644 --- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java +++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java @@ -53,6 +53,7 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; +import java.util.function.Consumer; import java.util.regex.Pattern; import javax.jdo.JDOException; @@ -80,38 +81,52 @@ import org.apache.hadoop.hive.metastore.events.AddPartitionEvent; import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent; import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent; import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent; +import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent; import org.apache.hadoop.hive.metastore.events.AlterIndexEvent; import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent; +import org.apache.hadoop.hive.metastore.events.AlterSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.AlterTableEvent; import org.apache.hadoop.hive.metastore.events.ConfigChangeEvent; import org.apache.hadoop.hive.metastore.events.CreateDatabaseEvent; import org.apache.hadoop.hive.metastore.events.CreateFunctionEvent; +import org.apache.hadoop.hive.metastore.events.CreateISchemaEvent; +import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.CreateTableEvent; import org.apache.hadoop.hive.metastore.events.DropConstraintEvent; import org.apache.hadoop.hive.metastore.events.DropDatabaseEvent; import org.apache.hadoop.hive.metastore.events.DropFunctionEvent; +import org.apache.hadoop.hive.metastore.events.DropISchemaEvent; import org.apache.hadoop.hive.metastore.events.DropIndexEvent; import org.apache.hadoop.hive.metastore.events.DropPartitionEvent; +import org.apache.hadoop.hive.metastore.events.DropSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.DropTableEvent; import org.apache.hadoop.hive.metastore.events.InsertEvent; import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent; import org.apache.hadoop.hive.metastore.events.PreAddIndexEvent; import org.apache.hadoop.hive.metastore.events.PreAddPartitionEvent; import org.apache.hadoop.hive.metastore.events.PreAlterDatabaseEvent; +import org.apache.hadoop.hive.metastore.events.PreAlterISchemaEvent; import org.apache.hadoop.hive.metastore.events.PreAlterIndexEvent; import org.apache.hadoop.hive.metastore.events.PreAlterPartitionEvent; +import org.apache.hadoop.hive.metastore.events.PreAlterSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.PreAlterTableEvent; import org.apache.hadoop.hive.metastore.events.PreAuthorizationCallEvent; import org.apache.hadoop.hive.metastore.events.PreCreateDatabaseEvent; +import org.apache.hadoop.hive.metastore.events.PreCreateISchemaEvent; +import org.apache.hadoop.hive.metastore.events.PreAddSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.PreCreateTableEvent; import org.apache.hadoop.hive.metastore.events.PreDropDatabaseEvent; +import org.apache.hadoop.hive.metastore.events.PreDropISchemaEvent; import org.apache.hadoop.hive.metastore.events.PreDropIndexEvent; import org.apache.hadoop.hive.metastore.events.PreDropPartitionEvent; +import org.apache.hadoop.hive.metastore.events.PreDropSchemaVersionEvent; import org.apache.hadoop.hive.metastore.events.PreDropTableEvent; import org.apache.hadoop.hive.metastore.events.PreEventContext; import org.apache.hadoop.hive.metastore.events.PreLoadPartitionDoneEvent; import org.apache.hadoop.hive.metastore.events.PreReadDatabaseEvent; +import org.apache.hadoop.hive.metastore.events.PreReadISchemaEvent; import org.apache.hadoop.hive.metastore.events.PreReadTableEvent; +import org.apache.hadoop.hive.metastore.events.PreReadhSchemaVersionEvent; import org.apache.hadoop.hive.metastore.messaging.EventMessage.EventType; import org.apache.hadoop.hive.metastore.metrics.JvmPauseMonitor; import org.apache.hadoop.hive.metastore.metrics.Metrics; @@ -7329,7 +7344,6 @@ public class HiveMetaStore extends ThriftHiveMetastore { } } - @Override public WMCreateResourcePlanResponse create_resource_plan(WMCreateResourcePlanRequest request) throws AlreadyExistsException, InvalidObjectException, MetaException, TException { @@ -7480,7 +7494,8 @@ public class HiveMetaStore extends ThriftHiveMetastore { WMGetTriggersForResourePlanRequest request) throws NoSuchObjectException, MetaException, TException { try { - List<WMTrigger> triggers = getMS().getTriggersForResourcePlan(request.getResourcePlanName()); + List<WMTrigger> triggers = + getMS().getTriggersForResourcePlan(request.getResourcePlanName()); WMGetTriggersForResourePlanResponse response = new WMGetTriggersForResourePlanResponse(); response.setTriggers(triggers); return response; @@ -7542,6 +7557,25 @@ public class HiveMetaStore extends ThriftHiveMetastore { } @Override + public WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping( + WMCreateOrDropTriggerToPoolMappingRequest request) throws AlreadyExistsException, + NoSuchObjectException, InvalidObjectException, MetaException, TException { + try { + if (request.isDrop()) { + getMS().dropWMTriggerToPoolMapping( + request.getResourcePlanName(), request.getTriggerName(), request.getPoolPath()); + } else { + getMS().createWMTriggerToPoolMapping( + request.getResourcePlanName(), request.getTriggerName(), request.getPoolPath()); + } + return new WMCreateOrDropTriggerToPoolMappingResponse(); + } catch (MetaException e) { + LOG.error("Exception while trying to create or drop pool mappings", e); + throw e; + } + } + + @Override public WMDropMappingResponse drop_wm_mapping(WMDropMappingRequest request) throws NoSuchObjectException, InvalidOperationException, MetaException, TException { try { @@ -7553,22 +7587,438 @@ public class HiveMetaStore extends ThriftHiveMetastore { } } + public void create_ischema(ISchema schema) throws TException { + startFunction("create_ischema", ": " + schema.getName()); + boolean success = false; + Exception ex = null; + RawStore ms = getMS(); + try { + firePreEvent(new PreCreateISchemaEvent(this, schema)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.createISchema(schema); + + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.CREATE_ISCHEMA, new CreateISchemaEvent(true, this, schema)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.CREATE_ISCHEMA, + new CreateISchemaEvent(success, this, schema), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|AlreadyExistsException e) { + LOG.error("Caught exception creating schema", e); + ex = e; + throw e; + } finally { + endFunction("create_ischema", success, ex); + } + } + @Override - public WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping( - WMCreateOrDropTriggerToPoolMappingRequest request) throws AlreadyExistsException, - NoSuchObjectException, InvalidObjectException, MetaException, TException { + public void alter_ischema(String schemaName, ISchema newSchema) throws TException { + startFunction("alter_ischema", ": " + schemaName); + boolean success = false; + Exception ex = null; + RawStore ms = getMS(); try { - if (request.isDrop()) { - getMS().dropWMTriggerToPoolMapping( - request.getResourcePlanName(), request.getTriggerName(), request.getPoolPath()); - } else { - getMS().createWMTriggerToPoolMapping( - request.getResourcePlanName(), request.getTriggerName(), request.getPoolPath()); + ISchema oldSchema = ms.getISchema(schemaName); + if (oldSchema == null) { + throw new NoSuchObjectException("Could not find schema " + schemaName); } - return new WMCreateOrDropTriggerToPoolMappingResponse(); + firePreEvent(new PreAlterISchemaEvent(this, oldSchema, newSchema)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.alterISchema(schemaName, newSchema); + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ALTER_ISCHEMA, new AlterISchemaEvent(true, this, oldSchema, newSchema)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_ISCHEMA, + new AlterISchemaEvent(success, this, oldSchema, newSchema), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|NoSuchObjectException e) { + LOG.error("Caught exception altering schema", e); + ex = e; + throw e; + } finally { + endFunction("alter_ischema", success, ex); + } + } + + @Override + public ISchema get_ischema(String schemaName) throws TException { + startFunction("get_ischema", ": " + schemaName); + Exception ex = null; + ISchema schema = null; + try { + schema = getMS().getISchema(schemaName); + if (schema == null) { + throw new NoSuchObjectException("No schema named " + schemaName + " exists"); + } + firePreEvent(new PreReadISchemaEvent(this, schema)); + return schema; } catch (MetaException e) { - LOG.error("Exception while trying to create or drop pool mappings", e); + LOG.error("Caught exception getting schema", e); + ex = e; + throw e; + } finally { + endFunction("get_ischema", schema != null, ex); + } + } + + @Override + public void drop_ischema(String schemaName) throws TException { + startFunction("drop_ischema", ": " + schemaName); + Exception ex = null; + boolean success = false; + RawStore ms = getMS(); + try { + // look for any valid versions. This will also throw NoSuchObjectException if the schema + // itself doesn't exist, which is what we want. + SchemaVersion latest = ms.getLatestSchemaVersion(schemaName); + if (latest != null) { + ex = new InvalidOperationException("Schema " + schemaName + " cannot be dropped, it has" + + " at least one valid version"); + throw (InvalidObjectException)ex; + } + ISchema schema = ms.getISchema(schemaName); + firePreEvent(new PreDropISchemaEvent(this, schema)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.dropISchema(schemaName); + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.DROP_ISCHEMA, new DropISchemaEvent(true, this, schema)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.DROP_ISCHEMA, + new DropISchemaEvent(success, this, schema), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|NoSuchObjectException e) { + LOG.error("Caught exception dropping schema", e); + ex = e; + throw e; + } finally { + endFunction("drop_ischema", success, ex); + } + } + + @Override + public void add_schema_version(SchemaVersion schemaVersion) throws TException { + startFunction("add_schema_version", ": " + schemaVersion.getSchemaName() + ", " + + schemaVersion.getVersion()); + boolean success = false; + Exception ex = null; + RawStore ms = getMS(); + try { + // Make sure the referenced schema exists + if (ms.getISchema(schemaVersion.getSchemaName()) == null) { + throw new NoSuchObjectException("No schema named " + schemaVersion.getSchemaName()); + } + firePreEvent(new PreAddSchemaVersionEvent(this, schemaVersion)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.addSchemaVersion(schemaVersion); + + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ADD_SCHEMA_VERSION, new AddSchemaVersionEvent(true, this, schemaVersion)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_SCHEMA_VERSION, + new AddSchemaVersionEvent(success, this, schemaVersion), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|AlreadyExistsException e) { + LOG.error("Caught exception adding schema version", e); + ex = e; + throw e; + } finally { + endFunction("add_schema_version", success, ex); + } + } + + @Override + public SchemaVersion get_schema_version(String schemaName, int version) throws TException { + startFunction("get_schema_version", ": " + schemaName); + Exception ex = null; + SchemaVersion schemaVersion = null; + try { + schemaVersion = getMS().getSchemaVersion(schemaName, version); + if (schemaVersion == null) { + throw new NoSuchObjectException("No schema " + schemaName + " with version " + version + + "exists"); + } + firePreEvent(new PreReadhSchemaVersionEvent(this, Collections.singletonList(schemaVersion))); + return schemaVersion; + } catch (MetaException e) { + LOG.error("Caught exception getting schema version", e); + ex = e; + throw e; + } finally { + endFunction("get_schema_version", schemaVersion != null, ex); + } + } + + @Override + public SchemaVersion get_schema_latest_version(String schemaName) throws TException { + startFunction("get_latest_schema_version", ": " + schemaName); + Exception ex = null; + SchemaVersion schemaVersion = null; + try { + schemaVersion = getMS().getLatestSchemaVersion(schemaName); + if (schemaVersion == null) { + throw new NoSuchObjectException("No versions of schema " + schemaName + "exist"); + } + firePreEvent(new PreReadhSchemaVersionEvent(this, Collections.singletonList(schemaVersion))); + return schemaVersion; + } catch (MetaException e) { + LOG.error("Caught exception getting latest schema version", e); + ex = e; + throw e; + } finally { + endFunction("get_latest_schema_version", schemaVersion != null, ex); + } + } + + @Override + public List<SchemaVersion> get_schema_all_versions(String schemaName) throws TException { + startFunction("get_all_schema_versions", ": " + schemaName); + Exception ex = null; + List<SchemaVersion> schemaVersions = null; + try { + schemaVersions = getMS().getAllSchemaVersion(schemaName); + if (schemaVersions == null) { + throw new NoSuchObjectException("No versions of schema " + schemaName + "exist"); + } + firePreEvent(new PreReadhSchemaVersionEvent(this, schemaVersions)); + return schemaVersions; + } catch (MetaException e) { + LOG.error("Caught exception getting all schema versions", e); + ex = e; + throw e; + } finally { + endFunction("get_all_schema_versions", schemaVersions != null, ex); + } + } + + @Override + public void drop_schema_version(String schemaName, int version) throws TException { + startFunction("drop_schema_version", ": " + schemaName); + Exception ex = null; + boolean success = false; + RawStore ms = getMS(); + try { + SchemaVersion schemaVersion = ms.getSchemaVersion(schemaName, version); + if (schemaVersion == null) { + throw new NoSuchObjectException("No schema " + schemaName + " of version " + version); + } + firePreEvent(new PreDropSchemaVersionEvent(this, schemaVersion)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.dropSchemaVersion(schemaName, version); + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.DROP_SCHEMA_VERSION, new DropSchemaVersionEvent(true, this, schemaVersion)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.DROP_SCHEMA_VERSION, + new DropSchemaVersionEvent(success, this, schemaVersion), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|NoSuchObjectException e) { + LOG.error("Caught exception dropping schema version", e); + ex = e; + throw e; + } finally { + endFunction("drop_schema_version", success, ex); + } + } + + @Override + public FindSchemasByColsResp get_schemas_by_cols(FindSchemasByColsRqst rqst) throws TException { + startFunction("get_schemas_by_cols"); + Exception ex = null; + List<SchemaVersion> schemaVersions = Collections.emptyList(); + try { + schemaVersions = getMS().getSchemaVersionsByColumns(rqst.getColName(), + rqst.getColNamespace(), rqst.getType()); + firePreEvent(new PreReadhSchemaVersionEvent(this, schemaVersions)); + final List<FindSchemasByColsRespEntry> entries = new ArrayList<>(schemaVersions.size()); + schemaVersions.forEach(schemaVersion -> entries.add( + new FindSchemasByColsRespEntry(schemaVersion.getSchemaName(), schemaVersion.getVersion()))); + return new FindSchemasByColsResp(entries); + } catch (MetaException e) { + LOG.error("Caught exception doing schema version query", e); + ex = e; + throw e; + } finally { + endFunction("get_schemas_by_cols", !schemaVersions.isEmpty(), ex); + } + } + + @Override + public void map_schema_version_to_serde(String schemaName, int version, String serdeName) + throws TException { + startFunction("map_schema_version_to_serde"); + boolean success = false; + Exception ex = null; + RawStore ms = getMS(); + try { + SchemaVersion oldSchemaVersion = ms.getSchemaVersion(schemaName, version); + if (oldSchemaVersion == null) { + throw new NoSuchObjectException("No schema " + schemaName + " of version " + version); + } + SerDeInfo serde = ms.getSerDeInfo(serdeName); + if (serde == null) { + throw new NoSuchObjectException("No SerDe named " + serdeName); + } + SchemaVersion newSchemaVersion = new SchemaVersion(oldSchemaVersion); + newSchemaVersion.setSerDe(serde); + firePreEvent(new PreAlterSchemaVersionEvent(this, oldSchemaVersion, newSchemaVersion)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.alterSchemaVersion(schemaName, version, newSchemaVersion); + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ALTER_SCHEMA_VERSION, new AlterSchemaVersionEvent(true, this, + oldSchemaVersion, newSchemaVersion)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_SCHEMA_VERSION, + new AlterSchemaVersionEvent(success, this, oldSchemaVersion, newSchemaVersion), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|NoSuchObjectException e) { + LOG.error("Caught exception mapping schema version to serde", e); + ex = e; throw e; + } finally { + endFunction("map_schema_version_to_serde", success, ex); + } + } + + @Override + public void set_schema_version_state(String schemaName, int version, + SchemaVersionState state) throws TException { + startFunction("set_schema_version_state"); + boolean success = false; + Exception ex = null; + RawStore ms = getMS(); + try { + SchemaVersion oldSchemaVersion = ms.getSchemaVersion(schemaName, version); + if (oldSchemaVersion == null) { + throw new NoSuchObjectException("No schema " + schemaName + " of version " + version); + } + SchemaVersion newSchemaVersion = new SchemaVersion(oldSchemaVersion); + newSchemaVersion.setState(state); + firePreEvent(new PreAlterSchemaVersionEvent(this, oldSchemaVersion, newSchemaVersion)); + Map<String, String> transactionalListenersResponses = Collections.emptyMap(); + ms.openTransaction(); + try { + ms.alterSchemaVersion(schemaName, version, newSchemaVersion); + if (!transactionalListeners.isEmpty()) { + transactionalListenersResponses = + MetaStoreListenerNotifier.notifyEvent(transactionalListeners, + EventType.ALTER_SCHEMA_VERSION, new AlterSchemaVersionEvent(true, this, + oldSchemaVersion, newSchemaVersion)); + } + success = ms.commitTransaction(); + } finally { + if (!success) ms.rollbackTransaction(); + if (!listeners.isEmpty()) { + MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_SCHEMA_VERSION, + new AlterSchemaVersionEvent(success, this, oldSchemaVersion, newSchemaVersion), null, + transactionalListenersResponses, ms); + } + } + } catch (MetaException|NoSuchObjectException e) { + LOG.error("Caught exception changing schema version state", e); + ex = e; + throw e; + } finally { + endFunction("set_schema_version_state", success, ex); + } + } + + @Override + public void add_serde(SerDeInfo serde) throws TException { + startFunction("create_serde", ": " + serde.getName()); + Exception ex = null; + boolean success = false; + RawStore ms = getMS(); + try { + ms.openTransaction(); + ms.addSerde(serde); + success = ms.commitTransaction(); + } catch (MetaException|AlreadyExistsException e) { + LOG.error("Caught exception creating serde", e); + ex = e; + throw e; + } finally { + if (!success) ms.rollbackTransaction(); + endFunction("create_serde", success, ex); + } + } + + @Override + public SerDeInfo get_serde(String serdeName) throws TException { + startFunction("get_serde", ": " + serdeName); + Exception ex = null; + SerDeInfo serde = null; + try { + serde = getMS().getSerDeInfo(serdeName); + if (serde == null) { + throw new NoSuchObjectException("No serde named " + serdeName + " exists"); + } + return serde; + } catch (MetaException e) { + LOG.error("Caught exception getting serde", e); + ex = e; + throw e; + } finally { + endFunction("get_serde", serde != null, ex); } } }