sneaql 0.0.15-java → 0.0.16-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91f871ef54dcf89b3664fc1752bfc13cfb6ce787
-  data.tar.gz: fd38d7bf1c632db20ae61ae88ec57872a370edf9
+  metadata.gz: 9a88464715cbbb4c6efbadb8191725f3aeb3e7fa
+  data.tar.gz: a06d84d005827d7e072b1f582fc98debed7b0cf5
 SHA512:
-  metadata.gz: a5d6fa48016600fde9277250a4b7bdde4f3d1e3cee7c6305af06b9b084ed00c8d2ea21739315cb68472a4b348b1b99858468d71a1bc9a08868e454c34fdb5df7
-  data.tar.gz: 9bd0b13170e52f50b961b65228a139f1c879ccd4780d3610665aecd6698741b15232fbd9023453f25c6ea121467a4126f51b878e3440a15003a5045d22cc2c5c
+  metadata.gz: f42467e68a8c13215d3c36e2940ae51601a767ec253814a04180697fbdb94ab96086b65306e92442af35137c7a79cffe6b7da0b091f2dc7436ead25dd9d03f3f
+  data.tar.gz: 0b54cda35436015a39e72f328539b18f7c9373de8f0c888db6717a22fb365a6b45fd3e46fdba8d89e2cd1709ea2eacec9f74416e3c599eb46ab7abca7b219f9f

data/bin/sneaql

@@ -142,12 +142,6 @@ the above will execute the transform in the current directory.  note that sneaql
         
         logger.debug("available sneaql resources: #{Sneaql::Core.class_map}")
         
-        database = Sneaql::Core.database_type(jdbc_url)
-        unless database
-          raise 'database specified in jdbc url is not supported, or malformed jdbc url'
-          exit 1 
-        end
-        
         begin  
           require_relative jdbc_driver_jar
           java_import jdbc_driver_class
@@ -161,7 +155,6 @@ the above will execute the transform in the current directory.  note that sneaql
             transform_name: base_path,
             repo_base_dir: base_path,
             repo_type: 'local',
-            database: database,
             jdbc_url: jdbc_url,
             db_user: db_user,
             db_pass: db_pass,
@@ -263,12 +256,6 @@ the above will execute the transform in the current directory.  note that sneaql
         
         logger.debug("available sneaql resources: #{Sneaql::Core.class_map}")
         
-        database = Sneaql::Core.database_type(jdbc_url)
-        unless database
-          raise 'database specified in jdbc url is not supported, or malformed jdbc url'
-          exit 1 
-        end
-        
         begin  
           require_relative jdbc_driver_jar
           java_import jdbc_driver_class
@@ -282,7 +269,6 @@ the above will execute the transform in the current directory.  note that sneaql
             transform_name: base_path,
             repo_base_dir: base_path,
             repo_type: 'local',
-            database: database,
             jdbc_url: jdbc_url,
             db_user: db_user,
             db_pass: db_pass,

data/lib/sneaql.rb

@@ -1,17 +1,13 @@
 require 'jdbc_helpers'
 require 'logger'
 
-#require_relative 'sneaql_lib/logging.rb'
 require_relative 'sneaql_lib/exceptions.rb'
 require_relative 'sneaql_lib/core.rb'
-require_relative 'sneaql_lib/lock_manager.rb'
 require_relative 'sneaql_lib/repo_manager.rb'
 require_relative 'sneaql_lib/step_manager.rb'
 require_relative 'sneaql_lib/parser.rb'
 require_relative 'sneaql_lib/expressions.rb'
 require_relative 'sneaql_lib/recordset.rb'
-require_relative 'sneaql_lib/database_manager.rb'
-require_relative 'sneaql_lib/standard_db_objects.rb'
 require_relative 'sneaql_lib/docker.rb'
 require_relative 'sneaql_lib/tokenizer.rb'
 
@@ -50,7 +46,6 @@ module Sneaql
     #     transform_name: 'test-transform',
     #     repo_base_dir: "test/fixtures/test-transform",
     #     repo_type: 'local',
