TestDataBaseTypes.java

// 
// 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; 
    } 
  } 
}