/** Generate {@link Schema} from {@code RelDataType} which is used to create table. */ public static Schema toSchema(RelDataType tableInfo) { return tableInfo.getFieldList().stream().map(CalciteUtils::toField).collect(Schema.toSchema()); }
private Schema generateSchema( FieldTypeGenerator fieldTypeGenerator, SourceOfRandomness random, GenerationStatus status) { return IntStream.range(0, status.size() + 1) .mapToObj( i -> Field.of("field_" + i, fieldTypeGenerator.generate(random, status)) .withNullable(true)) .collect(toSchema()); } }
private Table toTable() { return Table.builder() .type(SqlDdlNodes.getString(type)) .name(name.getSimple()) .schema(columnList.stream().collect(toSchema())) .comment(SqlDdlNodes.getString(comment)) .location(SqlDdlNodes.getString(location)) .properties( (tblProperties == null) ? new JSONObject() : parseObject(SqlDdlNodes.getString(tblProperties))) .build(); } }
@Test public void testRejectsNullRecord() { Schema type = Stream.of(Schema.Field.of("f_int", Schema.FieldType.INT32)).collect(toSchema()); thrown.expect(IllegalArgumentException.class); Row.nullRow(type); }
@Test public void testCreateMapWithNullValue() { Map<Integer, String> data = new HashMap(); data.put(1, "value1"); data.put(2, "value2"); data.put(3, null); data.put(4, null); Schema type = Stream.of(Schema.Field.of("map", FieldType.map(FieldType.INT32, FieldType.STRING, true))) .collect(toSchema()); Row row = Row.withSchema(type).addValue(data).build(); assertEquals(data, row.getMap("map")); }
@Test public void testThrowsForIncorrectNumberOfFields() { Schema type = Stream.of( Schema.Field.of("f_int", FieldType.INT32), Schema.Field.of("f_str", FieldType.STRING), Schema.Field.of("f_double", FieldType.DOUBLE)) .collect(toSchema()); thrown.expect(IllegalArgumentException.class); Row.withSchema(type).addValues(1, "2").build(); }
@Test public void testCollector() { Schema type = Stream.of( Schema.Field.of("f_int", FieldType.INT32), Schema.Field.of("f_str", FieldType.STRING), Schema.Field.of("f_double", FieldType.DOUBLE)) .collect(toSchema()); Row row = Stream.of(1, "2", 3.0d).collect(toRow(type)); assertEquals(1, row.<Object>getValue("f_int")); assertEquals("2", row.getValue("f_str")); assertEquals(3.0d, row.<Object>getValue("f_double")); }
@Test public void testCreatesArray() { List<Integer> data = Lists.newArrayList(2, 3, 5, 7); Schema type = Stream.of(Schema.Field.of("array", Schema.FieldType.array(Schema.FieldType.INT32))) .collect(toSchema()); Row row = Row.withSchema(type).addArray(data).build(); assertEquals(data, row.getArray("array")); }
@Test public void testCreatesArrayWithNullElement() { List<Integer> data = Lists.newArrayList(2, null, 5, null); Schema type = Stream.of(Schema.Field.of("array", Schema.FieldType.array(Schema.FieldType.INT32, true))) .collect(toSchema()); Row row = Row.withSchema(type).addArray(data).build(); assertEquals(data, row.getArray("array")); }
@Test public void testCreatesNestedRow() { Schema nestedType = Stream.of(Schema.Field.of("f1_str", Schema.FieldType.STRING)).collect(toSchema()); Schema type = Stream.of( Schema.Field.of("f_int", Schema.FieldType.INT32), Schema.Field.of("nested", Schema.FieldType.row(nestedType))) .collect(toSchema()); Row nestedRow = Row.withSchema(nestedType).addValues("foobar").build(); Row row = Row.withSchema(type).addValues(42, nestedRow).build(); assertEquals((int) 42, (Object) row.getInt32("f_int")); assertEquals("foobar", row.getRow("nested").getString("f1_str")); }
private static Table mockTable(String name, String type) { return Table.builder() .name(name) .comment(name + " table") .location("/home/admin/" + name) .schema( Stream.of( Schema.Field.nullable("id", Schema.FieldType.INT32), Schema.Field.nullable("name", Schema.FieldType.STRING)) .collect(toSchema())) .type(type) .properties(new JSONObject()) .build(); }
private static Table fakeTable(String name) { return Table.builder() .name(name) .comment(name + " table") .location("project:dataset.table") .schema( Stream.of( Schema.Field.nullable("id", Schema.FieldType.INT32), Schema.Field.nullable("name", Schema.FieldType.STRING)) .collect(toSchema())) .type("bigquery") .build(); } }
@Test public void testCreateMapWithArrayValue() { Map<Integer, List<String>> data = ImmutableMap.<Integer, List<String>>builder() .put(1, Arrays.asList("value1")) .put(2, Arrays.asList("value2")) .build(); Schema type = Stream.of( Schema.Field.of( "map", FieldType.map(FieldType.INT32, FieldType.array(FieldType.STRING)))) .collect(toSchema()); Row row = Row.withSchema(type).addValue(data).build(); assertEquals(data, row.getMap("map")); }
@Test public void testCreatesArrayArrayWithNullElement() { List<List<Integer>> data = Lists.<List<Integer>>newArrayList(Lists.newArrayList(1, null, 3, null), null); Schema type = Stream.of( Schema.Field.of( "array", FieldType.array(FieldType.array(FieldType.INT32, true), true))) .collect(toSchema()); Row row = Row.withSchema(type).addArray(data).build(); assertEquals(data, row.getArray("array")); }
@Test public void testCreatesRowArray() { Schema nestedType = Stream.of(Schema.Field.of("f1_str", FieldType.STRING)).collect(toSchema()); List<Row> data = Lists.newArrayList( Row.withSchema(nestedType).addValues("one").build(), Row.withSchema(nestedType).addValues("two").build(), Row.withSchema(nestedType).addValues("three").build()); Schema type = Stream.of(Schema.Field.of("array", FieldType.array(FieldType.row(nestedType)))) .collect(toSchema()); Row row = Row.withSchema(type).addArray(data).build(); assertEquals(data, row.getArray("array")); }
@Test public void testCreatesArrayArray() { List<List<Integer>> data = Lists.<List<Integer>>newArrayList(Lists.newArrayList(1, 2, 3, 4)); Schema type = Stream.of(Schema.Field.of("array", FieldType.array(FieldType.array(FieldType.INT32)))) .collect(toSchema()); Row row = Row.withSchema(type).addArray(data).build(); assertEquals(data, row.getArray("array")); }
@Test public void testCreateMapWithRowValue() { Schema nestedType = Stream.of(Schema.Field.of("f1_str", FieldType.STRING)).collect(toSchema()); Map<Integer, Row> data = ImmutableMap.<Integer, Row>builder() .put(1, Row.withSchema(nestedType).addValues("one").build()) .put(2, Row.withSchema(nestedType).addValues("two").build()) .build(); Schema type = Stream.of(Schema.Field.of("map", FieldType.map(FieldType.INT32, FieldType.row(nestedType)))) .collect(toSchema()); Row row = Row.withSchema(type).addValue(data).build(); assertEquals(data, row.getMap("map")); }
@Test public void testCreateMapWithPrimitiveValue() { Map<Integer, String> data = ImmutableMap.<Integer, String>builder() .put(1, "value1") .put(2, "value2") .put(3, "value3") .put(4, "value4") .build(); Schema type = Stream.of(Schema.Field.of("map", FieldType.map(FieldType.INT32, FieldType.STRING))) .collect(toSchema()); Row row = Row.withSchema(type).addValue(data).build(); assertEquals(data, row.getMap("map")); }
@Test public void testCreatesArrayOfMap() { List<Map<Integer, String>> data = ImmutableList.<Map<Integer, String>>builder() .add(ImmutableMap.of(1, "value1")) .add(ImmutableMap.of(2, "value2")) .build(); Schema type = Stream.of( Schema.Field.of( "array", FieldType.array(FieldType.map(FieldType.INT32, FieldType.STRING)))) .collect(toSchema()); Row row = Row.withSchema(type).addArray(data).build(); assertEquals(data, row.getArray("array")); }
@Test public void testCollector() { Schema schema = Stream.of( Schema.Field.of("f_int", FieldType.INT32), Schema.Field.of("f_string", FieldType.STRING)) .collect(toSchema()); assertEquals(2, schema.getFieldCount()); assertEquals("f_int", schema.getField(0).getName()); assertEquals(FieldType.INT32, schema.getField(0).getType()); assertEquals("f_string", schema.getField(1).getName()); assertEquals(FieldType.STRING, schema.getField(1).getType()); }