-    #     database: 'sqlite',
     #     jdbc_url: 'jdbc:sqlite:memory',
     #     db_user: 'dbuser',
     #     db_pass: 'password',
@@ -62,34 +57,30 @@ module Sneaql
     # @param [Hash] params various parameters are passed to define the transform
     # @param [Logger] logger customer logger if provided (otherwise default logger is created)
     def initialize(params, logger = nil)
+      # initialzing and basic parameter stuff
       @logger = logger ? logger : Logger.new(STDOUT)
-
       @start_time = Time.new.utc
-
       current_status(:initializing)
       @params = params
-
       @exit_code = 0
-
       @transform_name = @params[:transform_name]
-      @transform_lock_id = @params[:transform_lock_id]
       @jdbc_url = @params[:jdbc_url]
       @db_user = @params[:db_user]
       @db_pass = @params[:db_pass]
-      @database = @params[:database]
-
+      
+      # build fancy objects for processing the transform
       @expression_handler = create_expression_handler
       @recordset_manager = create_recordset_manager
       @exception_manager = create_exception_manager
-
+      @repo_manager = create_repo_manager
+      @steps = create_metadata_manager
+      @parsed_steps = create_parsed_steps(@steps)
+      
       run if @params[:run] == true
     end
 
     # validate the transform.
     def validate
-      @repo_manager = create_repo_manager
-      @steps = create_metadata_manager
-      @parsed_steps = create_parsed_steps(@steps)
       current_status(:validating)
       validate_parsed_steps(@parsed_steps)
     rescue Sneaql::Exceptions::TransformIsLocked => e
@@ -119,17 +110,12 @@ module Sneaql
 
     # Runs the actual transform.
     def run
-      @repo_manager = create_repo_manager
-      @lock_manager = create_lock_manager if @params[:locked_transform] == true
-      @steps = create_metadata_manager
-      @parsed_steps = create_parsed_steps(@steps)
+      current_status(:validating)
       validate_parsed_steps(@parsed_steps)
+      current_status(:connecting_to_database)
       @jdbc_connection = create_jdbc_connection
       current_status(:running)
       iterate_steps_and_statements
-    rescue Sneaql::Exceptions::TransformIsLocked => e
-      @transform_error = e
-      @logger.info(e.message)
     rescue Sneaql::Exceptions::SQLTestExitCondition => e
       @transform_error = nil
       @logger.info(e.message)
@@ -140,7 +126,6 @@ module Sneaql
       @logger.error(e.message)
       e.backtrace { |b| @logger.error b }
     ensure
-      @lock_manager.remove_lock if @params[:locked_transform] == true
       @jdbc_connection.close if @jdbc_connection
       @end_time = Time.new.utc
 
@@ -172,16 +157,6 @@ module Sneaql
       Sneaql::Core.find_class(:repo_manager, @params[:repo_type]).new(@params, @logger)
     end
 
-    # Creates a TransformLockManager object
-    # The actual object returns depends upon params[:locked_transform] provided at initialize.
-    # @return [Sneaql::Core::RepoDownloadManager]
-    def create_lock_manager
-      # create a lock manager for this transform (uses a separate connection)
-      lock_manager = Sneaql::TransformLockManager.new(@params, @logger)
-      raise Sneaql::Exceptions::TransformIsLocked unless lock_manager.acquire_lock == true
-      lock_manager
-    end
-
     # Creates a StepMetadataManager object
     # The actual object returns depends upon params[:step_metadata_manager_type] provided at initialize.
     # @return [Sneaql::Core::StepMetadataManager]
@@ -243,10 +218,9 @@ module Sneaql
     # behavior for a connection that closes before a commit.
     def iterate_steps_and_statements
       @parsed_steps.each_with_index do |this_step|
-        # special handling is required for the exit_step_if command
-        # because there is a nested loop the exit_step var is needed
-        exit_step = false
-        break if exit_step == true
+        # raise any lingering errors not handled in previous step
+        raise @exception_manager.pending_error if @exception_manager.pending_error != nil
+        
         # set this so that other processes can poll the state
         @current_step = this_step[:step_number]
         # within a step... iterate through each statement
