@Override public boolean equals(Object object) { return object instanceof IAObject && deepEqual((IAObject) object); }
@Override public void generateNestedDerivedTypeNames() { for (int i = 0; i < fieldTypes.length; i++) { IAType fieldType = fieldTypes[i]; if (fieldType.getTypeTag().isDerivedType() && (fieldType.getTypeName() == null)) { AbstractComplexType nestedType = (AbstractComplexType) fieldType; nestedType.setTypeName(getTypeName() + "_" + fieldNames[i]); nestedType.generateNestedDerivedTypeNames(); } } }
public static Map<TypeSignature, IAType> computeTypes(MetadataTransactionContext mdTxnCtx, TypeExpression typeExpr, String typeName, String typeDataverse, Map<TypeSignature, IAType> typeMap) throws AlgebricksException { Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes = new HashMap<>(); Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes = new HashMap<>(); Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences = new HashMap<>(); firstPass(typeExpr, typeName, typeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences, typeDataverse); secondPass(mdTxnCtx, typeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences, typeDataverse); for (IAType type : typeMap.values()) { if (type.getTypeTag().isDerivedType()) { ((AbstractComplexType) type).generateNestedDerivedTypeNames(); } } return typeMap; }
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()); } } }
IARecordBuilder derivedRecordBuilder = new RecordBuilder(); ArrayBackedValueStorage fieldValue = new ArrayBackedValueStorage(); switch (derivedDatatype.getTypeTag()) { case ARRAY: tag = DerivedTypeTag.ORDEREDLIST; default: throw new UnsupportedOperationException( "No metadata record Type for " + derivedDatatype.getDisplayName());
@Override public void generateNestedDerivedTypeNames() { if (itemType.getTypeTag().isDerivedType() && itemType.getTypeName() == null) { AbstractComplexType nestedType = ((AbstractComplexType) itemType); nestedType.setTypeName(getTypeName() + "_Item"); nestedType.generateNestedDerivedTypeNames(); } }
@Override public void generateNestedDerivedTypeNames() { if (isUnknownableType()) { IAType nullableType = getActualType(); if (nullableType.getTypeTag().isDerivedType() && nullableType.getTypeName() == null) { AbstractComplexType derivedType = (AbstractComplexType) nullableType; derivedType.setTypeName(getTypeName()); derivedType.generateNestedDerivedTypeNames(); } } }