How to use

Struct

in

com.google.cloud.spanner

@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 writeTimestampNull() {
 write(baseInsert().set("TimestampValue").to((Timestamp) null).build());
 Struct row = readLastRow("TimestampValue");
 assertThat(row.isNull(0)).isTrue();
}

@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();
}