public TraitType defineTraitType(HierarchicalTypeDefinition<TraitType> traitDef) throws AtlasException { defineTypes(ImmutableList.<EnumTypeDefinition>of(), ImmutableList.<StructTypeDefinition>of(), ImmutableList.of(traitDef), ImmutableList.<HierarchicalTypeDefinition<ClassType>>of()); return getDataType(TraitType.class, traitDef.typeName); }
protected HierarchicalType createDataType(String type) { try { return TypeSystem.getInstance().getDataType(HierarchicalType.class, type); } catch (AtlasException e) { throw new CatalogRuntimeException("Unable to get type instance from type system for type: " + type, e); } }
@Override public void commitTypes(Map<String, IDataType> typesAdded) throws AtlasException { TypeSystem.this.commitTypes(typesAdded); }
@BeforeMethod public void setup() throws Exception { TypeSystem ts = TypeSystem.getInstance(); ts.reset(); }
String description = "_description"; String typeDescription = typeName + description; getTypeSystem().defineEnumType(typeName, typeDescription, new EnumValue("0", 0), new EnumValue("1", 1), new EnumValue("2", 2), new EnumValue("3", 3)); assertTrue(getTypeSystem().getTypeNames().contains(typeName)); IDataType type = getTypeSystem().getDataType(EnumType.class, typeName); Assert.assertNotNull(type); Assert.assertEquals(type.getDescription(), typeDescription); .createTraitTypeDef(typeName, typeDescription, ImmutableSet.<String>of(), TypesUtil.createRequiredAttrDef("type", DataTypes.STRING_TYPE)); getTypeSystem().defineTraitType(trait); assertTrue(getTypeSystem().getTypeNames().contains(typeName)); type = getTypeSystem().getDataType(TraitType.class, typeName); Assert.assertNotNull(type); Assert.assertEquals(type.getDescription(), typeDescription); .createClassTypeDef(typeName, typeDescription, ImmutableSet.<String>of(), TypesUtil.createRequiredAttrDef("type", DataTypes.STRING_TYPE)); getTypeSystem().defineClassType(classType); assertTrue(getTypeSystem().getTypeNames().contains(typeName)); type = getTypeSystem().getDataType(ClassType.class, typeName); Assert.assertNotNull(type); Assert.assertEquals(type.getDescription(), typeDescription); getTypeSystem().defineStructType(typeName, typeDescription, true, createRequiredAttrDef("a", DataTypes.INT_TYPE)); assertTrue(getTypeSystem().getTypeNames().contains(typeName)); type = getTypeSystem().getDataType(StructType.class, typeName); Assert.assertNotNull(type);
private IDataType dataType(String name) throws AtlasException { if (transientTypes.containsKey(name)) { return transientTypes.get(name); } return TypeSystem.this.getDataType(IDataType.class, name); }
TypeSystem ts = getTypeSystem(); defineEnums(ts); StructType structType = ts.defineStructType("ts", true, createRequiredAttrDef("a", DataTypes.INT_TYPE), createOptionalAttrDef("b", DataTypes.BOOLEAN_TYPE), createOptionalAttrDef("c", DataTypes.BYTE_TYPE), createOptionalAttrDef("d", DataTypes.SHORT_TYPE), createOptionalAttrDef("enum1", ts.getDataType(EnumType.class, "HiveObjectType")), createOptionalAttrDef("e", DataTypes.INT_TYPE), createOptionalAttrDef("f", DataTypes.INT_TYPE), createOptionalAttrDef("g", DataTypes.LONG_TYPE), createOptionalAttrDef("enum2", ts.getDataType(EnumType.class, "PrincipalType")), createOptionalAttrDef("h", DataTypes.FLOAT_TYPE), createOptionalAttrDef("i", DataTypes.DOUBLE_TYPE), createOptionalAttrDef("j", DataTypes.BIGINTEGER_TYPE), createOptionalAttrDef("k", DataTypes.BIGDECIMAL_TYPE), createOptionalAttrDef("enum3", ts.getDataType(EnumType.class, "TxnState")), createOptionalAttrDef("l", DataTypes.DATE_TYPE), createOptionalAttrDef("m", ts.defineArrayType(DataTypes.INT_TYPE)), createOptionalAttrDef("n", ts.defineArrayType(DataTypes.BIGDECIMAL_TYPE)), createOptionalAttrDef("o", ts.defineMapType(DataTypes.STRING_TYPE, DataTypes.DOUBLE_TYPE)), createOptionalAttrDef("enum4", ts.getDataType(EnumType.class, "LockLevel")));
protected ClassType defineClassTypeWithEnum(TypeSystem ts) throws AtlasException { return ts.defineClassType( createClassTypeDef("t4", ImmutableSet.<String>of(), createRequiredAttrDef("a", DataTypes.INT_TYPE), createOptionalAttrDef("b", DataTypes.BOOLEAN_TYPE), createOptionalAttrDef("c", DataTypes.BYTE_TYPE), createOptionalAttrDef("d", DataTypes.SHORT_TYPE), createOptionalAttrDef("enum1", ts.getDataType(EnumType.class, "HiveObjectType")), createOptionalAttrDef("e", DataTypes.INT_TYPE), createOptionalAttrDef("f", DataTypes.INT_TYPE), createOptionalAttrDef("g", DataTypes.LONG_TYPE), createOptionalAttrDef("enum2", ts.getDataType(EnumType.class, "PrincipalType")), createOptionalAttrDef("h", DataTypes.FLOAT_TYPE), createOptionalAttrDef("i", DataTypes.DOUBLE_TYPE), createOptionalAttrDef("j", DataTypes.BIGINTEGER_TYPE), createOptionalAttrDef("k", DataTypes.BIGDECIMAL_TYPE), createOptionalAttrDef("enum3", ts.getDataType(EnumType.class, "TxnState")), createOptionalAttrDef("l", DataTypes.DATE_TYPE), createOptionalAttrDef("m", ts.defineArrayType(DataTypes.INT_TYPE)), createOptionalAttrDef("n", ts.defineArrayType(DataTypes.BIGDECIMAL_TYPE)), createOptionalAttrDef("o", ts.defineMapType(DataTypes.STRING_TYPE, DataTypes.DOUBLE_TYPE)), createOptionalAttrDef("enum4", ts.getDataType(EnumType.class, "LockLevel")))); }
@BeforeClass public void onetimeSetup() throws Exception { // init TypeSystem TypeSystem ts = TypeSystem.getInstance().reset(); // Customer ClassType customerType = ts.defineClassType(TypesUtil .createClassTypeDef(CLASSTYPE_CUSTOMER, ImmutableSet.<String>of(), TypesUtil.createRequiredAttrDef("name", DataTypes.STRING_TYPE), TypesUtil.createRequiredAttrDef("id", DataTypes.LONG_TYPE))); // Address StructType addressType = ts.defineStructType(STRUCTTYPE_ADDRESS, true, TypesUtil.createRequiredAttrDef("first line", DataTypes.STRING_TYPE), TypesUtil.createOptionalAttrDef("second line", DataTypes.STRING_TYPE), TypesUtil.createRequiredAttrDef("city", DataTypes.STRING_TYPE), TypesUtil.createRequiredAttrDef("pincode", DataTypes.INT_TYPE)); // Privileged TraitType privilegedTrait = ts.defineTraitType(TypesUtil .createTraitTypeDef(TRAITTYPE_PRIVILEGED, ImmutableSet.<String>of(), TypesUtil.createRequiredAttrDef("category", DataTypes.INT_TYPE))); // Shipping EnumType shippingEnum = ts.defineEnumType(TypesUtil.createEnumTypeDef(ENUMTYPE_SHIPPING, new EnumValue("Domestic", 1), new EnumValue("International", 2))); }
public IDataType getDataType(String name) throws AtlasException { if (isCoreType(name)) { return coreTypes.get(name); IDataType dT = defineArrayType(getDataType(arrElemType)); return dT; if (mapType != null) { IDataType dT = defineMapType(getDataType(mapType[0]), getDataType(mapType[1])); return dT;
@BeforeMethod public void setup() throws Exception { TypeSystem ts = TypeSystem.getInstance(); ts.reset(); ts.defineStructType(STRUCT_TYPE_1, true, TypesUtil.createRequiredAttrDef("a", DataTypes.INT_TYPE), TypesUtil.createOptionalAttrDef("b", DataTypes.BOOLEAN_TYPE), TypesUtil.createOptionalAttrDef("c", DataTypes.BYTE_TYPE), TypesUtil.createOptionalAttrDef("k", DataTypes.BIGDECIMAL_TYPE), TypesUtil.createOptionalAttrDef("l", DataTypes.DATE_TYPE), TypesUtil.createOptionalAttrDef("m", ts.defineArrayType(DataTypes.INT_TYPE)), TypesUtil.createOptionalAttrDef("n", ts.defineArrayType(DataTypes.BIGDECIMAL_TYPE)), TypesUtil.createOptionalAttrDef("o", ts.defineMapType(DataTypes.STRING_TYPE, DataTypes.DOUBLE_TYPE)), TypesUtil.createOptionalAttrDef("p", DataTypes.STRING_TYPE), TypesUtil.createOptionalAttrDef("q", DataTypes.STRING_TYPE), TypesUtil.createOptionalAttrDef("r", ts.defineMapType(DataTypes.STRING_TYPE, DataTypes.STRING_TYPE))); System.out.println("defined structType = " + structType); ts.defineStructType(STRUCT_TYPE_2, true, TypesUtil.createRequiredAttrDef("a", DataTypes.INT_TYPE), TypesUtil.createOptionalAttrDef("s", STRUCT_TYPE_2)); System.out.println("defined recursiveStructType = " + recursiveStructType); ts.defineStructType(STRUCT_TYPE_3, true, TypesUtil.createRequiredAttrDef("a",DataTypes.STRING_TYPE)); System.out.println("defined structType = " + invalidStructType);
EnumTypeDefinition etd = new EnumTypeDefinition(newName(), new EnumValue("A", 1)); TypesDef typesDef = getTypesDef(etd); ts.defineTypes(typesDef); ts.updateTypes(typesDef); typesDef = getTypesDef(etd); try { ts.updateTypes(typesDef); Assert.fail("Expected TypeUpdateException"); } catch (TypeUpdateException e) { EnumType enumType = ts.getDataType(EnumType.class, etd.name); Assert.assertEquals(enumType.values().size(), 2); typesDef = getTypesDef(etd); try { ts.updateTypes(typesDef); Assert.fail("Expected TypeUpdateException"); } catch (TypeUpdateException e) {
TypeSystem ts = TypeSystem.getInstance().reset(); ts.defineClassType(TypesUtil.createClassTypeDef("A", ImmutableSet.<String>of())); ts.defineClassType(TypesUtil.createClassTypeDef("A1", ImmutableSet.of("A"))); ts.defineClassType(TypesUtil.createClassTypeDef("B", ImmutableSet.<String>of())); ts.defineClassType(TypesUtil.createClassTypeDef("C", ImmutableSet.of("B", "A"))); ImmutableList<String> results = ts.getTypeNames(new HashMap<TypeCache.TYPE_FILTER, String>() {{ put(TypeCache.TYPE_FILTER.SUPERTYPE, "A"); }}); results = ts.getTypeNames(new HashMap<TypeCache.TYPE_FILTER, String>() {{ put(TypeCache.TYPE_FILTER.NOT_SUPERTYPE, "A"); }}); results = ts.getTypeNames(new HashMap<TypeCache.TYPE_FILTER, String>() {{ put(TypeCache.TYPE_FILTER.SUPERTYPE, "A"); put(TypeCache.TYPE_FILTER.NOT_SUPERTYPE, "B"); results = ts.getTypeNames(new HashMap<TypeCache.TYPE_FILTER, String>() {{ put(TypeCache.TYPE_FILTER.CATEGORY, TypeCategory.TRAIT.name()); put(TypeCache.TYPE_FILTER.SUPERTYPE, "A"); results = ts.getTypeNames(null); assertTrue(results.containsAll(Arrays.asList("A", "A1", "B", "C")), "Results: " + results); results = ts.getTypeNames(new HashMap<TypeCache.TYPE_FILTER, String>());
protected final TypeSystem getTypeSystem() { return TypeSystem.getInstance(); }
@Test public void testIsRegistered() throws Exception { getTypeSystem().defineEnumType("enum_test", new EnumValue("0", 0), new EnumValue("1", 1), new EnumValue("2", 2), new EnumValue("3", 3)); assertTrue(getTypeSystem().isRegistered("enum_test")); }
@Test public void testGetTypeNames() throws Exception { getTypeSystem().defineEnumType("enum_test", new EnumValue("0", 0), new EnumValue("1", 1), new EnumValue("2", 2), new EnumValue("3", 3)); assertTrue(getTypeSystem().getTypeNames().contains("enum_test")); }
@Override public ImmutableMap<?, ?> convert(Object val, Multiplicity m) throws AtlasException { if (val != null) { Iterator<Map.Entry> it = null; if (Map.class.isAssignableFrom(val.getClass())) { it = ((Map) val).entrySet().iterator(); ImmutableMap.Builder b = ImmutableMap.builder(); while (it.hasNext()) { Map.Entry e = it.next(); b.put(keyType.convert(e.getKey(), TypeSystem.getInstance().allowNullsInCollections() ? Multiplicity.OPTIONAL : Multiplicity.REQUIRED), valueType.convert(e.getValue(), Multiplicity.OPTIONAL)); } return b.build(); } else { throw new ValueConversionException(this, val); } } if (!m.nullAllowed()) { throw new ValueConversionException.NullConversionException(m); } return null; }
@Test public void testTypeCategory() throws AtlasException { TypeSystem ts = getTypeSystem(); ts.reset(); StructTypeDefinition struct_A = createStructTypeDef("struct_A", createRequiredAttrDef("s_A", DataTypes.STRING_TYPE)); StructTypeDefinition struct_B = createStructTypeDef("struct_B", createRequiredAttrDef("s_B", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<TraitType> trait_A = createTraitTypeDef("trait_A", null, createRequiredAttrDef("t_A", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<TraitType> trait_B = createTraitTypeDef("trait_B", ImmutableSet.of("trait_A"), createRequiredAttrDef("t_B", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<TraitType> trait_C = createTraitTypeDef("trait_C", ImmutableSet.of("trait_A"), createRequiredAttrDef("t_C", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<TraitType> trait_D = createTraitTypeDef("trait_D", ImmutableSet.of("trait_B", "trait_C"), createRequiredAttrDef("t_D", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<ClassType> class_A = createClassTypeDef("class_A", null, createRequiredAttrDef("c_A", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<ClassType> class_B = createClassTypeDef("class_B", ImmutableSet.of("class_A"), createRequiredAttrDef("c_B", DataTypes.STRING_TYPE)); HierarchicalTypeDefinition<ClassType> class_C = createClassTypeDef("class_C", ImmutableSet.of("class_B"), createRequiredAttrDef("c_C", DataTypes.STRING_TYPE)); ts.defineTypes(ImmutableList.<EnumTypeDefinition>of(), ImmutableList.of(struct_A, struct_B), ImmutableList.of(trait_A, trait_B, trait_C, trait_D), ImmutableList.of(class_A, class_B, class_C)); final ImmutableList<String> structNames = ts.getTypeNamesByCategory(DataTypes.TypeCategory.STRUCT); final ImmutableList<String> traitNames = ts.getTypeNamesByCategory(DataTypes.TypeCategory.TRAIT); final ImmutableList<String> classNames = ts.getTypeNamesByCategory(DataTypes.TypeCategory.CLASS); Assert.assertEquals(structNames.size(), 2); Assert.assertEquals(traitNames.size(), 4); Assert.assertEquals(classNames.size(), 3); }
@Override public ImmutableList<String> getTypeNames() throws AtlasException { Set<String> typeNames = transientTypes.keySet(); typeNames.addAll(TypeSystem.this.getTypeNames()); return ImmutableList.copyOf(typeNames); }
public EnumType defineEnumType(String name, EnumValue... values) throws AtlasException { return defineEnumType(new EnumTypeDefinition(name, values)); }