private static void addIncompleteCollectionTypeReference(AbstractCollectionType collType, TypeReferenceExpression tre, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes, String defaultDataverse) { String typeName = tre.getIdent().second.getValue(); TypeSignature typeSignature = new TypeSignature( tre.getIdent().first == null ? defaultDataverse : tre.getIdent().first.getValue(), typeName); List<AbstractCollectionType> typeList = incompleteItemTypes.get(typeSignature); if (typeList == null) { typeList = new LinkedList<>(); incompleteItemTypes.put(typeSignature, typeList); } typeList.add(collType); }
@Override public boolean equals(Object o) { if (!(o instanceof TypeSignature)) { return false; } else { TypeSignature f = ((TypeSignature) o); return dataverse.equals(f.getNamespace()) && name.equals(f.getName()); } }
new ARecordType(typeSignature == null ? null : typeSignature.getName(), fldNames, fldTypes, isOpen); List<IRecordFieldDataGen> fieldDataGen = rtd.getFieldDataGen(); if (fieldDataGen.size() == n) { case TYPEREFERENCE: { TypeReferenceExpression tre = (TypeReferenceExpression) texpr; TypeSignature signature = new TypeSignature( tre.getIdent().first == null ? defaultDataverse : tre.getIdent().first.getValue(), tre.getIdent().second.getValue());
private static IAType solveTypeReference(TypeSignature typeSignature, Map<TypeSignature, IAType> typeMap) { IAType builtin = BuiltinTypeMap.getBuiltinType(typeSignature.getName()); if (builtin != null) { return builtin; } else { return typeMap.get(typeSignature); } }
private static AUnorderedListType computeUnorderedListType(TypeSignature typeSignature, UnorderedListTypeDefinition ultd, Map<TypeSignature, IAType> typeMap, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes, Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, String defaulDataverse) throws AlgebricksException { TypeExpression tExpr = ultd.getItemTypeExpression(); String typeName = typeSignature != null ? typeSignature.getName() : null; AUnorderedListType ault = new AUnorderedListType(null, typeName); setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, ault, defaulDataverse); return ault; }
private static void addIncompleteTopLevelTypeReference(TypeReferenceExpression tre, Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, String defaultDataverse) { String name = tre.getIdent().second.getValue(); TypeSignature typeSignature = new TypeSignature( tre.getIdent().first == null ? defaultDataverse : tre.getIdent().first.getValue(), name); List<TypeSignature> refList = incompleteTopLevelTypeReferences.get(name); if (refList == null) { refList = new LinkedList<>(); incompleteTopLevelTypeReferences.put( new TypeSignature(tre.getIdent().first == null ? defaultDataverse : tre.getIdent().first.getValue(), tre.getIdent().second.getValue()), refList); } refList.add(typeSignature); }
Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, typeSignature.getNamespace(), typeSignature.getName()); if (dt == null) { throw new AlgebricksException("Could not resolve type " + typeSignature); Datatype dt; if (MetadataManager.INSTANCE != null) { dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, typeSignature.getNamespace(), typeSignature.getName()); if (dt == null) { throw new AlgebricksException("Could not resolve type " + typeSignature);
private static AOrderedListType computeOrderedListType(TypeSignature typeSignature, OrderedListTypeDefinition oltd, Map<TypeSignature, IAType> typeMap, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes, Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, String defaultDataverse) throws AlgebricksException { TypeExpression tExpr = oltd.getItemTypeExpression(); String typeName = typeSignature != null ? typeSignature.getName() : null; AOrderedListType aolt = new AOrderedListType(null, typeName); setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, aolt, defaultDataverse); return aolt; }
throw new AlgebricksException("Cannot redefine builtin type " + typeName + " ."); TypeSignature typeSignature = new TypeSignature(typeDataverse, typeName); switch (typeExpr.getTypeKind()) { case TYPEREFERENCE: { TypeReferenceExpression tre = (TypeReferenceExpression) typeExpr; IAType t = solveTypeReference(new TypeSignature( tre.getIdent().first == null ? typeDataverse : tre.getIdent().first.getValue(), tre.getIdent().second.getValue()), typeMap);
public void translate() throws AlgebricksException { String defaultDataverse = getDefaultDataverse(); types = new HashMap<>(); typeDataGenMap = new HashMap<>(); for (Statement stmt : statements) { if (stmt.getKind() == Statement.Kind.TYPE_DECL) { TypeDecl td = (TypeDecl) stmt; String typeDataverse = td.getDataverseName() == null ? defaultDataverse : td.getDataverseName().getValue(); Map<TypeSignature, IAType> typeInStmt = TypeTranslator.computeTypes(mdTxnCtx, td.getTypeDef(), td.getIdent().getValue(), typeDataverse, types); types.putAll(typeInStmt); TypeSignature signature = new TypeSignature(typeDataverse, td.getIdent().getValue()); TypeDataGen tdg = td.getDatagenAnnotation(); if (tdg != null) { typeDataGenMap.put(signature, tdg); } } } }
TypeSignature signature = new TypeSignature( tre.getIdent().first == null ? defaultDataverse : tre.getIdent().first.getValue(), tre.getIdent().second.getValue());
TypeSignature typeSignature = new TypeSignature(dataverseName, indexName); fieldType = typeMap.get(typeSignature); overridesFieldTypes = true;
Map<TypeSignature, IAType> typeMap = TypeTranslator.computeTypes(mdTxnCtx, stmtCreateType.getTypeDef(), stmtCreateType.getIdent().getValue(), dataverseName); TypeSignature typeSignature = new TypeSignature(dataverseName, typeName); IAType type = typeMap.get(typeSignature); MetadataManager.INSTANCE.addDatatype(mdTxnCtx, new Datatype(dataverseName, typeName, type, false));