diff options
3 files changed, 397 insertions, 0 deletions
diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java new file mode 100644 index 00000000000..18dee272340 --- /dev/null +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java @@ -0,0 +1,339 @@ +package org.postgresql.test.jdbc2; + +import org.postgresql.test.TestUtil; +import junit.framework.TestCase; +import java.sql.*; + +/* + * TestCase to test the internal functionality of + * org.postgresql.jdbc2.DatabaseMetaData's various properties. + * Methods which return a ResultSet are tested elsewhere. + * This avoids a complicated setUp/tearDown for something like + * assertTrue(dbmd.nullPlusNonNullIsNull()); + */ + +public class DatabaseMetaDataPropertiesTest extends TestCase +{ + + private Connection con; + /* + * Constructor + */ + public DatabaseMetaDataPropertiesTest(String name) + { + super(name); + } + + protected void setUp() throws Exception + { + con = TestUtil.openDB(); + } + protected void tearDown() throws Exception + { + TestUtil.closeDB( con ); + } + + /* + * The spec says this may return null, but we always do! + */ + public void testGetMetaData() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + /* + * Test default capabilities + */ + public void testCapabilities() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(dbmd.allProceduresAreCallable()); + assertTrue(dbmd.allTablesAreSelectable()); // not true all the time + + // This should always be false for postgresql (at least for 7.x) + assertTrue(!dbmd.isReadOnly()); + + // does the backend support this yet? The protocol does... + assertTrue(!dbmd.supportsMultipleResultSets()); + + // yes, as multiple backends can have transactions open + assertTrue(dbmd.supportsMultipleTransactions()); + + assertTrue(dbmd.supportsMinimumSQLGrammar()); + assertTrue(!dbmd.supportsCoreSQLGrammar()); + assertTrue(!dbmd.supportsExtendedSQLGrammar()); + if (TestUtil.haveMinimumServerVersion(con,"7.3")) + assertTrue(dbmd.supportsANSI92EntryLevelSQL()); + else + assertTrue(!dbmd.supportsANSI92EntryLevelSQL()); + assertTrue(!dbmd.supportsANSI92IntermediateSQL()); + assertTrue(!dbmd.supportsANSI92FullSQL()); + + assertTrue(!dbmd.supportsIntegrityEnhancementFacility()); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + + public void testJoins() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(dbmd.supportsOuterJoins()); + assertTrue(dbmd.supportsFullOuterJoins()); + assertTrue(dbmd.supportsLimitedOuterJoins()); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testCursors() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(!dbmd.supportsPositionedDelete()); + assertTrue(!dbmd.supportsPositionedUpdate()); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testValues() + { + try { + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + int indexMaxKeys = dbmd.getMaxColumnsInIndex(); + if (TestUtil.haveMinimumServerVersion(con,"7.3")) { + assertEquals(indexMaxKeys,32); + } else { + assertEquals(indexMaxKeys,16); + } + } catch (SQLException sqle) { + fail(sqle.getMessage()); + } + } + + public void testNulls() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(!dbmd.nullsAreSortedAtStart()); + assertTrue( dbmd.nullsAreSortedAtEnd() != TestUtil.haveMinimumServerVersion(con,"7.2")); + assertTrue( dbmd.nullsAreSortedHigh() == TestUtil.haveMinimumServerVersion(con,"7.2")); + assertTrue(!dbmd.nullsAreSortedLow()); + + assertTrue(dbmd.nullPlusNonNullIsNull()); + + assertTrue(dbmd.supportsNonNullableColumns()); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testLocalFiles() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(!dbmd.usesLocalFilePerTable()); + assertTrue(!dbmd.usesLocalFiles()); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testIdentifiers() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(!dbmd.supportsMixedCaseIdentifiers()); // always false + assertTrue(dbmd.supportsMixedCaseQuotedIdentifiers()); // always true + + assertTrue(!dbmd.storesUpperCaseIdentifiers()); // always false + assertTrue(dbmd.storesLowerCaseIdentifiers()); // always true + assertTrue(!dbmd.storesUpperCaseQuotedIdentifiers()); // always false + assertTrue(!dbmd.storesLowerCaseQuotedIdentifiers()); // always false + assertTrue(!dbmd.storesMixedCaseQuotedIdentifiers()); // always false + + assertTrue(dbmd.getIdentifierQuoteString().equals("\"")); + + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testTables() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + // we can add columns + assertTrue(dbmd.supportsAlterTableWithAddColumn()); + + // we can only drop columns in >= 7.3 + if (TestUtil.haveMinimumServerVersion(con,"7.3")) { + assertTrue(dbmd.supportsAlterTableWithDropColumn()); + } else { + assertTrue(!dbmd.supportsAlterTableWithDropColumn()); + } + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testSelect() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + // yes we can?: SELECT col a FROM a; + assertTrue(dbmd.supportsColumnAliasing()); + + // yes we can have expressions in ORDERBY + assertTrue(dbmd.supportsExpressionsInOrderBy()); + + // Yes, an ORDER BY clause can contain columns that are not in the + // SELECT clause. + assertTrue(dbmd.supportsOrderByUnrelated()); + + assertTrue(dbmd.supportsGroupBy()); + assertTrue(dbmd.supportsGroupByUnrelated()); + assertTrue(dbmd.supportsGroupByBeyondSelect()); // needs checking + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testDBParams() + { + try + { + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(dbmd.getURL().equals(TestUtil.getURL())); + assertTrue(dbmd.getUserName().equals(TestUtil.getUser())); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testDbProductDetails() + { + try + { + assertTrue(con instanceof org.postgresql.PGConnection); + org.postgresql.jdbc2.AbstractJdbc2Connection pc = (org.postgresql.jdbc2.AbstractJdbc2Connection) con; + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(dbmd.getDatabaseProductName().equals("PostgreSQL")); + //The test below doesn't make sense to me, it tests that + //the version of the driver = the version of the database it is connected to + //since the driver should be backwardly compatible this test is commented out + //assertTrue(dbmd.getDatabaseProductVersion().startsWith( + // Integer.toString(pc.getDriver().getMajorVersion()) + // + "." + // + Integer.toString(pc.getDriver().getMinorVersion()))); + assertTrue(dbmd.getDriverName().equals("PostgreSQL Native Driver")); + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } + + public void testDriverVersioning() + { + try + { + assertTrue(con instanceof org.postgresql.PGConnection); + org.postgresql.jdbc2.AbstractJdbc2Connection pc = (org.postgresql.jdbc2.AbstractJdbc2Connection) con; + + DatabaseMetaData dbmd = con.getMetaData(); + assertNotNull(dbmd); + + assertTrue(dbmd.getDriverVersion().equals(pc.getDriver().getVersion())); + assertTrue(dbmd.getDriverMajorVersion() == pc.getDriver().getMajorVersion()); + assertTrue(dbmd.getDriverMinorVersion() == pc.getDriver().getMinorVersion()); + + + } + catch (SQLException ex) + { + fail(ex.getMessage()); + } + } +} + diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java new file mode 100644 index 00000000000..c2dd6ccf489 --- /dev/null +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java @@ -0,0 +1,11 @@ +package org.postgresql.test.jdbc2; + +import java.io.Serializable; + +public class SerializeObject implements Serializable { + + public int intcol; + public double doublecol; + public String stringcol; + +} diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java new file mode 100644 index 00000000000..73d512f5889 --- /dev/null +++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java @@ -0,0 +1,47 @@ +package org.postgresql.test.jdbc2; + +import org.postgresql.test.TestUtil; +import junit.framework.TestCase; +import java.sql.*; +import org.postgresql.util.Serialize; + +public class SerializeTest extends TestCase { + + private Connection conn; + private SerializeObject serobj; + private Serialize ser; + + public SerializeTest(String name) { + super(name); + } + + protected void setUp() throws Exception { + conn = TestUtil.openDB(); + serobj = new SerializeObject(); + serobj.intcol = 1; + serobj.doublecol = 3.4; + serobj.stringcol = "Hello"; + TestUtil.dropTable(conn,Serialize.toPostgreSQL(conn,serobj.getClass().getName())); + Serialize.create(conn, serobj); + Serialize.create(conn, serobj); + ser = new Serialize(conn,serobj); + } + + protected void tearDown() throws Exception { + TestUtil.dropTable(conn,Serialize.toPostgreSQL(conn,serobj.getClass().getName())); + } + + public void testCreateSerialize() { + try { + long oid = ser.storeObject(serobj); + SerializeObject serobj2 = (SerializeObject)ser.fetch(oid); + assertNotNull(serobj2); + assertEquals(serobj.intcol,serobj2.intcol); + assertTrue(Math.abs(serobj.doublecol-serobj2.doublecol) < 0.0001); + assertTrue(serobj.stringcol.equals(serobj2.stringcol)); + } catch (SQLException sqle) { + fail(sqle.getMessage()); + } + } + +} |