How to use

getLong

method

in

com.google.cloud.spanner.Struct

@Override
public long getLong(String columnName) {
 return getCurrentRowAsStruct().getLong(columnName);
}

 return Value.bool(value.getBoolean(fieldIndex));
case INT64:
 return Value.int64(value.getLong(fieldIndex));
case STRING:
 return Value.string(value.getString(fieldIndex));

@Override
public long getLong(int columnIndex) {
 return getCurrentRowAsStruct().getLong(columnIndex);
}

 @Override
 public Void run(TransactionContext transaction) {
  long rowCount =
    transaction.executeUpdate(Statement.of("UPDATE T SET v = v * 2 WHERE k = 'boo2';"));
  assertThat(rowCount).isEqualTo(1);
  assertThat(transaction.readRow("T", Key.of("boo2"), Arrays.asList("v")).getLong(0))
    .isEqualTo(2 * 2);
  return null;
 }
};

@Test
public void simple() {
 Struct row = execute(Statement.of("SELECT 1"), Type.int64());
 assertThat(row.getLong(0)).isEqualTo(1);
}

@Ignore // Not yet supported by the backend.
@Test
public void arrayOfStructNullElement() {
 Type structType =
   Type.struct(StructField.of("", Type.string()), StructField.of("", Type.int64()));
 Struct row =
   execute(
     Statement.of(
       "SELECT ARRAY(SELECT AS STRUCT 'a', 1"
         + " UNION ALL SELECT CAST (NULL AS STRUCT<string,int64>))"),
     Type.array(structType));
 assertThat(row.isNull(0)).isFalse();
 List<Struct> value = row.getStructList(0);
 assertThat(value.size()).isEqualTo(2);
 assertThat(value.get(0).getType()).isEqualTo(structType);
 assertThat(value.get(0).getString(0)).isEqualTo("a");
 assertThat(value.get(0).getLong(1)).isEqualTo(1);
 assertThat(value.get(1)).isNull();
}

@Test
public void bindInt64() {
 Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to(1234), Type.int64());
 assertThat(row.isNull(0)).isFalse();
 assertThat(row.getLong(0)).isEqualTo(1234);
}

@Test
public void unnamedFields() {
 Struct struct = Struct.newBuilder().add(Value.int64(2)).add(Value.int64(3)).build();
 assertThat(struct.getType())
   .isEqualTo(
     Type.struct(
       Type.StructField.of("", Type.int64()), Type.StructField.of("", Type.int64())));
 assertThat(struct.getLong(0)).isEqualTo(2);
 assertThat(struct.getLong(1)).isEqualTo(3);
}

@Test
public void bindStructWithUnnamedFields() {
 Struct p = Struct.newBuilder().add(Value.int64(1337)).add(Value.int64(7331)).build();
 Struct row =
   executeWithRowResultType(
     Statement.newBuilder("SELECT * FROM UNNEST([@p])").bind("p").to(p).build(),
     p.getType());
 assertThat(row.getLong(0)).isEqualTo(1337);
 assertThat(row.getLong(1)).isEqualTo(7331);
}

@Test
public void writeInt64() {
 write(baseInsert().set("Int64Value").to(1234).build());
 Struct row = readLastRow("Int64Value");
 assertThat(row.isNull(0)).isFalse();
 assertThat(row.getLong(0)).isEqualTo(1234L);
}

    .singleUse(TimestampBound.strong())
    .readRow("T", Key.of(key), Arrays.asList("V"))
    .getLong(0))
.isEqualTo(Long.valueOf(numThreads));

@Test
public void standardDMLWithDuplicates() {
 executeUpdate(DML_COUNT, INSERT_DML);
 executeUpdate(
   4,
   "UPDATE T SET v = 200 WHERE k = 'boo1';",
   "UPDATE T SET v = 300 WHERE k = 'boo1';",
   "UPDATE T SET v = 400 WHERE k = 'boo1';",
   "UPDATE T SET v = 500 WHERE k = 'boo1';");
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V"))
       .getLong(0))
   .isEqualTo(500);
 executeUpdate(DML_COUNT, DELETE_DML, DELETE_DML);
}

