@Override protected Schema outerSchema(Schema inner) { return Schema.createArray(inner); } }
@Override protected Schema outerSchema(Schema inner) { return Schema.createArray(inner); } }
private Schema createAvroArray(TypeInfo typeInfo) { ListTypeInfo listTypeInfo = (ListTypeInfo) typeInfo; Schema listSchema = createAvroSchema(listTypeInfo.getListElementTypeInfo()); return Schema.createArray(listSchema); }
@Override public Schema onSchemaProcessed(Schema rootSchema, Set<Schema> addressableRecords) { List<Schema> deltaTypes = new ArrayList<Schema>(addressableRecords.size() + 1); deltaTypes.add(rootSchema); deltaTypes.addAll(addressableRecords); Field deltaTypesField = new Field(DELTA, Schema.createUnion(deltaTypes), null, null); List<Field> deltaFields = new ArrayList<Field>(); deltaFields.add(deltaTypesField); Schema delta = Schema.createRecord(DELTA + "T", null, KAA_NAMESPACE, false); delta.setFields(deltaFields); return Schema.createArray(delta); }
private Schema getSchema(FieldDescriptor f) { Schema s = getNonRepeatedSchema(f); if (f.isRepeated()) s = Schema.createArray(s); return s; }
/** * Processes array type. * * @return generated value for input array type. */ private Object processArray() { Schema elementTypeSchema = Schema.create(Type.NULL); return new GenericData.Array<>(0, Schema.createArray(elementTypeSchema)); }
private Schema removeFieldsFromArray(Schema schema, Map<String, Schema> schemaMap) { return Schema.createArray(this.removeFields(schema.getElementType(), schemaMap)); }
@Override public void setStringArray(String fieldName, List<String> value) { GenericData.Array<String> avroArray = new GenericData.Array<>( Schema.createArray(Schema.create(Schema.Type.STRING)), value); set(fieldName, avroArray); }
private Schema arraySchema() { Schema schema = Schema.createArray(getElementConverter().schema()); schema.addProp(SOURCE_TYPE, ARRAY.toString().toLowerCase()); return schema; }
@Override public Schema schema() { Schema schema = Schema.createArray(getElementConverter().schema()); schema.addProp("source.type", "array"); return schema; } }
private static Schema createArraySchema() { List<Schema> schemas = new ArrayList<>(); for (int i = 0; i < 5; i++) { schemas.add(createInnerSchema("optional_field_" + i)); } Schema unionSchema = Schema.createUnion(schemas); return Schema.createArray(unionSchema); }
final public Schema ArrayType() throws ParseException { Schema elemSchema; jj_consume_token(ARRAY); jj_consume_token(LT); elemSchema = Type(); jj_consume_token(GT); {if (true) return Schema.createArray(elemSchema);} throw new Error("Missing return statement in function"); }
private static CommonArray createCommonArray(Schema schema, Object value) { List<CommonValue> list = new LinkedList<>(); list.add(new DefaultCommonValue(value)); CommonArray array = new DefaultCommonArray(Schema.createArray(schema), list); return array; }
private Schema recordSchema() { List<Field> fields = new ArrayList<>(); fields.add(new Field("anArray", Schema.createArray(Schema.create(Type.STRING)), null, null)); Schema schema = Schema.createRecord("arrayFoo", "test", "mytest", false); schema.setFields(fields); return schema; }
@Test public void testGetStringArrayUtf8() throws IOException { // Expectation: Even though we read an Avro object with UTF8 underneath, the accessor converts it into a // Java String List<String> expectedQuotes = ImmutableList.of("abc", "defg"); GenericData.Array<Utf8> strings = new GenericData.Array<Utf8>(2, Schema.createArray(Schema.create(Schema.Type.STRING))); expectedQuotes.forEach(s -> strings.add(new Utf8(s))); record.put("favorite_quotes", strings); Assert.assertEquals(accessor.getGeneric("favorite_quotes"), expectedQuotes); }
@Test public void testIsUnionOnArray() { Schema schema = Schema.createArray(Schema.create(Type.LONG)); assertFalse(schema.isUnion()); }
private GenericRecord generateRecordWithArrays() { ArrayList<Schema.Field> fields = new ArrayList<Schema.Field>(); String fieldName = "array1"; Schema fieldSchema = Schema.createArray(Schema.create(Schema.Type.STRING)); String docString = "doc"; fields.add(new Schema.Field(fieldName, fieldSchema, docString, null)); Schema schema = Schema.createRecord("name", docString, "test", false); schema.setFields(fields); GenericData.Record record = new GenericData.Record(schema); GenericData.Array<String> arr = new GenericData.Array<>(2, fieldSchema); arr.add("foobar"); arr.add("foobaz"); record.put("array1", arr); return record; } }
private GenericArray<String> buildTestArray() { Schema s = Schema.createArray(Schema.create(Schema.Type.STRING)); GenericArray<String> arr = new GenericData.Array<>(3, s); arr.add("one"); arr.add("two"); arr.add("three"); return arr; }
@Test public void testArrayReversal() { Schema schema = Schema.createArray(Schema.create(Schema.Type.INT)); GenericArray<Integer> forward = new GenericData.Array<>(10, schema); GenericArray<Integer> backward = new GenericData.Array<>(10, schema); for (int i = 0; i <= 9; i++) { forward.add(i); } for (int i = 9; i >= 0; i--) { backward.add(i); } forward.reverse(); assertTrue(forward.equals(backward)); }
@Test public void testArray() { Schema longSchema = Schema.create(Schema.Type.LONG); Schema expected = Schema.createArray(longSchema); Schema schema1 = SchemaBuilder.array().items().longType(); Assert.assertEquals(expected, schema1); Schema schema2 = SchemaBuilder.array().items(longSchema); Assert.assertEquals(expected, schema2); Schema schema3 = SchemaBuilder.array().prop("p", "v") .items().type("long"); expected.addProp("p", "v"); Assert.assertEquals(expected, schema3); }