public static IAType findType(MetadataTransactionContext mdTxnCtx, String dataverse, String typeName) throws AlgebricksException { if (dataverse == null || typeName == null) { return null; } Datatype type = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, dataverse, typeName); if (type == null) { throw new AlgebricksException("Type name '" + typeName + "' unknown in dataverse '" + dataverse + "'"); } return type.getDatatype(); }
ARecordType aRecType = (ARecordType) datatype.getDatatype(); return new Datatype( datatype.getDataverseName(), datatype.getDatatypeName(), new ARecordType(aRecType.getTypeName(), aRecType.getFieldNames(), aRecType.getFieldTypes(), aRecType.isOpen()), datatype.getIsAnonymous());
public Datatype dropDatatype(Datatype datatype) { synchronized (datatypes) { Map<String, Datatype> m = datatypes.get(datatype.getDataverseName()); if (m == null) { return null; } return m.remove(datatype.getDatatypeName()); } }
private void confirmDatatypeIsUnusedByDatatypes(TxnId txnId, String dataverseName, String datatypeName) throws AlgebricksException, RemoteException { // If any datatype uses this type, throw an error // TODO: Currently this loads all types into memory. This will need to be fixed // for large numbers of types Datatype dataTypeToBeDropped = getDatatype(txnId, dataverseName, datatypeName); assert dataTypeToBeDropped != null; IAType typeToBeDropped = dataTypeToBeDropped.getDatatype(); List<Datatype> datatypes = getAllDatatypes(txnId); for (Datatype dataType : datatypes) { // skip types in different dataverses as well as the type to be dropped itself if (!dataType.getDataverseName().equals(dataverseName) || dataType.getDatatype().getTypeName().equals(datatypeName)) { continue; } AbstractComplexType recType = (AbstractComplexType) dataType.getDatatype(); if (recType.containsType(typeToBeDropped)) { throw new AlgebricksException("Cannot drop type " + dataverseName + "." + datatypeName + " being used by type " + dataverseName + "." + recType.getTypeName()); } } }
aString.setValue(dataType.getDataverseName()); stringSerde.serialize(aString, tupleBuilder.getDataOutput()); tupleBuilder.addFieldEndOffset(); aString.setValue(dataType.getDatatypeName()); stringSerde.serialize(aString, tupleBuilder.getDataOutput()); tupleBuilder.addFieldEndOffset(); aString.setValue(dataType.getDataverseName()); stringSerde.serialize(aString, fieldValue.getDataOutput()); recordBuilder.addField(MetadataRecordTypes.DATATYPE_ARECORD_DATAVERSENAME_FIELD_INDEX, fieldValue); aString.setValue(dataType.getDatatypeName()); stringSerde.serialize(aString, fieldValue.getDataOutput()); recordBuilder.addField(MetadataRecordTypes.DATATYPE_ARECORD_DATATYPENAME_FIELD_INDEX, fieldValue); IAType fieldType = dataType.getDatatype(); fieldType = ((AUnionType) dataType.getDatatype()).getActualType();
private static void insertMetadataDatatypes(MetadataTransactionContext mdTxnCtx) throws AlgebricksException { ArrayList<IAType> types = new ArrayList<>(); types.addAll(BuiltinTypeMap.getAllBuiltinTypes()); getMetadataTypes(types); for (int i = 0; i < types.size(); i++) { MetadataManager.INSTANCE.addDatatype(mdTxnCtx, new Datatype(MetadataConstants.METADATA_DATAVERSE_NAME, types.get(i).getTypeName(), types.get(i), false)); } MetadataManager.INSTANCE.addDatatype(mdTxnCtx, MetadataBuiltinEntities.ANY_OBJECT_DATATYPE); if (LOGGER.isInfoEnabled()) { LOGGER.info("Finished inserting initial datatypes."); } }
@Override public void dropDatatype(TxnId txnId, String dataverseName, String datatypeName) throws AlgebricksException, RemoteException { confirmDatatypeIsUnused(txnId, dataverseName, datatypeName); // Delete the datatype entry, including all it's nested anonymous types. try { ITupleReference searchKey = createTuple(dataverseName, datatypeName); // Searches the index for the tuple to be deleted. Acquires an S // lock on the 'datatype' dataset. ITupleReference tuple = getTupleToBeDeleted(txnId, MetadataPrimaryIndexes.DATATYPE_DATASET, searchKey); // Get nested types List<String> nestedTypes = getNestedComplexDatatypeNamesForThisDatatype(txnId, dataverseName, datatypeName); deleteTupleFromIndex(txnId, MetadataPrimaryIndexes.DATATYPE_DATASET, tuple); for (String nestedType : nestedTypes) { Datatype dt = getDatatype(txnId, dataverseName, nestedType); if (dt != null && dt.getIsAnonymous()) { dropDatatype(txnId, dataverseName, dt.getDatatypeName()); } } } catch (HyracksDataException e) { if (e.getComponent().equals(ErrorCode.HYRACKS) && e.getErrorCode() == ErrorCode.UPDATE_OR_DELETE_NON_EXISTENT_KEY) { throw new AlgebricksException("Cannot drop type '" + datatypeName + "' because it doesn't exist", e); } else { throw new AlgebricksException(e); } } }
@Override public void addDatatype(TxnId txnId, Datatype datatype) throws AlgebricksException, RemoteException { try { DatatypeTupleTranslator tupleReaderWriter = tupleTranslatorProvider.getDataTypeTupleTranslator(txnId, this, true); ITupleReference tuple = tupleReaderWriter.getTupleFromMetadataEntity(datatype); insertTupleIntoIndex(txnId, MetadataPrimaryIndexes.DATATYPE_DATASET, tuple); } catch (HyracksDataException e) { if (e.getComponent().equals(ErrorCode.HYRACKS) && e.getErrorCode() == ErrorCode.DUPLICATE_KEY) { throw new AlgebricksException( "A datatype with name '" + datatype.getDatatypeName() + "' already exists.", e); } else { throw new AlgebricksException(e); } } }
booleanSerde.serialize(type.getIsAnonymous() ? ABoolean.TRUE : ABoolean.FALSE, fieldValue.getDataOutput()); derivedRecordBuilder.addField(MetadataRecordTypes.DERIVEDTYPE_ARECORD_ISANONYMOUS_FIELD_INDEX, fieldValue);
public void dropDataDatatype(String dataverseName, String datatypeName) { Datatype datatype = new Datatype(dataverseName, datatypeName, null, false); droppedCache.addDatatypeIfNotExists(datatype); logAndApply(new MetadataLogicalOperation(datatype, false)); }
public Datatype addDatatypeIfNotExists(Datatype datatype) { synchronized (datatypes) { Map<String, Datatype> m = datatypes.get(datatype.getDataverseName()); if (m == null) { m = new HashMap<>(); datatypes.put(datatype.getDataverseName(), m); } if (!m.containsKey(datatype.getDatatypeName())) { return m.put(datatype.getDatatypeName(), datatype); } return null; } }
forceDropDatatype(txnId, dataverseName, dataverseDatatypes.get(i).getDatatypeName());
private List<String> getNestedComplexDatatypeNamesForThisDatatype(TxnId txnId, String dataverseName, String datatypeName) throws AlgebricksException, RemoteException { // Return all field types that aren't builtin types Datatype parentType = getDatatype(txnId, dataverseName, datatypeName); List<IAType> subTypes = null; if (parentType.getDatatype().getTypeTag() == ATypeTag.OBJECT) { ARecordType recType = (ARecordType) parentType.getDatatype(); subTypes = Arrays.asList(recType.getFieldTypes()); } else if (parentType.getDatatype().getTypeTag() == ATypeTag.UNION) { AUnionType recType = (AUnionType) parentType.getDatatype(); subTypes = recType.getUnionList(); } List<String> nestedTypes = new ArrayList<>(); if (subTypes != null) { for (IAType subType : subTypes) { if (!(subType instanceof BuiltinType)) { nestedTypes.add(subType.getTypeName()); } } } return nestedTypes; }
private String handleNestedDerivedType(String typeName, AbstractComplexType nestedType, Datatype topLevelType, String dataverseName, String datatypeName) throws HyracksDataException { try { metadataNode.addDatatype(txnId, new Datatype(dataverseName, typeName, nestedType, true)); } catch (AlgebricksException e) { // The nested record type may have been inserted by a previous DDL statement or // by // a previous nested type. if (!(e.getCause() instanceof HyracksDataException)) { throw HyracksDataException.create(e); } else { HyracksDataException hde = (HyracksDataException) e.getCause(); if (!hde.getComponent().equals(ErrorCode.HYRACKS) || hde.getErrorCode() != ErrorCode.DUPLICATE_KEY) { throw hde; } } } catch (RemoteException e) { // TODO: This should not be a HyracksDataException. Can't // fix this currently because of BTree exception model whose // fixes must get in. throw HyracksDataException.create(e); } return typeName; } }
@Override public void addDatatype(MetadataTransactionContext ctx, Datatype datatype) throws AlgebricksException { try { metadataNode.addDatatype(ctx.getTxnId(), datatype); } catch (RemoteException e) { throw new MetadataException(ErrorCode.REMOTE_EXCEPTION_WHEN_CALLING_METADATA_NODE, e); } try { ctx.addDatatype( metadataNode.getDatatype(ctx.getTxnId(), datatype.getDataverseName(), datatype.getDatatypeName())); } catch (RemoteException e) { throw new MetadataException(ErrorCode.REMOTE_EXCEPTION_WHEN_CALLING_METADATA_NODE, e); } }
public static IAType getTypeFromTypeName(MetadataNode metadataNode, TxnId txnId, String dataverseName, String typeName, boolean optional) throws AlgebricksException { IAType type = _builtinTypeMap.get(typeName); if (type == null) { try { Datatype dt = metadataNode.getDatatype(txnId, dataverseName, typeName); type = dt.getDatatype(); } catch (RemoteException e) { throw new MetadataException(e); } } if (optional) { type = AUnionType.createUnknownableType(type); } return type; } }
fieldId++; return new Datatype(dataverseName, datatypeName, new ARecordType(datatypeName, fieldNames, fieldTypes, isOpen), isAnonymous); .getValueByPos(MetadataRecordTypes.DERIVEDTYPE_ARECORD_UNORDEREDLIST_FIELD_INDEX)) .getStringValue(); return new Datatype(dataverseName, datatypeName, new AUnorderedListType(BuiltinTypeMap.getTypeFromTypeName(metadataNode, txnId, dataverseName, unorderedlistTypeName, false), datatypeName), .getValueByPos(MetadataRecordTypes.DERIVEDTYPE_ARECORD_ORDEREDLIST_FIELD_INDEX)) .getStringValue(); return new Datatype(dataverseName, datatypeName, new AOrderedListType(BuiltinTypeMap.getTypeFromTypeName(metadataNode, txnId, dataverseName, orderedlistTypeName, false), datatypeName), return new Datatype(dataverseName, datatypeName, type, false);
private void writeCollectionType(Datatype instance, AbstractComplexType type, DataOutput out) throws HyracksDataException { AbstractCollectionType listType = (AbstractCollectionType) type; IAType itemType = listType.getItemType(); if (itemType.getTypeTag().isDerivedType()) { handleNestedDerivedType(itemType.getTypeName(), (AbstractComplexType) itemType, instance, instance.getDataverseName(), instance.getDatatypeName()); } aString.setValue(listType.getItemType().getTypeName()); stringSerde.serialize(aString, out); }
ctx = MetadataManager.INSTANCE.beginTransaction(); Datatype t = MetadataManager.INSTANCE.getDatatype(ctx, dataverseName, datatypeName); if (t == null || t.getDatatype().getTypeTag() != ATypeTag.OBJECT) { throw new MetadataException(ErrorCode.FEED_METADATA_UTIL_UNEXPECTED_FEED_DATATYPE, datatypeName); outputType = (ARecordType) t.getDatatype(); MetadataManager.INSTANCE.commitTransaction(ctx); } catch (ACIDException | RemoteException e) {
TypeSignature typeSignature = new TypeSignature(dataverseName, typeName); IAType type = typeMap.get(typeSignature); MetadataManager.INSTANCE.addDatatype(mdTxnCtx, new Datatype(dataverseName, typeName, type, false));