Test code for SQL Types
//
// Lapetus Ltd Java Class. Copyright (c) Lapetus Systems Ltd, 2009, 2010.
// -----------------------------------------------------------------------
// This is the intellectual property of Lapetus Systems Ltd, Artemis, Greece.
// --------------------------------------------------------------------------
// www.lapetus-ltd.com, www.lapetus.com.gr, www.lapetus.eu
// -------------------------------------------------------
// $LastChangedRevision: 1191 $
// $LastChangedDate:: 2010-11-18 15:53:39#$
// ----------------------------------------
//
import com.lapetus_ltd._2009.xml.types.*;
import com.lapetus_ltd.api.TLptsMainDatabase;
import com.lapetus_ltd.api.common.TLptsCharSetLocaleUtil;
import com.lapetus_ltd.api.common.TLptsCryptoUtil;
import com.lapetus_ltd.api.common.logger.ILptsLogListener;
import com.lapetus_ltd.api.common.logger.TLptsLog;
import com.lapetus_ltd.api.common.logger.TLptsLogger;
import com.lapetus_ltd.api.db.control.*;
import com.lapetus_ltd.api.db.utils.TLptsDriverLoader;
import com.lapetus_ltd.api.db.xml.types.TLptsDBConnectionType;
import com.lapetus_ltd.api.db.xml.types.TLptsDBUpInsDelSetType;
import com.lapetus_ltd.api.db.xml.types.TLptsDBUpInsDelWhereType;
import com.lapetus_ltd.api.db.xml.types.TLptsDriverType;
import junit.framework.TestCase;
import java.math.BigDecimal;
import java.sql.*;
import java.util.ResourceBundle;
// ######################################################################################################
// #### Test code for the dbJAPI build process. This code will stop the build process on ERROR ####
// ######################################################################################################
//
// Class Description : This module tests types of columns against the MySQL database.
//
// The class inserts data into tables in the MySQL, MS-SQL and Postgres Data sources and then selects the records for verification.
// The data inserted is of all the types supported by each DB and the exact values are checked at the end.
//
// The rowset listener therefore performs the SELECT creations and verification of the selected data, after the insertions have completed.
//
public class TestDataBaseTypes extends TestCase
{
private String connectionMSSqlId = null;
private String connectionPostgresId = null;
private String connectionMySqlId = null;
private int testCompleted = 0;
static public void main(String[] args)
{
TestDataBaseTypes tdbt = new TestDataBaseTypes();
tdbt.testDataBaseTypes();
}
public void testDataBaseTypes()
{
// required so that the API can function correctly.
TLptsMainDatabase.init();
// register a listener for the logging system.
TLptsLogger.addListener(new ILptsLogListener()
{
public void newLogGenerated(TLptsLog log)
{
if (log.getType().equals(TLptsLogger.LOG_TYPE.ERROR))
{
fail("LOG ERROR :" + log.getMessage() + " : " + log.getSupportingText() + " : Exception : " + log.getExceptionMessage());
System.exit(0);
}
if (log.getType().equals(TLptsLogger.LOG_TYPE.WARNING))
System.out.println("LOG WARNING :" + log.getMessage() + " : " + log.getSupportingText());
if (log.getType().equals(TLptsLogger.LOG_TYPE.MESSAGE))
System.out.println("LOG MESSAGE :" + log.getMessage() + " : " + log.getSupportingText());
}
});
// register a listener for the connections
TLptsFactoryConnection.addListener(new ConnectionStatementListener());
// register a listener for the rowsets produced
TLptsFactoryRowSet.addListener(new RowSetListener());
// register a listener for the statements
TLptsFactoryStatement.addListener(new StatementListener());
TLptsDBConnectionType connectionType;
// Connect To PostgreSQL
connectionType = connectToDB("POSTGRESQL_DB");
if (connectionType != null)
{
connectionPostgresId = connectionType.getId();
TLptsFactoryConnection.initiateConnection(connectionType); // This generates another thread!!
}
// Connect To MySQL
connectionType = connectToDB("MYSQL_DB");
if (connectionType != null)
{
connectionMySqlId = connectionType.getId();
TLptsFactoryConnection.initiateConnection(connectionType); // This generates another thread!!
}
// Connect To MS SQL
connectionType = connectToDB("MSSQL_DB");
if (connectionType != null)
{
connectionMSSqlId = connectionType.getId();
TLptsFactoryConnection.initiateConnection(connectionType); // This generates another thread!!
}
// ##############################################################################################################
// See ExampleConnectionUsage.connectToDB for an example of how to connect to other Data Sources
// ##############################################################################################################
}
// ####################################################################################
// C O N N E C T I O N
// ####################################################################################
private TLptsDBConnectionType connectToDB(String title)
{
String driverName = "", dbName = "", userName = "", password = "";
ResourceBundle bundle = ResourceBundle.getBundle("resources"); // we have stored all the database info in this bundle
TLptsDBConnectionType connectionType = new TLptsDBConnectionType();
connectionType.setTitle(title);
if (title.equals("MYSQL_DB"))
{
dbName = bundle.getString("Testing.database.mysql.testdb2");
userName = bundle.getString("Testing.database.mysql.user");
password = bundle.getString("Testing.database.mysql.password");
driverName = "com.mysql.jdbc.jdbc2.optional.MysqlDataSource";
}
if (title.equals("MSSQL_DB"))
{
dbName = bundle.getString("Testing.database.mssql.testdb1");
userName = bundle.getString("Testing.database.mssql.user");
password = bundle.getString("Testing.database.mssql.password");
driverName = "com.microsoft.sqlserver.jdbc.SQLServerDataSource";
}
if (title.equals("POSTGRESQL_DB"))
{
dbName = bundle.getString("Testing.database.postgresql.testdb1");
userName = bundle.getString("Testing.database.postgresql.user");
password = bundle.getString("Testing.database.postgresql.password");
driverName = "org.postgresql.ds.PGSimpleDataSource";
}
XLptsDriverType driver = TLptsDriverLoader.getDriverTypeByClassName(driverName);
if (driver == null)
{
System.out.println("Could not find driver for class " + driverName);
return null;
}
TLptsDriverType driverType = new TLptsDriverType(driver);
// changing values that are default in the driver.loader.xml file.
// the DB is now set correctly and will filter through to the Datasource interface execution
driverType.setValueForInterfaceFunctionParameter("setDatabaseName", "Database Name", dbName);
connectionType.setDriverType(driverType);
if (userName == null || password == null)
connectionType.setCredentials(TLptsCryptoUtil.defaultEncryptCredentialsRSA(driverType.getGuestUser(),
driverType.getGuestPassword()));
else
connectionType.setCredentials(TLptsCryptoUtil.defaultEncryptCredentialsRSA(userName, password));
return connectionType;
}
// ####################################################################################
// I N S E R T F U N C T I O N S
// ####################################################################################
private void insertDataOfAllTypesPostgreSQL()
{
// clean up the table so that we can insert records
deleteRecord(connectionPostgresId, "1");
// Find the Connection to insert data
TLptsConnection connection = TLptsFactoryConnection.getConnection(connectionPostgresId);
if (connection == null)
{
TLptsLogger.logError("Could not find Postgres connection", null); // this will cause a fail as it is caught by the log listener
return;
}
// Create the statement and set the Type of Statement.
TLptsStatement insertStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.INSERT);
insertStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
insertStatement.setXResultSetConcurrency(ResultSet.CONCUR_UPDATABLE);
XLptsDBStatementTableType table = insertStatement.getTableItemByName("allTypes");
table.setSelected(true);
XLptsDBStatementColumnType column;
// now we need to select the columns for insertion and specify the values for insertion
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "idAllTypes")) != null)
{
// The Expression type can be a simple Expression (PROGRAMMATIC), another lapetus statement (LPTS_STATEMENT) or a stored
// procedure (STORED_PROCEDURE) from the same data source. We choose a static value, which is programmatically specified.
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1");
// Now we have to set the insert parameters for this column
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "charColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "D");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "bigintColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1234567");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "booleanColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "true");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "bytesColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "bytes column");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setSqlType(Types.VARBINARY);
column.getUpInsDelParameterItem().setCharset(TLptsCharSetLocaleUtil.NO_CHARSET_TRANSLATION);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "characterColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "D");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "charactervaryingColumn")) != null)
{
column.setSelected(true);
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "var char column");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "dateColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010-06-10");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "doubleprecisionColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "125.357");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "integerColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "15963");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "numericColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "14859.00");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "oidColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1234567");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "realColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "145.85");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "smallintColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "78");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "textColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "text column");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "timewithtimezoneColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "09:15:23");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "timewithouttimezoneColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "18:36:05");
column.setUpInsDelParameterItem(parameters);
}
insertStatement.setTitle("Insert Statement");
System.out.println("SQL Statement " + insertStatement.getTitle() + ": " + insertStatement.getSqlStatementFormatted());
TLptsFactoryRowSet.executeDynamicInsert(insertStatement);
}
private void insertDataOfAllTypesMSSQL()
{
// clean up the table so that we can insert a record again
deleteRecord(connectionMSSqlId, "1");
TLptsConnection connection = TLptsFactoryConnection.getConnection(connectionMSSqlId);
if (connection == null)
{
TLptsLogger.logError("Could not find MS-SQL connection", null); // this will cause a fail as it is caught by the log listener
return;
}
TLptsStatement insertStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.INSERT);
insertStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
insertStatement.setXResultSetConcurrency(ResultSet.CONCUR_UPDATABLE);
XLptsDBStatementTableType table = insertStatement.getTableItemByName("allTypes");
table.setSelected(true);
XLptsDBStatementColumnType column;
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "idAllTypes")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "bigIntColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1234567");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "binaryColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "binary column");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setSqlType(Types.VARBINARY);
column.getUpInsDelParameterItem().setCharset(TLptsCharSetLocaleUtil.NO_CHARSET_TRANSLATION);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "bitColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "true");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "charColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "D");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "datetimeColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010-08-23 13:19:27");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "decimalColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "356.85");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "floatColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "142.35");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "imageColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "image column test");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-8");
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "integerColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "15963");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "moneyColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "356.8500");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "ncharColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "D");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-16LE");
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "ntextColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "n text column");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "numericColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "14859.00");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "nvarcharColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "n var char column");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-16LE");
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "realColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "145.85");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "smalldatetimeColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010-08-23 13:19:00.0");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "smallintColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "78");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "smallmoneyColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "23.1000");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "textColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "text column");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "tinyintColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "4");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "uniqueidentifierColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "Column Identifier");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset(TLptsCharSetLocaleUtil.NO_CHARSET_TRANSLATION);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "varbinaryColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "var binary column");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-8");
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "varcharColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "var char column");
column.setUpInsDelParameterItem(parameters);
}
if ((column = insertStatement.getColumnItemByName(table.getTableName(), "xmlColumn")) != null)
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "<mainScreenDimensions><maximized>false</maximized></mainScreenDimensions>");
column.setUpInsDelParameterItem(parameters);
}
insertStatement.setTitle("Insert Statement");
System.out.println("SQL Statement " + insertStatement.getTitle() + ": " + insertStatement.getSqlStatementFormatted());
TLptsFactoryRowSet.executeDynamicInsert(insertStatement);
}
private void insertDataOfAllTypesMySQL()
{
// clean up the table so that we can insert a record again
deleteRecord(connectionMySqlId, "2");
TLptsConnection connection = TLptsFactoryConnection.getConnection(connectionMySqlId);
if (connection == null)
return;
TLptsStatement insertStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.INSERT);
insertStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
insertStatement.setXResultSetConcurrency(ResultSet.CONCUR_UPDATABLE);
XLptsDBStatementTableType table = insertStatement.getTableItemByName("allTypes");
table.setSelected(true);
// lets try a different mechanism for selecting columns, with a loop
for (XLptsDBStatementColumnType column : insertStatement.getColumnItemsForTable(table.getTableName()))
{
if (column.getColumnName().equals("idAllTypes"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("integerColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "15963");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("varcharColumn"))
{
column.setSelected(true);
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "var char column");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("decimalColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "356.85");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("datetimeColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010-06-24 12:35:12");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("blobColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "blob Test");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-8");
} else if (column.getColumnName().equals("longBlobColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "long blob Test");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-8");
} else if (column.getColumnName().equals("mediumBlobColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "Medium blob Test");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-8");
} else if (column.getColumnName().equals("tinyBlobColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("dateColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010-06-10");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("timeColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "09:15:23");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("timeStampColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010-08-23 13:19:27");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("yearColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "2010");
column.setUpInsDelParameterItem(parameters);
parameters.setSqlType(Types.INTEGER);
} else if (column.getColumnName().equals("bigIntColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1234567");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("doubleColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "125.357");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("floatColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "142.35");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("mediumIntColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "175");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("smallintColumn"))
{
column.setSelected(true);
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "78");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("tinyIntColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "4");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("binaryColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "1");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("charColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "D");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("varBinaryColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "var binary column");
column.setUpInsDelParameterItem(parameters);
column.getUpInsDelParameterItem().setCharset("UTF-8");
} else if (column.getColumnName().equals("longTextColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "long text column");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("mediumTextColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "medium text column");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("textColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "text column");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("tinyTextColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "tiny text column");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("bitColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "true");
column.setUpInsDelParameterItem(parameters);
} else if (column.getColumnName().equals("enumColumn"))
{
TLptsDBUpInsDelSetType parameters = new TLptsDBUpInsDelSetType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, "N");
column.setUpInsDelParameterItem(parameters);
}
}
insertStatement.setTitle("Insert Statement");
System.out.println("SQL Statement " + insertStatement.getTitle() + ": " + insertStatement.getSqlStatementFormatted());
TLptsFactoryRowSet.executeDynamicInsert(insertStatement);
}
// this delete function is used by all insert functions
private void deleteRecord(String connectionID, String criteria)
{
// Find the Connection to delete data
TLptsConnection connection = TLptsFactoryConnection.getConnection(connectionID);
if (connection == null)
{
TLptsLogger.logError("Could not DELETE : Connection not found :" + connectionID, null);
return;
}
// Create the statement and set the Type of Statement to DELETE.
TLptsStatement deleteStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.DELETE);
// set scroll sensitive so that compatibility is achieved across the DB types
deleteStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
// ResultSet Concurrency should be updatable
deleteStatement.setXResultSetConcurrency(ResultSet.CONCUR_UPDATABLE);
// set the table that will be delete from
XLptsDBStatementTableType table = deleteStatement.getTableItemByName("allTypes");
table.setSelected(true);
// set the column that will use its data for the CRITERIA processing for deleting rows.
XLptsDBStatementColumnType column = deleteStatement.getColumnItemByName(table.getTableName(), "idAllTypes");
// We want to delete all IDs with the criteria string provided
if (column != null)
{
TLptsDBUpInsDelWhereType whereType = new TLptsDBUpInsDelWhereType(XLptsDBUpInsDelSourceType.PROGRAMMATIC, criteria);
// Set the operation we want as ILPtsStatement.OPERATION_*
whereType.setOperation(TLptsFactoryStatement.OPERATION_EQUAL);
// Set the WHERE parameter for Update, Insert and Delete
column.setUpInsDelParameterItem(whereType);
}
// set a logical name
deleteStatement.setTitle("Delete_Statement_" + connectionID);
// print out the statement
System.out.println("SQL Statement " + deleteStatement.getTitle() + ": " + deleteStatement.getSqlStatementFormatted());
TLptsFactoryRowSet.executeDynamicDelete(deleteStatement);
}
// ###############################################################################################################
// #### C O N N E C T I O N L I S T E N E R
// ###############################################################################################################
private class ConnectionStatementListener implements ILptsFactoryConnectionListener
{
public synchronized void newConnectionCreated(TLptsConnection connection)
{
System.out.println("New Connection created successfully. Statements can be processed. " + connection.getTitle());
if (connection.getId().equals(connectionMySqlId))
insertDataOfAllTypesMySQL();
else if (connection.getId().equals(connectionMSSqlId))
insertDataOfAllTypesMSSQL();
else if (connection.getId().equals(connectionPostgresId))
insertDataOfAllTypesPostgreSQL();
}
public void newConnectionProcessStarted()
{
System.out.println("Connecting...");
}
public void newConnectionFailed(TLptsLog log)
{
System.out.println("New Connection Failed. The logger got this.");
}
public void removedAndClosedConnection(TLptsConnection connection)
{
System.out.println("Connection removed from Connection Manager and closed successfully ... " + connection.getTitle());
}
}
// ###############################################################################################################
// #### S T A T E M E N T L I S T E N E R
// ###############################################################################################################
private class StatementListener implements ILptsFactoryStatementListener
{
public void newStatementProcessStarted(TLptsConnection connection)
{
}
public void newStatementCreated(TLptsConnection connection, TLptsStatement statement)
{
if (statement.getTypeOfStatement() == XLptsDBTypeOfStatementType.SELECT)
TLptsFactoryRowSet.executeSelectStatement(statement, 1, 0, false);
}
public void newStatementFailed(TLptsConnection connection)
{
TLptsLogger.logError("Failed to Create Statement for connection " + connection.getTitle(), null);
}
public void removedAndClosedStatement(TLptsConnection connection, TLptsStatement statement)
{
}
}
// ###############################################################################################################
// #### R O W S E T L I S T E N E R
// ###############################################################################################################
// when every INSERT completes (INSERT_COMPLETE), it causes a SELECT statement to be generated.
// the SELECT is then also processed in this listener (NEW_SELECT_RESULTSET)
// the result of the SELECT is then checked for the values and types.
private class RowSetListener implements ILptsFactoryRowSetListener
{
public void rowEvent(TLptsRowEvent rowEvent)
{
}
public boolean processNewRowSetRows(TLptsRowSetEvent rowSetEvent)
{
if (rowSetEvent.getEventType() == TLptsRowSetEvent.EVENT_TYPE.INSERT_COMPLETE)
{
try
{
TLptsConnection connection = ((TLptsConnection) rowSetEvent.getStatement().getConnection());
System.out.println("Statement " + rowSetEvent.getStatement().getTitle() + " " + connection.getTitle() + " update execution complete...");
if (connection.getId().equals(connectionPostgresId))
{
TLptsStatement selectStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.SELECT);
// set result set type
selectStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
// set the table and columns for selecting
selectStatement.setSqlStatementUser("SELECT * FROM \"allTypes\" WHERE \"allTypes\".\"idAllTypes\" = 1");
// the statement is modified by hand and will not be generated from the selected tables and columns.
selectStatement.setSqlStatementModified(true);
selectStatement.setTitle("Select");
System.out.println("SQL Statement " + selectStatement.getTitle() + ": " + selectStatement.getSqlStatementFormatted());
TLptsFactoryStatement.createNewStatement(connection, selectStatement);
} else if (connection.getId().equals(connectionMSSqlId))
{
TLptsStatement selectStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.SELECT);
selectStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
selectStatement.setSqlStatementUser("SELECT * FROM [allTypes] WHERE [allTypes].[idAllTypes] = 1");
selectStatement.setSqlStatementModified(true);
selectStatement.setTitle("Select");
System.out.println("SQL Statement " + selectStatement.getTitle() + ": " + selectStatement.getSqlStatementFormatted());
TLptsFactoryStatement.createNewStatement(connection, selectStatement);
} else if (connection.getId().equals(connectionMySqlId))
{
TLptsStatement selectStatement = new TLptsStatement(connection, XLptsDBTypeOfStatementType.SELECT);
selectStatement.setXResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
selectStatement.setSqlStatementUser("SELECT * FROM `alltypes` WHERE `alltypes`.`idAllTypes` = 2");
selectStatement.setSqlStatementModified(true);
selectStatement.setTitle("Select");
System.out.println("SQL Statement " + selectStatement.getTitle() + ": " + selectStatement.getSqlStatementFormatted());
TLptsFactoryStatement.createNewStatement(connection, selectStatement);
}
} catch (SQLException e)
{
TLptsLogger.logError("Cannot get Title from Connection", e);
}
} else if (rowSetEvent.getEventType() == TLptsRowSetEvent.EVENT_TYPE.NEW_SELECT_RESULTSET)
{
try
{
ResultSet rs = rowSetEvent.getRowSet();
rs.beforeFirst();
if (((TLptsConnection) rowSetEvent.getStatement().getConnection()).getId().equals(connectionPostgresId))
{
while (rs.next())
{
assertEquals("--> ID should be 1", 1, rs.getInt(1));
assertEquals("--> charColumn should be D", "D", rs.getString(2));
assertEquals("--> bigIntColumn should be 1234567", new Long(1234567), new Long(rs.getLong(5)));
assertEquals("--> booleanColumn should be true", true, rs.getBoolean(8));
byte[] b = rs.getBytes(9);
for (int i = 0; i < "bytes column".getBytes().length; i++)
assertEquals("--> varBinaryColumn is not the same", "bytes column".getBytes()[i], b[i]);
assertEquals("--> characterColumn should be D", "D", rs.getString(10));
assertEquals("--> charactervaryingColumn should be var char column", "var char column", rs.getString(11));
assertEquals("--> dateColumn should be 2010-06-10", Date.valueOf("2010-06-10"), rs.getDate(15));
assertEquals("--> doubleColumn should be 125.357", 125.357, rs.getDouble(16));
assertEquals("--> integerColumn should be 15963", 15963, rs.getInt(19));
assertEquals("--> numericColumn should be 14859", new BigDecimal("14859.00"), rs.getBigDecimal(23));
assertEquals("--> oidColumn should be 1234567", new Long(1234567), new Long(rs.getLong(24)));
assertEquals("--> realColumn should be 145.85", (float) 145.85, rs.getFloat(27));
assertEquals("--> smallintColumn should be 78", 78, rs.getShort(38));
assertEquals("--> textColumn should be text column", "text column", rs.getString(40));
assertEquals("--> timewithouttimezoneColumn should be text column", Time.valueOf("09:15:23"), rs.getTime(42));
assertEquals("--> timewithouttimezoneColumn should be text column", Time.valueOf("18:36:05"), rs.getTime(43));
System.out.println("PostgreSQL Database Types Test complete");
}
Statement statement = rowSetEvent.getStatement().getConnection().createStatement();
if (statement.executeUpdate("DELETE FROM \"allTypes\" WHERE \"allTypes\".\"idAllTypes\" = 1") != 1)
TLptsLogger.logError("Cannot Delete Row From PostgreSQL", null);
testCompleted++;
} else if (((TLptsConnection) rowSetEvent.getStatement().getConnection()).getId().equals(connectionMSSqlId))
{
while (rs.next())
{
assertEquals("--> ID should be 1", 1, rs.getInt(1));
assertEquals("--> bigIntColumn should be 1234567", new Long(1234567), new Long(rs.getLong(2)));
byte[] b = rs.getBytes(3);
for (int i = 0; i < "binary column".getBytes().length; i++)
assertEquals("--> binaryColumn is not the same", "binary column".getBytes()[i], b[i]);
assertEquals("--> bitColumn should be true", true, rs.getBoolean(4));
assertEquals("--> charColumn should be D", "D", rs.getString(5));
assertEquals("--> datetimeColumn should be 2010-08-23 13:19:27", java.sql.Timestamp.valueOf("2010-08-23 13:19:27"), rs.getTimestamp(6));
assertEquals("--> decimalColumn should be 356.85", new BigDecimal("356.85"), rs.getBigDecimal(7));
assertEquals("--> floatColumn should be 142.35", (float) 142.35, rs.getFloat(8));
b = rs.getBytes(9);
for (int i = 0; i < "image column test".getBytes("UTF-8").length; i++)
assertEquals("--> imageColumn is not the same", "image column test".getBytes("UTF-8")[i], b[i]);
assertEquals("--> integerColumn should be 15963", 15963, rs.getInt(10));
assertEquals("--> moneyColumn should be 356.8500", new BigDecimal("356.8500"), rs.getBigDecimal(11));
assertEquals("--> ncharColumn should be D", "D", rs.getString(12));
assertEquals("--> ntextColumn should be n text column", "n text column", rs.getString(13));
assertEquals("--> numericColumn should be 14859", new BigDecimal("14859.00"), rs.getBigDecimal(14));
assertEquals("--> nvarcharColumn should be n var char column", "n var char column", rs.getString(15));
assertEquals("--> realColumn should be 145.85", (float) 145.85, rs.getFloat(16));
assertEquals("--> smalldatetimeColumn should be 2010-08-23 13:19:00.0", java.sql.Timestamp.valueOf("2010-08-23 13:19:00.0"), rs.getTimestamp(17));
assertEquals("--> smallintColumn should be 78", 78, rs.getShort(18));
assertEquals("--> smallmoneyColumn should be 23.1000", new BigDecimal("23.1000"), rs.getBigDecimal(19));
assertEquals("--> textColumn should be text column", "text column", rs.getString(20));
assertEquals("--> tinyintColumn should be 4", 4, rs.getByte(22));
assertEquals("--> uniqueidentifierColumn should be D", "756C6F43-6E6D-4920-6465-6E7469666965", rs.getString(23));
b = rs.getBytes(24);
for (int i = 0; i < "var binary column".getBytes("UTF-8").length; i++)
assertEquals("--> varBinaryColumn is not the same", "var binary column".getBytes("UTF-8")[i], b[i]);
assertEquals("--> varcharColumn should be var char column", "var char column", rs.getString(25));
assertEquals("--> xmlColumn should be ", "<mainScreenDimensions><maximized>false</maximized></mainScreenDimensions>", rs.getString(26));
System.out.println("MS SQL Database Types Test complete");
}
Statement statement = rowSetEvent.getStatement().getConnection().createStatement();
if (statement.executeUpdate("DELETE FROM [allTypes] WHERE [allTypes].[idAllTypes] = 1") != 1)
TLptsLogger.logError("Cannot Delete Row From MS SQL", null);
testCompleted++;
} else if (((TLptsConnection) rowSetEvent.getStatement().getConnection()).getId().equals(connectionMySqlId))
{
while (rs.next())
{
assertEquals("--> ID should be 2", 2, rs.getInt(1));
assertEquals("--> integerColumn should be 15963", 15963, rs.getInt(2));
assertEquals("--> varcharColumn should be var char column", "var char column", rs.getString(3));
assertEquals("--> decimalColumn should be 356.85", new BigDecimal("356.85"), rs.getBigDecimal(4));
assertEquals("--> datetimeColumn should be 2010-06-24 12:35:12", java.sql.Timestamp.valueOf("2010-06-24 12:35:12"), rs.getTimestamp(5));
byte[] b = rs.getBytes(6);
for (int i = 0; i < "blob Test".getBytes("UTF-8").length; i++)
assertEquals("--> blobColumn is not the same", "blob Test".getBytes("UTF-8")[i], b[i]);
b = rs.getBytes(7);
for (int i = 0; i < "long blob Test".getBytes("UTF-8").length; i++)
assertEquals("--> longBlobColumn is not the same", "long blob Test".getBytes("UTF-8")[i], b[i]);
b = rs.getBytes(8);
for (int i = 0; i < "Medium blob Test".getBytes("UTF-8").length; i++)
assertEquals("--> mediumBlobColumn is not the same", "Medium blob Test".getBytes("UTF-8")[i], b[i]);
assertEquals("--> tinyBlobColumn is not the same", new Byte("1"), (Byte) rs.getByte(9));
assertEquals("--> dateColumn should be 2010-06-10", Date.valueOf("2010-06-10"), rs.getDate(10));
assertEquals("--> timeColumn should be 09:15:23", Time.valueOf("09:15:23"), rs.getTime(11));
assertEquals("--> timeStampColumn should be 2010-08-23 13:19:27", java.sql.Timestamp.valueOf("2010-08-23 13:19:27"), rs.getTimestamp(12));
assertEquals("--> yearColumn should be 2010", 2010, rs.getInt(13));
assertEquals("--> bigIntColumn should be 1234567", new Long(1234567), new Long(rs.getLong(22)));
assertEquals("--> doubleColumn should be 125.357", 125.357, rs.getDouble(23));
assertEquals("--> floatColumn should be 142.35", (float) 142.35, rs.getFloat(24));
assertEquals("--> mediumIntColumn should be 175", 175, rs.getInt(25));
assertEquals("--> smallintColumn should be 78", 78, rs.getShort(26));
assertEquals("--> tinyIntColumn should be 4", 4, rs.getByte(27));
assertEquals("--> binaryColumn is not the same", new Byte("1"), (Byte) rs.getByte(28));
assertEquals("--> charColumn should be D", "D", rs.getString(29));
b = rs.getBytes(30);
for (int i = 0; i < "var binary column".getBytes("UTF-8").length; i++)
assertEquals("--> varBinaryColumn is not the same", "var binary column".getBytes("UTF-8")[i], b[i]);
assertEquals("--> longTextColumn should be long text column", "long text column", rs.getString(31));
assertEquals("--> mediumTextColumn should be medium text column", "medium text column", rs.getString(32));
assertEquals("--> textColumn should be text column", "text column", rs.getString(33));
assertEquals("--> tinyTextColumn should be text column", "tiny text column", rs.getString(34));
assertEquals("--> bitColumn should be true", true, rs.getBoolean(35));
assertEquals("--> enumColumn should be N", "N", rs.getString(36));
System.out.println("MySQL Database Types Test complete");
}
Statement statement = rowSetEvent.getStatement().getConnection().createStatement();
if (statement.executeUpdate("DELETE FROM `allTypes` WHERE `allTypes`.`idAllTypes` = 2") != 1)
TLptsLogger.logError("Cannot Delete Row From MySQL", null);
testCompleted++;
}
} catch (SQLException e)
{
TLptsLogger.logError("SQL Exception", e);
} catch (Exception e)
{
TLptsLogger.logError("Exception", e);
}
}
if (testCompleted == 3)
{
System.out.println("#####################################################");
System.out.println("# All Tests for Database Types Passed Successfully! #");
System.out.println("#####################################################");
System.exit(0);
}
return false;
}
}
}