@Override public int getColumnDisplaySize(final int column) throws SQLException { return resultSetMetaData.getColumnDisplaySize(column); }
@Override public int getColumnDisplaySize(int column) throws InvalidResultSetAccessException { try { return this.resultSetMetaData.getColumnDisplaySize(column); } catch (SQLException se) { throw new InvalidResultSetAccessException(se); } }
public PostgreSQLColumnDescription(final ResultSetMetaData resultSetMetaData, final int columnIndex) throws SQLException { columnName = resultSetMetaData.getColumnName(columnIndex); this.columnIndex = columnIndex; typeOID = PostgreSQLColumnType.valueOfJDBCType(resultSetMetaData.getColumnType(columnIndex)).getValue(); columnLength = resultSetMetaData.getColumnDisplaySize(columnIndex); } }
private static String[][] executeQuery(PreparedStatement statement) throws SQLException { final ResultSet resultSet = statement.executeQuery(); try { final ResultSetMetaData metaData = resultSet.getMetaData(); final int columnCount = metaData.getColumnCount(); final List<String[]> list = new ArrayList<String[]>(); String[] values = new String[columnCount]; for (int i = 1; i <= columnCount; i++) { values[i - 1] = metaData.getColumnName(i) + '\n' + metaData.getColumnTypeName(i) + '(' + metaData.getColumnDisplaySize(i) + ')'; } list.add(values); while (resultSet.next()) { values = new String[columnCount]; for (int i = 1; i <= columnCount; i++) { values[i - 1] = resultSet.getString(i); } list.add(values); } return list.toArray(new String[0][]); } finally { resultSet.close(); } }
@Override public int resultSetMetaData_getColumnDisplaySize(ResultSetMetaDataProxy metaData, int column) throws SQLException { if (this.pos < filterSize) { return nextFilter().resultSetMetaData_getColumnDisplaySize(this, metaData, column); } return metaData.getResultSetMetaDataRaw().getColumnDisplaySize(column); }
public ColumnDefinition41Packet(final int sequenceId, final ResultSetMetaData resultSetMetaData, final int columnIndex) throws SQLException { this(sequenceId, resultSetMetaData.getSchemaName(columnIndex), resultSetMetaData.getTableName(columnIndex), resultSetMetaData.getTableName(columnIndex), resultSetMetaData.getColumnLabel(columnIndex), resultSetMetaData.getColumnName(columnIndex), resultSetMetaData.getColumnDisplaySize(columnIndex), ColumnType.valueOfJDBCType(resultSetMetaData.getColumnType(columnIndex)), resultSetMetaData.getScale(columnIndex)); }
public ColumnDefinition41Packet(final int sequenceId, final ResultSetMetaData resultSetMetaData, final int columnIndex) throws SQLException { this(sequenceId, resultSetMetaData.getSchemaName(columnIndex), resultSetMetaData.getTableName(columnIndex), resultSetMetaData.getTableName(columnIndex), resultSetMetaData.getColumnLabel(columnIndex), resultSetMetaData.getColumnName(columnIndex), resultSetMetaData.getColumnDisplaySize(columnIndex), ColumnType.valueOfJDBCType(resultSetMetaData.getColumnType(columnIndex)), resultSetMetaData.getScale(columnIndex)); }
IncrementalRows(BeeLine beeLine, ResultSet rs) throws SQLException { super(beeLine, rs); this.rs = rs; labelRow = new Row(rsMeta.getColumnCount()); maxRow = new Row(rsMeta.getColumnCount()); int maxWidth = beeLine.getOpts().getMaxColumnWidth(); // pre-compute normalization so we don't have to deal // with SQLExceptions later for (int i = 0; i < maxRow.sizes.length; ++i) { // normalized display width is based on maximum of display size // and label size maxRow.sizes[i] = Math.max( maxRow.sizes[i], rsMeta.getColumnDisplaySize(i + 1)); maxRow.sizes[i] = Math.min(maxWidth, maxRow.sizes[i]); } nextRow = labelRow; endOfResult = false; }
public void assertColumnDefinition(String table, String column, int expectedType, @Nullable Integer expectedSize, @Nullable Boolean isNullable) { try (Connection connection = getConnection(); PreparedStatement stmt = connection.prepareStatement("select * from " + table); ResultSet res = stmt.executeQuery()) { Integer columnIndex = getColumnIndex(res, column); if (columnIndex == null) { fail("The column '" + column + "' does not exist"); } assertThat(res.getMetaData().getColumnType(columnIndex)).isEqualTo(expectedType); if (expectedSize != null) { assertThat(res.getMetaData().getColumnDisplaySize(columnIndex)).isEqualTo(expectedSize); } if (isNullable != null) { assertThat(res.getMetaData().isNullable(columnIndex)).isEqualTo(isNullable ? columnNullable : columnNoNulls); } } catch (Exception e) { throw new IllegalStateException("Fail to check column", e); } }
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); }
length = resultSetMetaData.getColumnDisplaySize( columnPos );
/** * 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_getColumnDisplaySize_forBOOLEAN() throws SQLException { assertThat( rowMetadata.getColumnDisplaySize( ordOptBOOLEAN ), equalTo( 1 ) ); }
/** * 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(ServerSession 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.convertSQLTypeToValueType(meta.getColumnType(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); } }
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); } } }
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 {
precision[i] = meta.getColumnDisplaySize(i + 1); if (type != Types.NULL) { server.checkType(pgType);
boolean isEqualsTo(ResultSetMetaData metadata, int colNum) throws SQLException { return metadata.getCatalogName(colNum).equals(InfoSchemaConstants.IS_CATALOG_NAME) && metadata.getSchemaName(colNum).isEmpty() && metadata.getTableName(colNum).isEmpty() && metadata.getColumnName(colNum).equals(columnName) && metadata.getColumnLabel(colNum).equals(columnName) && metadata.getColumnType(colNum) == type && metadata.isNullable(colNum) == nullable && // There is an existing bug where query results doesn't contain the precision for VARCHAR field. //metadata.getPrecision(colNum) == precision && metadata.getScale(colNum) == scale && metadata.isSigned(colNum) == signed && metadata.getColumnDisplaySize(colNum) == displaySize && metadata.getColumnClassName(colNum).equals(className) && metadata.isSearchable(colNum) && metadata.isAutoIncrement(colNum) == false && metadata.isCaseSensitive(colNum) == false && metadata.isReadOnly(colNum) && metadata.isWritable(colNum) == false && metadata.isDefinitelyWritable(colNum) == false && metadata.isCurrency(colNum) == false; }
DataType.getValueTypeFromResultSet(meta, i + 1), meta.getPrecision(i + 1), meta.getScale(i + 1), meta.getColumnDisplaySize(i + 1));