Refine search
@Test public void testCursorMixedOrder() { RecordSet recordSet = new JdbcRecordSet(jdbcClient, session, split, ImmutableList.of( columnHandles.get("value"), columnHandles.get("value"), columnHandles.get("text"))); try (RecordCursor cursor = recordSet.cursor()) { assertEquals(cursor.getType(0), BIGINT); assertEquals(cursor.getType(1), BIGINT); assertEquals(cursor.getType(2), VARCHAR); Map<String, Long> data = new LinkedHashMap<>(); while (cursor.advanceNextPosition()) { assertEquals(cursor.getLong(0), cursor.getLong(1)); data.put(cursor.getSlice(2).toStringUtf8(), cursor.getLong(0)); } assertEquals(data, ImmutableMap.<String, Long>builder() .put("one", 1L) .put("two", 2L) .put("three", 3L) .put("ten", 10L) .put("eleven", 11L) .put("twelve", 12L) .build()); } }
public FieldSetFilteringRecordSet(FunctionRegistry functionRegistry, RecordSet delegate, List<Set<Integer>> fieldSets) { requireNonNull(functionRegistry, "functionRegistry is null"); this.delegate = requireNonNull(delegate, "delegate is null"); ImmutableList.Builder<Set<Field>> fieldSetsBuilder = ImmutableList.builder(); List<Type> columnTypes = delegate.getColumnTypes(); for (Set<Integer> fieldSet : requireNonNull(fieldSets, "fieldSets is null")) { ImmutableSet.Builder<Field> fieldSetBuilder = ImmutableSet.builder(); for (int field : fieldSet) { fieldSetBuilder.add(new Field( field, functionRegistry.getScalarFunctionImplementation(internalOperator(OperatorType.EQUAL, BooleanType.BOOLEAN, ImmutableList.of(columnTypes.get(field), columnTypes.get(field)))).getMethodHandle())); } fieldSetsBuilder.add(fieldSetBuilder.build()); } this.fieldSets = fieldSetsBuilder.build(); }
public RecordPageSource(RecordSet recordSet) { this(requireNonNull(recordSet, "recordSet is null").getColumnTypes(), recordSet.cursor()); }
private List<Long> readTimeStampsFrom(RecordSet recordSet) { ImmutableList.Builder<Long> result = ImmutableList.builder(); try (RecordCursor cursor = recordSet.cursor()) { while (cursor.advanceNextPosition()) { for (int i = 0; i < recordSet.getColumnTypes().size(); i++) { cursor.isNull(i); } if (cursor.isNull(0)) { return result.build(); } assertTrue(recordSet.getColumnTypes().get(0) instanceof TimestampType); result.add(cursor.getLong(0)); } } return result.build(); }
private static IndexedTable indexTable(RecordSet recordSet, final List<String> outputColumns, List<String> keyColumns) { List<Integer> keyPositions = keyColumns.stream() .map(columnName -> { int position = outputColumns.indexOf(columnName); checkState(position != -1); return position; }) .collect(toImmutableList()); ImmutableListMultimap.Builder<MaterializedTuple, MaterializedTuple> indexedValuesBuilder = ImmutableListMultimap.builder(); List<Type> outputTypes = recordSet.getColumnTypes(); List<Type> keyTypes = extractPositionValues(outputTypes, keyPositions); RecordCursor cursor = recordSet.cursor(); while (cursor.advanceNextPosition()) { List<Object> values = extractValues(cursor, outputTypes); List<Object> keyValues = extractPositionValues(values, keyPositions); indexedValuesBuilder.put(new MaterializedTuple(keyValues), new MaterializedTuple(values)); } return new IndexedTable(keyColumns, keyTypes, outputColumns, outputTypes, indexedValuesBuilder.build()); }
@Test public void testGetColumnTypes() { RecordSet recordSet = new JdbcRecordSet(jdbcClient, session, split, ImmutableList.of( new JdbcColumnHandle("test", "text", JDBC_VARCHAR, VARCHAR), new JdbcColumnHandle("test", "text_short", JDBC_VARCHAR, createVarcharType(32)), new JdbcColumnHandle("test", "value", JDBC_BIGINT, BIGINT))); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(VARCHAR, createVarcharType(32), BIGINT)); recordSet = new JdbcRecordSet(jdbcClient, session, split, ImmutableList.of( new JdbcColumnHandle("test", "value", JDBC_BIGINT, BIGINT), new JdbcColumnHandle("test", "text", JDBC_VARCHAR, VARCHAR))); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(BIGINT, VARCHAR)); recordSet = new JdbcRecordSet(jdbcClient, session, split, ImmutableList.of( new JdbcColumnHandle("test", "value", JDBC_BIGINT, BIGINT), new JdbcColumnHandle("test", "value", JDBC_BIGINT, BIGINT), new JdbcColumnHandle("test", "text", JDBC_VARCHAR, VARCHAR))); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(BIGINT, BIGINT, VARCHAR)); recordSet = new JdbcRecordSet(jdbcClient, session, split, ImmutableList.of()); assertEquals(recordSet.getColumnTypes(), ImmutableList.of()); }
@Test public void testGetRecords() List<ColumnHandle> columnHandles = ImmutableList.copyOf(metadata.getColumnHandles(SESSION, tableHandle).values()); Map<String, Integer> columnIndex = indexColumns(columnHandles); try (RecordCursor cursor = recordSetProvider.getRecordSet(transaction, SESSION, cassandraSplit, columnHandles).cursor()) { while (cursor.advanceNextPosition()) { try { assertReadFields(cursor, tableMetadata.getColumns()); String keyValue = cursor.getSlice(columnIndex.get("key")).toStringUtf8(); assertTrue(keyValue.startsWith("key ")); int rowId = Integer.parseInt(keyValue.substring(4)); assertEquals(keyValue, String.format("key %d", rowId)); assertEquals(Bytes.toHexString(cursor.getSlice(columnIndex.get("typebytes")).getBytes()), String.format("0x%08X", rowId));
public ConcatRecordSet(Iterable<RecordSet> recordSets, List<Type> types) { this.recordSets = requireNonNull(recordSets, "recordSets is null"); for (RecordSet recordSet : recordSets) { checkState(recordSet.getColumnTypes().equals(types), "RecordSet types do not match declared types"); } this.types = ImmutableList.copyOf(requireNonNull(types, "types is null")); }
public static PrestoThriftPageResult fromRecordSet(RecordSet recordSet) { List<Type> types = recordSet.getColumnTypes(); int numberOfColumns = types.size(); int positions = totalRecords(recordSet); if (numberOfColumns == 0) { return new PrestoThriftPageResult(ImmutableList.of(), positions, null); } List<PrestoThriftBlock> thriftBlocks = new ArrayList<>(numberOfColumns); for (int columnIndex = 0; columnIndex < numberOfColumns; columnIndex++) { thriftBlocks.add(fromRecordSetColumn(recordSet, columnIndex, positions)); } return new PrestoThriftPageResult(thriftBlocks, positions, null); }
@Override public List<Type> getColumnTypes() { return ImmutableList.<Type>builder() .addAll(delegate.getColumnTypes()) .addAll(appendedTypes) .build(); }
@Test public void testRecordSetProvider() throws Exception { for (SchemaTableName schemaTableName : metadata.listTables(SESSION, JMX_SCHEMA_NAME)) { RecordSet recordSet = getRecordSet(schemaTableName); try (RecordCursor cursor = recordSet.cursor()) { while (cursor.advanceNextPosition()) { for (int i = 0; i < recordSet.getColumnTypes().size(); i++) { cursor.isNull(i); } } } } }
.collect(toImmutableList()); RecordCursor cursor = data.cursor(); while (true) { if (!cursor.advanceNextPosition()) { if (batch.size() > 0) { batch.execute(); Type type = columns.get(column).getType(); if (BOOLEAN.equals(type)) { batch.bind(column, cursor.getBoolean(column)); batch.bind(column, cursor.getLong(column));
public MappedRecordSet(RecordSet delegate, List<Integer> delegateFieldIndex) { this.delegate = requireNonNull(delegate, "delegate is null"); this.delegateFieldIndex = Ints.toArray(requireNonNull(delegateFieldIndex, "delegateFieldIndex is null")); List<Type> types = delegate.getColumnTypes(); this.columnTypes = delegateFieldIndex.stream().map(types::get).collect(toImmutableList()); }
private static Block convertColumnToBlock(RecordSet recordSet, int columnIndex, int positions) Type type = recordSet.getColumnTypes().get(columnIndex); BlockBuilder output = type.createBlockBuilder(null, positions); Class<?> javaType = type.getJavaType(); RecordCursor cursor = recordSet.cursor(); for (int position = 0; position < positions; position++) { checkState(cursor.advanceNextPosition(), "cursor has less values than expected"); if (cursor.isNull(columnIndex)) { output.appendNull(); type.writeBoolean(output, cursor.getBoolean(columnIndex));
public static PrestoThriftBlock fromLongBasedColumn(RecordSet recordSet, int columnIndex, int positions, BiFunction<boolean[], long[], PrestoThriftBlock> result) { if (positions == 0) { return result.apply(null, null); } boolean[] nulls = null; long[] longs = null; RecordCursor cursor = recordSet.cursor(); for (int position = 0; position < positions; position++) { checkState(cursor.advanceNextPosition(), "cursor has less values than expected"); if (cursor.isNull(columnIndex)) { if (nulls == null) { nulls = new boolean[positions]; } nulls[position] = true; } else { if (longs == null) { longs = new long[positions]; } longs[position] = cursor.getLong(columnIndex); } } checkState(!cursor.advanceNextPosition(), "cursor has more values than expected"); return result.apply(nulls, longs); }
private static int totalRecords(RecordSet recordSet) { RecordCursor cursor = recordSet.cursor(); int result = 0; while (cursor.advanceNextPosition()) { result++; } return result; } }
@Override public RecordCursor cursor(ConnectorTransactionHandle transactionHandle, ConnectorSession session, TupleDomain<Integer> constraint) { return DATA.cursor(); } }
@Override public List<Type> getColumnTypes() { return delegate.getColumnTypes(); }
@Test public void testGetColumnTypes() { RecordSet recordSet = new ExampleRecordSet(new ExampleSplit("test", "schema", "table", dataUri), ImmutableList.of( new ExampleColumnHandle("test", "text", createUnboundedVarcharType(), 0), new ExampleColumnHandle("test", "value", BIGINT, 1))); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(createUnboundedVarcharType(), BIGINT)); recordSet = new ExampleRecordSet(new ExampleSplit("test", "schema", "table", dataUri), ImmutableList.of( new ExampleColumnHandle("test", "value", BIGINT, 1), new ExampleColumnHandle("test", "text", createUnboundedVarcharType(), 0))); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(BIGINT, createUnboundedVarcharType())); recordSet = new ExampleRecordSet(new ExampleSplit("test", "schema", "table", dataUri), ImmutableList.of( new ExampleColumnHandle("test", "value", BIGINT, 1), new ExampleColumnHandle("test", "value", BIGINT, 1), new ExampleColumnHandle("test", "text", createUnboundedVarcharType(), 0))); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(BIGINT, BIGINT, createUnboundedVarcharType())); recordSet = new ExampleRecordSet(new ExampleSplit("test", "schema", "table", dataUri), ImmutableList.of()); assertEquals(recordSet.getColumnTypes(), ImmutableList.of()); }