@Override public int getPrecision(final int column) throws SQLException { return resultSetMetaData.getPrecision(column); }
@Override public int getPrecision(int column) throws InvalidResultSetAccessException { try { return this.resultSetMetaData.getPrecision(column); } catch (SQLException se) { throw new InvalidResultSetAccessException(se); } }
@Override public int resultSetMetaData_getPrecision(ResultSetMetaDataProxy metaData, int column) throws SQLException { if (this.pos < filterSize) { return nextFilter().resultSetMetaData_getPrecision(this, metaData, column); } return metaData.getResultSetMetaDataRaw() .getPrecision(column); }
ColumnInfo ci = new ColumnInfo(meta.getColumnName(i), meta.getColumnType(i), meta.getPrecision(i), meta.getScale(i)); info[i - 1] = ci;
/** * @param rsMeta Metadata. * @return List of fields metadata. * @throws SQLException If failed. */ public static List<GridQueryFieldMetadata> meta(ResultSetMetaData rsMeta) throws SQLException { List<GridQueryFieldMetadata> meta = new ArrayList<>(rsMeta.getColumnCount()); for (int i = 1; i <= rsMeta.getColumnCount(); i++) { String schemaName = rsMeta.getSchemaName(i); String typeName = rsMeta.getTableName(i); String name = rsMeta.getColumnLabel(i); String type = rsMeta.getColumnClassName(i); int precision = rsMeta.getPrecision(i); int scale = rsMeta.getScale(i); if (type == null) // Expression always returns NULL. type = Void.class.getName(); meta.add(new H2SqlFieldMetadata(schemaName, typeName, name, type, precision, scale)); } return meta; }
String name = meta.getColumnLabel(i + 1); int sqlType = meta.getColumnType(i + 1); int precision = meta.getPrecision(i + 1); int scale = meta.getScale(i + 1); simple.addColumn(name, sqlType, precision, scale);
@Override public ColumnDesc[] evalQueryMetadata(String query) { if (StringUtils.isEmpty(query)) { throw new RuntimeException("Evaluate query shall not be empty."); } try (Connection conn = dataSource.getConnection(); Statement state = conn.createStatement(); ResultSet rs = state.executeQuery(dataSource.convertSql(query))) { ResultSetMetaData rsMeta = rs.getMetaData(); ColumnDesc[] columnDescs = new ColumnDesc[rsMeta.getColumnCount()]; for (int i = 0; i < columnDescs.length; i++) { columnDescs[i] = new ColumnDesc(); columnDescs[i].setName(rsMeta.getColumnName(i + 1).toUpperCase(Locale.ROOT)); String kylinType = dataSource.toKylinTypeName(rsMeta.getColumnType(i + 1)); int precision = (SqlUtil.isPrecisionApplicable(kylinType) && rsMeta.getPrecision(i + 1) > 0) ? rsMeta.getPrecision(i + 1) : -1; int scale = (SqlUtil.isScaleApplicable(kylinType) && rsMeta.getScale(i + 1) > 0) ? rsMeta.getScale(i + 1) : -1; columnDescs[i].setDatatype(new DataType(kylinType, precision, scale).toString()); columnDescs[i].setId(String.valueOf(i + 1)); } return columnDescs; } catch (Exception e) { throw new RuntimeException("Cannot evaluate metadata of query: " + query, e); } }
@Ignore( "TODO(DRILL-3355): unignore when getPrecision(...) implemented" ) @Test public void test_getPrecision_forDOUBLE() throws SQLException { // Is it actual bits?: assertThat( rowMetadata.getPrecision( ordReqDOUBLE ), equalTo( 53 ) ); // Is it number of possible decimal digits? assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 7 ) ); // Is it minimum guaranteed decimal digits? assertThat( rowMetadata.getPrecision( ordReqDOUBLE ), equalTo( 6 ) ); }
@Ignore( "TODO(DRILL-3355): unignore when getPrecision(...) implemented" ) @Test public void test_getPrecision_forINTEGER() throws SQLException { // Is it actual bits?: assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 32 ) ); // Is it number of possible decimal digits? assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 10 ) ); // Is it minimum guaranteed decimal digits? assertThat( rowMetadata.getPrecision( ordReqINTEGER ), equalTo( 9 ) ); }
private Pair<List<List<String>>, List<SelectedColumnMeta>> createResponseFromResultSet(ResultSet resultSet) throws Exception { List<List<String>> results = Lists.newArrayList(); List<SelectedColumnMeta> columnMetas = Lists.newArrayList(); ResultSetMetaData metaData = resultSet.getMetaData(); int columnCount = metaData.getColumnCount(); // Fill in selected column meta for (int i = 1; i <= columnCount; ++i) { columnMetas.add(new SelectedColumnMeta(metaData.isAutoIncrement(i), metaData.isCaseSensitive(i), metaData.isSearchable(i), metaData.isCurrency(i), metaData.isNullable(i), metaData.isSigned(i), metaData.getColumnDisplaySize(i), metaData.getColumnLabel(i), metaData.getColumnName(i), metaData.getSchemaName(i), metaData.getCatalogName(i), metaData.getTableName(i), metaData.getPrecision(i), metaData.getScale(i), metaData.getColumnType(i), metaData.getColumnTypeName(i), metaData.isReadOnly(i), metaData.isWritable(i), metaData.isDefinitelyWritable(i))); } // fill in results while (resultSet.next()) { List<String> oneRow = Lists.newArrayListWithCapacity(columnCount); for (int i = 0; i < columnCount; i++) { oneRow.add((resultSet.getString(i + 1))); } results.add(oneRow); } return new Pair<>(results, columnMetas); }
/** * Extracts expression columns from the given result set. * * @param session the session * @param rs the result set * @return an array of expression columns */ public static Expression[] getExpressionColumns(Session session, ResultSet rs) { try { ResultSetMetaData meta = rs.getMetaData(); int columnCount = meta.getColumnCount(); Expression[] expressions = new Expression[columnCount]; Database db = session == null ? null : session.getDatabase(); for (int i = 0; i < columnCount; i++) { String name = meta.getColumnLabel(i + 1); int type = DataType.getValueTypeFromResultSet(meta, i + 1); int precision = meta.getPrecision(i + 1); int scale = meta.getScale(i + 1); int displaySize = meta.getColumnDisplaySize(i + 1); Column col = new Column(name, type, precision, scale, displaySize); Expression expr = new ExpressionColumn(db, col); expressions[i] = expr; } return expressions; } catch (SQLException e) { throw DbException.convert(e); } }
@Override public void executeQuery(String sql, List<List<String>> results, List<SelectedColumnMeta> columnMetas) { //extract column metadata ResultSet rs = null; ResultSetMetaData metaData; int columnCount; try (Connection conn = dataSource.getConnection(); Statement state = conn.createStatement()) { rs = state.executeQuery(sql); extractResults(rs, results); metaData = rs.getMetaData(); columnCount = metaData.getColumnCount(); // fill in selected column meta for (int i = 1; i <= columnCount; ++i) { int kylinTypeId = dataSource.toKylinTypeId(metaData.getColumnTypeName(i), metaData.getColumnType(i)); String kylinTypeName = dataSource.toKylinTypeName(kylinTypeId); columnMetas.add(new SelectedColumnMeta(metaData.isAutoIncrement(i), metaData.isCaseSensitive(i), false, metaData.isCurrency(i), metaData.isNullable(i), false, metaData.getColumnDisplaySize(i), metaData.getColumnLabel(i), metaData.getColumnName(i), null, null, null, metaData.getPrecision(i), metaData.getScale(i), kylinTypeId, kylinTypeName, metaData.isReadOnly(i), false, false)); } } catch (Exception e) { throw new RuntimeException("executeQuery failed", e); } finally { DBUtils.closeQuietly(rs); } }
@Test public void test_getPrecision_forBOOLEAN() throws SQLException { assertThat( rowMetadata.getPrecision( ordOptBOOLEAN ), equalTo( 0 ) ); }
private void printResultSetMetaData(ResultSet rs) throws SQLException { ResultSetMetaData metadata = rs.getMetaData(); System.out.println("Metadata:"); for (int i = 0; i < metadata.getColumnCount(); i++) { String metaStr = metadata.getCatalogName(i + 1) + " " + metadata.getColumnClassName(i + 1) + " " + metadata.getColumnDisplaySize(i + 1) + " " + metadata.getColumnLabel(i + 1) + " " + metadata.getColumnName(i + 1) + " " + metadata.getColumnType(i + 1) + " " + metadata.getColumnTypeName(i + 1) + " " + metadata.getPrecision(i + 1) + " " + metadata.getScale(i + 1) + " " + metadata.getSchemaName(i + 1) + " " + metadata.getTableName(i + 1); System.out.println(metaStr); } } }
/** * Determine the column definitions for the supplied result set and add each column to the specified consumer. * * @param resultSet the query result set; may not be null * @param consumer the consumer of the definitions; may not be null * @throws SQLException if an error occurs while using the result set */ public static void columnsFor(ResultSet resultSet, Consumer<Column> consumer) throws SQLException { ResultSetMetaData metadata = resultSet.getMetaData(); ColumnEditor column = Column.editor(); for (int position = 1; position <= metadata.getColumnCount(); ++position) { String columnLabel = metadata.getColumnLabel(position); column.name(columnLabel != null ? columnLabel : metadata.getColumnName(position)); column.type(metadata.getColumnTypeName(position)); column.jdbcType(metadata.getColumnType(position)); column.length(metadata.getPrecision(position)); column.scale(metadata.getScale(position)); column.optional(isNullable(metadata.isNullable(position))); column.autoIncremented(metadata.isAutoIncrement(position)); column.generated(false); consumer.accept(column.create()); } }
@Ignore( "TODO(DRILL-3367): unignore when DECIMAL is no longer DOUBLE" ) @Test public void test_getPrecision_forDECIMAL_5_3() throws SQLException { assertThat( rowMetadata.getPrecision( ordReqDECIMAL_5_3 ), equalTo( 5 ) ); }
@Test public void testConvertToAvroStreamForUnsignedIntegerWithPrecision1ReturnedAsLong_NIFI5612() throws SQLException, IOException { final String mockColumnName = "t_int"; final ResultSetMetaData metadata = mock(ResultSetMetaData.class); when(metadata.getColumnCount()).thenReturn(1); when(metadata.getColumnType(1)).thenReturn(Types.INTEGER); when(metadata.isSigned(1)).thenReturn(false); when(metadata.getPrecision(1)).thenReturn(1); when(metadata.getColumnName(1)).thenReturn(mockColumnName); when(metadata.getTableName(1)).thenReturn("table"); final ResultSet rs = resultSetReturningMetadata(metadata); final Long ret = 0L; when(rs.getObject(Mockito.anyInt())).thenReturn(ret); final InputStream instream = convertResultSetToAvroInputStream(rs); final DatumReader<GenericRecord> datumReader = new GenericDatumReader<>(); try (final DataFileStream<GenericRecord> dataFileReader = new DataFileStream<>(instream, datumReader)) { GenericRecord record = null; while (dataFileReader.hasNext()) { record = dataFileReader.next(record); assertEquals(Long.toString(ret), record.get(mockColumnName).toString()); } } }
@Test public void testConvertToAvroStreamForNumbers() throws SQLException, IOException { final ResultSetMetaData metadata = mock(ResultSetMetaData.class); when(metadata.getColumnCount()).thenReturn(1); when(metadata.getColumnType(1)).thenReturn(testParams.sqlType); when(metadata.isSigned(1)).thenReturn(testParams.signed); when(metadata.getPrecision(1)).thenReturn(testParams.precision); when(metadata.getColumnName(1)).thenReturn("t_int"); when(metadata.getTableName(1)).thenReturn("table"); final ResultSet rs = resultSetReturningMetadata(metadata); final int ret = 0; when(rs.getObject(Mockito.anyInt())).thenReturn(ret); final InputStream instream = convertResultSetToAvroInputStream(rs); final DatumReader<GenericRecord> datumReader = new GenericDatumReader<>(); try (final DataFileStream<GenericRecord> dataFileReader = new DataFileStream<>(instream, datumReader)) { GenericRecord record = null; while (dataFileReader.hasNext()) { record = dataFileReader.next(record); assertEquals(Integer.toString(ret), record.get("t_int").toString()); } } } }
@Test public void testConvertToAvroStreamForUnsignedIntegerWithPrecision10() throws SQLException, IOException { final String mockColumnName = "t_int"; final ResultSetMetaData metadata = mock(ResultSetMetaData.class); when(metadata.getColumnCount()).thenReturn(1); when(metadata.getColumnType(1)).thenReturn(Types.INTEGER); when(metadata.isSigned(1)).thenReturn(false); when(metadata.getPrecision(1)).thenReturn(10); when(metadata.getColumnName(1)).thenReturn(mockColumnName); when(metadata.getTableName(1)).thenReturn("table"); final ResultSet rs = resultSetReturningMetadata(metadata); final Long ret = 0L; when(rs.getObject(Mockito.anyInt())).thenReturn(ret); final InputStream instream = convertResultSetToAvroInputStream(rs); final DatumReader<GenericRecord> datumReader = new GenericDatumReader<>(); try (final DataFileStream<GenericRecord> dataFileReader = new DataFileStream<>(instream, datumReader)) { GenericRecord record = null; while (dataFileReader.hasNext()) { record = dataFileReader.next(record); assertEquals(Long.toString(ret), record.get(mockColumnName).toString()); } } }
private static String toString(ResultSetMetaData metadata, int colNum) throws SQLException { return "ResultSetMetaData(" + colNum + ")[" + "columnName='" + metadata.getColumnName(colNum) + '\'' + ", type='" + metadata.getColumnType(colNum) + '\'' + ", nullable=" + metadata.isNullable(colNum) + ", displaySize=" + metadata.getColumnDisplaySize(colNum) + ", precision=" + metadata.getPrecision(colNum) + ", scale=" + metadata.getScale(colNum) + ", signed=" + metadata.isSigned(colNum) + ", className='" + metadata.getColumnClassName(colNum) + '\'' + ']'; } private static class ExpectedColumnResult {