activerecord-jdbc-adapter 5.0.pre1 → 51.0

data/lib/arjdbc/postgresql/base/schema_definitions.rb

@@ -1,131 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module PostgreSQL
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-        attr_accessor :array
-        def array?; !!@array; end
-      end
-
-      module ColumnMethods
-        def xml(*args)
-          options = args.extract_options!
-          column(args[0], 'xml', options)
-        end
-
-        def tsvector(*args)
-          options = args.extract_options!
-          column(args[0], 'tsvector', options)
-        end
-
-        def int4range(name, options = {})
-          column(name, 'int4range', options)
-        end
-
-        def int8range(name, options = {})
-          column(name, 'int8range', options)
-        end
-
-        def tsrange(name, options = {})
-          column(name, 'tsrange', options)
-        end
-
-        def tstzrange(name, options = {})
-          column(name, 'tstzrange', options)
-        end
-
-        def numrange(name, options = {})
-          column(name, 'numrange', options)
-        end
-
-        def daterange(name, options = {})
-          column(name, 'daterange', options)
-        end
-
-        def hstore(name, options = {})
-          column(name, 'hstore', options)
-        end
-
-        def ltree(name, options = {})
-          column(name, 'ltree', options)
-        end
-
-        def inet(name, options = {})
-          column(name, 'inet', options)
-        end
-
-        def cidr(name, options = {})
-          column(name, 'cidr', options)
-        end
-
-        def macaddr(name, options = {})
-          column(name, 'macaddr', options)
-        end
-
-        def uuid(name, options = {})
-          column(name, 'uuid', options)
-        end
-
-        def json(name, options = {})
-          column(name, 'json', options)
-        end
-
-        def jsonb(name, options = {})
-          column(name, :jsonb, options)
-        end
-
-        def bit(name, options)
-          column(name, 'bit', options)
-        end
-
-        def bit_varying(name, options)
-          column(name, 'bit varying', options)
-        end
-      end
-
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-        include ColumnMethods
-
-        def primary_key(name, type = :primary_key, options = {})
-          return super unless type == :uuid
-          options[:default] = options.fetch(:default, 'uuid_generate_v4()')
-          options[:primary_key] = true
-          column name, type, options
-        end if ::ActiveRecord::VERSION::MAJOR > 3 # 3.2 super expects (name)
-
-        def column(name, type = nil, options = {})
-          super
-          column = self[name]
-          # NOTE: <= 3.1 no #new_column_definition hard-coded ColumnDef.new :
-          # column = self[name] || ColumnDefinition.new(@base, name, type)
-          # thus we simply do not support array column definitions on <= 3.1
-          column.array = options[:array] if column.is_a?(ColumnDefinition)
-          self
-        end
-
-        private
-
-        if ::ActiveRecord::VERSION::MAJOR > 3
-
-          def create_column_definition(name, type)
-            ColumnDefinition.new name, type
-          end
-
-        else # no #create_column_definition on 3.2
-
-          def new_column_definition(base, name, type)
-            definition = ColumnDefinition.new base, name, type
-            @columns << definition
-            @columns_hash[name] = definition
-            definition
-          end
-
-        end
-
-      end
-
-      class Table < ActiveRecord::ConnectionAdapters::Table
-        include ColumnMethods
-      end
-    end
-  end
-end

data/lib/arjdbc/postgresql/explain_support.rb

@@ -1,53 +0,0 @@
-module ArJdbc
-  module PostgreSQL
-    # @private
-    module ExplainSupport
-      def supports_explain?
-        true
-      end
-
-      def explain(arel, binds = [])
-        sql = "EXPLAIN #{to_sql(arel, binds)}"
-        result = exec_query(sql, "EXPLAIN", binds)
-        ExplainPrettyPrinter.new.pp result # we can assume AR >= 3.1
-      end
-      # @private
-      class ExplainPrettyPrinter
-        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
-        # PostgreSQL shell:
-        #
-        # QUERY PLAN
-        # ------------------------------------------------------------------------------
-        # Nested Loop Left Join (cost=0.00..37.24 rows=8 width=0)
-        # Join Filter: (posts.user_id = users.id)
-        # -> Index Scan using users_pkey on users (cost=0.00..8.27 rows=1 width=4)
-        # Index Cond: (id = 1)
-        # -> Seq Scan on posts (cost=0.00..28.88 rows=8 width=4)
-        # Filter: (posts.user_id = 1)
-        # (6 rows)
-        #
-        def pp(result)
-          header = result.columns.first
-          lines = result.rows.map(&:first)
-
-          # We add 2 because there's one char of padding at both sides, note
-          # the extra hyphens in the example above.
-          width = [header, *lines].map(&:length).max + 2
-
-          pp = []
-
-          pp << header.center(width).rstrip
-          pp << '-' * width
-
-          pp += lines.map {|line| " #{line}"}
-
-          nrows = result.rows.length
-          rows_label = nrows == 1 ? 'row' : 'rows'
-          pp << "(#{nrows} #{rows_label})"
-
-          pp.join("\n") + "\n"
-        end
-      end
-    end
-  end
-end

