| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb.test; |
| |
| import java.sql.ResultSet; |
| import java.sql.ResultSetMetaData; |
| import java.sql.SQLException; |
| |
| import org.hsqldb.error.ErrorCode; |
| |
| import junit.framework.AssertionFailedError; |
| |
| /** |
| * is a test which verifies the functionality of replacing asterisks in VIEW statements with column |
| * lists. |
| * |
| * During investigating http://www.openoffice.org/issues/show_bug.cgi?id=78296 (an issue raised |
| * in OpenOffice.org, which integrates HSQLDB), it rose that views did not behave to the standard |
| * in that they don't always reflect the table column list at the time of creation of the view. |
| * |
| * This was changed so that when you CREATE a VIEW, then any asterisks in the constituting |
| * statement are replaced with their column lists. |
| * |
| * This test verifies this functionality in a number of different flavours. |
| * |
| * @author frank.schoenheit@sun.com |
| */ |
| public class TestViewAsterisks extends TestBase { |
| |
| java.sql.Statement m_statement; |
| java.sql.Connection m_connection; |
| |
| /** Creates a new instance of TestViewAsterisks */ |
| public TestViewAsterisks(String testName) { |
| super(testName, null, false, false); |
| } |
| |
| /** |
| * creates the database tables needed for the test |
| */ |
| private void setupDatabase() { |
| |
| try { |
| m_connection = newConnection(); |
| m_statement = m_connection.createStatement(); |
| |
| executeStatement("DROP TABLE ABC IF EXISTS CASCADE"); |
| executeStatement("DROP TABLE TABLE_A IF EXISTS CASCADE"); |
| executeStatement("DROP TABLE TABLE_B IF EXISTS CASCADE"); |
| executeStatement("DROP VIEW V1 IF EXISTS CASCADE"); // V1 is created by a previous test case |
| executeStatement( |
| "CREATE TABLE ABC (ID INTEGER NOT NULL PRIMARY KEY, A VARCHAR(50), B VARCHAR(50), C VARCHAR(50))"); |
| executeStatement("INSERT INTO ABC VALUES (1, 'a', 'b', 'c')"); |
| executeStatement("INSERT INTO ABC VALUES (2, 'd', 'e', 'f')"); |
| executeStatement( |
| "CREATE TABLE TABLE_A (ID_A INTEGER NOT NULL PRIMARY KEY, NAME_A VARCHAR(50))"); |
| executeStatement("INSERT INTO TABLE_A VALUES (1, 'first A')"); |
| executeStatement("INSERT INTO TABLE_A VALUES (2, 'second A')"); |
| executeStatement( |
| "CREATE TABLE TABLE_B (ID_B INTEGER NOT NULL PRIMARY KEY, NAME_B VARCHAR(50))"); |
| executeStatement("INSERT INTO TABLE_B VALUES (1, 'first B')"); |
| executeStatement("INSERT INTO TABLE_B VALUES (2, 'second B')"); |
| } catch (SQLException ex) { |
| fail(ex.toString()); |
| } |
| } |
| |
| public void setUp() { |
| super.setUp(); |
| setupDatabase(); |
| } |
| |
| protected void tearDown() { |
| executeStatement("SHUTDOWN"); |
| super.tearDown(); |
| } |
| |
| /** |
| * executes a given m_statement |
| * |
| * <p>Basically, this method calls <code>m_statement.execute(sql)</code>, |
| * but wraps any <code>SQLException</code>s into a JUnit error. |
| */ |
| private void executeStatement(String sql) { |
| executeStatement(sql, 0); |
| } |
| |
| private void executeStatement(String sql, int expectedVendorCode) { |
| |
| try { |
| m_statement.execute(sql); |
| assertTrue( |
| "executing\n " + sql |
| + "\nwas expected to fail, but it didn't", expectedVendorCode |
| == 0); |
| } catch (SQLException ex) { |
| if (expectedVendorCode == 0) { |
| fail(ex.toString()); |
| } |
| |
| assertEquals( |
| "executing\n " + sql |
| + "\ndid not result in the expected error", expectedVendorCode, -ex |
| .getErrorCode()); |
| } |
| } |
| |
| /** |
| * creates a view with the given name, the given constituting statement, and an optional column list |
| * |
| * @param viewName |
| * specifies the name of the view to create |
| * @param columnList |
| * list of names of the columns of the view, will be specified in the CREATE VIEW statement. Might be <code>null</code>. |
| * @param viewStatement |
| * the statement of the view |
| */ |
| private void createView(String viewName, String[] columnList, |
| String viewStatement) throws SQLException { |
| |
| StringBuffer colList = new StringBuffer(); |
| |
| if (columnList != null) { |
| colList.append(" ("); |
| |
| for (int i = 0; i < columnList.length; ++i) { |
| colList.append('"').append(columnList[i]).append('"'); |
| |
| if (i < columnList.length - 1) { |
| colList.append(','); |
| } |
| } |
| |
| colList.append(")"); |
| } |
| |
| executeStatement("CREATE VIEW " + viewName + colList.toString() |
| + " AS " + viewStatement); |
| |
| if (columnList != null) { |
| ensureTableColumns(viewName, columnList); |
| } |
| } |
| |
| /** |
| * retrieves the statement which defines a given view |
| */ |
| private String getViewStatement(String viewName) throws SQLException { |
| |
| ResultSet res = m_statement.executeQuery( |
| "SELECT VIEW_DEFINITION FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '" |
| + viewName + "'"); |
| |
| res.next(); |
| |
| String statement = res.getString(1); |
| |
| return statement; |
| } |
| |
| /** |
| * ensures two tables (or views, that is) have the same content |
| */ |
| private void ensureEqualContent(String tableNameLHS, |
| String tableNameRHS) throws SQLException { |
| |
| ResultSet lhs = m_statement.executeQuery("SELECT * FROM \"" |
| + tableNameLHS + "\""); |
| ResultSet rhs = m_statement.executeQuery("SELECT * FROM \"" |
| + tableNameRHS + "\""); |
| ResultSetMetaData meta = lhs.getMetaData(); |
| |
| while (lhs.next() && rhs.next()) { |
| for (int col = 1; col <= meta.getColumnCount(); ++col) { |
| assertEquals("table content does not match: cp. " |
| + tableNameLHS + "-" + tableNameRHS + ", row " |
| + lhs.getRow() + ", col " |
| + col, lhs.getObject(col), rhs.getObject(col)); |
| } |
| } |
| |
| // lhs should be after last, rhs still on last |
| assertTrue("row count does not match: " + tableNameLHS + "-" |
| + tableNameRHS, lhs.isAfterLast() && rhs.isLast()); |
| } |
| |
| /** |
| * ensures the content of a given table matches a given object array's content |
| */ |
| private void ensureTableContent(String tableName, |
| Object[][] tableData) throws SQLException { |
| |
| ResultSet lhs = m_statement.executeQuery("SELECT * FROM \"" |
| + tableName + "\""); |
| ResultSetMetaData meta = lhs.getMetaData(); |
| int colCount = meta.getColumnCount(); |
| |
| while (lhs.next()) { |
| int row = lhs.getRow(); |
| |
| assertEquals(colCount, tableData[row - 1].length); |
| |
| for (int col = 1; col <= colCount; ++col) { |
| assertEquals( |
| "unexpected table content in " + tableName + " (row " |
| + row + ", col " + col + ")", tableData[row - 1][col - 1], |
| lhs.getObject(col)); |
| } |
| } |
| } |
| |
| /** |
| * creates a view with a given name and statement, ensures that it's statement is translated as expected, and ensures |
| * that the content of the view is as expected |
| * |
| * @param viewName |
| * the name of the to-be-created view |
| * @param columnNames |
| * the names of the columns of the view, as to be specified in the CREATE VIEW statement. Might be null, |
| * in this case the view will be created without an explicit column list |
| * @param viewStatement |
| * the statement of the to-be-created view |
| * @param expectedTranslatedStatement |
| * the expected statement of the view, after it has been implicitly translated by HSQL. If the actual |
| * statement after creation does not match this expected statement, this is a failure condition which |
| * results in a AssertionFailedError being thrown. |
| * @param expectedContent |
| * the expected content of the view. If this is <code>null</code>, it is ignored. Else, if it is a |
| * string, it is interpreted as name of the table which must have the same content as a view. If |
| * it's no string either, it must be a two-dimensional Object array specifying the expected content. |
| */ |
| private void checkViewTranslationAndContent(String viewName, |
| String[] columnList, String viewStatement, |
| String expectedTranslatedStatement, |
| Object expectedContent) throws SQLException { |
| |
| createView(viewName, columnList, viewStatement); |
| |
| String actualTranslatedStatement = getViewStatement(viewName); |
| |
| if (!actualTranslatedStatement.equals(expectedTranslatedStatement)) { |
| StringBuffer message = new StringBuffer(); |
| |
| message.append(viewName).append( |
| "'s statement not translated as expected\n"); |
| message.append("original statement:\n ").append( |
| viewStatement).append('\n'); |
| message.append("expected translated statement:\n ").append( |
| expectedTranslatedStatement).append('\n'); |
| message.append("actual translated statement:\n ").append( |
| actualTranslatedStatement).append('\n'); |
| |
| throw new AssertionFailedError(message.toString()); |
| } |
| |
| if (expectedContent instanceof Object[][]) { |
| ensureTableContent(viewName, (Object[][]) expectedContent); |
| } |
| } |
| |
| /** |
| * ensures that a given table has columns with a given name |
| */ |
| private void ensureTableColumns(String tableName, |
| String[] columnNames) throws SQLException { |
| |
| ResultSet res = m_connection.getMetaData().getColumns(null, null, |
| tableName, "%"); |
| |
| while (res.next()) { |
| assertEquals( |
| "unexpected column name in table \"" + tableName |
| + "\" at position " |
| + (res.getRow() - 1), res.getString( |
| "COLUMN_NAME"), columnNames[res.getRow() - 1]); |
| } |
| |
| res.previous(); |
| assertEquals("not enough columns in table \"" + tableName + "\"", |
| columnNames.length, res.getRow()); |
| } |
| |
| /** |
| * checks views selecting an asterisk from a table, in different flavours |
| */ |
| private void checkSimpleViews() throws SQLException { |
| |
| // ................................................................ |
| // SELECT * |
| checkViewTranslationAndContent( |
| "S1", null, "SELECT * FROM ABC", |
| "SELECT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC", |
| "ABC"); |
| |
| // adding a column to "ABC" should succeed, and still leave the view with the columns |
| // before the addition |
| executeStatement("ALTER TABLE ABC ADD COLUMN D VARCHAR(50)"); |
| ensureTableColumns("ABC", new String[] { |
| "ID", "A", "B", "C", "D" |
| }); |
| ensureTableColumns("S1", new String[] { |
| "ID", "A", "B", "C" |
| }); |
| |
| // dropping the column which is not part of the view should be possible |
| executeStatement("ALTER TABLE ABC DROP COLUMN D"); |
| |
| // dropping another column which *is* part of the view shouldn't |
| executeStatement("ALTER TABLE ABC DROP COLUMN C", ErrorCode.X_42536); |
| |
| // finally, dropping the column with CASCADE should work, and also drop the view |
| //executeStatement("ALTER TABLE ABC DROP COLUMN C CASCADE"); |
| // DROP COLUMN c CASCADE not implemented, yet |
| // ................................................................ |
| // same as S1, but this time add a LIMIT clause to the statement |
| checkViewTranslationAndContent( |
| "S2", null, "SELECT LIMIT 0 2 * FROM ABC ORDER BY ID", |
| "SELECT LIMIT 0 2 PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC ORDER BY ID", |
| "ABC"); |
| |
| // ................................................................ |
| // same as S1, but this time add a TOP clause to the statement |
| checkViewTranslationAndContent( |
| "S3", null, "SELECT TOP 2 * FROM ABC ORDER BY ID", |
| "SELECT TOP 2 PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC ORDER BY ID", |
| "ABC"); |
| |
| // ................................................................ |
| // same as S1, but this time add a DISTINCT clause to the statement |
| checkViewTranslationAndContent( |
| "S4", null, "SELECT DISTINCT * FROM ABC", |
| "SELECT DISTINCT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC", |
| "ABC"); |
| |
| // ................................................................ |
| // same as S1, but this time qualifying the asterisk |
| checkViewTranslationAndContent( |
| "S5", null, "SELECT ABC.* FROM ABC", |
| "SELECT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC", |
| "ABC"); |
| |
| // ................................................................ |
| // same as S5, but this time also giving the table an alias |
| checkViewTranslationAndContent( |
| "S6", null, "SELECT \"A\".* FROM ABC AS A", |
| "SELECT A.ID,A.A,A.B,A.C FROM PUBLIC.ABC AS A", |
| "ABC"); |
| |
| // ................................................................ |
| // same as S1, but bracket the SELECT definition |
| checkViewTranslationAndContent( |
| "S7", null, "( SELECT * FROM ABC )", |
| "(SELECT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC)", |
| "ABC"); |
| } |
| |
| /** |
| * checks views selecting an asterisk plus existing columns |
| */ |
| private void checkAsterisksCombined() throws SQLException { |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "C1", null, "SELECT * AS \"a2\" FROM ABC", |
| "SELECT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C AS\"a2\" FROM PUBLIC.ABC", |
| new Object[][] { |
| new Object[] { |
| new Integer(1), "a", "b", "c" |
| }, new Object[] { |
| new Integer(2), "d", "e", "f" |
| } |
| }); |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "C2", null, "SELECT B AS \"b2\", ABC.* FROM ABC", |
| "SELECT B AS\"b2\" , PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC", |
| new Object[][] { |
| new Object[] { |
| "b", new Integer(1), "a", "b", "c" |
| }, new Object[] { |
| "e", new Integer(2), "d", "e", "f" |
| } |
| }); |
| } |
| |
| /** |
| * checks views selecting asterisks from multiple tables |
| */ |
| private void checkMultipleTables() throws SQLException { |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "M1", null, "SELECT * FROM TABLE_A, TABLE_B", |
| "SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A,PUBLIC.TABLE_B.ID_B,PUBLIC.TABLE_B.NAME_B FROM PUBLIC.TABLE_A,PUBLIC.TABLE_B", |
| new Object[][] { |
| new Object[] { |
| new Integer(1), "first A", new Integer(1), "first B" |
| }, new Object[] { |
| new Integer(1), "first A", new Integer(2), "second B" |
| }, new Object[] { |
| new Integer(2), "second A", new Integer(1), "first B" |
| }, new Object[] { |
| new Integer(2), "second A", new Integer(2), "second B" |
| } |
| }); |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "M2", null, "SELECT TABLE_B.*, TABLE_A.* FROM TABLE_A, TABLE_B", |
| "SELECT PUBLIC.TABLE_B.ID_B,PUBLIC.TABLE_B.NAME_B , PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A,PUBLIC.TABLE_B", |
| new Object[][] { |
| new Object[] { |
| new Integer(1), "first B", new Integer(1), "first A" |
| }, new Object[] { |
| new Integer(2), "second B", new Integer(1), "first A" |
| }, new Object[] { |
| new Integer(1), "first B", new Integer(2), "second A" |
| }, new Object[] { |
| new Integer(2), "second B", new Integer(2), "second A" |
| } |
| }); |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "M3", null, "SELECT \"TABLE_A\".* FROM TABLE_A, TABLE_B", |
| "SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A,PUBLIC.TABLE_B", |
| new Object[][] { |
| new Object[] { |
| new Integer(1), "first A" |
| }, new Object[] { |
| new Integer(1), "first A" |
| }, new Object[] { |
| new Integer(2), "second A" |
| }, new Object[] { |
| new Integer(2), "second A" |
| } |
| }); |
| } |
| |
| /** |
| * checks views selecting from sub selects |
| */ |
| private void checkSubSelects() throws SQLException { |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "Q1", null, "SELECT * FROM ( SELECT * FROM ABC )", |
| "SELECT ID,A,B,C FROM(SELECT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC)", |
| null); |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "Q2", null, |
| "SELECT * FROM ( SELECT * FROM TABLE_A ), ( SELECT * FROM TABLE_B )", |
| "SELECT ID_A,NAME_A,ID_B,NAME_B FROM(SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A),(SELECT PUBLIC.TABLE_B.ID_B,PUBLIC.TABLE_B.NAME_B FROM PUBLIC.TABLE_B)", |
| null); |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "Q3", null, "SELECT A.* FROM ( SELECT * FROM TABLE_A ) AS A", |
| "SELECT A.ID_A,A.NAME_A FROM(SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A)AS A", |
| null); |
| |
| // ................................................................ |
| checkViewTranslationAndContent( |
| "Q4", null, |
| "SELECT A.*, B.* FROM ( SELECT * FROM TABLE_A ) AS A, ( SELECT * FROM TABLE_B ) AS B", |
| "SELECT A.ID_A,A.NAME_A , B.ID_B,B.NAME_B FROM(SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A)AS A,(SELECT PUBLIC.TABLE_B.ID_B,PUBLIC.TABLE_B.NAME_B FROM PUBLIC.TABLE_B)AS B", |
| null); |
| } |
| |
| /** |
| * checks views which are defined using a column list |
| */ |
| private void checkColumnLists() throws SQLException { |
| |
| // just to ensure the column count handling is as expected, else below tests might be useless |
| executeStatement("CREATE VIEW IMPOSSIBLE (\"A\") AS SELECT * FROM ABC", |
| ErrorCode.X_42593); |
| |
| // ................................................................ |
| // not that it should make any difference to S1, but who knows |
| checkViewTranslationAndContent("L1", new String[] { |
| "C1", "C2", "C3", "C4" |
| }, "SELECT * FROM ABC", "SELECT PUBLIC.ABC.ID,PUBLIC.ABC.A,PUBLIC.ABC.B,PUBLIC.ABC.C FROM PUBLIC.ABC", |
| "ABC"); |
| } |
| |
| /** |
| * checks views based on other views |
| */ |
| private void checkViewsOnViews() throws SQLException { |
| |
| // ................................................................ |
| // not that it should make any difference whether we SELECT FROM a table or view, but who knows |
| checkViewTranslationAndContent( |
| "V1", null, "SELECT * FROM S1", |
| "SELECT PUBLIC.S1.ID,PUBLIC.S1.A,PUBLIC.S1.B,PUBLIC.S1.C FROM PUBLIC.S1", "L1"); |
| } |
| |
| /** |
| * checks views based on a UNION statement |
| */ |
| private void checkUnionViews() throws SQLException { |
| |
| checkViewTranslationAndContent( |
| "U1", null, "SELECT * FROM TABLE_A UNION SELECT * FROM TABLE_B", |
| "SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A UNION SELECT PUBLIC.TABLE_B.ID_B,PUBLIC.TABLE_B.NAME_B FROM PUBLIC.TABLE_B", |
| new Object[][] { |
| new Object[] { |
| new Integer(1), "first A" |
| }, new Object[] { |
| new Integer(1), "first B" |
| }, new Object[] { |
| new Integer(2), "second A" |
| }, new Object[] { |
| new Integer(2), "second B" |
| } |
| }); |
| checkViewTranslationAndContent( |
| "U2", null, |
| "SELECT * FROM ( SELECT * FROM TABLE_A UNION SELECT * FROM TABLE_B )", |
| "SELECT ID_A,NAME_A FROM(SELECT PUBLIC.TABLE_A.ID_A,PUBLIC.TABLE_A.NAME_A FROM PUBLIC.TABLE_A UNION SELECT PUBLIC.TABLE_B.ID_B,PUBLIC.TABLE_B.NAME_B FROM PUBLIC.TABLE_B)", |
| new Object[][] { |
| new Object[] { |
| new Integer(1), "first A" |
| }, new Object[] { |
| new Integer(1), "first B" |
| }, new Object[] { |
| new Integer(2), "second A" |
| }, new Object[] { |
| new Integer(2), "second B" |
| } |
| }); |
| } |
| |
| /** |
| * main test method of this class |
| */ |
| public void test() { |
| |
| try { |
| checkSimpleViews(); |
| checkAsterisksCombined(); |
| checkMultipleTables(); |
| checkSubSelects(); |
| checkColumnLists(); |
| checkViewsOnViews(); |
| checkUnionViews(); |
| } catch (SQLException ex) { |
| fail(ex.toString()); |
| } |
| } |
| |
| /** |
| * entry point to run the test directly |
| */ |
| public static void main(String[] argv) { |
| runWithResult(TestViewAsterisks.class, "test"); |
| } |
| } |
