| /* |
| |
| Derby - Class org.apache.derbyTesting.functionTests.store.OnlineBackupTest1 |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| package org.apache.derbyTesting.functionTests.tests.store; |
| import java.sql.Connection; |
| import java.sql.Statement; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import org.apache.derby.tools.ij; |
| import org.apache.derbyTesting.functionTests.util.TestUtil; |
| |
| /* |
| * This class tests online backup when dml/ddl actions |
| * are running in parallel to the backup thread. |
| * |
| * @version 1.0 |
| */ |
| |
| public class OnlineBackupTest1 { |
| |
| private static final String TEST_DATABASE_NAME = "wombat" ; |
| private static final String TEST_TABLE_NAME = "emp"; |
| private static final String TEST_TABLE_NAME_1 = "emp_1"; |
| private static final String TEST_TABLE_NAME_2 = "emp_2"; |
| private static final String BACKUP_PATH = "extinout/onlinebackuptest1"; |
| |
| public static void main(String[] argv) throws Throwable { |
| |
| OnlineBackupTest1 test = new OnlineBackupTest1(); |
| ij.getPropertyArg(argv); |
| |
| try { |
| test.runTest(); |
| } |
| catch (SQLException sqle) { |
| dumpSQLException(sqle); |
| } |
| } |
| |
| |
| /* |
| * Test online backup with unlogged operations. And DML/DDL's |
| * running in paralel to the backup. After the backup is complete restore |
| * the database from the backup and performs consistency checks on the |
| * database to make sure backup was good one. |
| */ |
| private void runTest() throws Exception { |
| logMessage("Begin Online Backup Test1"); |
| Connection conn = ij.startJBMS(); |
| conn.setAutoCommit(false); |
| DatabaseActions dbActions = new DatabaseActions(conn); |
| //create the test tables. |
| dbActions.createTable(TEST_TABLE_NAME); |
| dbActions.createTable(TEST_TABLE_NAME_1); |
| dbActions.createTable(TEST_TABLE_NAME_2); |
| conn.commit(); |
| |
| // start first unlogged operation |
| dbActions.startUnloggedAction(TEST_TABLE_NAME_1); |
| logMessage("First Transaction with Unlogged Operation Started"); |
| |
| // start second unlogged opearation |
| Connection conn1 = ij.startJBMS(); |
| conn1.setAutoCommit(false); |
| DatabaseActions dbActions1 = new DatabaseActions(conn1); |
| dbActions1.startUnloggedAction(TEST_TABLE_NAME_2); |
| logMessage("Second Transaction with Unlogged Operation Started"); |
| |
| // setup threads. |
| // start a thread to perform online backup |
| OnlineBackup backup = new OnlineBackup(TEST_DATABASE_NAME, BACKUP_PATH); |
| Thread backupThread = new Thread(backup, "BACKUP"); |
| |
| // run some dml actions in another thread |
| Connection dmlConn = TestUtil.getConnection(TEST_DATABASE_NAME, null); |
| DatabaseActions dmlActions = |
| new DatabaseActions(DatabaseActions.DMLACTIONS, dmlConn); |
| Thread dmlThread = new Thread(dmlActions, "DML_THREAD"); |
| |
| // run some DDL create/drop tables in another thread |
| Connection ddlConn = TestUtil.getConnection(TEST_DATABASE_NAME, null); |
| |
| DatabaseActions ddlActions = |
| new DatabaseActions(DatabaseActions.CREATEDROPS, ddlConn); |
| Thread ddlThread = new Thread(ddlActions, "DDL_THREAD"); |
| |
| try { |
| // start a thread to perform online backup |
| backupThread.start(); |
| // wait for the backup to start |
| backup.waitForBackupToBegin(); |
| logMessage("BACKUP STARTED"); |
| |
| // run some dml actions in another thread |
| dmlThread.start(); |
| |
| // run some DDL create/drop tables in another thread |
| ddlThread.start(); |
| |
| // sleep for few seconds just to make sure backup thread is actually |
| // gone to a wait state for unlogged actions to commit and there is |
| // some ddl and dml activity in progress. |
| java.lang.Thread.sleep(50000); |
| |
| // backup should not even start doing real work before the |
| // unlogged transaction is commited |
| if(!backup.isRunning()) |
| logMessage("Backup is not waiting for unlogged actions to commit"); |
| |
| // end the unlogged work transaction. |
| dbActions.endUnloggedAction(TEST_TABLE_NAME_1); |
| // end the unlogged work transaction. |
| dbActions1.endUnloggedAction(TEST_TABLE_NAME_2); |
| |
| backup.waitForBackupToEnd(); |
| |
| }finally { |
| //stop all threads activities. |
| backupThread.join(); |
| dmlActions.stopActivity(); |
| ddlActions.stopActivity(); |
| dmlThread.join(); |
| ddlThread.join(); |
| } |
| // close the connections. |
| conn.close(); |
| conn1.close(); |
| dmlConn.close(); |
| ddlConn.close() ; |
| |
| |
| //shutdown the test db |
| shutdown(TEST_DATABASE_NAME); |
| |
| // restore the database from the backup and run some checks |
| backup.restoreFromBackup(); |
| logMessage("Restored From the Backup"); |
| runConsistencyChecker(TEST_DATABASE_NAME); |
| logMessage("Consistency Check is Done"); |
| //shutdown the test db |
| shutdown(TEST_DATABASE_NAME); |
| logMessage("End Online Backup Test1"); |
| } |
| |
| |
| /** |
| * Run some consistency checks. |
| * @param dbName consistency checks are performed on this database. |
| */ |
| void runConsistencyChecker(String dbName) throws SQLException { |
| Connection conn = TestUtil.getConnection(dbName, null); |
| Statement stmt = conn.createStatement(); |
| stmt.execute("values SYSCS_UTIL.SYSCS_CHECK_TABLE('APP', 'EMP')"); |
| //check the data in the EMP table. |
| DatabaseActions dbActions = new DatabaseActions(conn); |
| dbActions.select(TEST_TABLE_NAME); |
| dbActions.select(TEST_TABLE_NAME_1); |
| dbActions.select(TEST_TABLE_NAME_2); |
| conn.close(); |
| |
| } |
| |
| |
| |
| /** |
| * Shutdown the datbase |
| * @param dbName Name of the database to shutdown. |
| */ |
| void shutdown(String dbName) { |
| |
| try{ |
| //shutdown |
| TestUtil.getConnection(dbName, "shutdown=true"); |
| }catch(SQLException se){ |
| if (se.getSQLState() != null && se.getSQLState().equals("08006")) |
| System.out.println("database shutdown properly"); |
| else |
| dumpSQLException(se); |
| } |
| } |
| |
| /** |
| * Write message to the standard output. |
| */ |
| void logMessage(String str) { |
| System.out.println(str); |
| } |
| |
| |
| /** |
| * dump the SQLException to the standard output. |
| */ |
| static private void dumpSQLException(SQLException sqle) { |
| |
| org.apache.derby.tools.JDBCDisplayUtil. ShowSQLException(System.out, sqle); |
| sqle.printStackTrace(System.out); |
| } |
| |
| /* |
| * This class implements some DML and DDL operations to |
| * run againest the datbase, when the backup is in progress. |
| * Some of these operations can be run in seperate threads in a |
| * loop until they are stopped by some other thread. |
| */ |
| |
| class DatabaseActions implements Runnable { |
| |
| public static final int DMLACTIONS = 1; |
| public static final int CREATEDROPS = 2; |
| |
| private static final int COMMIT = 1; |
| private static final int ROLLBACK = 2; |
| private static final int OPENTX = 3; |
| |
| private int action = 0; |
| private volatile boolean stopActivity = false ; |
| private Connection conn; |
| |
| DatabaseActions(Connection conn) { |
| this.conn = conn; |
| }; |
| |
| DatabaseActions(int action, Connection conn) { |
| this.action = action; |
| this.conn = conn; |
| } |
| |
| /** |
| * stops any actions that are looping on a differt threads. |
| */ |
| public void stopActivity() { |
| stopActivity = true; |
| } |
| |
| /** |
| * implementation of run() method in the Runnable interface, which |
| * is invoked when a thread is started using this class object. |
| * <p> |
| * Performs DML ot DDL actions. |
| */ |
| public void run() { |
| try { |
| conn.setAutoCommit(false); |
| switch(action) { |
| case DMLACTIONS : |
| performDmlActions(); |
| break; |
| case CREATEDROPS: |
| performCreateDropTables() ; |
| break; |
| } |
| } catch (SQLException sqle) { |
| org.apache.derby.tools.JDBCDisplayUtil.ShowSQLException(System.out, sqle); |
| sqle.printStackTrace(System.out); |
| } |
| } |
| |
| |
| /* |
| * Run insert, update, select on the test table in a loop. |
| */ |
| void performDmlActions() throws SQLException { |
| |
| while(!stopActivity) { |
| insert(TEST_TABLE_NAME, 100, COMMIT, 10); |
| insert(TEST_TABLE_NAME, 100, ROLLBACK, 10); |
| update(TEST_TABLE_NAME, 50, ROLLBACK, 10); |
| select(TEST_TABLE_NAME); |
| } |
| } |
| |
| |
| |
| /** |
| * start an Unlogged operation, but don't commit the transaction. |
| * @param tableName name of the table to start the unlogged operation. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void startUnloggedAction(String tableName) throws SQLException { |
| // load some data |
| insert(tableName, 100, COMMIT, 10); |
| // execute a unlogged database operation |
| Statement s = conn.createStatement(); |
| |
| // index creation does not log the index entries |
| s.executeUpdate("create index " + tableName + "_name_idx on " + |
| tableName + "(name) "); |
| s.close(); |
| } |
| |
| |
| /** |
| * end an Unlogged operation, commit the transaction. |
| * @param tableName name of the table to end unlogged operation. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void endUnloggedAction(String tableName) throws SQLException { |
| // insert some rows, insert should be successful even if |
| // backup is blocking for uncommitted unlogged operations. |
| insert(tableName, 1000, OPENTX, 10); |
| conn.commit(); |
| } |
| |
| |
| /** |
| * Create and Drop some tables. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void performCreateDropTables() throws SQLException { |
| |
| Statement s = conn.createStatement(); |
| while(!stopActivity) { |
| for( int i = 0 ; i < 10; i++) { |
| String tableName = "emp" + i ; |
| createTable(tableName); |
| //load some data |
| insert(tableName, 100, OPENTX, 10); |
| if((i % 2) == 0) { |
| conn.commit(); |
| } |
| else |
| conn.rollback(); |
| } |
| |
| //drop all the table that are created above. |
| for( int i = 0 ; i < 10 ; i=i+2) { |
| String tableName = "emp" + i ; |
| s.executeUpdate("drop TABLE " + "emp" +i ); |
| conn.commit(); |
| } |
| } |
| s.close(); |
| } |
| |
| |
| |
| /** |
| * Insert some rows into the specified table. |
| * @param tableName name of the table that rows are inserted. |
| * @param rowCount Number of rows to Insert. |
| * @param txStatus Transacton status commit/rollback/open. |
| * @param commitCount After how many inserts commit/rollbacku should happen. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void insert(String tableName, int rowCount, |
| int txStatus, int commitCount) throws SQLException { |
| |
| PreparedStatement ps = conn.prepareStatement("INSERT INTO " + |
| tableName + |
| " VALUES(?,?,?)"); |
| for (int i = 0; i < rowCount; i++) { |
| |
| ps.setInt(1, i); // ID |
| ps.setString(2 , "skywalker" + i); |
| ps.setFloat(3, (float)(i * 2000)); |
| ps.executeUpdate(); |
| if ((i % commitCount) == 0) |
| { |
| endTransaction(txStatus); |
| } |
| } |
| |
| endTransaction(txStatus); |
| ps.close(); |
| } |
| |
| |
| |
| /** |
| * commit/rollback the transaction. |
| * @param txStatus Transacton status commit/rollback/open. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void endTransaction(int txStatus) throws SQLException |
| { |
| switch(txStatus){ |
| case COMMIT: |
| conn.commit(); |
| break; |
| case ROLLBACK: |
| conn.rollback(); |
| break; |
| case OPENTX: |
| //do nothing |
| break; |
| } |
| } |
| |
| /** |
| * update some rows in the table. |
| * @param tableName name of the table that rows are updates. |
| * @param rowCount Number of rows to update. |
| * @param txStatus Transacton status commit/rollback/open. |
| * @param commitCount After how many updates commit/rollback should |
| * happen. |
| * @exception SQLException if any database exception occurs. |
| */ |
| |
| void update(String tableName, int rowCount, |
| int txStatus, int commitCount) throws SQLException |
| { |
| |
| PreparedStatement ps = conn.prepareStatement("update " + tableName + |
| " SET name = ? where id=?"); |
| |
| for (int i = 0; i < rowCount; i++) { |
| ps.setString(1 , "moonwalker" + i); |
| ps.setInt(2, i); // ID |
| ps.executeUpdate(); |
| if ((i % commitCount) == 0) |
| { |
| endTransaction(txStatus); |
| } |
| } |
| endTransaction(txStatus); |
| ps.close(); |
| } |
| |
| |
| /* |
| * read the rows in the table. |
| * @param tableName select operation is perfomed on this table. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void select(String tableName) throws SQLException { |
| |
| Statement s = conn.createStatement(); |
| ResultSet rs = s.executeQuery("SELECT ID, name from " + |
| tableName + " order by id" ); |
| int count = 0; |
| int id = 0; |
| while(rs.next()) |
| { |
| int tid = rs.getInt(1); |
| String name = rs.getString(2); |
| if(name.equals("skywalker" + id) && tid!= id) |
| { |
| logMessage("DATA IN THE TABLE IS NOT AS EXPECTED"); |
| logMessage("Got :ID=" + tid + " Name=:" + name); |
| logMessage("Expected: ID=" + id + "Name=" + "skywalker" + id ); |
| } |
| |
| id++; |
| count++; |
| } |
| |
| rs.close(); |
| s.close(); |
| conn.commit(); |
| } |
| |
| /* |
| * create the tables that are used by this test. |
| * @param tableName Name of the table to create. |
| * @exception SQLException if any database exception occurs. |
| */ |
| void createTable(String tableName) throws SQLException { |
| |
| Statement s = conn.createStatement(); |
| s.executeUpdate("CREATE TABLE " + tableName + |
| "(id INT," + |
| "name CHAR(200),"+ |
| "salary float)"); |
| s.executeUpdate("create index " + tableName + "_id_idx on " + |
| tableName + "(id)"); |
| s.close(); |
| } |
| |
| } |
| } |
