@Override public boolean containsType(IAType type) { for (IAType aType : fieldTypes) { if (aType.getTypeName().equals(type.getTypeName())) { return true; } } return false; } }
@Override public boolean containsType(IAType type) { return isTyped() && itemType.getTypeName().equals(type.getTypeName()); } }
@Override public AOrderedListType create(IAType type) { return new AOrderedListType(type, type.getTypeName() + "OrderedList"); } });
@Override public AOrderedListType create(IAType type) { return new AOrderedListType(type, type.getTypeName() + "UnorderedList"); } });
public static IAType createUnknownableType(IAType t) { String s = t != null ? t.getTypeName() : null; return createUnknownableType(t, s == null ? null : s + "?"); }
public static IAType createMissableType(IAType t) { if (t != null && t.getTypeTag() == ATypeTag.MISSING) { return t; } String s = t != null ? t.getTypeName() : null; return createMissableType(t, s == null ? null : s + "?"); }
@Override public IAType computeType(ILogicalExpression expression, IVariableTypeEnvironment env, IMetadataProvider<?, ?> metadataProvider) throws AlgebricksException { return new AUnorderedListType(((AUnorderedListType) type).getItemType(), type.getTypeName()); }
public static IAType createNullableType(IAType t) { if (t != null && t.getTypeTag() == ATypeTag.NULL) { return t; } String s = t != null ? t.getTypeName() : null; return createNullableType(t, s == null ? null : s + "?"); }
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 IAType computeType(ILogicalExpression expression, IVariableTypeEnvironment env, IMetadataProvider<?, ?> metadataProvider) throws AlgebricksException { return new AOrderedListType(((AOrderedListType) type).getItemType(), ((AOrderedListType) type).getItemType().getTypeName()); }
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); }
@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() { 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(); } } }
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 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()); } } }
@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(); } } }
private void parseToNumericTarget(ATypeTag typeTag, IAType objectType, DataOutput out) throws IOException { ATypeTag targetTypeTag = getTargetTypeTag(typeTag, objectType); boolean parsed = false; if (targetTypeTag != null) { admLexer.getLastTokenImage(tmpTokenImage); parsed = parseValue(tmpTokenImage.getBuffer(), tmpTokenImage.getBegin(), tmpTokenImage.getLength(), targetTypeTag, out); } if (!parsed) { throw new ParseException(mismatchErrorMessage + objectType.getTypeName() + mismatchErrorMessage2 + typeTag); } }
throw new RuntimeDataException(ErrorCode.PARSER_ADM_DATA_PARSER_TYPE_MISMATCH, definedType.getTypeName());
objectType.getTypeName() + " got " + typeTag);
throw new ParseException(mismatchErrorMessage + objectType.getTypeName() + mismatchErrorMessage2 + typeTag);