data/lib/arjdbc/postgresql/oid/bytea.rb

@@ -1,2 +0,0 @@
-class ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Bytea
-end

data/lib/arjdbc/postgresql/schema_creation.rb

@@ -1,60 +0,0 @@
-module ArJdbc
-  module PostgreSQL
-    # @private copied (and adjusted) from native adapter 4.0/4.1/4.2
-    class SchemaCreation < ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
-
-      private
-
-      def visit_AddColumn(o)
-        sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
-        sql = "ADD COLUMN #{quote_column_name(o.name)} #{sql_type}"
-        add_column_options!(sql, column_options(o))
-      end unless AR42
-
-      def visit_ColumnDefinition(o)
-        sql = super
-        if o.primary_key? && o.type == :uuid
-          sql << " PRIMARY KEY "
-          add_column_options!(sql, column_options(o))
-        end
-        sql
-      end unless AR42
-
-      def visit_ColumnDefinition(o)
-        sql = super
-        if o.primary_key? && o.type != :primary_key
-          sql << " PRIMARY KEY "
-          add_column_options!(sql, column_options(o))
-        end
-        sql
-      end if AR42
-
-      def add_column_options!(sql, options)
-        if options[:array] || options[:column].try(:array)
-          sql << '[]'
-        end
-
-        column = options.fetch(:column) { return super }
-        if column.type == :uuid && options[:default] =~ /\(\)/
-          sql << " DEFAULT #{options[:default]}"
-        else
-          super
-        end
-      end
-
-      def type_for_column(column)
-        if column.array
-          @conn.lookup_cast_type("#{column.sql_type}[]")
-        else
-          super
-        end
-      end if AR42
-
-    end
-
-    def schema_creation
-      SchemaCreation.new self
-    end
-
-  end
-end if ::ActiveRecord::ConnectionAdapters::AbstractAdapter.const_defined? :SchemaCreation

data/lib/arjdbc/tasks/oracle/enhanced_structure_dump.rb

