private Schema getResetType() { if (resetTSchema == null) { List<String> resetStrings = new ArrayList<String>(1); resetStrings.add(RESET); resetTSchema = Schema.createEnum(RESET + "T", null, KAA_NAMESPACE, resetStrings); } return resetTSchema; }
private Schema getUnchangedType() { if (unchangedTSchema == null) { List<String> unchangedStrings = new ArrayList<String>(1); unchangedStrings.add(UNCHANGED); unchangedTSchema = Schema.createEnum(UNCHANGED + "T", null, KAA_NAMESPACE, unchangedStrings); } return unchangedTSchema; }
@Override public Schema schema() { this.schema = Schema.createEnum(this.enumName, "", "", this.enumSet); this.schema.addProp("source.type", "enum"); return this.schema; } }
@Override public Schema schema() { this.schema = Schema.createEnum(this.enumName, "", namespace, this.enumSet); this.schema.addProp(SOURCE_TYPE, ENUM.toString().toLowerCase()); return buildUnionIfNullable(this.schema); } }
private Schema getSchema(EnumDescriptor d) { List<String> symbols = new ArrayList<>(); for (EnumValueDescriptor e : d.getValues()) { symbols.add(e.getName()); } return Schema.createEnum(d.getName(), null, getNamespace(d.getFile(), d.getContainingType()), symbols); }
/** Configure this enum type's symbols, and end its configuration. Populates the default if it was set.**/ public R symbols(String... symbols) { Schema schema = Schema.createEnum(name(), doc(), space(), Arrays.asList(symbols), this.enumDefault); completeSchema(schema); return context().complete(schema); }
/** Configure this enum type's symbols, and end its configuration. **/ public R symbols(String... symbols) { Schema schema = Schema.createEnum(name(), doc(), space(), Arrays.asList(symbols)); completeSchema(schema); return context().complete(schema); }
@Test public void shouldDeserializeEnumToString() { final org.apache.avro.Schema enumSchema = org.apache.avro.Schema.createEnum( "enum", "doc", "namespace", ImmutableList.of("V0", "V1", "V2")); shouldDeserializeTypeCorrectly( enumSchema, new GenericData.EnumSymbol(enumSchema, "V1"), Schema.OPTIONAL_STRING_SCHEMA, "V1"); }
@Test public void testIsUnionOnEnum() { Schema schema = Schema.createEnum("name", "doc", "namespace", Collections.singletonList("value")); assertFalse(schema.isUnion()); }
@Test public void testToStringIsJson() throws JsonParseException, IOException { Field stringField = new Field("string", Schema.create(Type.STRING), null, null); Field enumField = new Field("enum", Schema.createEnum("my_enum", "doc", null, Arrays.asList("a", "b", "c")), null, null); Schema schema = Schema.createRecord("my_record", "doc", "mytest", false); schema.setFields(Arrays.asList(stringField, enumField)); GenericRecord r = new GenericData.Record(schema); // \u2013 is EN DASH r.put(stringField.name(), "hello\nthere\"\tyou\u2013}"); r.put(enumField.name(), new GenericData.EnumSymbol(enumField.schema(),"a")); String json = r.toString(); JsonFactory factory = new JsonFactory(); JsonParser parser = factory.createJsonParser(json); ObjectMapper mapper = new ObjectMapper(); // will throw exception if string is not parsable json mapper.readTree(parser); }
@Test public void testNestedNonNullNamespace1() { Schema inner1 = Schema.createEnum("InnerEnum", null, "space", Arrays.asList("x")); Schema inner2 = Schema.parse("{\"type\":\"record\",\"namespace\":\"space\",\"name\":" +"\"InnerRecord\",\"fields\":[]}"); Schema nullOuter = Schema.createRecord("Outer", null, null, false); nullOuter.setFields(Arrays.asList(new Field("f1", inner1, null, null), new Field("f2", inner2, null, null))); assertEquals(nullOuter, Schema.parse(nullOuter.toString())); }
final public Schema EnumDeclaration() throws ParseException { String name; List<String> symbols; String defaultSymbol = null; jj_consume_token(ENUM); String doc = getDoc(); name = Identifier(); symbols = EnumBody(); switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { case EQUALS: jj_consume_token(EQUALS); defaultSymbol = Identifier(); jj_consume_token(SEMICOLON); break; default: jj_la1[5] = jj_gen; ; } Schema s = Schema.createEnum(name, doc, this.namespace, symbols, defaultSymbol); names.put(s.getFullName(), s); {if (true) return s;} throw new Error("Missing return statement in function"); }
/** * Creates the class type field. * * @return the field */ private Field createClassTypeField() { List<String> classTypeSymbols = Arrays.asList(OBJECT, EVENT); Schema classTypeEnum = Schema.createEnum(CLASS_TYPE_TYPE_NAME, null, BASE_SCHEMA_FORM_NAMESPACE, classTypeSymbols); Field classTypeField = new Field(CLASS_TYPE, classTypeEnum, null, null); classTypeField.addProp(DISPLAY_NAME, "Class type"); JsonNodeFactory jsonFactory = JsonNodeFactory.instance; ArrayNode displayNamesNode = jsonFactory.arrayNode(); displayNamesNode.add(TextNode.valueOf("Object")); displayNamesNode.add(TextNode.valueOf("Event")); classTypeField.addProp(DISPLAY_NAMES, displayNamesNode); classTypeField.addProp(DISPLAY_PROMPT, "Select class type"); classTypeField.addProp(BY_DEFAULT, OBJECT); return classTypeField; }
/** * Creates the override strategy field. * * @return the field */ private Field createOverrideStrategyField() { List<String> overrideStrategySymbols = Arrays.asList(OverrideStrategy.APPEND.name(), OverrideStrategy.REPLACE.name()); Schema overrideStrategyEnum = Schema.createEnum(OVERRIDE_STRATEGY_TYPE_NAME, null, BASE_SCHEMA_FORM_NAMESPACE, overrideStrategySymbols); Field overrideStrategyField = new Field(OVERRIDE_STRATEGY, Schema.createUnion(Arrays.asList( overrideStrategyEnum, Schema.create(Type.NULL))), null, null); overrideStrategyField.addProp(DISPLAY_NAME, "Override strategy"); JsonNodeFactory jsonFactory = JsonNodeFactory.instance; ArrayNode displayNamesNode = jsonFactory.arrayNode(); displayNamesNode.add(TextNode.valueOf("Append")); displayNamesNode.add(TextNode.valueOf("Replace")); overrideStrategyField.addProp(DISPLAY_NAMES, displayNamesNode); overrideStrategyField.addProp(DISPLAY_PROMPT, "Select array override strategy"); return overrideStrategyField; }
@Test public void testEnum() { List<String> symbols = Arrays.asList("a", "b"); Schema expected = Schema.createEnum("myenum", null, null, symbols); expected.addProp("p", "v"); Schema schema = SchemaBuilder.enumeration("myenum") .prop("p", "v").symbols("a", "b"); Assert.assertEquals(expected, schema); }
@Test public void testEnumWithDefault() { List<String> symbols = Arrays.asList("a", "b"); String enumDefault = "a"; Schema expected = Schema.createEnum("myenum", null, null, symbols, enumDefault); expected.addProp("p", "v"); Schema schema = SchemaBuilder.enumeration("myenum") .prop("p", "v").defaultSymbol(enumDefault).symbols("a", "b"); Assert.assertEquals(expected, schema); }
@Test public void testEnumCompare() { Schema s = Schema.createEnum("Kind",null,null,Arrays.asList("Z","Y","X")); GenericEnumSymbol z = new GenericData.EnumSymbol(s, "Z"); GenericEnumSymbol y = new GenericData.EnumSymbol(s, "Y"); assertEquals(0, z.compareTo(z)); assertTrue(y.compareTo(z) > 0); assertTrue(z.compareTo(y) < 0); }
@Test public void validateRequiresGenericSymbolForEnumSchema() { final Schema schema = Schema.createEnum("my_enum", "doc", "namespace", Arrays.asList("ONE","TWO","THREE")); final GenericData gd = GenericData.get(); /* positive cases */ assertTrue(gd.validate(schema, new GenericData.EnumSymbol(schema, "ONE"))); assertTrue(gd.validate(schema, new GenericData.EnumSymbol(schema, anEnum.ONE))); /* negative cases */ assertFalse("We don't expect GenericData to allow a String datum for an enum schema", gd.validate(schema, "ONE")); assertFalse("We don't expect GenericData to allow a Java Enum for an enum schema", gd.validate(schema, anEnum.ONE)); }
@Test public void testDecimalWithNonByteArrayTypes() { final LogicalType decimal = LogicalTypes.decimal(5, 2); // test simple types Schema[] nonBytes = new Schema[] { Schema.createRecord("Record", null, null, false), Schema.createArray(Schema.create(Schema.Type.BYTES)), Schema.createMap(Schema.create(Schema.Type.BYTES)), Schema.createEnum("Enum", null, null, Arrays.asList("a", "b")), Schema.createUnion(Arrays.asList( Schema.create(Schema.Type.BYTES), Schema.createFixed("fixed", null, null, 4))), Schema.create(Schema.Type.BOOLEAN), Schema.create(Schema.Type.INT), Schema.create(Schema.Type.LONG), Schema.create(Schema.Type.FLOAT), Schema.create(Schema.Type.DOUBLE), Schema.create(Schema.Type.NULL), Schema.create(Schema.Type.STRING) }; for (final Schema schema : nonBytes) { assertThrows("Should reject type: " + schema.getType(), IllegalArgumentException.class, "Logical type decimal must be backed by fixed or bytes", new Callable() { @Override public Object call() throws Exception { decimal.addToSchema(schema); return null; } }); } }
@Test public void testPrimitives() throws Exception { check(Schema.create(Schema.Type.NULL), new ColumnMetaData("null", ValueType.NULL)); check(Schema.create(Schema.Type.BOOLEAN), new ColumnMetaData("boolean", ValueType.BOOLEAN)); check(Schema.create(Schema.Type.INT), new ColumnMetaData("int", ValueType.INT)); check(Schema.create(Schema.Type.LONG), new ColumnMetaData("long", ValueType.LONG)); check(Schema.create(Schema.Type.FLOAT), new ColumnMetaData("float", ValueType.FLOAT)); check(Schema.create(Schema.Type.DOUBLE), new ColumnMetaData("double", ValueType.DOUBLE)); check(Schema.create(Schema.Type.BYTES), new ColumnMetaData("bytes", ValueType.BYTES)); check(Schema.create(Schema.Type.STRING), new ColumnMetaData("string", ValueType.STRING)); check(Schema.createEnum("E", null, null, Arrays.asList("X","Y","Z")), new ColumnMetaData("E", ValueType.INT)); check(Schema.createFixed("F", null, null, 5), new ColumnMetaData("F", ValueType.BYTES)); }