@Override public Slice getSlice(int field) { return delegate.getSlice(field); }
@Override public Slice getSlice(int field) { return delegate.getSlice(field); }
@Override public Slice getSlice(int field) { checkPositionIndex(field, delegateFieldCount + appendedTypes.size()); if (field < delegateFieldCount) { return delegate.getSlice(field); } else { return (Slice) appendedValues.get(field - delegateFieldCount); } }
@Override public Slice getSlice(int field) { if (coercers[field] == null) { return delegate.getSlice(field); } return coercers[field].getSlice(delegate, field); }
@Override public Slice getSlice(int field) { return delegate.getSlice(toDelegateField(field)); }
@Override public io.airlift.slice.Slice getSlice(int field) { checkState(!closed); checkPositionIndex(field, types.size()); return currentCursor.getSlice(field); }
@Override public Slice getSlice(int field) { ColumnMapping columnMapping = columnMappings.get(field); if (columnMapping.getKind() == REGULAR) { return delegate.getSlice(columnMapping.getIndex()); } return slices[field]; }
@Override public void coerce(RecordCursor delegate, int field) { try { long value = Long.parseLong(delegate.getSlice(field).toStringUtf8()); if (minValue <= value && value <= maxValue) { setLong(value); } else { setIsNull(true); } } catch (NumberFormatException e) { setIsNull(true); } } }
@Test public void testGetRecordSet() { ConnectorTransactionHandle transaction = new JdbcTransactionHandle(); JdbcRecordSetProvider recordSetProvider = new JdbcRecordSetProvider(jdbcClient); RecordSet recordSet = recordSetProvider.getRecordSet(transaction, SESSION, split, ImmutableList.of(textColumn, textShortColumn, valueColumn)); assertNotNull(recordSet, "recordSet is null"); RecordCursor cursor = recordSet.cursor(); assertNotNull(cursor, "cursor is null"); Map<String, Long> data = new LinkedHashMap<>(); while (cursor.advanceNextPosition()) { data.put(cursor.getSlice(0).toStringUtf8(), cursor.getLong(2)); assertEquals(cursor.getSlice(0), cursor.getSlice(1)); } 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()); }
private static Object extractObject(RecordCursor cursor, int field, Type type) { if (cursor.isNull(field)) { return null; } Class<?> javaType = type.getJavaType(); if (javaType == boolean.class) { return cursor.getBoolean(field); } else if (javaType == long.class) { return cursor.getLong(field); } else if (javaType == double.class) { return cursor.getDouble(field); } else if (javaType == Slice.class) { return cursor.getSlice(field).toStringUtf8(); } throw new AssertionError("Unsupported type: " + type); }
@Test public void testCursorSimple() { RecordSet recordSet = new JdbcRecordSet(jdbcClient, session, split, ImmutableList.of( columnHandles.get("text"), columnHandles.get("text_short"), columnHandles.get("value"))); try (RecordCursor cursor = recordSet.cursor()) { assertEquals(cursor.getType(0), VARCHAR); assertEquals(cursor.getType(1), createVarcharType(32)); assertEquals(cursor.getType(2), BIGINT); Map<String, Long> data = new LinkedHashMap<>(); while (cursor.advanceNextPosition()) { data.put(cursor.getSlice(0).toStringUtf8(), cursor.getLong(2)); assertEquals(cursor.getSlice(0), cursor.getSlice(1)); assertFalse(cursor.isNull(0)); assertFalse(cursor.isNull(1)); assertFalse(cursor.isNull(2)); } 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()); } }
@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()); } }
assertEquals(cursor.getSlice(0).toStringUtf8(), address.toString()); assertEquals(cursor.getSlice(2).toStringUtf8(), "127.0.0.1"); assertEquals(cursor.getSlice(3).toStringUtf8(), "POST"); assertEquals(cursor.getSlice(4).toStringUtf8(), "/v1/memory"); assertTrue(cursor.isNull(5)); assertTrue(cursor.isNull(6)); assertEquals(cursor.getSlice(0).toStringUtf8(), address.toString()); assertEquals(cursor.getSlice(2).toStringUtf8(), "127.0.0.1"); assertEquals(cursor.getSlice(3).toStringUtf8(), "GET"); assertEquals(cursor.getSlice(4).toStringUtf8(), "/v1/service/presto/general"); assertEquals(cursor.getSlice(5).toStringUtf8(), "foo"); assertEquals(cursor.getSlice(6).toStringUtf8(), "ffffffff-ffff-ffff-ffff-ffffffffffff"); assertEquals(cursor.getLong(7), 200); assertEquals(cursor.getLong(8), 0); assertEquals(cursor.getLong(9), 37); assertEquals(cursor.getLong(10), 1094); assertEquals(cursor.getSlice(11).toStringUtf8(), "a7229d56-5cbd-4e23-81ff-312ba6be0f12");
private Comparable<?> getPrestoValue(RecordCursor recordCursor, List<Column> columns, int columnId) { if (recordCursor.isNull(columnId)) { return null; } Column column = columns.get(columnId); ColumnType.Base baseType = column.getType().getBase(); switch (baseType) { case IDENTIFIER: case INTEGER: case DATE: case TIME: case DECIMAL: return recordCursor.getLong(columnId); case VARCHAR: case CHAR: return recordCursor.getSlice(columnId).toStringAscii(); } throw new UnsupportedOperationException(format("Unsupported TPCDS base type [%s]", baseType)); } }
@Test public void testGetRecordSet() { ExampleRecordSetProvider recordSetProvider = new ExampleRecordSetProvider(new ExampleConnectorId("test")); RecordSet recordSet = recordSetProvider.getRecordSet(ExampleTransactionHandle.INSTANCE, SESSION, new ExampleSplit("test", "schema", "table", dataUri), ImmutableList.of( new ExampleColumnHandle("test", "text", createUnboundedVarcharType(), 0), new ExampleColumnHandle("test", "value", BIGINT, 1))); assertNotNull(recordSet, "recordSet is null"); RecordCursor cursor = recordSet.cursor(); assertNotNull(cursor, "cursor is null"); Map<String, Long> data = new LinkedHashMap<>(); while (cursor.advanceNextPosition()) { data.put(cursor.getSlice(0).toStringUtf8(), cursor.getLong(1)); } assertEquals(data, ImmutableMap.<String, Long>builder() .put("ten", 10L) .put("eleven", 11L) .put("twelve", 12L) .build()); }
@Test public void testCursor() { ListBasedRecordSet recordSet = new ListBasedRecordSet( ImmutableList.of( Arrays.asList("1", null, "3"), Arrays.asList("ab", "c", null)), ImmutableList.of(BIGINT, VARCHAR)); assertEquals(recordSet.getColumnTypes(), ImmutableList.of(BIGINT, VARCHAR)); RecordCursor cursor = recordSet.cursor(); assertTrue(cursor.advanceNextPosition()); assertEquals(cursor.getType(0), BIGINT); assertEquals(cursor.getType(1), VARCHAR); assertThrows(IndexOutOfBoundsException.class, () -> cursor.getLong(2)); assertEquals(cursor.getLong(0), 1L); assertEquals(cursor.getSlice(1), Slices.utf8Slice("ab")); assertTrue(cursor.advanceNextPosition()); assertTrue(cursor.isNull(0)); assertEquals(cursor.getSlice(1), Slices.utf8Slice("c")); assertTrue(cursor.advanceNextPosition()); assertEquals(cursor.getLong(0), 3L); assertTrue(cursor.isNull(1)); assertFalse(cursor.advanceNextPosition()); assertThrows(IndexOutOfBoundsException.class, () -> cursor.getLong(0)); } }
@Test public void testCursorMixedOrder() { RecordSet 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))); RecordCursor cursor = recordSet.cursor(); 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("ten", 10L) .put("eleven", 11L) .put("twelve", 12L) .build()); }
@Test public void testCursorSimple() { RecordSet recordSet = new ExampleRecordSet(new ExampleSplit("test", "schema", "table", dataUri), ImmutableList.of( new ExampleColumnHandle("test", "text", createUnboundedVarcharType(), 0), new ExampleColumnHandle("test", "value", BIGINT, 1))); RecordCursor cursor = recordSet.cursor(); assertEquals(cursor.getType(0), createUnboundedVarcharType()); assertEquals(cursor.getType(1), BIGINT); Map<String, Long> data = new LinkedHashMap<>(); while (cursor.advanceNextPosition()) { data.put(cursor.getSlice(0).toStringUtf8(), cursor.getLong(1)); assertFalse(cursor.isNull(0)); assertFalse(cursor.isNull(1)); } assertEquals(data, ImmutableMap.<String, Long>builder() .put("ten", 10L) .put("eleven", 11L) .put("twelve", 12L) .build()); }
private static boolean fieldEquals(RecordCursor cursor, Field field1, Field field2) { checkArgument(cursor.getType(field1.getField()).equals(cursor.getType(field2.getField())), "Should only be comparing fields of the same type"); if (cursor.isNull(field1.getField()) || cursor.isNull(field2.getField())) { return false; } Class<?> javaType = cursor.getType(field1.getField()).getJavaType(); try { if (javaType == long.class) { return TRUE.equals((Boolean) field1.getEqualsMethodHandle().invokeExact(cursor.getLong(field1.getField()), cursor.getLong(field2.getField()))); } else if (javaType == double.class) { return TRUE.equals((Boolean) field1.getEqualsMethodHandle().invokeExact(cursor.getDouble(field1.getField()), cursor.getDouble(field2.getField()))); } else if (javaType == boolean.class) { return TRUE.equals((Boolean) field1.getEqualsMethodHandle().invokeExact(cursor.getBoolean(field1.getField()), cursor.getBoolean(field2.getField()))); } else if (javaType == Slice.class) { return TRUE.equals((Boolean) field1.getEqualsMethodHandle().invokeExact(cursor.getSlice(field1.getField()), cursor.getSlice(field2.getField()))); } else { return TRUE.equals((Boolean) field1.getEqualsMethodHandle().invoke(cursor.getObject(field1.getField()), cursor.getObject(field2.getField()))); } } catch (Throwable t) { throwIfUnchecked(t); throw new RuntimeException(t); } }
Slice slice = cursor.getSlice(columnIndex); type.writeSlice(output, slice, 0, slice.length());