@@ -254,6 +228,7 @@ module Sneaql
           # set this so that other processes can poll the state
           @current_statement = stmt_index + 1
           
+          # log the pending error
           @exception_manager.output_pending_error
           
           # log some useful info
@@ -280,7 +255,13 @@ module Sneaql
               @expression_handler.evaluate_all_expressions(this_stmt),
               @logger
             )
-
+            
+            if @exception_manager.pending_error != nil
+              unless c.class == Sneaql::Core::Commands::SneaqlOnError
+                raise @exception_manager.pending_error
+              end
+            end
+            
             c.action(*this_cmd[:arguments])
 
             # check if there was an error from the action
@@ -294,7 +275,6 @@ module Sneaql
             end
 
           rescue Sneaql::Exceptions::SQLTestStepExitCondition => e
-            exit_step = true
             @logger.info e.message
             break
           end

data/lib/sneaql_lib/step_manager.rb

@@ -24,51 +24,5 @@ module Sneaql
         end
       end
     end
-
-    # source step metadata from a standardized table in the target database
-    class TransformStepTableManager < Sneaql::Core::StepMetadataManager
-      Sneaql::Core::RegisterMappedClass.new(
-        :step_metadata_manager,
-        'transform_steps_table',
-        Sneaql::StepManagers::TransformStepTableManager
-      )
-
-      # Manages steps based in a standardized table.
-      def manage_steps
-        jdbc_connection = JDBCHelpers::ConnectionFactory.new(
-          @params[:jdbc_url],
-          @params[:db_user],
-          @params[:db_pass]
-        ).connection
-
-        @steps = JDBCHelpers::QueryResultsToArray.new(
-          jdbc_connection,
-          steps_sql
-        ).results
-
-        @steps.map! do |s|
-          {
-            step_number: s['transform_step'],
-            step_file: s['sql_file_path_in_repo']
-          }
-        end
-
-        jdbc_connection.close
-      end
-
-      def steps_sql
-        %(select
-          transform_step
-          ,sql_file_path_in_repo
-        from
-          #{@params[:transform_steps_table]}
-        where
-          transform_name='#{@params[:transform_name]}'
-          and
-          is_active=#{@params[:database_manager].has_boolean ? 'true' : 1}
-        order by
-          transform_step asc;)
-      end
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sneaql
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: java
 authors:
 - jeremy winters
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-05-18 00:00:00.000000000 Z
+date: 2017-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -119,19 +119,12 @@ files:
 - lib/sneaql.rb
 - lib/sneaql_lib/base.rb
 - lib/sneaql_lib/core.rb
-- lib/sneaql_lib/database_manager.rb
-- lib/sneaql_lib/database_prefs/redshift.rb
-- lib/sneaql_lib/database_prefs/sqlite.rb
-- lib/sneaql_lib/database_prefs/vertica.rb
 - lib/sneaql_lib/docker.rb
 - lib/sneaql_lib/exceptions.rb
 - lib/sneaql_lib/expressions.rb
-- lib/sneaql_lib/lock_manager.rb
 - lib/sneaql_lib/parser.rb
 - lib/sneaql_lib/recordset.rb
 - lib/sneaql_lib/repo_manager.rb
-- lib/sneaql_lib/standard.rb
-- lib/sneaql_lib/standard_db_objects.rb
 - lib/sneaql_lib/step_manager.rb
 - lib/sneaql_lib/tokenizer.rb
 homepage: https://www.full360.com

data/lib/sneaql_lib/database_manager.rb

