/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package tests.java.sql;
import dalvik.annotation.KnownFailure;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import tests.support.DatabaseCreator;
import tests.support.Support_SQL;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.StringTokenizer;
@TestTargetClass(DatabaseMetaData.class)
public class DatabaseMetaDataTest extends TestCase {
private static String VIEW_NAME = "myView";
private static String CREATE_VIEW_QUERY = "CREATE VIEW " + VIEW_NAME
+ " AS SELECT * FROM " + DatabaseCreator.TEST_TABLE1;
private static String DROP_VIEW_QUERY = "DROP VIEW " + VIEW_NAME;
protected static Connection conn;
protected static DatabaseMetaData meta;
protected static Statement statement;
protected static Statement statementForward;
private static int id = 1;
public void setUp() throws Exception {
super.setUp();
Support_SQL.loadDriver();
try {
conn = Support_SQL.getConnection();
meta = conn.getMetaData();
statement = conn.createStatement();
statementForward = conn.createStatement(
ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
createTestTables();
} catch (SQLException e) {
System.out.println("Error in test setup: "+e.getMessage());
}
}
protected void tearDown() throws Exception {
try {
conn = Support_SQL.getConnection();
meta = conn.getMetaData();
statement = conn.createStatement();
deleteTestTables();
} catch (SQLException e) {
System.out.println("Error in teardown: "+e.getMessage());
} finally {
try {
conn.close();
} catch (SQLException e) {
}
}
super.tearDown();
}
private void createTestTables() {
try {
ResultSet userTab = meta.getTables(null, null, null, null);
while (userTab.next()) {
String tableName = userTab.getString("TABLE_NAME");
if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
statement.execute(DatabaseCreator.DROP_TABLE1);
} else if (tableName
.equals(DatabaseCreator.TEST_TABLE3)) {
statement.execute(DatabaseCreator.DROP_TABLE3);
} else if (tableName.equals(VIEW_NAME)) {
statement.execute(DROP_VIEW_QUERY);
}
}
userTab.close();
statement.execute(DatabaseCreator.CREATE_TABLE3);
statement.execute(DatabaseCreator.CREATE_TABLE1);
statement.execute(CREATE_VIEW_QUERY);
meta = conn.getMetaData();
} catch (SQLException e) {
fail("Unexpected SQLException " + e.toString());
}
}
private void deleteTestTables() {
try {
statement.execute(DatabaseCreator.DROP_TABLE1);
statement.execute(DatabaseCreator.DROP_TABLE3);
statement.execute(DROP_VIEW_QUERY);
} catch (SQLException e) {
fail("Unexpected SQLException " + e.toString());
} finally {
try {
if (! conn.isClosed()) {
conn.close();
}
} catch (SQLException e) {
}
}
}
/*
public void setUp() {
try {
super.setUp();
try {
conn = Support_SQL.getConnection();
statement = conn.createStatement();
statementForward = conn.createStatement(
ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
meta = conn.getMetaData();
assertFalse(conn.isClosed());
} catch (SQLException e) {
fail("Unexpected SQLException " + e.toString());
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
*/
/**
* @tests {@link java.sql.DatabaseMetaData #getBestRowIdentifier(java.lang.String,
* java.lang.String, java.lang.String, int, boolean) }
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Not all variants of parameters can be tested: updates on resultSets are not supported.",
method = "getBestRowIdentifier",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, int.class, boolean.class}
)
public void test_getBestRowIdentifierLjava_lang_StringLjava_lang_StringLjava_lang_StringIZ()
throws SQLException {
ResultSet result = statementForward.executeQuery("SELECT * FROM "
+ DatabaseCreator.TEST_TABLE1);
//Updatable ResultSet not supported, converted to normal insert statement
statementForward.executeUpdate("INSERT INTO " + DatabaseCreator.TEST_TABLE1
+ " (id, field1) VALUES( 1234567, 'test1');");
/* not supported
try {
result.moveToInsertRow();
result.updateInt("id", 1234567);
result.updateString("field1", "test1");
result.insertRow();
} catch (SQLException e) {
fail("Unexpected SQLException " + e.toString());
}
*/
result.close();
ResultSet rs = meta.getBestRowIdentifier(null, null,
DatabaseCreator.TEST_TABLE1, DatabaseMetaData.bestRowSession,
true);
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue("Rows not obtained", rs.next());
int col = rsmd.getColumnCount();
assertEquals("Incorrect number of columns", 8, col);
String[] columnNames = {
"SCOPE", "COLUMN_NAME", "DATA_TYPE", "TYPE_NAME",
"COLUMN_SIZE", "BUFFER_LENGTH", "DECIMAL_DIGITS",
"PSEUDO_COLUMN"};
for (int c = 1; c <= col; ++c) {
assertEquals("Incorrect column name", columnNames[c - 1], rsmd
.getColumnName(c));
}
assertEquals("Incorrect scope", DatabaseMetaData.bestRowSession, rs
.getShort("SCOPE"));
assertEquals("Incorrect column name", "_ROWID_", rs.getString("COLUMN_NAME"));
assertEquals("Incorrect data type", java.sql.Types.INTEGER, rs.getInt("DATA_TYPE"));
assertEquals("Incorrect type name", "INTEGER", rs.getString("TYPE_NAME"));
rs.close();
// Exception testing
conn.close();
try {
meta.getColumns(null, null,
DatabaseCreator.TEST_TABLE1, "%");
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getColumns(java.lang.String,
* java.lang.String, java.lang.String, java.lang.String)
*
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Tests Columns and search for arbitrary columns. test fails: Columns Name's not according to spec.",
method = "getColumns",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
)
@KnownFailure("Not supported : pattern with %")
public void test_getColumnsArbitrary() throws SQLException {
ResultSet setAllNull = null;
ResultSet setMixed = null;
ResultSet allArbitrary = null;
String[] tablesName = {DatabaseCreator.TEST_TABLE1,
DatabaseCreator.TEST_TABLE3};
Arrays.sort(tablesName);
int setSize = 0;
try {
allArbitrary = meta.getColumns("%","%","%","%");
assertNotNull(allArbitrary);
checkColumnsShape(allArbitrary);
setSize = crossCheckGetColumnsAndResultSetMetaData(allArbitrary, false);
assertEquals(6, setSize);
setMixed = meta.getColumns(null, null,"%","%");
assertNotNull(setMixed);
checkColumnsShape(setMixed);
setSize = crossCheckGetColumnsAndResultSetMetaData(setMixed, false);
assertEquals(6, setSize);
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
// Exception testing
conn.close();
try {
meta.getColumns(null, null,
DatabaseCreator.TEST_TABLE1, "%");
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getColumns(java.lang.String,
* java.lang.String, java.lang.String, java.lang.String)
*
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Tests getColumns with no Catalog and Schema. test fails on arguments: '', '', '%', '%'",
method = "getColumns",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
)
@KnownFailure("Not supported ops applied: test fails on arguments: '', '', '%', '%' ")
public void test_getColumnsTableWithNoCatalogSchema() throws SQLException{
try {
ResultSet noSchemaTable = meta.getColumns("", "",
DatabaseCreator.TEST_TABLE1, "fkey");
assertNotNull(noSchemaTable);
noSchemaTable.last();
int size = noSchemaTable.getRow();
assertEquals(
"Does not support empty string as input parameter or Wildcard %",
1, size);
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
try {
ResultSet noSchemaTable = meta.getColumns("", "",
DatabaseCreator.TEST_TABLE1, "%");
assertNotNull(noSchemaTable);
noSchemaTable.last();
int size = noSchemaTable.getRow();
assertEquals(
"Does not support empty string as input parameter or Wildcard %",
5, size);
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
try {
ResultSet noSchemaTable = meta.getColumns("", "", "%", "%");
assertNotNull(noSchemaTable);
noSchemaTable.last();
int size = noSchemaTable.getRow();
assertEquals(
"Does not support double Wildcard '%' as input",
6, size);
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
// Exception checking
conn.close();
try {
meta.getColumns(null, null,
DatabaseCreator.TEST_TABLE1, "%");
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getColumns(java.lang.String,
* java.lang.String, java.lang.String, java.lang.String)
*
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "tests for specific tables. test fails: invalid nullable value.",
method = "getColumns",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
)
@KnownFailure("Wildcard operator does not seem wo work correctly.")
public void test_getColumnsSpecific() throws SQLException {
String[] tablesName = {
DatabaseCreator.TEST_TABLE1, DatabaseCreator.TEST_TABLE3};
String[] fields = {"id", "field1", "field2", "field3", "fkey"};
String[] nullable = {"YES", "NO",""};
int[] nullableInt = {
DatabaseMetaData.columnNoNulls,
DatabaseMetaData.columnNullable,
DatabaseMetaData.columnNullableUnknown};
Arrays.sort(tablesName);
Arrays.sort(fields);
Arrays.sort(nullableInt);
Arrays.sort(nullable);
int countSingle = 0;
int countAll1 = 0;
int countAll2 = 0;
try {
ResultSet rs = meta.getColumns(null, null,
DatabaseCreator.TEST_TABLE1, "%");
while (rs.next()) {
assertTrue("Invalid table name", Arrays.binarySearch(
tablesName, rs.getString("TABLE_NAME")) > -1);
assertTrue("Invalid field name", Arrays.binarySearch(fields, rs
.getString("COLUMN_NAME")) > -1);
assertTrue("Invalid nullable value", Arrays.binarySearch(
nullable, rs.getString("IS_NULLABLE")) > -1);
assertTrue("Invalid nullable code", Arrays.binarySearch(
nullableInt, rs.getInt("NULLABLE")) > -1);
countSingle++;
}
assertEquals("Not all results are found", 5, countSingle);
rs.close();
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
try {
ResultSet rs = meta.getColumns(null, null, "%"+DatabaseCreator.CREATE_TABLE1.substring(0, 3)+"%","%" );
while (rs.next()) {
assertTrue("Wrong table name", Arrays.binarySearch(tablesName,
rs.getString("TABLE_NAME")) > -1);
countAll1++;
}
assertEquals("Not all results are found", 6, countAll1);
rs.close();
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
try {
ResultSet rs = meta.getColumns(null, null, "%TEST_%", "%");
while (rs.next()) {
assertTrue("Wrong table name", Arrays.binarySearch(tablesName,
rs.getString("TABLE_NAME")) > -1);
countAll2++;
}
assertEquals("Not all results are found", 6, countAll2);
rs.close();
} catch (SQLException e) {
fail("Unexpected exception: " + e.getMessage());
}
// Exception checking
conn.close();
try {
meta.getColumns(null, null,
DatabaseCreator.TEST_TABLE1, "%");
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getConnection()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getConnection",
args = {}
)
public void test_getConnection() throws SQLException {
assertEquals("Incorrect connection value", conn, meta.getConnection());
// Exception checking
conn.close();
try {
Connection con = meta.getConnection();
assertTrue(con.isClosed());
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getCrossReference(java.lang.String,
* java.lang.String, java.lang.String, java.lang.String,
* java.lang.String, java.lang.String)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Test fails: Foreign keys not supported",
method = "getCrossReference",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
)
@KnownFailure("(Ticket 91) Tables apply foreign key constraint. Catalogs not supported")
public void test_getCrossReferenceLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
throws SQLException {
ResultSet rs = meta.getCrossReference(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE3, conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue("Rows do not obtained", rs.next());
int col = rsmd.getColumnCount();
assertEquals("Incorrect number of columns", 14, col);
String[] columnNames = { "PKTABLE_CAT", "PKTABLE_SCHEM",
"PKTABLE_NAME", "PKCOLUMN_NAME", "FKTABLE_CAT",
"FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ",
"UPDATE_RULE", "DELETE_RULE", "FK_NAME", "PK_NAME",
"DEFERRABILITY" };
for (int c = 1; c <= col; ++c) {
assertEquals("Incorrect column name", columnNames[c - 1], rsmd
.getColumnName(c));
}
// TODO getCatalog is not supported
assertEquals("Incorrect primary key table catalog", conn.getCatalog(),
rs.getString("PKTABLE_CAT"));
assertEquals("Incorrect primary key table schema", "", rs
.getString("PKTABLE_SCHEM"));
assertEquals("Incorrect primary key table name",
DatabaseCreator.TEST_TABLE3, rs.getString("PKTABLE_NAME"));
assertEquals("Incorrect primary key column name", "fkey", rs
.getString("PKCOLUMN_NAME"));
// TODO getCatalog is not supported
assertEquals("Incorrect foreign key table catalog", conn.getCatalog(),
rs.getString("FKTABLE_CAT"));
assertEquals("Incorrect foreign key table schema", "", rs
.getString("FKTABLE_SCHEM"));
assertEquals("Incorrect foreign key table name",
DatabaseCreator.TEST_TABLE1, rs.getString("FKTABLE_NAME"));
assertEquals("Incorrect foreign key column name", "fk", rs
.getString("FKCOLUMN_NAME"));
assertEquals("Incorrect sequence number within foreign key", 1, rs
.getShort("KEY_SEQ"));
assertEquals("Incorrect update rule value",
DatabaseMetaData.importedKeyNoAction, rs
.getShort("UPDATE_RULE"));
assertEquals("Incorrect delete rule value",
DatabaseMetaData.importedKeyNoAction, rs
.getShort("DELETE_RULE"));
assertNull("Incorrect foreign key name", rs.getString("FK_NAME"));
assertNull("Incorrect primary key name", rs.getString("PK_NAME"));
assertEquals("Incorrect deferrability",
DatabaseMetaData.importedKeyNotDeferrable, rs
.getShort("DEFERRABILITY"));
rs.close();
// Exception checking
conn.close();
try {
meta.getCrossReference(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE3, conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
// Exception checking
conn.close();
try {
meta.getCrossReference(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE3, conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDatabaseMajorVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getDatabaseMajorVersion",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDatabaseMajorVersion() throws SQLException {
assertTrue("Incorrdct database major version", meta
.getDatabaseMajorVersion() >= 0);
// Exception checking
conn.close();
try {
meta.getDatabaseMajorVersion();
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDatabaseMinorVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getDatabaseMinorVersion",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDatabaseMinorVersion() throws SQLException {
assertTrue("Incorrect database minor version", meta
.getDatabaseMinorVersion() >= 0);
// Exception checking
conn.close();
try {
meta.getDatabaseMinorVersion();
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDatabaseProductName()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getDatabaseProductName",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDatabaseProductName() throws SQLException {
assertTrue("Incorrect database product name", !"".equals(meta
.getDatabaseProductName().trim()));
// Exception checking
conn.close();
try {
meta.getDatabaseProductName();
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDatabaseProductVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getDatabaseProductVersion",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDatabaseProductVersion() throws SQLException {
assertTrue("Incorrect database product version", !"".equals(meta
.getDatabaseProductVersion().trim()));
// Exception checking
conn.close();
try {
meta.getDatabaseProductVersion();
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDefaultTransactionIsolation()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getDefaultTransactionIsolation",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDefaultTransactionIsolation() throws SQLException {
int defaultLevel = meta.getDefaultTransactionIsolation();
switch (defaultLevel) {
case Connection.TRANSACTION_NONE:
case Connection.TRANSACTION_READ_COMMITTED:
case Connection.TRANSACTION_READ_UNCOMMITTED:
case Connection.TRANSACTION_REPEATABLE_READ:
case Connection.TRANSACTION_SERIALIZABLE:
// these levels are OK
break;
default:
fail("Incorrect value of default transaction isolation level");
}
// Exception checking
conn.close();
try {
meta.getDefaultTransactionIsolation();
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDriverMajorVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getDriverMajorVersion",
args = {}
)
public void test_getDriverMajorVersion() throws SQLException {
assertTrue("Incorrect driver major version", meta
.getDriverMajorVersion() >= 0);
}
/**
* @tests java.sql.DatabaseMetaData#getDriverMinorVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getDriverMinorVersion",
args = {}
)
public void test_getDriverMinorVersion() {
assertTrue("Incorrect driver minor version", meta
.getDriverMinorVersion() >= 0);
}
/**
* @tests java.sql.DatabaseMetaData#getDriverName()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getDriverName",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDriverName() throws SQLException {
String driverName = meta.getDriverName();
assertTrue("Incorrect driver name", driverName.trim().startsWith(
"SQLite"));
// Exception checking
conn.close();
try {
meta.getDriverName();
fail("SQLException not thrown");
} catch (SQLException e) {
// ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getDriverVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getDriverVersion",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getDriverVersion() throws SQLException {
assertTrue("Incorrect driver version", !"".equals(meta
.getDriverVersion().trim()));
//Exception checking
conn.close();
try {
meta.getDriverVersion();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getImportedKeys(java.lang.String,
* java.lang.String, java.lang.String)
*/
@TestTargetNew(
level = TestLevel.NOT_FEASIBLE,
notes = "Test fails: Keys are not supported",
method = "getImportedKeys",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
)
@KnownFailure("Keys are not supported: Ticket 91")
public void test_getImportedKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
throws SQLException {
ResultSet rs = meta.getImportedKeys(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue("Rows do not obtained", rs.next());
int col = rsmd.getColumnCount();
assertEquals("Incorrect number of columns", 14, col);
String[] columnNames = { "PKTABLE_CAT", "PKTABLE_SCHEM",
"PKTABLE_NAME", "PKCOLUMN_NAME", "FKTABLE_CAT",
"FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ",
"UPDATE_RULE", "DELETE_RULE", "FK_NAME", "PK_NAME",
"DEFERRABILITY" };
for (int c = 1; c <= col; ++c) {
assertEquals("Incorrect column name", columnNames[c - 1], rsmd
.getColumnName(c));
}
// TODO getCatalog is not supported
assertEquals("Incorrect primary key table catalog", conn.getCatalog(),
rs.getString("PKTABLE_CAT"));
assertEquals("Incorrect primary key table schema", "", rs
.getString("PKTABLE_SCHEM"));
assertEquals("Incorrect primary key table name",
DatabaseCreator.TEST_TABLE3, rs.getString("PKTABLE_NAME"));
assertEquals("Incorrect primary key column name", "fkey", rs
.getString("PKCOLUMN_NAME"));
assertEquals("Incorrect foreign key table catalog", conn.getCatalog(),
rs.getString("FKTABLE_CAT"));
assertEquals("Incorrect foreign key table schema", "", rs
.getString("FKTABLE_SCHEM"));
assertEquals("Incorrect foreign key table name",
DatabaseCreator.TEST_TABLE1, rs.getString("FKTABLE_NAME"));
assertEquals("Incorrect foreign key column name", "fk", rs
.getString("FKCOLUMN_NAME"));
assertEquals("Incorrect sequence number within foreign key", 1, rs
.getShort("KEY_SEQ"));
assertEquals("Incorrect update rule value",
DatabaseMetaData.importedKeyNoAction, rs
.getShort("UPDATE_RULE"));
assertEquals("Incorrect delete rule value",
DatabaseMetaData.importedKeyNoAction, rs
.getShort("DELETE_RULE"));
// assertNotNull("Incorrect foreign key name", rs.getString("FK_NAME"));
assertEquals("Incorrect primary key name", null, rs
.getString("PK_NAME"));
assertEquals("Incorrect deferrability",
DatabaseMetaData.importedKeyNotDeferrable, rs
.getShort("DEFERRABILITY"));
rs.close();
//Exception checking
conn.close();
try {
meta.getImportedKeys(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getMaxCursorNameLength()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getMaxCursorNameLength",
args = {}
)
public void test_getMaxCursorNameLength() throws SQLException {
int nameLength = meta.getMaxCursorNameLength();
if (nameLength > 0) {
try {
statement.setCursorName(new String(new byte[nameLength + 1]));
fail("Expected SQLException was not thrown");
} catch (SQLException e) {
// expected
}
} else if (nameLength < 0) {
fail("Incorrect length of cursor name");
}
}
/**
* @tests java.sql.DatabaseMetaData#getJDBCMinorVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getJDBCMinorVersion",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getJDBCMinorVersion() throws SQLException {
assertTrue("Incorrect JDBC minor version",
meta.getJDBCMinorVersion() >= 0);
//Exception checking
conn.close();
try {
meta.getJDBCMinorVersion();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getJDBCMajorVersion()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getJDBCMajorVersion",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getJDBCMajorVersion() throws SQLException {
assertTrue("Incorrect JDBC major version",
meta.getJDBCMajorVersion() >= 0);
//Exception checking
conn.close();
try {
meta.getJDBCMajorVersion();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getNumericFunctions()
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Test fails. Not implemented correctly. SQLException checking test fails",
method = "getNumericFunctions",
args = {}
)
@KnownFailure("Not supported feature, Ticket 98. Broken because "+
"NUMERIC_FUNCTIONS not complete. When fixed change to @KnownFailure")
public void test_getNumericFunctions() throws SQLException {
escapedFunctions(NUMERIC_FUNCTIONS, meta.getNumericFunctions());
//Exception checking
conn.close();
try {
meta.getNumericFunctions();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getPrimaryKeys(java.lang.String,
* java.lang.String, java.lang.String)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Functionality test fails: keys and catalogs are not supported.",
method = "getPrimaryKeys",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
)
@KnownFailure(" Ticket 91 : relies on not supported features: getCatalog, keys")
public void test_getPrimaryKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
throws SQLException {
ResultSet rs = meta.getPrimaryKeys(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue("Rows not obtained", rs.next());
int col = rsmd.getColumnCount();
assertEquals("Incorrect number of columns", 6, col);
String[] columnNames = { "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME",
"COLUMN_NAME", "KEY_SEQ", "PK_NAME" };
for (int c = 1; c <= col; ++c) {
assertEquals("Incorrect column name", columnNames[c - 1], rsmd
.getColumnName(c));
}
assertEquals("Incorrect table catalogue", conn.getCatalog(), rs
.getString("TABLE_CAT").toLowerCase());
assertEquals("Incorrect table schema", "", rs
.getString("TABLE_SCHEM"));
assertEquals("Incorrect table name", DatabaseCreator.TEST_TABLE1, rs
.getString("TABLE_NAME").toLowerCase());
assertEquals("Incorrect column name", "id", rs.getString("COLUMN_NAME")
.toLowerCase());
assertEquals("Incorrect sequence number", 1, rs.getShort("KEY_SEQ"));
assertEquals("Incorrect primary key name", "primary", rs.getString(
"PK_NAME").toLowerCase());
rs.close();
//Exception checking
conn.close();
try {
meta.getPrimaryKeys(conn.getCatalog(), null,
DatabaseCreator.TEST_TABLE1);
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getResultSetHoldability()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getResultSetHoldability",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getResultSetHoldability() throws SQLException {
int hdb = meta.getResultSetHoldability();
switch (hdb) {
case ResultSet.HOLD_CURSORS_OVER_COMMIT:
case ResultSet.CLOSE_CURSORS_AT_COMMIT:
// these holdabilities are OK
break;
default:
fail("Incorrect value of holdability");
}
assertFalse("Incorrect result set holdability", meta
.supportsResultSetHoldability(hdb));
//Exception checking
conn.close();
try {
meta.getResultSetHoldability();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getSQLKeywords()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getSQLKeywords",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getSQLKeywords() throws SQLException {
assertTrue("Incorrect SQL keywords", !"".equals(meta.getSQLKeywords()
.trim()));
//Exception checking
conn.close();
try {
meta.getSQLKeywords();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getSQLStateType()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getSQLStateType",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getSQLStateType() throws SQLException {
int type = meta.getSQLStateType();
switch (type) {
case DatabaseMetaData.sqlStateSQL99:
case DatabaseMetaData.sqlStateXOpen:
// these types are OK
break;
default:
fail("Incorrect SQL state types");
}
//Exception checking
conn.close();
try {
meta.getSQLStateType();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getSchemas()
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "SQLException checking test fails",
method = "getSchemas",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getSchemas() throws SQLException {
ResultSet rs = meta.getSchemas();
ResultSetMetaData rsmd = rs.getMetaData();
assertTrue("Rows do not obtained", rs.next());
int col = rsmd.getColumnCount();
assertEquals("Incorrect number of columns", 1, col);
String[] columnNames = { "TABLE_SCHEM", "TABLE_CATALOG" };
for (int c = 1; c <= col; ++c) {
assertEquals("Incorrect column name", columnNames[c - 1], rsmd
.getColumnName(c));
}
rs.close();
//Exception checking
conn.close();
try {
meta.getSchemas();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getSearchStringEscape()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getSearchStringEscape",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getSearchStringEscape() throws SQLException {
assertTrue("Incorrect search string escape", !"".equals(meta
.getSearchStringEscape().trim()));
//Exception checking
conn.close();
try {
meta.getSearchStringEscape();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getStringFunctions()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Functionality test fails. SQLException checking test fails",
method = "getStringFunctions",
args = {}
)
@KnownFailure("not supported")
public void test_getStringFunctions() throws SQLException {
escapedFunctions(STRING_FUNCTIONS, meta.getStringFunctions());
//Exception checking
conn.close();
try {
meta.getStringFunctions();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getSystemFunctions()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Functionality test fails. SQLException checking test fails",
method = "getSystemFunctions",
args = {}
)
@KnownFailure("not supported")
public void test_getSystemFunctions() throws SQLException {
escapedFunctions(SYSTEM_FUNCTIONS, meta.getSystemFunctions());
//Exception checking
conn.close();
try {
meta.getSystemFunctions();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getTableTypes()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getTableTypes",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getTableTypes() throws SQLException {
String[] tableTypes = { "LOCAL TEMPORARY", "TABLE", "VIEW" };
ResultSet rs = meta.getTableTypes();
while (rs.next()) {
assertTrue("Wrong table type", Arrays.binarySearch(tableTypes, rs
.getString("TABLE_TYPE")) > -1);
}
rs.close();
//Exception checking
conn.close();
try {
meta.getTableTypes();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData #getTables(java.lang.String,
* java.lang.String, java.lang.String, java.lang.String[])
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Test fails.",
method = "getTables",
args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String[].class}
)
@KnownFailure("If no schema is associated: returns empty string where actually null be returned?. Ticket 98")
public void test_getTablesLjava_lang_StringLjava_lang_StringLjava_lang_String$Ljava_lang_String()
throws SQLException {
String[] tablesName = {
VIEW_NAME, DatabaseCreator.TEST_TABLE1,
DatabaseCreator.TEST_TABLE3};
String[] tablesType = {"TABLE", "VIEW"};
Arrays.sort(tablesName);
Arrays.sort(tablesType);
// case 1. get all tables. There are two tables and one view in the
// database
ResultSet rs = meta.getTables(null, null, null, null);
while (rs.next()) {
assertTrue("Wrong table name", Arrays.binarySearch(tablesName, rs
.getString("TABLE_NAME")) > -1);
//No Schema associated
assertNull("Wrong table schema: "+rs.getString("TABLE_SCHEM"), rs.getString("TABLE_SCHEM"));
assertTrue("Wrong table type", Arrays.binarySearch(tablesType, rs
.getString("TABLE_TYPE")) > -1);
assertEquals("Wrong parameter REMARKS", "", rs.getString("REMARKS"));
}
rs.close();
// case 2. get tables with specified types. There are no tables of such
// types
rs = meta.getTables(conn.getCatalog(), null, null, new String[] {
"SYSTEM TABLE", "LOCAL TEMPORARY" });
assertFalse("Some tables exist", rs.next());
rs.close();
// case 3. get tables with specified types. There is a table of such
// types
rs = meta.getTables(conn.getCatalog(), null, null, new String[] {
"VIEW", "LOCAL TEMPORARY" });
assertTrue("No tables exist", rs.next());
assertEquals("Wrong table name", VIEW_NAME, rs.getString("TABLE_NAME"));
assertNull("Wrong table schema: "+rs.getString("TABLE_SCHEM"), rs.getString("TABLE_SCHEM"));
assertEquals("Wrong table type", "VIEW", rs.getString("TABLE_TYPE"));
assertEquals("Wrong parameter REMARKS", "", rs.getString("REMARKS"));
assertFalse("Wrong size of result set", rs.next());
assertFalse("Some tables exist", rs.next());
rs.close();
// case 4. get all tables using tables pattern.
// There are two tables and one view in the database
rs = meta.getTables(null, null, "%", null);
while (rs.next()) {
assertTrue("Wrong table name", Arrays.binarySearch(tablesName, rs
.getString("TABLE_NAME")) > -1);
assertNull("Wrong table schema ", rs.getString("TABLE_SCHEM"));
assertTrue("Wrong table type", Arrays.binarySearch(tablesType, rs
.getString("TABLE_TYPE")) > -1);
assertEquals("Wrong parameter REMARKS", "", rs.getString("REMARKS"));
}
rs.close();
//Exception checking
conn.close();
try {
meta.getTables(null, null, null, null);
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getTimeDateFunctions()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Does not return any functions. test fails. SQLException checking test fails",
method = "getTimeDateFunctions",
args = {}
)
@KnownFailure("not supported")
public void test_getTimeDateFunctions() throws SQLException {
escapedFunctions(TIMEDATE_FUNCTIONS, meta.getTimeDateFunctions());
//Exception checking
conn.close();
try {
meta.getTimeDateFunctions();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getTypeInfo()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getTypeInfo",
args = {}
)
@KnownFailure("not supported")
public void test_getTypeInfo() throws SQLException {
insertNewRecord();
ResultSet rs = meta.getTypeInfo();
final String[] names = { "TYPE_NAME", "DATA_TYPE", "PRECISION",
"LITERAL_PREFIX", "LITERAL_SUFFIX", "CREATE_PARAMS",
"NULLABLE", "CASE_SENSITIVE", "SEARCHABLE",
"UNSIGNED_ATTRIBUTE", "FIXED_PREC_SCALE", "AUTO_INCREMENT",
"LOCAL_TYPE_NAME", "MINIMUM_SCALE", "MAXIMUM_SCALE",
"SQL_DATA_TYPE", "SQL_DATETIME_SUB", "NUM_PREC_RADIX" };
Arrays.sort(names);
for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) {
assertTrue("wrong column was return", Arrays.binarySearch(names, rs
.getMetaData().getColumnName(i + 1)) > -1);
}
int[] types = { Types.ARRAY, Types.BIGINT, Types.BINARY, Types.BIT,
Types.BLOB, Types.BOOLEAN, Types.CHAR, Types.CLOB,
Types.DATALINK, Types.DATE, Types.DECIMAL, Types.DISTINCT,
Types.DOUBLE, Types.FLOAT, Types.INTEGER, Types.JAVA_OBJECT,
Types.LONGVARBINARY, Types.LONGVARCHAR, Types.NULL,
Types.NUMERIC, Types.OTHER, Types.REAL, Types.REF,
Types.SMALLINT, Types.STRUCT, Types.TIME, Types.TIMESTAMP,
Types.TINYINT, Types.VARBINARY, Types.VARCHAR };
Arrays.sort(types);
while (rs.next()) {
assertTrue("wrong type was return ", Arrays.binarySearch(types, rs
.getInt("DATA_TYPE")) > -1);
}
rs.close();
//Exception checking
conn.close();
try {
meta.getTypeInfo();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getURL()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getURL",
args = {}
)
@KnownFailure("Ticket 98")
public void test_getURL() throws SQLException {
assertEquals("Wrong url", Support_SQL.sqlUrl, meta.getURL());
//Exception checking
conn.close();
try {
meta.getURL();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#getUserName()
*
* NOT_FEASIBLE not supported
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "getUserName",
args = {}
)
@KnownFailure("Ticket 98")
public void s() throws SQLException {
assertEquals("Wrong user name", Support_SQL.sqlUser, meta.getUserName());
//Exception checking
conn.close();
try {
meta.getUserName();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#insertsAreDetected(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "insertsAreDetected",
args = {int.class}
)
@KnownFailure("Ticket 98")
public void test_insertsAreDetectedI() throws SQLException {
assertFalse(
"visible row insert can be detected for TYPE_FORWARD_ONLY type",
meta.insertsAreDetected(ResultSet.TYPE_FORWARD_ONLY));
assertFalse(
"visible row insert can be detected for TYPE_SCROLL_INSENSITIVE type",
meta.insertsAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
assertFalse(
"visible row insert can be detected for TYPE_SCROLL_SENSITIVE type",
meta.insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
//Exception checking
conn.close();
try {
meta.insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE);
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#isReadOnly()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "isReadOnly",
args = {}
)
@KnownFailure("Ticket 98")
public void test_isReadOnly() throws SQLException {
assertFalse("database is not read-only", meta.isReadOnly());
//Exception checking
conn.close();
try {
meta.isReadOnly();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#othersDeletesAreVisible(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails.",
method = "othersDeletesAreVisible",
args = {int.class}
)
@KnownFailure("Ticket 98")
public void test_othersDeletesAreVisibleI() throws SQLException {
assertFalse(
"deletes made by others are visible for TYPE_FORWARD_ONLY type",
meta.othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
assertFalse(
"deletes made by others are visible for TYPE_SCROLL_INSENSITIVE type",
meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
assertFalse(
"deletes made by others are visible for TYPE_SCROLL_SENSITIVE type",
meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
//Exception checking
conn.close();
try {
assertFalse("inserts made by others are visible for unknown type", meta
.othersDeletesAreVisible(ResultSet.CONCUR_READ_ONLY));
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#othersInsertsAreVisible(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "othersInsertsAreVisible",
args = {int.class}
)
@KnownFailure("Ticket 98")
public void test_othersInsertsAreVisibleI() throws SQLException {
assertFalse(
"inserts made by others are visible for TYPE_FORWARD_ONLY type",
meta.othersInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
assertFalse(
"inserts made by others are visible for TYPE_SCROLL_INSENSITIVE type",
meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
assertFalse(
"inserts made by others are visible for TYPE_SCROLL_SENSITIVE type",
meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
//Exception checking
conn.close();
try {
assertFalse("inserts made by others are visible for unknown type", meta
.othersInsertsAreVisible(ResultSet.CONCUR_READ_ONLY));
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#othersUpdatesAreVisible(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = " Verification with invalid parameters missed.",
method = "othersUpdatesAreVisible",
args = {int.class}
)
@KnownFailure("Ticket 98")
public void test_othersUpdatesAreVisibleI() throws SQLException {
assertFalse(
"updates made by others are visible for TYPE_FORWARD_ONLY type",
meta.othersUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
assertFalse(
"updates made by others are visible for TYPE_SCROLL_INSENSITIVE type",
meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
assertFalse(
"updates made by others are visible for TYPE_SCROLL_SENSITIVE type",
meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
//Exception checking
try {
assertFalse("updates made by others are visible for unknown type", meta
.othersUpdatesAreVisible(ResultSet.CONCUR_READ_ONLY));
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#storesMixedCaseQuotedIdentifiers()
*/
@TestTargets ({
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "storesMixedCaseQuotedIdentifiers",
args = {}
),
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "storesMixedCaseIdentifiers",
args = {}
)
})
public void test_storesMixedCaseQuotedIdentifiers() throws SQLException {
String quote = meta.getIdentifierQuoteString();
insertNewRecord();
String selectQuery = "SELECT " + quote + "fieLD1" + quote + " FROM "
+ DatabaseCreator.TEST_TABLE1;
try {
statement.executeQuery(selectQuery);
if (!meta.storesMixedCaseIdentifiers()) {
fail("mixed case is supported");
}
} catch (SQLException e) {
if (meta.storesMixedCaseQuotedIdentifiers()) {
fail("quoted case is not supported");
}
}
//Exception checking
/*
conn.close();
try {
meta.storesMixedCaseIdentifiers();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
conn.close();
try {
meta.storesMixedCaseQuotedIdentifiers();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Exception test fails.",
method = "getIdentifierQuoteString",
args = {}
)
@KnownFailure("Ticket 98")
public void testGetIdentifierQuoteString() throws SQLException {
assertNotNull(
meta.getIdentifierQuoteString()
);
//Exception test
/*
conn.close();
try {
meta.getIdentifierQuoteString();
fail("Should throw exception");
} catch (SQLException e) {
//ok
}
*/
}
/**
* @tests java.sql.DatabaseMetaData#supportsColumnAliasing()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsColumnAliasing",
args = {}
)
@KnownFailure("not supported. SQLException checking test fails")
public void test_supportsColumnAliasing() throws SQLException {
insertNewRecord();
String alias = "FIELD3";
String selectQuery = "SELECT field1 AS " + alias + " FROM "
+ DatabaseCreator.TEST_TABLE1;
ResultSet rs = statement.executeQuery(selectQuery);
ResultSetMetaData rsmd = rs.getMetaData();
if (meta.supportsColumnAliasing()) {
// supports aliasing
assertEquals("Wrong count of columns", 1, rsmd.getColumnCount());
assertEquals("Aliasing is not supported", alias, rsmd
.getColumnLabel(1));
} else {
// doesn't support aliasing
assertEquals("Aliasing is supported", 0, rsmd.getColumnCount());
}
rs.close();
//Exception checking
conn.close();
try {
meta.supportsColumnAliasing();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsExpressionsInOrderBy()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsExpressionsInOrderBy",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsExpressionsInOrderBy() throws SQLException {
insertNewRecord();
String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+ " ORDER BY id + field3";
try {
statement.executeQuery(selectQuery);
if (!meta.supportsExpressionsInOrderBy()) {
fail("Expressions in order by are supported");
}
} catch (SQLException e) {
if (meta.supportsExpressionsInOrderBy()) {
fail("Expressions in order by are not supported");
}
}
//Exception checking
conn.close();
try {
meta.supportsExpressionsInOrderBy();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsGroupBy()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsGroupBy",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsGroupBy() throws SQLException {
insertNewRecord();
String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+ " GROUP BY field3";
try {
statement.executeQuery(selectQuery);
if (!meta.supportsGroupBy()) {
fail("group by are supported");
}
} catch (SQLException e) {
if (meta.supportsGroupBy()) {
fail("group by are not supported");
}
}
//Exception checking
conn.close();
try {
meta.supportsGroupBy();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsGroupByUnrelated()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsGroupByUnrelated",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsGroupByUnrelated() throws SQLException {
insertNewRecord();
String selectQuery = "SELECT field1, field2 FROM "
+ DatabaseCreator.TEST_TABLE1 + " GROUP BY field3";
try {
statement.executeQuery(selectQuery);
if (!meta.supportsGroupByUnrelated()) {
fail("unrelated columns in group by are supported");
}
} catch (SQLException e) {
if (meta.supportsGroupByUnrelated()) {
fail("unrelated columns in group by are not supported");
}
}
//Exception checking
conn.close();
try {
meta.supportsGroupByUnrelated();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsNonNullableColumns()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException thrown",
method = "supportsNonNullableColumns",
args = {}
)
@KnownFailure("Ticket 98")
public void test_supportsNonNullableColumns() throws SQLException {
assertTrue(
"columns in this database may not be defined as non-nullable",
meta.supportsNonNullableColumns());
statementForward.execute("create table companies(id integer not null);");
statementForward.execute("drop table companies");
//Exception checking
conn.close();
try {
meta.supportsNonNullableColumns();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsOrderByUnrelated()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsOrderByUnrelated",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsOrderByUnrelated() throws SQLException {
insertNewRecord();
String selectQuery = "SELECT field1, field2 FROM "
+ DatabaseCreator.TEST_TABLE1 + " ORDER BY id + field3";
try {
statement.executeQuery(selectQuery);
if (!meta.supportsOrderByUnrelated()) {
fail("unrelated columns in order by are supported");
}
} catch (SQLException e) {
if (meta.supportsOrderByUnrelated()) {
fail("unrelated columns in order by are not supported");
}
}
//Exception checking
conn.close();
try {
meta.supportsOrderByUnrelated();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsSelectForUpdate()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsSelectForUpdate",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsSelectForUpdate() throws SQLException {
insertNewRecord();
String selectQuery = "SELECT field1 FROM "
+ DatabaseCreator.TEST_TABLE1 + " FOR UPDATE";
try {
statement.executeQuery(selectQuery);
if (!meta.supportsSelectForUpdate()) {
fail("select for update are supported");
}
} catch (SQLException e) {
if (!meta.supportsSelectForUpdate()) {
fail("select for update are not supported");
}
}
//Exception checking
conn.close();
try {
meta.supportsSelectForUpdate();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsSubqueriesInExists()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsSubqueriesInExists",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsSubqueriesInExists() throws SQLException {
insertNewRecord();
String selectQuery = "SELECT field1 FROM "
+ DatabaseCreator.TEST_TABLE1
+ " WHERE EXISTS(SELECT field2 FROM "
+ DatabaseCreator.TEST_TABLE1 + ")";
try {
statement.executeQuery(selectQuery);
if (!meta.supportsSubqueriesInExists()) {
fail("Subqueries in exists are supported");
}
} catch (SQLException e) {
if (meta.supportsSubqueriesInExists()) {
fail("Subqueries in exists are not supported");
}
}
//Exception checking
conn.close();
try {
meta.supportsSubqueriesInExists();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsTableCorrelationNames()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "SQLException checking test fails",
method = "supportsTableCorrelationNames",
args = {}
)
@KnownFailure("exception test fails")
public void test_supportsTableCorrelationNames() throws SQLException {
insertNewRecord();
assertFalse(conn.isClosed());
String corelationName = "TABLE_NAME";
String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+ " AS " + corelationName;
ResultSet rs = statementForward.executeQuery(selectQuery);
ResultSetMetaData rsmd = rs.getMetaData();
int numOfColumn = rsmd.getColumnCount();
for (int i = 0; i < numOfColumn; i++) {
if (meta.supportsTableCorrelationNames()) {
assertEquals("Corelation names is now supported",
corelationName, rsmd.getTableName(i + 1));
} else {
assertEquals("Corelation names is supported",
DatabaseCreator.TEST_TABLE1, rsmd.getTableName(i + 1));
}
}
//Exception checking
conn.close();
try {
meta.supportsTableCorrelationNames();
fail("SQLException not thrown");
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#supportsTransactionIsolationLevel(int)
*/
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = " Not all Transaction isolation levels supported.",
method = "supportsTransactionIsolationLevel",
args = {int.class}
)
public void test_supportsTransactionIsolationLevelI() throws SQLException {
assertFalse("database supports TRANSACTION_NONE isolation level", meta
.supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
// TODO only Connection.TRANSACTION_SERIALIZABLE is supported
// assertTrue(
// "database doesn't supports TRANSACTION_READ_COMMITTED isolation level",
// meta
// .supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED));
// assertTrue(
// "database doesn't supports TRANSACTION_READ_UNCOMMITTED isolation level",
// meta
// .supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED));
// assertTrue(
// "database doesn't supports TRANSACTION_REPEATABLE_READ isolation level",
// meta
// .supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ));
assertTrue(
"database doesn't supports TRANSACTION_SERIALIZABLE isolation level",
meta
.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE));
//Exception checking
try {
assertFalse("database supports unknown isolation level", meta
.supportsTransactionIsolationLevel(Integer.MAX_VALUE));;
} catch (SQLException e) {
//ok
}
}
/**
* @tests java.sql.DatabaseMetaData#updatesAreDetected(int)
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = " Verification with invalid parameters missed.",
method = "updatesAreDetected",
args = {int.class}
)
public void test_updatesAreDetectedI() throws SQLException {
assertFalse(
"visible row update can be detected for TYPE_FORWARD_ONLY type",
meta.updatesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
assertFalse(
"visible row update can be detected for TYPE_SCROLL_INSENSITIVE type",
meta.updatesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
assertFalse(
"visible row update can be detected for TYPE_SCROLL_SENSITIVE type",
meta.updatesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
assertFalse("visible row update can be detected for unknown type", meta
.updatesAreDetected(100));
//Exception checking
conn.close();
try {
meta.updatesAreDetected(ResultSet.CLOSE_CURSORS_AT_COMMIT);
assertFalse("visible row update can be detected for unknown type", meta
.updatesAreDetected(ResultSet.CLOSE_CURSORS_AT_COMMIT));
} catch (SQLException e) {
//ok
}
}
protected static void insertNewRecord() throws SQLException {
if (conn.isClosed()) {
System.out.println("DatabaseMetaDataTest.insertNewRecord() : closed");
}
String insertQuery = "INSERT INTO " + DatabaseCreator.TEST_TABLE1
+ " (id, field1, field2, field3) VALUES(" + id + ", '"
+ "value" + id + "', " + id + ", " + id + ")";
id++;
statement.execute(insertQuery);
}
//BEGIN APACHE-DERBY
/**
* Test Method from Apache Derby Project
* Class
* org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
*
* Compare a ResultSet from getColumns() with ResultSetMetaData returned
* from a SELECT * against the table. This method handles situations where a
* full set of the columns are in the ResultSet. The first action is to call
* rs.next(). The ResultSet will be closed by this method.
*
* @param rs
* resultset to crossCheck
* @param partial
* used to indicate if ordinal position should get checked
* @return the number of rows in the resultSet
* @throws SQLException
*/
private int crossCheckGetColumnsAndResultSetMetaData(ResultSet rs,
boolean partial)
throws SQLException
{
Statement s = conn.createStatement();
while (rs.next())
{
String schema = rs.getString("TABLE_SCHEM");
String table = rs.getString("TABLE_NAME");
ResultSet rst = s.executeQuery(
"SELECT * FROM " + schema+"."+table);
ResultSetMetaData rsmdt = rst.getMetaData();
for (int col = 1; col <= rsmdt.getColumnCount() ; col++)
{
if (!partial) {
if (col != 1)
assertTrue(rs.next());
assertEquals("ORDINAL_POSITION",
col, rs.getInt("ORDINAL_POSITION"));
}
assertEquals("TABLE_CAT",
"", rs.getString("TABLE_CAT"));
assertEquals("TABLE_SCHEM",
schema, rs.getString("TABLE_SCHEM"));
assertEquals("TABLE_NAME",
table, rs.getString("TABLE_NAME"));
crossCheckGetColumnRowAndResultSetMetaData(rs, rsmdt);
if (partial)
break;
}
rst.close();
}
int count = rs.getRow();
rs.close();
s.close();
return count;
}
/**
* * Test Method from Apache Derby Project
* Class
* org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
*
* Cross check a single row from getColumns() with ResultSetMetaData
* for a SELECT * from the same table.
* @param rs ResultSet from getColumns already positioned on the row.
* @param rsmdt ResultSetMetaData for the SELECT *
* @param odbc 0 for JDBC call, 1 for ODBC. Needed to allow for difference
* in using BUFFER_LENGTH (ODBC) or no(JDBC).
* @throws SQLException
*/
public static void crossCheckGetColumnRowAndResultSetMetaData(
ResultSet rs, ResultSetMetaData rsmdt)
throws SQLException
{
int col = rs.getInt("ORDINAL_POSITION");
assertEquals("RSMD.getCatalogName",
rsmdt.getCatalogName(col), rs.getString("TABLE_CAT"));
assertEquals("RSMD.getSchemaName",
rsmdt.getSchemaName(col), rs.getString("TABLE_SCHEM"));
assertEquals("RSMD.getTableName",
rsmdt.getTableName(col), rs.getString("TABLE_NAME"));
assertEquals("COLUMN_NAME",
rsmdt.getColumnName(col), rs.getString("COLUMN_NAME"));
// DERBY-2285 BOOLEAN columns appear different on
// network client.
// meta returns BOOLEAN
// RSMD returns SMALLINT
int metaColumnType = rs.getInt("DATA_TYPE");
if (metaColumnType == Types.BOOLEAN )
{
assertEquals("TYPE_NAME",
"BOOLEAN", rs.getString("TYPE_NAME"));
assertEquals("TYPE_NAME",
"SMALLINT", rsmdt.getColumnTypeName(col));
assertEquals("DATA_TYPE",
Types.SMALLINT, rsmdt.getColumnType(col));
}
else if (metaColumnType == Types.JAVA_OBJECT)
{
// meta returns JAVA_OBJECT
// RSMD returns LONGVARBINARY!
assertEquals("DATA_TYPE",
Types.LONGVARBINARY, rsmdt.getColumnType(col));
}
else if (metaColumnType == Types.VARBINARY )
{
// meta returns different type name to RSMD
assertEquals("DATA_TYPE",
Types.VARBINARY, rsmdt.getColumnType(col));
}
else if (metaColumnType == Types.BINARY )
{
// meta returns different type name to RSMD
assertEquals("DATA_TYPE",
Types.BINARY, rsmdt.getColumnType(col));
}
else if (metaColumnType == Types.NUMERIC )
{
// DERBY-584 inconsistency in numeric & decimal
assertEquals("DATA_TYPE",
Types.DECIMAL, rsmdt.getColumnType(col));
assertEquals("TYPE_NAME",
"DECIMAL", rsmdt.getColumnTypeName(col));
assertEquals("TYPE_NAME",
"NUMERIC", rs.getString("TYPE_NAME"));
}
else
{
assertEquals("DATA_TYPE",
rsmdt.getColumnType(col), rs.getInt("DATA_TYPE"));
assertEquals("TYPE_NAME",
rsmdt.getColumnTypeName(col), rs.getString("TYPE_NAME"));
}
/*
if (metaColumnType != Types.JAVA_OBJECT) {
System.out.println("TYPE " + rs.getInt("DATA_TYPE"));
System.out.println(JDBC.escape(schema, table) + " " + rs.getString("COLUMN_NAME"));
assertEquals("COLUMN_SIZE",
rsmdt.getPrecision(col), rs.getInt("COLUMN_SIZE"));
}
*/
/*
assertEquals("DECIMAL_DIGITS",
rsmdt.getScale(col), rs.getInt("DECIMAL_DIGITS"));
*/
// This assumes the constants defined by meta and ResultSet
// for nullability are equal. They are by inspection
// and since they are static final and part of a defined
// api by definition they cannot change. We also
// check statically this is true in the testConstants fixture.
assertEquals("NULLABLE",
rsmdt.isNullable(col), rs.getInt("NULLABLE"));
// REMARKS set to empty string by Derby
assertEquals("REMARKS", "", rs.getString("REMARKS"));
// IS_NULLABLE
switch (rsmdt.isNullable(col))
{
case ResultSetMetaData.columnNoNulls:
assertEquals("IS_NULLABLE", "NO", rs.getString("IS_NULLABLE"));
break;
case ResultSetMetaData.columnNullable:
assertEquals("IS_NULLABLE", "YES", rs.getString("IS_NULLABLE"));
break;
case ResultSetMetaData.columnNullableUnknown:
assertEquals("IS_NULLABLE", "", rs.getString("IS_NULLABLE"));
break;
default:
fail("invalid return from rsmdt.isNullable(col)");
}
// SCOPE not supported
assertNull("SCOPE_CATLOG", rs.getString("SCOPE_CATLOG"));
assertNull("SCOPE_SCHEMA", rs.getString("SCOPE_SCHEMA"));
assertNull("SCOPE_TABLE", rs.getString("SCOPE_TABLE"));
// DISTINCT not supported
assertEquals("SOURCE_DATA_TYPE", 0, rs.getShort("SOURCE_DATA_TYPE"));
assertTrue(rs.wasNull());
// IS_AUTOINCREMENT added in JDBC 4.0
assertEquals("IS_AUTOINCREMENT",
rsmdt.isAutoIncrement(col) ? "YES" : "NO",
rs.getString("IS_AUTOINCREMENT"));
assertFalse(rs.wasNull());
}
/*
* Check the shape of the ResultSet from any getColumns call.
*/
private void checkColumnsShape(ResultSet rs) throws SQLException {
int[] columnTypes = new int[] {
Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
Types.SMALLINT, Types.VARCHAR, Types.INTEGER, Types.INTEGER,
Types.INTEGER, Types.INTEGER, Types.INTEGER, Types.VARCHAR,
Types.VARCHAR, Types.INTEGER, Types.INTEGER, Types.INTEGER,
Types.INTEGER, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
Types.VARCHAR, Types.SMALLINT, Types.VARCHAR};
assertMetaDataResultSet(rs, new String[] {
"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",
"SCOPE_CATLOG", "SCOPE_SCHEMA", "SCOPE_TABLE",
"SOURCE_DATA_TYPE", "IS_AUTOINCREMENT"}, columnTypes, null);
}
public static void assertMetaDataResultSet(ResultSet rs,
String[] columnNames, int[] columnTypes,
boolean[] nullability) throws SQLException
{
// see ResultSetGetterTest, getType() -> this test fails currently
assertEquals(ResultSet.TYPE_FORWARD_ONLY, rs.getType());
assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
if (columnNames != null)
assertColumnNames(rs, columnNames);
if (columnTypes != null)
assertColumnTypes(rs, columnTypes);
if (nullability != null)
assertNullability(rs, nullability);
}
/**
* * Test Method from Apache Derby Project
* Class
* org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
*
* Takes a result set and an array of expected colum names (as
* Strings) and asserts that the column names in the result
* set metadata match the number, order, and names of those
* in the array.
*
* @param rs ResultSet for which we're checking column names.
* @param expectedColNames Array of expected column names.
*/
public static void assertColumnNames(ResultSet rs,
String [] expectedColNames) throws SQLException
{
ResultSetMetaData rsmd = rs.getMetaData();
int actualCols = rsmd.getColumnCount();
for (int i = 0; i < actualCols; i++)
{
assertEquals("Column names do not match:",
expectedColNames[i], rsmd.getColumnName(i+1));
}
assertEquals("Unexpected column count:",
expectedColNames.length, rsmd.getColumnCount());
}
/**
* Test Method from Apache Derby Project
* Class
* org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
*
* Takes a result set and an array of expected column types
* from java.sql.Types
* and asserts that the column types in the result
* set metadata match the number, order, and names of those
* in the array.
*
* No length information for variable length types
* can be passed. For ResultSets from JDBC DatabaseMetaData
* the specification only indicates the types of the
* columns, not the length.
*
* @param rs ResultSet for which we're checking column names.
* @param expectedTypes Array of expected column types.
*/
public static void assertColumnTypes(ResultSet rs,
int[] expectedTypes) throws SQLException
{
ResultSetMetaData rsmd = rs.getMetaData();
int actualCols = rsmd.getColumnCount();
assertEquals("Unexpected column count:",
expectedTypes.length, rsmd.getColumnCount());
for (int i = 0; i < actualCols; i++)
{
assertEquals("Column types do not match for column " + (i+1),
expectedTypes[i], rsmd.getColumnType(i+1));
}
}
/**
* Check the nullability of the column definitions for
* the ResultSet matches the expected values.
* @param rs
* @param nullability
* @throws SQLException
*/
public static void assertNullability(ResultSet rs,
boolean[] nullability) throws SQLException
{
ResultSetMetaData rsmd = rs.getMetaData();
int actualCols = rsmd.getColumnCount();
assertEquals("Unexpected column count:",
nullability.length, rsmd.getColumnCount());
for (int i = 0; i < actualCols; i++)
{
int expected = nullability[i] ?
ResultSetMetaData.columnNullable : ResultSetMetaData.columnNoNulls;
assertEquals("Column nullability do not match for column " + (i+1),
expected, rsmd.isNullable(i+1));
}
}
//BEGIN Apache Derby DatabaseMetaDataTest
/*
* Escaped function testing TODO complete this list
*/
private static final String[][] NUMERIC_FUNCTIONS = {
// Section C.1 JDBC 3.0 spec.
{"ABS", "-25.67"},
// {"ACOS", "0.0707"}, {"ASIN", "0.997"},
// {"ATAN", "14.10"}, {"ATAN2", "0.56", "1.2"}, {"CEILING", "3.45"},
// {"COS", "1.2"}, {"COT", "3.4"}, {"DEGREES", "2.1"}, {"EXP", "2.3"},
// {"FLOOR", "3.22"}, {"LOG", "34.1"}, {"LOG10", "18.7"},
// {"MOD", "124", "7"}, {"PI"}, {"POWER", "2", "3"},
// {"RADIANS", "54"}, {"RAND", "17"},
{"ROUND", "345.345", "1"}
// {"SIGN", "-34"}, {"SIN", "0.32"}, {"SQRT", "6.22"},
// {"TAN", "0.57",}, {"TRUNCATE", "345.395", "1"}
};
private static final String[][] TIMEDATE_FUNCTIONS = {
// Section C.3 JDBC 3.0 spec.
{"date","'now'"}
//TODO Complete list
};
private static final String[][] SYSTEM_FUNCTIONS = {
// Section C.4 JDBC 3.0 spec.
{"IFNULL", "'this'", "'that'"}, {"USER"}
};
/*
* TODO complete or check this list
*/
private static final String[][] STRING_FUNCTIONS = {
// Section C.2 JDBC 3.0 spec.
// {"ASCII", "'Yellow'"}, {"CHAR", "65"},
// {"CONCAT", "'hello'", "'there'"},
// {"DIFFERENCE", "'Pires'", "'Piers'"},
// {"INSERT", "'Bill Clinton'", "4", "'William'"},
// {"LCASE", "'Fernando Alonso'"}, {"LEFT", "'Bonjour'", "3"},
// {"LENGTH", "'four '"}, {"LOCATE", "'jour'", "'Bonjour'"},
{"LTRIM", "' left trim '"},
// {"REPEAT", "'echo'", "3"},
// {"REPLACE", "'to be or not to be'", "'be'", "'England'"},
// {"RTRIM", "' right trim '"}, {"SOUNDEX", "'Derby'"},
// {"SPACE", "12"},
// {"SUBSTRING", "'Ruby the Rubicon Jeep'", "10", "7",},
// {"UCASE", "'Fernando Alonso'"}
};
/**
* Six combinations of valid identifiers with mixed case, to see how the
* various pattern matching and returned values handle them. This test only
* creates objects in these schemas.
*/
private static final String[] IDS = {
"one_meta_test", "TWO_meta_test", "ThReE_meta_test",
"\"four_meta_test\"", "\"FIVE_meta_test\"", "\"sIx_meta_test\""};
/**
* All the builtin schemas.
*/
private static final String[] BUILTIN_SCHEMAS = {
//TODO: Are there any other built in schemas?
};
public static String getStoredIdentifier(String sqlIdentifier) {
if (sqlIdentifier.charAt(0) == '"')
return sqlIdentifier.substring(1, sqlIdentifier.length() - 1);
else
return sqlIdentifier.toUpperCase();
}
/**
* Test getSchemas() without modifying the database.
*
* @throws SQLException
*/
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Derby test for getSchema",
method = "getSchemas",
args = {}
)
public void testGetSchemasReadOnly() throws SQLException {
ResultSet rs = meta.getSchemas();
checkSchemas(rs, new String[0]);
}
/**
* Check the returned information from a getSchemas(). The passed in
* String[] expected is a list of the schemas expected to be present in the
* returned set. The returned set may contain additional schemas which will
* be ignored, thus this test can be used regardless of the database state.
* The builtin schemas are automatically checked and must not be part of the
* passed in list.
*/
public static void checkSchemas(ResultSet rs, String[] userExpected)
throws SQLException {
// Add in the system schemas
String[] expected = new String[BUILTIN_SCHEMAS.length
+ userExpected.length];
System.arraycopy(BUILTIN_SCHEMAS, 0, expected, 0,
BUILTIN_SCHEMAS.length);
System.arraycopy(userExpected, 0, expected, BUILTIN_SCHEMAS.length,
userExpected.length);
// Remove any quotes from user schemas and upper case
// those without quotes.
for (int i = BUILTIN_SCHEMAS.length; i < expected.length; i++) {
expected[i] = getStoredIdentifier(expected[i]);
}
// output is ordered by TABLE_SCHEM
Arrays.sort(expected);
int nextMatch = 0;
while (rs.next()) {
String schema = rs.getString("TABLE_SCHEM");
assertNotNull(schema);
// Catalogs not supported
// assertNull(rs.getString("TABLE_CATALOG"));
if (nextMatch < expected.length) {
if (expected[nextMatch].equals(schema)) nextMatch++;
}
}
rs.close();
assertEquals("Schemas missing ", expected.length, nextMatch);
}
private void assertMatchesPattern(String pattern, String result) {
if (!doesMatch(pattern, 0, result, 0)) {
fail("Bad pattern matching:" + pattern + " result:" + result);
}
}
/**
* See if a string matches the pattern as defined by DatabaseMetaData. By
* passing in non-zero values can check sub-sets of the pattern against the
* sub strings of the result. <BR>
* _ matches a single character <BR>
* % matches zero or more characters <BR>
* Other characters match themselves.
*
* @param pattern
* Pattern
* @param pp
* Position in pattern to start the actual pattern from
* @param result
* result string
* @param rp
* position in result to starting checking
* @return true if a match is found
*/
private boolean doesMatch(String pattern, int pp, String result, int rp) {
// Find a match
for (;;) {
if (pp == pattern.length() && rp == result.length()) return true;
// more characters to match in the result but
// no more pattern.
if (pp == pattern.length()) return false;
char pc = pattern.charAt(pp);
if (pc == '_') {
// need to match a single character but
// exhausted result, so no match.
if (rp == result.length()) return false;
pp++;
rp++;
} else if (pc == '%') {
// % at end, complete match regardless of
// position of result since % matches zero or more.
if (pp == pattern.length() - 1) {
return true;
}
// Brut force, we have a pattern like %X
// and we are say in the third character of
// abCdefgX
// then start a 'CdefgX' and look for a match,
// then 'defgX' etc.
for (int sp = rp; sp < result.length(); sp++) {
if (doesMatch(pattern, pp + 1, result, sp)) {
// Have a match for the pattern after the %
// which means we have a match for the pattern
// with the % since we can match 0 or mor characters
// with %.
return true;
}
}
// Could not match the pattern after the %
return false;
} else {
// need to match a single character but
// exhausted result, so no match.
if (rp == result.length()) return false;
// Single character, must match exactly.
if (pc != result.charAt(rp)) {
// Computer says no.
return false;
}
pp++;
rp++;
}
}
}
/**
* Check that the list of escaped functions provided by the driver is a
* strict subet of the specified set, the list does not contain duplicates,
* all the functions listed can be executed and that if a function is not in
* the list but is specified it cannot be executed.
*/
private void escapedFunctions(String[][] specList, String metaDataList)
throws SQLException {
boolean[] seenFunction = new boolean[specList.length];
StringTokenizer st = new StringTokenizer(metaDataList, ",");
int counter = 0;
while (st.hasMoreTokens()) {
counter++;
String function = st.nextToken();
// find this function in the list
boolean isSpecFunction = false;
for (int f = 0; f < specList.length; f++) {
String[] specDetails = specList[f];
if (function.equals(specDetails[0])) {
// Matched spec.
if (seenFunction[f])
fail("Function in list twice: " + function);
seenFunction[f] = true;
isSpecFunction = true;
executeEscaped(specDetails);
break;
}
}
if (!isSpecFunction) {
fail("Non-JDBC spec function in list: " + function);
}
}
// Now see if any speced functions are not in the metadata list
assertSame("Function missing in metadata impl",specList.length, counter);
for (int f = 0; f < specList.length; f++) {
if (seenFunction[f]) continue;
String[] specDetails = specList[f];
// bug DERBY-723 CHAR maps to wrong function
if ("CHAR".equals(specDetails[0])) continue;
try {
executeEscaped(specDetails);
fail("function works but not declared in list: "
+ specDetails[0]);
} catch (SQLException e) {
//ok
}
}
}
/**
* Test we can execute a function listed as a supported
* JDBC escaped function. We don't care about the actual
* return value, that should be tested elsewhere in
* the specific test of a function.
*/
private void executeEscaped(String[] specDetails)
throws SQLException
{
String sql = "SELECT " + specDetails[0] + "(";
for (int p = 0; p < specDetails.length - 1; p++)
{
if (p != 0)
sql = sql + ", ";
sql = sql + specDetails[p + 1];
}
sql = sql + ") ;";
System.out.println("DatabaseMetaDataTest.executeEscaped() "+sql);
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery(sql);
assertNotNull("not supported function: "+sql,rs);
rs.close();
st.close();
}
//END APACHE-DERBY
}
|
