@Test public void duplicateFields() { // Duplicate fields are allowed - some SQL queries produce this type of value. Struct struct = Struct.newBuilder().set("").to("x").set("").to(Value.int64(2)).build(); assertThat(struct.getType()) .isEqualTo( Type.struct( Type.StructField.of("", Type.string()), Type.StructField.of("", Type.int64()))); assertThat(struct.isNull(0)).isFalse(); assertThat(struct.isNull(1)).isFalse(); assertThat(struct.getString(0)).isEqualTo("x"); assertThat(struct.getLong(1)).isEqualTo(2); }
private Value getValue(int fieldIndex) { Type fieldType = value.getColumnType(fieldIndex); switch (fieldType.getCode()) { case BOOL: return Value.bool(value.getBoolean(fieldIndex)); case INT64: return Value.int64(value.getLong(fieldIndex)); case STRING: return Value.string(value.getString(fieldIndex)); case BYTES: return Value.bytes(value.getBytes(fieldIndex)); case FLOAT64: return Value.float64(value.getDouble(fieldIndex)); case DATE: return Value.date(value.getDate(fieldIndex)); case TIMESTAMP: return Value.timestamp(value.getTimestamp(fieldIndex)); case STRUCT: return Value.struct(value.getStruct(fieldIndex)); case ARRAY: Type elementType = fieldType.getArrayElementType(); switch (elementType.getCode()) { case BOOL: return Value.boolArray(value.getBooleanArray(fieldIndex)); case INT64: return Value.int64Array(value.getLongArray(fieldIndex)); case STRING: return Value.stringArray(value.getStringList(fieldIndex)); case BYTES:
@Test public void bindBoolArrayEmpty() { Struct row = execute( Statement.newBuilder("SELECT @v").bind("v").toBoolArray(Arrays.<Boolean>asList()), Type.array(Type.bool())); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBooleanList(0)).containsExactly(); }
@Override public int hashCode() { int result = getType().hashCode(); for (int i = 0; i < getColumnCount(); ++i) { result = 31 * result + Objects.hashCode(getAsObject(i)); } return result; }
private void checkNonNullStruct(int columnIndex, Object columnNameForError) { Type actualType = getColumnType(columnIndex); checkState( actualType.getCode() == Code.STRUCT, "Column %s is not of correct type: expected STRUCT<...> but was %s", columnNameForError, actualType); checkNonNull(columnIndex, columnNameForError); }
private Object getAsObject(int columnIndex) { Type type = getColumnType(columnIndex); if (isNull(columnIndex)) { return null; switch (type.getCode()) { case BOOL: return getBooleanInternal(columnIndex); case INT64: return getLongInternal(columnIndex); case FLOAT64: return getDoubleInternal(columnIndex); case STRING: return getStringInternal(columnIndex); case BYTES: return getBytesInternal(columnIndex); case TIMESTAMP: return getTimestampInternal(columnIndex); case DATE: return getDateInternal(columnIndex); case STRUCT: return getStructInternal(columnIndex); case ARRAY: switch (type.getArrayElementType().getCode()) { case BOOL: return getBooleanListInternal(columnIndex); case INT64: return getLongListInternal(columnIndex); case FLOAT64: return getDoubleListInternal(columnIndex);
@Test public void writeBoolArray() { write(baseInsert().set("BoolArrayValue").toBoolArray(Arrays.asList(true, null, false)).build()); Struct row = readLastRow("BoolArrayValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBooleanList(0)).containsExactly(true, null, false).inOrder(); expectedException.expect(NullPointerException.class); row.getBooleanArray(0); }
@Test public void structArrayFieldNull() { Type elementType = Type.struct( Arrays.asList( Type.StructField.of("ff1", Type.string()), Type.StructField.of("ff2", Type.int64()))); Struct struct = Struct.newBuilder().set("f1").to("x").set("f2").toStructArray(elementType, null).build(); assertThat(struct.getType()) .isEqualTo( Type.struct( Type.StructField.of("f1", Type.string()), Type.StructField.of("f2", Type.array(elementType)))); assertThat(struct.isNull(0)).isFalse(); assertThat(struct.isNull(1)).isTrue(); }
@Test public void bindStructNull() { Struct row = execute( Statement.newBuilder("SELECT @p IS NULL") .bind("p") .to( Type.struct( asList( Type.StructField.of("f1", Type.string()), Type.StructField.of("f2", Type.float64()))), null) .build(), Type.bool()); assertThat(row.getBoolean(0)).isTrue(); }
@Test public void simpleInsert() { TransactionManager manager = client.transactionManager(); TransactionContext txn = manager.begin(); assertThat(manager.getState()).isEqualTo(TransactionState.STARTED); txn.buffer( Mutation.newInsertBuilder("T").set("K").to("Key1").set("BoolValue").to(true).build()); manager.commit(); assertThat(manager.getState()).isEqualTo(TransactionState.COMMITTED); Struct row = client.singleUse().readRow("T", Key.of("Key1"), Arrays.asList("K", "BoolValue")); assertThat(row.getString(0)).isEqualTo("Key1"); assertThat(row.getBoolean(1)).isTrue(); }
@Test public void writeBool() { write(baseInsert().set("BoolValue").to(true).build()); Struct row = readLastRow("BoolValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBoolean(0)).isTrue(); }
@Test public void bindInt64ArrayEmpty() { Struct row = execute( Statement.newBuilder("SELECT @v").bind("v").toInt64Array(Arrays.<Long>asList()), Type.array(Type.int64())); assertThat(row.isNull(0)).isFalse(); assertThat(row.getLongList(0)).containsExactly(); }
@Test public void bindTimestampArrayEmpty() { Struct row = execute( Statement.newBuilder("SELECT @v") .bind("v") .toTimestampArray(Arrays.<Timestamp>asList()), Type.array(Type.timestamp())); assertThat(row.isNull(0)).isFalse(); assertThat(row.getTimestampList(0)).containsExactly(); }
@Test public void writeString() { write(baseInsert().set("StringValue").to("V1").build()); Struct row = readLastRow("StringValue"); assertThat(row.isNull(0)).isFalse(); assertThat(row.getString(0)).isEqualTo("V1"); }
@Test public void singleStrong() { History expected = history.get(history.size() - 1); ReadOnlyTransaction readContext = client.singleUseReadOnlyTransaction(); Struct row = readRow(readContext); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); assertThat(readContext.getReadTimestamp()).isAtLeast(expected.timestamp); row = readRow(client.singleUse()); assertThat(row).isNotNull(); assertThat(row.getString(0)).isEqualTo(expected.value); }
@Test public void bindStructWithStructField() { Struct nestedStruct = Struct.newBuilder().set("ff1").to("abc").build(); Struct p = Struct.newBuilder().set("f1").to(nestedStruct).build(); Struct row = executeWithRowResultType( Statement.newBuilder("SELECT @p.f1.ff1").bind("p").to(p).build(), nestedStruct.getType()); assertThat(row.getString(0)).isEqualTo("abc"); }
@Test public void bindBool() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to(true).build(), Type.bool()); assertThat(row.isNull(0)).isFalse(); assertThat(row.getBoolean(0)).isEqualTo(true); }
@Test public void bindStructWithNullStructField() { Type emptyStructType = Type.struct(new ArrayList<StructField>()); Struct p = Struct.newBuilder().set("f1").to(emptyStructType, null).build(); Struct row = execute(Statement.newBuilder("SELECT @p.f1 IS NULL").bind("p").to(p).build(), Type.bool()); assertThat(row.getBoolean(0)).isTrue(); }
@Test public void bindDateArrayNull() { Struct row = execute( Statement.newBuilder("SELECT @v").bind("v").toDateArray(null), Type.array(Type.date())); assertThat(row.isNull(0)).isTrue(); }