@@ -1,79 +0,0 @@
-module Sneaql
-  module Core
-    # returns the database type based upon the jdbc url
-    # @param [String]
-    def self.database_type(jdbc_url)
-      Sneaql::Core.class_map[:database].each do |d|
-        return d[:text] if jdbc_url.match(d[:text])
-      end
-    end
-
-    # Manages preferences for a specific RDBMS implementation.
-    class DatabaseManager
-      attr_reader(
-        :has_boolean,
-        :autocommit_off_statement,
-        :supports_transactions,
-        :supports_table_locking,
-        :begin_statement,
-        :commit_statement,
-        :rollback_statement
-      )
-
-      # @param [Hash] options values to override defaults
-      def initialize(options = {})
-        @has_boolean = options.fetch(:has_boolean, default_has_boolean)
-        @autocommit_off_statement = options.fetch(:autocommit_off_statement, default_autocommit_off_statement)
-        @supports_transactions = options.fetch(:supports_transactions, default_supports_transactions)
-        @supports_table_locking = options.fetch(:supports_table_locking, default_supports_table_locking)
-        @begin_statement = options.fetch(:begin_statement, default_begin_statement)
-        @commit_statement = options.fetch(:commit_statement, default_commit_statement)
-        @rollback_statement = options.fetch(:rollback_statement, default_rollback_statement)
-      end
-
-      # @return [Boolean]
-      def default_has_boolean
-        false
-      end
-
-      # @return [String]
-      def default_autocommit_off_statement
-        nil
-      end
-
-      # @return [Boolean]
-      def default_supports_transactions
-        true
-      end
-
-      # @return [Boolean]
-      def default_supports_table_locking
-        false
-      end
-
-      # @return [String] begin statement
-      def default_begin_statement
-        "begin;"
-      end
-
-      # @return [String] commit statement
-      def default_commit_statement
-        "commit;"
-      end
-
-      # @return [String] rollback statement
-      def default_rollback_statement
-        "rollback;"
-      end
-
-      # @param [String] table_name
-      # @return [String] rollback statement
-      def lock_table_statement(table_name)
-        "lock table #{table_name};"
-      end
-    end
-  end
-end
-
-# Require all tested RDBMS
-Dir.glob("#{File.dirname(__FILE__)}/database_prefs/*.rb").each { |f| require File.expand_path(f) }

data/lib/sneaql_lib/database_prefs/redshift.rb

@@ -1,21 +0,0 @@
-module Sneaql
-  module Core
-    # Settings for interaction with Amazon Redshift
-    class RedshiftDatabaseManager < Sneaql::Core::DatabaseManager
-      Sneaql::Core::RegisterMappedClass.new(
-        :database,
-        'redshift',
-        Sneaql::Core::RedshiftDatabaseManager
-      )
-
-      def initialize
-        super(
-          {
-            has_boolean: true,
-            autocommit_off_statement: 'set autocommit=off;'
-          }
-        )
-      end
-    end
-  end
-end

data/lib/sneaql_lib/database_prefs/sqlite.rb

@@ -1,12 +0,0 @@
-module Sneaql
-  module Core
-    # Settings for interacting with SQLite
-    class SqliteDatabaseManager < Sneaql::Core::DatabaseManager
-      Sneaql::Core::RegisterMappedClass.new(
-        :database,
-        'sqlite',
-        Sneaql::Core::SqliteDatabaseManager
-      )
-    end
-  end
-end

data/lib/sneaql_lib/database_prefs/vertica.rb

@@ -1,21 +0,0 @@
-module Sneaql
-  module Core
-    # Settings for interacting with HP Vertica
-    class VerticaDatabaseManager < Sneaql::Core::DatabaseManager
-      Sneaql::Core::RegisterMappedClass.new(
-        :database,
-        'vertica',
-        Sneaql::Core::VerticaDatabaseManager
-      )
-
-      def initialize
-        super(
-          {
-            has_boolean: true,
-            autocommit_off_statement: 'set session autocommit to off;'
-          }
-        )
-      end
-    end
-  end
-end

data/lib/sneaql_lib/lock_manager.rb

