@Override public boolean next() throws SpannerException { return delegate.next(); }
private static Struct queryRow(ReadContext ctx) { ResultSet resultSet = Statement.of("SELECT StringValue FROM TestTable").executeQuery(ctx); // TODO(user): Consider a library routine to consume a single row from a query. assertThat(resultSet.next()).isTrue(); Struct row = resultSet.getCurrentRowAsStruct(); assertThat(resultSet.next()).isFalse(); return row; }
private List<Struct> resultRows(Statement statement, Type expectedRowType) { ArrayList<Struct> results = new ArrayList<>(); ResultSet resultSet = statement.executeQuery(client.singleUse(TimestampBound.strong())); while (resultSet.next()) { Struct row = resultSet.getCurrentRowAsStruct(); results.add(row); } assertThat(resultSet.getType()).isEqualTo(expectedRowType); assertThat(resultSet.next()).isFalse(); return results; }
ResultSetStats analyzeQuery() { // [START read_context_analyze_query] ReadContext rc = dbClient.singleUse(); ResultSet resultSet = rc.analyzeQuery( Statement.of("SELECT SingerId, AlbumId, MarketingBudget FROM Albums"), ReadContext.QueryAnalyzeMode.PROFILE); while (resultSet.next()) { // Discard the results. We're only processing because getStats() below requires it. resultSet.getCurrentRowAsStruct(); } ResultSetStats stats = resultSet.getStats(); // [END read_context_analyze_query] return stats; } }
private void keepAlive() { markUsed(); delegate .singleUse(TimestampBound.ofMaxStaleness(60, TimeUnit.SECONDS)) .executeQuery(Statement.newBuilder("SELECT 1").build()) .next(); }
@Override public Status scan( String table, String startKey, int recordCount, Set<String> fields, Vector<HashMap<String, ByteIterator>> result) { if (queriesForReads) { return scanUsingQuery(table, startKey, recordCount, fields, result); } Iterable<String> columns = fields == null ? STANDARD_FIELDS : fields; KeySet keySet = KeySet.newBuilder().addRange(KeyRange.closedClosed(Key.of(startKey), Key.of())).build(); try (ResultSet resultSet = dbClient.singleUse(timestampBound) .read(table, keySet, columns, Options.limit(recordCount))) { while (resultSet.next()) { HashMap<String, ByteIterator> row = new HashMap<>(); decodeStruct(columns, resultSet, row); result.add(row); } return Status.OK; } catch (Exception e) { LOGGER.log(Level.INFO, "scan()", e); return Status.ERROR; } }
private Struct executeWithRowResultType(Statement statement, Type expectedRowType) { ResultSet resultSet = statement.executeQuery(client.singleUse(TimestampBound.strong())); assertThat(resultSet.next()).isTrue(); assertThat(resultSet.getType()).isEqualTo(expectedRowType); Struct row = resultSet.getCurrentRowAsStruct(); assertThat(resultSet.next()).isFalse(); return row; }
@Override public Struct read(ReadContext ctx, String key) { ResultSet resultSet = ctx.executeQuery( Statement.newBuilder("SELECT V FROM T WHERE K = @key") .bind("key") .to(key) .build()); assertThat(resultSet.next()).isTrue(); Struct row = resultSet.getCurrentRowAsStruct(); assertThat(resultSet.next()).isFalse(); return row; } });
private void validate(ResultSet resultSet, BitSet seenRows) { while (resultSet.next()) { assertThat(seenRows.get((int) resultSet.getLong(0))).isFalse(); seenRows.set((int) resultSet.getLong(0)); ByteArray data = resultSet.getBytes(1); assertThat(data.length()).isEqualTo(resultSet.getLong(3)); assertThat(resultSet.getLong(2)).isEqualTo(hasher.hashBytes(data.toByteArray()).asLong()); } } }
void partitionQuery() { // [START partition_query] final BatchReadOnlyTransaction txn = batchClient.batchReadOnlyTransaction(TimestampBound.strong()); List<Partition> partitions = txn.partitionQuery( PartitionOptions.getDefaultInstance(), Statement.of("SELECT SingerId, FirstName, LastName FROM Singers")); for (final Partition p : partitions) { try (ResultSet results = txn.execute(p)) { while (results.next()) { long singerId = results.getLong(0); String firstName = results.getString(1); String lastName = results.getString(2); System.out.println("[" + singerId + "] " + firstName + " " + lastName); } } } // [END partition_query] }
private void validate(ResultSet resultSet) { int i = 0; while (resultSet.next()) { assertThat(resultSet.getLong(0)).isEqualTo(i); ByteArray data = resultSet.getBytes(1); assertThat(data.length()).isEqualTo(resultSet.getLong(3)); assertThat(resultSet.getLong(2)).isEqualTo(hasher.hashBytes(data.toByteArray()).asLong()); assertThat(++i).isAtMost(numRows); } assertThat(i).isEqualTo(numRows); } }
@Override public Long run(TransactionContext transaction) { long rowCount = 0; for (final String stmt : stmts) { ResultSet resultSet = transaction.executeQuery(Statement.of(stmt)); assertThat(resultSet.next()).isFalse(); assertThat(resultSet.getStats()).isNotNull(); rowCount += resultSet.getStats().getRowCountExact(); } return rowCount; } };
@Test public void analyzeProfile() { Statement statement = Statement.of("SELECT 1 AS column UNION ALL SELECT 2 AS column ORDER BY column"); ResultSet resultSet = statement.analyzeQuery(client.singleUse(TimestampBound.strong()), QueryAnalyzeMode.PROFILE); assertThat(resultSet.next()).isTrue(); assertThat(resultSet.getType()).isEqualTo(Type.struct(StructField.of("column", Type.int64()))); assertThat(resultSet.getLong(0)).isEqualTo(1); assertThat(resultSet.next()).isTrue(); assertThat(resultSet.getLong(0)).isEqualTo(2); assertThat(resultSet.next()).isFalse(); ResultSetStats receivedStats = resultSet.getStats(); assertThat(receivedStats).isNotNull(); assertThat(receivedStats.hasQueryPlan()).isTrue(); assertThat(receivedStats.hasQueryStats()).isTrue(); }
@Test public void analyzePlan() { Statement statement = Statement.of("SELECT 1 AS column UNION ALL SELECT 2"); ResultSet resultSet = statement.analyzeQuery(client.singleUse(TimestampBound.strong()), QueryAnalyzeMode.PLAN); assertThat(resultSet.next()).isFalse(); assertThat(resultSet.getType()).isEqualTo(Type.struct(StructField.of("column", Type.int64()))); ResultSetStats receivedStats = resultSet.getStats(); assertThat(receivedStats).isNotNull(); assertThat(receivedStats.hasQueryPlan()).isTrue(); assertThat(receivedStats.hasQueryStats()).isFalse(); }
@Test public void emptyRead() { ResultSet resultSet = client .singleUse(TimestampBound.strong()) .read( TABLE_NAME, KeySet.range(KeyRange.closedOpen(Key.of("k99"), Key.of("z"))), ALL_COLUMNS); assertThat(resultSet.next()).isFalse(); assertThat(resultSet.getType()).isEqualTo(TABLE_TYPE); }
@Test public void indexEmptyRead() { ResultSet resultSet = client .singleUse(TimestampBound.strong()) .readUsingIndex( TABLE_NAME, INDEX_NAME, KeySet.range(KeyRange.closedOpen(Key.of("v99"), Key.of("z"))), ALL_COLUMNS); assertThat(resultSet.next()).isFalse(); assertThat(resultSet.getType()).isEqualTo(TABLE_TYPE); }
@Test public void unboundParameter() { ResultSet resultSet = Statement.of("SELECT @v").executeQuery(client.singleUse(TimestampBound.strong())); expectedException.expect(isSpannerException(ErrorCode.INVALID_ARGUMENT)); expectedException.expectMessage("No parameter found for binding: v"); resultSet.next(); }
@Test public void cursorErrorDeferred() { // Error should be deferred until next(). This gives consistent behavior with respect to // non-blocking implementations (e.g., gRPC). ResultSet resultSet = client .singleUse(TimestampBound.strong()) .read("BadTableName", KeySet.singleKey(Key.of("k1")), ALL_COLUMNS); expectedException.expect(isSpannerException(ErrorCode.NOT_FOUND)); expectedException.expectMessage("BadTableName"); resultSet.next(); }
@Test public void largeErrorText() { String veryLongString = Joiner.on("").join(Iterables.limit(Iterables.cycle("x"), 8000)); Statement statement = Statement.newBuilder("SELECT REGEXP_CONTAINS(@value, @regexp)") .bind("value") .to("") .bind("regexp") .to("(" + veryLongString) .build(); ResultSet resultSet = statement.executeQuery(client.singleUse(TimestampBound.strong())); expectedException.expect(isSpannerException(ErrorCode.OUT_OF_RANGE)); expectedException.expectMessage("Cannot parse regular expression"); resultSet.next(); }