private List<Field<?>> extractKeys() { List<Field<?>> result = new ArrayList<>(); for (String key : tableSchema.getPrimaryKeys()) { // the NullPointerException should never be thrown since the primary keys must always have a type FieldType.Type type = tableSchema.getType(key); switch (Objects.requireNonNull(type)) { case INTEGER: result.add(Fields.intField(key, (int) columns.get(key))); break; case LONG: result.add(Fields.longField(key, (long) columns.get(key))); break; case STRING: result.add(Fields.stringField(key, (String) columns.get(key))); break; case BYTES: result.add(Fields.bytesField(key, (byte[]) columns.get(key))); break; default: // this should never happen since all the keys are from the table schema and should never contain other types throw new IllegalStateException( String.format("The type %s of the primary key %s is not a valid key type", type, key)); } } return result; }
case BYTES: byte[] bytesVal = splitter.getBytes(); keys.add(Fields.bytesField(key, bytesVal)); builder.put(key, bytesVal); break;
private Set<Field<?>> generateFieldsSet() { return ImmutableSet.of( Fields.bytesField("bytes", Bytes.toBytes("bytesval")), Fields.stringField("string", "strval"), Fields.doubleField("double", 100.0), Fields.intField("int", 30), Fields.bytesField("double-bytes", Bytes.toBytes(100.0)), Fields.bytesField("long-bytes", Bytes.toBytes(600L)) ); } }
private Field<?> createField(String name, FieldType.Type type, Object value) { switch (type) { case BYTES: return Fields.bytesField(name, (byte[]) value); case LONG: return Fields.longField(name, (Long) value); case INTEGER: return Fields.intField(name, (Integer) value); case DOUBLE: return Fields.doubleField(name, (Double) value); case FLOAT: return Fields.floatField(name, (Float) value); case STRING: return Fields.stringField(name, (String) value); default: throw new IllegalStateException("Unknown field type " + type); } }
private List<Collection<Field<?>>> writeSimpleStructuredRows(int max, String suffix) throws Exception { List<Collection<Field<?>>> expected = new ArrayList<>(max); for (int i = 0; i < max; i++) { List<Field<?>> fields = Arrays.asList(Fields.intField(KEY, i), Fields.longField(KEY2, (long) i), Fields.stringField(STRING_COL, VAL + i + suffix), Fields.doubleField(DOUBLE_COL, (double) i), Fields.floatField(FLOAT_COL, (float) i), Fields.bytesField(BYTES_COL, Bytes.toBytes("bytes-" + i))); expected.add(fields); getTransactionRunner().run(context -> { StructuredTable table = context.getTable(SIMPLE_TABLE); table.upsert(fields); }); } return expected; }
private List<Field<?>> convertRowToFields(StructuredRow row, List<String> columns) { List<Field<?>> fields = new ArrayList<>(); for (String name : columns) { FieldType.Type type = SIMPLE_SCHEMA.getType(name); if (type == null) { throw new InvalidFieldException(SIMPLE_TABLE, name); } switch (type) { case BYTES: fields.add(Fields.bytesField(name, row.getBytes(name))); break; case STRING: fields.add(Fields.stringField(name, row.getString(name))); break; case FLOAT: fields.add(Fields.floatField(name, row.getFloat(name))); break; case DOUBLE: fields.add(Fields.doubleField(name, row.getDouble(name))); break; case INTEGER: fields.add(Fields.intField(name, row.getInteger(name))); break; case LONG: fields.add(Fields.longField(name, row.getLong(name))); break; } } return fields; }
DOUBLE_COL, Fields.doubleField(DOUBLE_COL, 100.0), FLOAT_COL, Fields.floatField(FLOAT_COL, 10.0f), BYTES_COL, Fields.bytesField(BYTES_COL, Bytes.toBytes("new-bytes")), LONG_COL, Fields.longField(LONG_COL, 500L) );
private List<Collection<Field<?>>> scanSimpleStructuredRows(Range range, int max) throws Exception { List<Collection<Field<?>>> actual = new ArrayList<>(max); getTransactionRunner().run(context -> { StructuredTable table = context.getTable(SIMPLE_TABLE); try (CloseableIterator<StructuredRow> iterator = table.scan(range, max)) { while (iterator.hasNext()) { StructuredRow row = iterator.next(); actual.add(Arrays.asList(Fields.intField(KEY, row.getInteger(KEY)), Fields.longField(KEY2, row.getLong(KEY2)), Fields.stringField(STRING_COL, row.getString(STRING_COL)), Fields.doubleField(DOUBLE_COL, row.getDouble(DOUBLE_COL)), Fields.floatField(FLOAT_COL, row.getFloat(FLOAT_COL)), Fields.bytesField(BYTES_COL, row.getBytes(BYTES_COL)))); } } }); return actual; } }