@Override public boolean advanceNextPosition() { return delegate.advanceNextPosition(); }
@Override public long getLong(int field) { return delegate.getLong(field); }
@Override public boolean isNull(int field) { return delegate.isNull(field); }
@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)); } }
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); } }
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)); type.writeLong(output, cursor.getLong(columnIndex)); type.writeDouble(output, cursor.getDouble(columnIndex)); Slice slice = cursor.getSlice(columnIndex); type.writeSlice(output, slice, 0, slice.length()); type.writeObject(output, cursor.getObject(columnIndex)); checkState(!cursor.advanceNextPosition(), "cursor has more values than expected"); return output.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); }
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(); }
@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()); }
@Override public Slice getSlice(int field) { return delegate.getSlice(field); }
@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); } } } } }
@Override public void coerce(RecordCursor delegate, int field) { if (delegate.isNull(field)) { setIsNull(true); return; } Block block = (Block) delegate.getObject(field); if (pageBuilder.isFull()) { pageBuilder.reset(); } BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(0); BlockBuilder rowBuilder = blockBuilder.beginBlockEntry(); for (int i = 0; i < toFieldTypes.size(); i++) { if (i >= fromFieldTypes.size() || block.isNull(i)) { rowBuilder.appendNull(); } else if (coercers[i] == null) { toFieldTypes.get(i).appendTo(block, i, rowBuilder); } else { rewriteBlock(fromFieldTypes.get(i), toFieldTypes.get(i), block, i, rowBuilder, coercers[i], bridgingRecordCursor); } } blockBuilder.closeEntry(); pageBuilder.declarePosition(); setObject(toType.getObject(blockBuilder, blockBuilder.getPositionCount() - 1)); } }
@Override public Type getType(int field) { return delegate.getType(field); }
@Override public double getDouble(int field) { return delegate.getDouble(field); }
@Override public boolean getBoolean(int field) { return delegate.getBoolean(field); }
@Override public void close() { delegate.close(); } }
@Override public Object getObject(int field) { return delegate.getObject(field); }
@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)); } }
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); } }
@Override public Slice getSlice(int field) { return delegate.getSlice(field); }