@Test
public void standardDML() {
 executeUpdate(DML_COUNT, INSERT_DML);
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V"))
       .getLong(0))
   .isEqualTo(1);
 executeUpdate(DML_COUNT, UPDATE_DML);
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V"))
       .getLong(0))
   .isEqualTo(100);
 executeUpdate(DML_COUNT, DELETE_DML);
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V")))
   .isNull();
}

 @Override
 public Long run(TransactionContext transaction) throws SpannerException {
  Struct row = strategy.read(transaction, key);
  long newValue = row.getLong(0) + 1;
  transaction.buffer(
    Mutation.newUpdateBuilder("T").set("K").to(key).set("V").to(newValue).build());
  commitBarrier.countDown();
  // Synchronize so that all threads attempt to commit at the same time.
  Uninterruptibles.awaitUninterruptibly(commitBarrier);
  return newValue;
 }
};

@Test
public void partitionedDML() {
 executeUpdate(DML_COUNT, INSERT_DML);
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V"))
       .getLong(0))
   .isEqualTo(1);
 long rowCount = client.executePartitionedUpdate(Statement.of(UPDATE_DML));
 // Note: With PDML there is a possibility of network replay or partial update to occur, causing
 // this assert to fail. We should remove this assert if it is a recurring failure in IT tests.
 assertThat(rowCount).isEqualTo(DML_COUNT);
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V"))
       .getLong(0))
   .isEqualTo(100);
 rowCount = client.executePartitionedUpdate(Statement.of(DELETE_DML));
 assertThat(rowCount).isEqualTo(DML_COUNT);
 assertThat(
     client
       .singleUse(TimestampBound.strong())
       .readRow("T", Key.of("boo1"), Arrays.asList("V")))
   .isNull();
}

@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 void assertRow(Struct actualRow, JSONArray expectedRow) throws Exception {
 assertThat(actualRow.getColumnCount()).isEqualTo(expectedRow.length());
 for (int i = 0; i < expectedRow.length(); i++) {
  switch (actualRow.getColumnType(i).getCode()) {
   case BOOL:
    assertThat(actualRow.getBoolean(i)).isEqualTo(expectedRow.getBoolean(i));
    break;
   case STRING:
    assertThat(actualRow.getString(i)).isEqualTo(expectedRow.getString(i));
    break;
   case INT64:
    assertThat(actualRow.getLong(i)).isEqualTo(expectedRow.getLong(i));
    break;
   case FLOAT64:
    assertThat(actualRow.getDouble(i)).isEqualTo(expectedRow.getDouble(i));
    break;
   case BYTES:
    assertThat(actualRow.getBytes(i))
      .isEqualTo(ByteArray.fromBase64(expectedRow.getString(i)));
    break;
   case ARRAY:
    Type elementType = actualRow.getColumnType(i).getArrayElementType();
    assertArray(getRawList(actualRow, i, elementType), expectedRow.getJSONArray(i));
    break;
   default:
    Assert.fail("Unexpected type code:" + actualRow.getColumnType(i).getCode());
  }
 }
}

assertThat(value.get(0).getType()).isEqualTo(structType);
assertThat(value.get(0).getString(0)).isEqualTo("a");
assertThat(value.get(0).getLong(1)).isEqualTo(1);
assertThat(value.get(1).getType()).isEqualTo(structType);
assertThat(value.get(1).getString(0)).isEqualTo("b");
assertThat(value.get(1).getLong(1)).isEqualTo(2);

@Test
public void builder() {
 // These tests are basic: AbstractStructReaderTypesTest already covers all type getters.
 Struct struct =
   Struct.newBuilder()
     .set("f1")
     .to("x")
     .set("f2")
     .to(2)
     .set("f3")
     .to(Value.bool(null))
     .build();
 assertThat(struct.getType())
   .isEqualTo(
     Type.struct(
       Type.StructField.of("f1", Type.string()),
       Type.StructField.of("f2", Type.int64()),
       Type.StructField.of("f3", Type.bool())));
 assertThat(struct.isNull(0)).isFalse();
 assertThat(struct.isNull(1)).isFalse();
 assertThat(struct.isNull(2)).isTrue();
 assertThat(struct.getString(0)).isEqualTo("x");
 assertThat(struct.getLong(1)).isEqualTo(2);
}

@Test
public void bindStructWithDuplicateFieldNames() {
 Struct p =
   Struct.newBuilder()
     .set("f1")
     .to(Value.int64(1337))
     .set("f1")
     .to(Value.string("1337"))
     .build();
 Struct row =
   executeWithRowResultType(
     Statement.newBuilder("SELECT * FROM UNNEST([@p])").bind("p").to(p).build(),
     p.getType());
 assertThat(row.getLong(0)).isEqualTo(1337);
 assertThat(row.getString(1)).isEqualTo("1337");
}