Querying character column sizes using DatabaseMetadata

Question

Hi,
In a UTF-8 database, I've created two testing tables, one that uses byte length semantics (BLS) for its CHAR and VARCHAR2 columns, and one using character length semantics (CLS). If I use the standard JDBC DatabaseMetdata.getColumns() query, the size of the CLS columns is reported as 4 times that of the BLS columns. I don't believe this is the desired behaviour for the JDBC drivers.
Regardless, does anyone know a way to accurately determine (preferably using standard JDBC methods) the size of a CHAR or VARCHAR column in characters across different database configurations? I need this to compare column lengths in a ASCII and UTF8 database.
I'm using the standalone JDBC drivers v9.2.0.3 for JDK1.4 (odjbc.jar) running aginst Oracle 9.2.0.0.
The following code, which contains some DDL to create sample tables, can be used to dump the column metadata returned by Oracle's database drivers.
import java.sql.*;
import java.util.*;
The following script can be used to create two test tables, the first with
byte-size columns, and the second with character-size columns.
CREATE TABLE TMP
TMP_ID NUMBER(12) NOT NULL PRIMARY KEY,
TMP_CHAR CHAR(200 BYTE),
TMP_VCHAR VARCHAR2(100 BYTE)
CREATE TABLE TMP2
TMP_ID NUMBER(12) NOT NULL PRIMARY KEY,
TMP_CHAR CHAR(200 CHAR),
TMP_VCHAR VARCHAR2(100 CHAR)
public class DatabaseMetadata
private static final String COLUMN_NAMES[] = {
"TABLE_CAT",
"TABLE_SCHEM",
"TABLE_NAME",
"COLUMN_NAME",
"DATA_TYPE",
"TYPE_NAME",
"COLUMN_SIZE",
"BUFFER_LENGTH",
"DECIMAL_DIGITS",
"NUM_PREC_RADIX",
"NULLABLE",
"REMARKS",
"COLUMN_DEF",
"SQL_DATA_TYPE",
"SQL_DATETIME_SUB",
"CHAR_OCTET_LENGTH",
"ORDINAL_POSITION",
"IS_NULLABLE"
private static final int COLUMN_WIDTHS[] = {
10, // "TABLE_CAT",
11, // "TABLE_SCHEM",
10, // "TABLE_NAME",
11, // "COLUMN_NAME",
10, // "DATA_TYPE",
10, // "TYPE_NAME",
11, // "COLUMN_SIZE",
13, // "BUFFER_LENGTH",
13, // "DECIMAL_DIGITS",
13, // "NUM_PREC_RADIX",
10, // "NULLABLE",
10, // "REMARKS",
10, // "COLUMN_DEF",
10, // "SQL_DATA_TYPE",
10, // "SQL_DATETIME_SUB",
10, // "CHAR_OCTET_LENGTH",
10, // "ORDINAL_POSITION",
10, // "IS_NULLABLE"
private static final char WHITESPACE[] =
.toCharArray();
private static final String HYPHENS =
private static String formatRow(String row[])
StringBuffer buffer = new StringBuffer(128);
for (int j=0;j<row.length;j++)
if (j > 0)
buffer.append(" | ");
String text = row[j];
int width = COLUMN_WIDTHS[j];
if (text == null)
buffer.append(WHITESPACE, 0, width);
else if (text.length() > width)
buffer.append(text.substring(0, width));
else
buffer.append(text).append(WHITESPACE, 0, width - text.length());
} // j
return buffer.toString();
} // private static String formatRow(String[])
private static void printColumnMetadata(
DatabaseMetaData metadata, String tableName)
throws SQLException
System.out.println("\n" + tableName + "\n");
System.out.println(formatRow(COLUMN_NAMES));
String hyphens[] = new String[18];
Arrays.fill(hyphens, HYPHENS);
System.out.println(formatRow(hyphens));
ResultSet results = metadata.getColumns(null, null, tableName, "%");
String columnMetadata[] = new String[18];
while (results.next())
for (int i=0;i<18;i++)
Object result = results.getObject(i+1);
columnMetadata[i] = result == null ? "NULL" : result.toString();
} // i
System.out.println(formatRow(columnMetadata));
results.close();
} // private static void printColumnMetadata(DatabaseMetaData, String)
public static void main(String argv[])
throws Exception
Driver driver = (Driver)Class.forName(
"oracle.jdbc.driver.OracleDriver").newInstance();
DriverManager.registerDriver(driver);
Connection connection = DriverManager.getConnection(
argv[0], argv[1], argv[2]);
// ((oracle.jdbc.OracleConnection)connection).setRemarksReporting(true);
try
DatabaseMetaData metadata = connection.getMetaData();
printColumnMetadata(metadata, "TMP");
printColumnMetadata(metadata, "TMP2");
catch (SQLException e)
e.printStackTrace();
connection.close();
} // public class DatabaseMetadata

Answer 1

It appears that this forum uses "[" "i" "]" to denote italics internally, so these characters are missing where the code sample becomes italic, between 'columnMetadata' and '='.