@@ -1,176 +0,0 @@
-require 'jdbc_helpers'
-
-module Sneaql
-  module Core
-    # manages transform locking operations using a standardized
-    # table for storing the locks.
-    class TransformLockManager
-      # set instance variables that will be used to manage the locks
-      def initialize(params, logger = nil)
-        @logger = logger ? logger : Logger.new(STDOUT)
-        @transform_name = params[:transform_name]
-        @transform_lock_id = params[:transform_lock_id]
-        @transform_lock_table = params[:transform_lock_table]
-        @jdbc_url = params[:jdbc_url]
-        @db_user = params[:db_user]
-        @db_pass = params[:db_pass]
-        @database_manager = Sneaql::Core.find_class(
-          :database,
-          params[:database]
-        ).new
-      rescue => e
-        @logger.error e.message
-        e.backtrace.each { |b| @logger.error b}
-      end
-
-      # Creates a connection in the current JDBC context
-      def create_jdbc_connection
-        JDBCHelpers::ConnectionFactory.new(
-          @jdbc_url,
-          @db_user,
-          @db_pass,
-          @logger
-        ).connection
-      end
-
-      # Checks to see if the current transform is locked
-      # @return [Boolean]
-      def acquire_lock
-        # check to see if this transform is locked by
-        # another transform returns true if locked
-        jdbc_connection = create_jdbc_connection
-
-        # initialize lock value
-        lock_value = false
-
-        if @database_manager.supports_transactions == true
-          JDBCHelpers::Execute.new(
-            jdbc_connection,
-            @database_manager.begin_statement,
-            @logger
-          )
-        end
-
-        if @database_manager.supports_table_locking == true
-          JDBCHelpers::Execute.new(
-            jdbc_connection,
-            @database_manager.lock_table_statement(@transform_lock_table),
-            @logger
-          )
-        end
-
-        # query the number of rows which match the condition...
-        # should be 1 or 0... 1 indicating a lock
-        r = JDBCHelpers::SingleValueFromQuery.new(
-          jdbc_connection,
-          %(select
-            count(*)
-          from
-            #{@transform_lock_table}
-          where
-            transform_name='#{@transform_name}'
-            and
-            transform_lock_id!=#{@transform_lock_id};),
-            @logger
-        ).result
-
-        # table is unlocked
-        if r == 0
-          l = JDBCHelpers::Execute.new(
-            jdbc_connection,
-            %{insert into #{@transform_lock_table}
-              (
-                transform_lock_id,
-                transform_name,
-                transform_lock_time
-              )
-              values
-              (
-                #{@transform_lock_id},
-                '#{@transform_name}',
-                current_timestamp
-              );},
-              @logger
-          )
-
-          if @database_manager.supports_transactions == true
-            JDBCHelpers::Execute.new(
-              jdbc_connection,
-              @database_manager.commit_statement,
-              @logger
-            )
-          end
-
-          lock_value = true
-        else
-          if @database_manager.supports_transactions == true
-            JDBCHelpers::Execute.new(
-              jdbc_connection,
-              @database_manager.rollback_statement,
-              @logger
-            )
-          end
-          lock_value = false
-        end
-
-        if lock_value == true
-          @logger.info("#{@transform_name} transform lock acquired;")
-        else
-          @logger.info("#{@transform_name} is locked by another process")
-        end
-      ensure
-        # close this connection
-        jdbc_connection.close
-
-        lock_value
-      end
-
-      # Removes transform lock if it's present.
-      def remove_lock
-        # get a fresh jdbc connection...
-        # to avoid committing the main transform unnecessarily
-        jdbc_connection = create_jdbc_connection
-
-        if @database_manager.supports_transactions == true
-          JDBCHelpers::Execute.new(
-            jdbc_connection,
-            @database_manager.begin_statement,
-            @logger
-          )
-        end
-
-        if @database_manager.supports_table_locking == true
-          JDBCHelpers::Execute.new(
-            jdbc_connection,
-            @database_manager.lock_table_statement(@transform_lock_table),
-            @logger
-          )
-        end
-
-        # delete the lock record and commit
-        JDBCHelpers::Execute.new(
-          jdbc_connection,
-          %(delete from #{@transform_lock_table}
-          where transform_name='#{@transform_name}'
-          and transform_lock_id=#{@transform_lock_id};),
-          @logger
-        )
-
-        c = JDBCHelpers::Execute.new(
-          jdbc_connection,
-          @database_manager.commit_statement,
-          @logger
-        )
-      ensure
-        jdbc_connection.close
-
-        return true
-      end
-
-      # TBD
-      def lock_all_available_transforms
-        # undefined at this time
-      end
-    end
-  end
-end

data/lib/sneaql_lib/standard.rb

@@ -1,30 +0,0 @@
-module Sneaql
-  # Classes to manage DB objects for standard SneaQL deployment.
-  module Standard
-    # Manages execution of a standard transform
-    class StandardTransform
-      
-      attr_accessor {
-        :jdbc_url,
-        :db_user,
-        :db_pass
-      }
-      
-      def initialize()
-        # set parameters
-        
-        # determine database type
-        
-      end
-      
-      def execute_all_transforms()
-      
-      end
-      
-      def execute_single_transform(transform_name)
-        
-      end
-      
-    end
-  end
-end

data/lib/sneaql_lib/standard_db_objects.rb

@@ -1,232 +0,0 @@
-module Sneaql
-  # Classes to manage DB objects for standard SneaQL deployment.
-  module Standard
-    # Facilitate creation/recreation of database table objects
-    # for standard SneaQL deployment.
-    class DBObjectCreator
-      attr_accessor :jdbc_connection
-
-      # @param [Object] jdbc_connection
-      # @param [Sneaql::Core::DatabaseManager] database_manager
-      # @param [Logger] logger
-      def initialize(jdbc_connection, database_manager, logger = nil)
-        @logger = logger ? logger : Logger.new(STDOUT)
-        @jdbc_connection = jdbc_connection
-        @database_manager = database_manager
-      end
-
-      # Drops and recreates the primary transform table.
-      # @param [String] transform_table_name fully qualified name for this table
-      # @return [Boolean]
-      def recreate_transforms_table(transform_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          "drop table if exists #{ transform_table_name };",
-          @logger
-        )
-        create_transforms_table(transform_table_name)
-        return true
-      end
-
-      # Creates the primary transform table.
-      # @param [String] transform_table_name fully qualified name for this table
-      # @return [Boolean]
-      def create_transforms_table(transform_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          transforms_table_create_statement(transform_table_name),
-          @logger
-        )
-        return true
-      end
-
-      # Coerces a boolean to the appropriate value for the database type.
-      # May return a 0 or 1 in RDBMS where boolean is not supported.
-      # @param [Boolean] boolean_value
-      # @return [Boolean, Fixnum]
-      def coerce_boolean(boolean_value)
-        if @database_manager.has_boolean
-          boolean_value
-        else
-          boolean_value == true ? 1 : 0
-        end
-      end
-
-      # Create table statement for primary transform table.
-      # @param [String] transform_table_name fully qualified name for this table
-      # @return [String]
-      def transforms_table_create_statement(transform_table_name)
-        %{create table if not exists #{ transform_table_name }
-          (
-          	transform_name varchar(255) not null
-          	,sql_repository varchar(255)
-          	,sql_repository_branch varchar(255)
-          	,is_active #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,notify_on_success #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,notify_on_non_precondition_failure #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,notify_on_precondition_failure #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,updated_ts timestamp
-          );}
-      end
-
-      # Creates a record in the transforms table.
-      # @param [String] transform_table_name
-      # @param [Hash] params Hash of parameters with symbols matching column names
-      def create_transform(transform_table_name, params)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          create_transform_statement(transform_table_name, params),
-          @logger
-        )
-      end
-
-      # @param [String] transform_table_name
-      # @param [Hash] params Hash of parameters with symbols matching column names
-      def create_transform_statement(transform_table_name, params)
-        %{insert into #{transform_table_name}
-          (
-            transform_name
-            ,sql_repository
-            ,sql_repository_branch
-            ,is_active
-            ,notify_on_success
-            ,notify_on_non_precondition_failure
-            ,notify_on_precondition_failure
-            ,updated_ts
-          )
-          values
-          (
-            '#{params[:transform_name]}'
-            ,'#{params[:sql_repository]}'
-            ,'#{params[:sql_repository_branch]}'
-            ,#{coerce_boolean(params[:is_active])}
-            ,#{coerce_boolean(params[:notify_on_success])}
-            ,#{coerce_boolean(params[:notify_on_non_precondition_failure])}
-            ,#{coerce_boolean(params[:notify_on_precondition_failure])}
-            ,current_timestamp
-          );}
-      end
-
-      # Drops and recreates the transform steps table.
-      # @param [String] transform_steps_table_name fully qualified name for this table
-      # @return [Boolean]
-      def recreate_transform_steps_table(transform_steps_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          "drop table if exists #{ transform_steps_table_name };",
-          @logger
-        )
-        create_transform_steps_table(transform_steps_table_name)
-        return true
-      end
-
-      # Creates the transform steps table.
-      # @param [String] transform_steps_table_name fully qualified name for this table
-      # @return [Boolean]
-      def create_transform_steps_table(transform_steps_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          transform_steps_table_create_statement(transform_steps_table_name),
-          @logger
-        )
-        return true
-      end
-
-      # Create table statement for transform steps table.
-      # @param [String] transform_steps_table_name fully qualified name for this table
-      # @return [String]
-      def transform_steps_table_create_statement(transform_steps_table_name)
-        %{create table if not exists #{ transform_steps_table_name }
-          (
-          	transform_name varchar(255) not null
-          	,transform_step integer not null
-          	,sql_file_path_in_repo varchar(1024)
-          	,is_active #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,is_precondition #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,updated_ts timestamp
-          );}
-      end
-
-      # Drops and recreates the transform lock table.
-      # @param [String] transform_lock_table_name fully qualified name for this table
-      # @return [Boolean]
-      def recreate_transform_lock_table(transform_lock_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          "drop table if exists #{ transform_lock_table_name };",
-          @logger
-        )
-        create_transform_lock_table(transform_lock_table_name)
-        return true
-      end
-
-      # Creates the transform lock table.
-      # @param [String] transform_lock_table_name fully qualified name for this table
-      # @return [Boolean]
-      def create_transform_lock_table(transform_lock_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          transform_lock_table_create_statement(transform_lock_table_name),
-          @logger
-        )
-        return true
-      end
-
-      # Create table statement for transform lock table.
-      # @param [String] transform_lock_table_name fully qualified name for this table
-      # @return [String]
-      def transform_lock_table_create_statement(transform_lock_table_name)
-        %{create table if not exists #{ transform_lock_table_name }
-          (
-          	transform_lock_id bigint
-          	,transform_name varchar(255)
-          	,transform_lock_time timestamp
-          );}
-      end
-
-      # Drops and recreates the transform log table.
-      # @param [String] transform_log_table_name fully qualified name for this table
-      # @return [Boolean]
-      def recreate_transform_log_table(transform_log_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          "drop table if exists #{ transform_log_table_name };",
-          @logger
-        )
-        create_transform_log_table(transform_log_table_name)
-        return true
-      end
-
-      # Creates the transform log table.
-      # @param [String] transform_log_table_name fully qualified name for this table
-      # @return [Boolean]
-      def create_transform_log_table(transform_log_table_name)
-        JDBCHelpers::Execute.new(
-          @jdbc_connection,
-          transform_log_table_create_statement(transform_log_table_name),
-          @logger
-        )
-        return true
-      end
-
-      # Create table statement for transform log table.
-      # @param [String] transform_log_table_name fully qualified name for this table
-      # @return [String]
-      def transform_log_table_create_statement(transform_log_table_name)
-        %{create table if not exists #{ transform_log_table_name }
-          (
-          	transform_run_id bigint
-          	,transform_lock_id bigint
-          	,transform_name varchar(255)
-          	,transform_step integer
-          	,transform_statement integer
-          	,all_steps_complete #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,failed_in_precondition #{ if @database_manager.has_boolean then 'boolean' else 'smallint' end }
-          	,message varchar(65000)
-          	,transform_start_time timestamp
-          	,transform_end_time timestamp
-          );}
-      end
-    end
-  end
-end