@@ -1,297 +0,0 @@
-# NOTE: kindly copy-pasted from Raimonds Simanovskis's oracle-enhanced adapter :
-# https://github.com/rsim/oracle-enhanced/blob/master/lib/active_record/connection_adapters/oracle_enhanced_structure_dump.rb
-
-module ActiveRecord #:nodoc:
-  module ConnectionAdapters #:nodoc:
-    module OracleEnhancedStructureDump #:nodoc:
-
-      # Statements separator used in structure dump to allow loading of structure dump also with SQL*Plus
-      STATEMENT_TOKEN = "\n\n/\n\n"
-
-      def structure_dump #:nodoc:
-        structure = select_values("SELECT sequence_name FROM user_sequences ORDER BY 1").map do |seq|
-          "CREATE SEQUENCE \"#{seq}\""
-        end
-        select_values("SELECT table_name FROM all_tables t
-                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'
-                      AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv WHERE mv.owner = t.owner AND mv.mview_name = t.table_name)
-                      AND NOT EXISTS (SELECT mvl.log_table FROM all_mview_logs mvl WHERE mvl.log_owner = t.owner AND mvl.log_table = t.table_name)
-                    ORDER BY 1").each do |table_name|
-          virtual_columns = virtual_columns_for(table_name)
-          ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
-          cols = select_all(%Q{
-            SELECT column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
-            FROM user_tab_columns
-            WHERE table_name = '#{table_name}'
-            ORDER BY column_id
-          }).map do |row|
-            if(v = virtual_columns.find {|col| col['column_name'] == row['column_name']})
-              structure_dump_virtual_column(row, v['data_default'])
-            else
-              structure_dump_column(row)
-            end
-          end
-          ddl << cols.join(",\n ")
-          ddl << structure_dump_primary_key(table_name)
-          ddl << "\n)"
-          structure << ddl
-          structure << structure_dump_indexes(table_name)
-          structure << structure_dump_unique_keys(table_name)
-        end
-
-        join_with_statement_token(structure) << structure_dump_fk_constraints
-      end
-
-      def structure_dump_column(column) #:nodoc:
-        col = "\"#{column['column_name']}\" #{column['data_type']}"
-        if column['data_type'] =='NUMBER' && ! column['data_precision'].blank?
-          col << "(#{column['data_precision'].to_i}"
-          col << ",#{column['data_scale'].to_i}" unless column['data_scale'].blank?
-          col << ')'
-        elsif column['data_type'].include?('CHAR')
-          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
-          col <<  "(#{length})"
-        end
-        col << " DEFAULT #{column['data_default']}" unless column['data_default'].blank?
-        col << ' NOT NULL' if column['nullable'] == 'N'
-        col
-      end
-
-      def structure_dump_virtual_column(column, data_default) #:nodoc:
-        data_default = data_default.gsub(/"/, '')
-        col = "\"#{column['column_name']}\" #{column['data_type']}"
-        if column['data_type'] =='NUMBER' && ! column['data_precision'].blank?
-          col << "(#{column['data_precision'].to_i}"
-          col << ",#{column['data_scale'].to_i}" unless column['data_scale'].blank?
-          col << ')'
-        elsif column['data_type'].include?('CHAR')
-          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
-          col <<  "(#{length})"
-        end
-        col << " GENERATED ALWAYS AS (#{data_default}) VIRTUAL"
-      end
-
-      def structure_dump_primary_key(table) #:nodoc:
-        opts = {:name => '', :cols => []}
-        pks = select_all(<<-SQL, "Primary Keys")
-          SELECT a.constraint_name, a.column_name, a.position
-            FROM user_cons_columns a
-            JOIN user_constraints c
-              ON a.constraint_name = c.constraint_name
-           WHERE c.table_name = '#{table.upcase}'
-             AND c.constraint_type = 'P'
-             AND c.owner = SYS_CONTEXT('userenv', 'session_user')
-        SQL
-        pks.each do |row|
-          opts[:name] = row['constraint_name']
-          opts[:cols][row['position']-1] = row['column_name']
-        end
-        opts[:cols].length > 0 ? ",\n CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : ''
-      end
-
-      def structure_dump_unique_keys(table) #:nodoc:
-        keys = {}
-        uks = select_all(<<-SQL, "Primary Keys")
-          SELECT a.constraint_name, a.column_name, a.position
-            FROM user_cons_columns a
-            JOIN user_constraints c
-              ON a.constraint_name = c.constraint_name
-           WHERE c.table_name = '#{table.upcase}'
-             AND c.constraint_type = 'U'
-             AND c.owner = SYS_CONTEXT('userenv', 'session_user')
-        SQL
-        uks.each do |uk|
-          keys[uk['constraint_name']] ||= []
-          keys[uk['constraint_name']][uk['position']-1] = uk['column_name']
-        end
-        keys.map do |k,v|
-          "ALTER TABLE #{table.upcase} ADD CONSTRAINT #{k} UNIQUE (#{v.join(',')})"
-        end
-      end
-
-      def structure_dump_indexes(table_name) #:nodoc:
-        indexes(table_name).map do |options|
-          column_names = options[:columns]
-          options = {:name => options[:name], :unique => options[:unique]}
-          index_name   = index_name(table_name, :column => column_names)
-          if Hash === options # legacy support, since this param was a string
-            index_type = options[:unique] ? "UNIQUE" : ""
-            index_name = options[:name] || index_name
-          else
-            index_type = options
-          end
-          quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
-          "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
-        end
-      end
-
-      def structure_dump_fk_constraints #:nodoc:
-        fks = select_all("SELECT table_name FROM all_tables WHERE owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1").map do |table|
-          if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
-            foreign_keys.map do |fk|
-              sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} "
-              sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
-            end
-          end
-        end.flatten.compact
-        join_with_statement_token(fks)
-      end
-
-      def dump_schema_information #:nodoc:
-        sm_table = ActiveRecord::Migrator.schema_migrations_table_name
-        migrated = select_values("SELECT version FROM #{sm_table} ORDER BY version")
-        join_with_statement_token(migrated.map{|v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}')" })
-      end
-
-      # Extract all stored procedures, packages, synonyms and views.
-      def structure_dump_db_stored_code #:nodoc:
-        structure = []
-        select_all("SELECT DISTINCT name, type
-                     FROM all_source
-                    WHERE type IN ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
-                      AND name NOT LIKE 'BIN$%'
-                      AND owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY type").each do |source|
-          ddl = "CREATE OR REPLACE   \n"
-          select_all(%Q{
-                  SELECT text
-                    FROM all_source
-                   WHERE name = '#{source['name']}'
-                     AND type = '#{source['type']}'
-                     AND owner = SYS_CONTEXT('userenv', 'session_user')
-                   ORDER BY line
-                }).each do |row|
-            ddl << row['text']
-          end
-          ddl << ";" unless ddl.strip[-1,1] == ';'
-          structure << ddl
-        end
-
-        # export views
-        select_all("SELECT view_name, text FROM user_views").each do |view|
-          structure << "CREATE OR REPLACE VIEW #{view['view_name']} AS\n #{view['text']}"
-        end
-
-        # export synonyms
-        select_all("SELECT owner, synonym_name, table_name, table_owner
-                      FROM all_synonyms
-                     WHERE owner = SYS_CONTEXT('userenv', 'session_user') ").each do |synonym|
-          structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}"
-          structure << " FOR #{synonym['table_owner']}.#{synonym['table_name']}"
-        end
-
-        join_with_statement_token(structure)
-      end
-
-      def structure_drop #:nodoc:
-        statements = select_values("SELECT sequence_name FROM user_sequences ORDER BY 1").map do |seq|
-          "DROP SEQUENCE \"#{seq}\""
-        end
-        select_values("SELECT table_name from all_tables t
-                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N'
-                      AND NOT EXISTS (SELECT mv.mview_name FROM all_mviews mv WHERE mv.owner = t.owner AND mv.mview_name = t.table_name)
-                      AND NOT EXISTS (SELECT mvl.log_table FROM all_mview_logs mvl WHERE mvl.log_owner = t.owner AND mvl.log_table = t.table_name)
-                    ORDER BY 1").each do |table|
-          statements << "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
-        end
-        join_with_statement_token(statements)
-      end
-
-      def temp_table_drop #:nodoc:
-        join_with_statement_token(select_values(
-                  "SELECT table_name FROM all_tables
-                    WHERE owner = SYS_CONTEXT('userenv', 'session_user') AND secondary = 'N' AND temporary = 'Y' ORDER BY 1").map do |table|
-          "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
-        end)
-      end
-
-      def full_drop(preserve_tables=false) #:nodoc:
-        s = preserve_tables ? [] : [structure_drop]
-        s << temp_table_drop if preserve_tables
-        s << drop_sql_for_feature("view")
-        s << drop_sql_for_feature("materialized view")
-        s << drop_sql_for_feature("synonym")
-        s << drop_sql_for_feature("type")
-        s << drop_sql_for_object("package")
-        s << drop_sql_for_object("function")
-        s << drop_sql_for_object("procedure")
-        s.join
-      end
-
-      def add_column_options!(sql, options) #:nodoc:
-        type = options[:type] || ((column = options[:column]) && column.type)
-        type = type && type.to_sym
-        # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
-        if options_include_default?(options)
-          if type == :text
-            sql << " DEFAULT #{quote(options[:default])}"
-          else
-            # from abstract adapter
-            sql << " DEFAULT #{quote(options[:default], options[:column])}"
-          end
-        end
-        # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
-        if options[:null] == false
-          sql << " NOT NULL"
-        elsif options[:null] == true
-          sql << " NULL" unless type == :primary_key
-        end
-        # add AS expression for virtual columns
-        if options[:as].present?
-          sql << " AS (#{options[:as]})"
-        end
-      end
-
-      def execute_structure_dump(string)
-        string.split(STATEMENT_TOKEN).each do |ddl|
-          ddl.chop! if ddl[-1,1] == ';'
-          execute(ddl) unless ddl.blank?
-        end
-      end
-
-      private
-
-      # virtual columns are an 11g feature.  This returns [] if feature is not
-      # present or none are found.
-      # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
-      def virtual_columns_for(table)
-        begin
-          select_all <<-SQL
-            SELECT column_name, data_default
-              FROM user_tab_cols
-             WHERE virtual_column = 'YES'
-               AND table_name = '#{table.upcase}'
-          SQL
-        # feature not supported previous to 11g
-        rescue ActiveRecord::StatementInvalid => e
-          []
-        end
-      end
-
-      def drop_sql_for_feature(type)
-        short_type = type == 'materialized view' ? 'mview' : type
-        join_with_statement_token(
-        select_values("SELECT #{short_type}_name FROM user_#{short_type.tableize}").map do |name|
-          "DROP #{type.upcase} \"#{name}\""
-        end)
-      end
-
-      def drop_sql_for_object(type)
-        join_with_statement_token(
-        select_values("SELECT object_name FROM user_objects WHERE object_type = '#{type.upcase}'").map do |name|
-          "DROP #{type.upcase} \"#{name}\""
-        end)
-      end
-
-      def join_with_statement_token(array)
-        string = array.join(STATEMENT_TOKEN)
-        string << STATEMENT_TOKEN unless string.blank?
-        string
-      end
-
-    end
-  end
-end
-
-ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
-  include ActiveRecord::ConnectionAdapters::OracleEnhancedStructureDump
-end

data/lib/arjdbc/tasks/oracle_database_tasks.rb

@@ -1,65 +0,0 @@
-require 'arjdbc/tasks/jdbc_database_tasks'
-
-module ArJdbc
-  module Tasks
-    class OracleDatabaseTasks < JdbcDatabaseTasks
-
-      def create
-        print "Please provide the SYSTEM password for your oracle installation\n>"
-        system_password = $stdin.gets.strip
-        establish_connection(config.merge('username' => 'SYSTEM', 'password' => system_password))
-        unless ( config = self.config ).key?('username')
-          config = config_from_url(config['url']) if config['url']
-        end
-        begin
-          connection.execute "CREATE USER #{config['username']} IDENTIFIED BY #{config['password']}"
-        rescue => e
-          if e.message =~ /ORA-01920/ # user name conflicts with another user or role name
-            connection.execute "ALTER USER #{config['username']} IDENTIFIED BY #{config['password']}"
-          else
-            raise e
-          end
-        end
-        connection.execute "GRANT unlimited tablespace TO #{config['username']}"
-        connection.execute "GRANT create session TO #{config['username']}"
-        connection.execute "GRANT create table TO #{config['username']}"
-        connection.execute "GRANT create sequence TO #{config['username']}"
-      end
-
-      def drop
-        self.class.load_enhanced_structure_dump
-        establish_connection(config)
-        connection.execute_structure_dump(connection.full_drop)
-      end
-
-      def purge
-        self.class.load_enhanced_structure_dump
-        establish_connection(:test)
-        connection.execute_structure_dump(connection.full_drop)
-        connection.execute("PURGE RECYCLEBIN") rescue nil
-      end
-
-      def structure_dump(filename)
-        self.class.load_enhanced_structure_dump
-        establish_connection(config)
-        File.open(filename, "w:utf-8") { |f| f << connection.structure_dump }
-      end
-
-      def structure_load(filename)
-        self.class.load_enhanced_structure_dump
-        establish_connection(config)
-        connection.execute_structure_dump(File.read(filename))
-      end
-
-      def self.load_enhanced_structure_dump
-        unless defined? ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
-          ActiveRecord::ConnectionAdapters.module_eval do
-            const_set :OracleEnhancedAdapter, ActiveRecord::ConnectionAdapters::OracleAdapter
-          end
-        end
-        require 'arjdbc/tasks/oracle/enhanced_structure_dump'
-      end
-
-    end
-  end
-end

data/src/java/arjdbc/oracle/OracleModule.java

@@ -1,75 +0,0 @@
-/*
- * The MIT License
- *
- * Copyright 2013-2014 Karol Bucek.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-package arjdbc.oracle;
-
-import static arjdbc.util.QuotingUtils.BYTES_0;
-import static arjdbc.util.QuotingUtils.BYTES_1;
-import static arjdbc.util.QuotingUtils.quoteCharWith;
-
-import org.jruby.RubyModule;
-import org.jruby.RubyString;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-
-/**
- * ArJdbc::Oracle
- *
- * @author kares
- */
-public class OracleModule {
-
-    public static RubyModule load(final RubyModule arJdbc) {
-        RubyModule oracle = arJdbc.defineModuleUnder("Oracle");
-        oracle.defineAnnotatedMethods( OracleModule.class );
-        return oracle;
-    }
-
-    @JRubyMethod(name = "quote_string", required = 1)
-    public static IRubyObject quote_string(
-            final ThreadContext context,
-            final IRubyObject self,
-            final IRubyObject string) { // string.gsub("'", "''") :
-        final char single = '\'';
-        final RubyString quoted = quoteCharWith(
-            context, (RubyString) string, single, single
-        );
-        return quoted;
-    }
-
-    @JRubyMethod(name = "quoted_true", required = 0)
-    public static IRubyObject quoted_true(
-            final ThreadContext context,
-            final IRubyObject self) {
-        return RubyString.newString(context.getRuntime(), BYTES_1);
-    }
-
-    @JRubyMethod(name = "quoted_false", required = 0)
-    public static IRubyObject quoted_false(
-            final ThreadContext context,
-            final IRubyObject self) {
-        return RubyString.newString(context.getRuntime(), BYTES_0);
-    }
-
-}