viking-sequel 3.10.0

data/lib/sequel/adapters/jdbc/as400.rb

@@ -0,0 +1,58 @@
+module Sequel
+  module JDBC
+    # Database and Dataset support for AS400 databases accessed via JDBC.
+    module AS400
+      # Instance methods for AS400 Database objects accessed via JDBC.
+      module DatabaseMethods
+        # AS400 uses the :as400 database type.
+        def database_type
+          :as400
+        end
+
+        # Return Sequel::JDBC::AS400::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::AS400::Dataset.new(self, opts)
+        end
+
+        # TODO: Fix for AS400
+        def last_insert_id(conn, opts={})
+          nil
+        end
+      end
+      
+      # Dataset class for AS400 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        WILDCARD = Sequel::LiteralString.new('*').freeze
+        
+        # AS400 needs to use a couple of subselects for all limits and offsets.
+        def select_sql
+          return super unless l = @opts[:limit]
+          o = @opts[:offset] || 0
+          order = @opts[:order]
+          dsa1 = dataset_alias(1)
+          dsa2 = dataset_alias(2)
+          rn = row_number_column
+          irn = Sequel::SQL::Identifier.new(rn).qualify(dsa2)
+          subselect_sql(unlimited.
+            from_self(:alias=>dsa1).
+            select_more(Sequel::SQL::QualifiedIdentifier.new(dsa1, WILDCARD),
+              Sequel::SQL::WindowFunction.new(SQL::Function.new(:ROW_NUMBER), Sequel::SQL::Window.new(:order=>order)).as(rn)).
+            from_self(:alias=>dsa2).
+            select(Sequel::SQL::QualifiedIdentifier.new(dsa2, WILDCARD)).
+            where((irn > o) & (irn <= l + o)))
+        end
+          
+        def supports_window_functions?
+          true
+        end
+          
+        private
+        
+        # The alias to use for the row_number column when emulating LIMIT and OFFSET
+        def row_number_column
+          :x_sequel_row_number_x
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -0,0 +1,133 @@
+module Sequel
+  module JDBC
+    # Database and Dataset support for H2 databases accessed via JDBC.
+    module H2
+      # Instance methods for H2 Database objects accessed via JDBC.
+      module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Aprimary_key/i.freeze
+      
+        # H2 uses the :h2 database type.
+        def database_type
+          :h2
+        end
+
+        # Return Sequel::JDBC::H2::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::H2::Dataset.new(self, opts)
+        end
+        
+        # H2 uses an IDENTITY type
+        def serial_primary_key_options
+          {:primary_key => true, :type => :identity}
+        end
+        
+        private
+        
+        # H2 needs to add a primary key column as a constraint
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :add_column
+            if (pk = op.delete(:primary_key)) || (ref = op.delete(:table))
+              sqls = [super(table, op)]
+              sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})" if pk
+              if ref
+                op[:table] = ref
+                sqls << "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])}) #{column_references_sql(op)}"
+              end
+              sqls
+            else
+              super(table, op)
+            end
+          when :rename_column
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} RENAME TO #{quote_identifier(op[:new_name])}"
+          when :set_column_null
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET#{' NOT' unless op[:null]} NULL"
+          when :set_column_type
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+          else
+            super(table, op)
+          end
+        end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:h2:mem:' ? o.merge(:max_connections=>1) : o
+        end
+      
+        # Use IDENTITY() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT IDENTITY();')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end 
+        end
+        
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
+      end
+      
+      # Dataset class for H2 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+        
+        # Work around H2's lack of a case insensitive LIKE operator
+        def complex_expression_sql(op, args)
+          case op
+          when :ILIKE
+            super(:LIKE, [SQL::PlaceholderLiteralString.new("CAST(? AS VARCHAR_IGNORECASE)", [args.at(0)]), args.at(1)])
+          when :"NOT ILIKE"
+            super(:"NOT LIKE", [SQL::PlaceholderLiteralString.new("CAST(? AS VARCHAR_IGNORECASE)", [args.at(0)]), args.at(1)])
+          else
+            super(op, args)
+          end
+        end
+        
+        # H2 requires SQL standard datetimes
+        def requires_sql_standard_datetimes?
+          true
+        end
+
+        # H2 doesn't support IS TRUE
+        def supports_is_true?
+          false
+        end
+        
+        # H2 doesn't support JOIN USING
+        def supports_join_using?
+          false
+        end
+        
+        # H2 doesn't support multiple columns in IN/NOT IN
+        def supports_multiple_column_in?
+          false
+        end 
+
+        private
+      
+        # H2 expects hexadecimal strings for blob values
+        def literal_blob(v)
+          literal_string v.unpack("H*").first
+        end
+        
+        def convert_type(v)
+          case v
+          when Java::OrgH2Jdbc::JdbcClob
+            convert_type(v.getSubString(1, v.length))
+          else
+            super(v)
+          end
+        end
+        
+        def select_clause_methods
+          SELECT_CLAUSE_METHODS
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/mssql.rb

@@ -0,0 +1,57 @@
+Sequel.require 'adapters/shared/mssql'
+
+module Sequel
+  module JDBC
+    class Database
+      # Alias the generic JDBC version so it can be called directly later
+      alias jdbc_schema_parse_table schema_parse_table
+    end
+    
+    # Database and Dataset instance methods for MSSQL specific
+    # support via JDBC.
+    module MSSQL
+      # Database instance methods for MSSQL databases accessed via JDBC.
+      module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Apk__/i.freeze
+        
+        include Sequel::MSSQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::MSSQL::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # Get the last inserted id using SCOPE_IDENTITY().
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
+            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end
+        end
+        
+        # Call the generic JDBC version instead of MSSQL version,
+        # since the JDBC version handles primary keys.
+        def schema_parse_table(table, opts={})
+          jdbc_schema_parse_table(table, opts)
+        end
+        
+        # Primary key indexes appear to start with pk__ on MSSQL
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
+      end
+      
+      # Dataset class for MSSQL datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -0,0 +1,78 @@
+Sequel.require 'adapters/shared/mysql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for MySQL specific
+    # support via JDBC.
+    module MySQL
+      # Database instance methods for MySQL databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::MySQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::MySQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::MySQL::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # The database name for the given database.  Need to parse it out
+        # of the connection string, since the JDBC does no parsing on the
+        # given connection string by default.
+        def database_name
+          u = URI.parse(uri.sub(/\Ajdbc:/, ''))
+          (m = /\/(.*)/.match(u.path)) && m[1]
+        end
+        
+        # Get the last inserted id using LAST_INSERT_ID().
+        def last_insert_id(conn, opts={})
+          if stmt = opts[:stmt]
+            rs = stmt.getGeneratedKeys
+            begin
+              if rs.next
+                rs.getInt(1)
+              else
+                0
+              end
+            ensure
+              rs.close
+            end
+          else
+            stmt = conn.createStatement
+            begin
+              rs = stmt.executeQuery('SELECT LAST_INSERT_ID()')
+              rs.next
+              rs.getInt(1)
+            ensure
+              stmt.close
+            end
+          end
+        end
+
+        def requires_return_generated_keys?
+          true
+        end
+      end
+      
+      # Dataset class for MySQL datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MySQL::DatasetMethods
+        
+        # Use execute_insert to execute the insert_sql.
+        def insert(*values)
+          execute_insert(insert_sql(*values))
+        end
+        
+        # Use execute_insert to execute the replace_sql.
+        def replace(*args)
+          execute_insert(replace_sql(*args))
+        end
+        
+        # MySQL on JDBC does provides an accurate number of rows matched.
+        def provides_accurate_rows_matched?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -0,0 +1,50 @@
+Sequel.require 'adapters/shared/oracle'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for Oracle databases accessed via JDBC.
+    module Oracle
+      # Instance methods for Oracle Database objects accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Oracle::DatabaseMethods
+        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+        
+        # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Oracle::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # Use JDBC connection's setAutoCommit to false to start transactions
+        def begin_transaction(conn)
+          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+          conn
+        end
+        
+        # Use JDBC connection's commit method to commit transactions
+        def commit_transaction(conn)
+          log_yield(TRANSACTION_COMMIT){conn.commit}
+        end
+        
+        # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+        def remove_transaction(conn)
+          conn.setAutoCommit(true) if conn
+          @transactions.delete(Thread.current)
+        end
+        
+        # Use JDBC connection's rollback method to rollback transactions
+        def rollback_transaction(conn)
+          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        end
+      end
+      
+      # Dataset class for Oracle datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Oracle::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -0,0 +1,108 @@
+Sequel.require 'adapters/shared/postgres'
+
+module Sequel
+  Postgres::CONVERTED_EXCEPTIONS << NativeException
+  
+  module JDBC
+    # Adapter, Database, and Dataset support for accessing a PostgreSQL
+    # database via JDBC.
+    module Postgres
+      # Methods to add to the JDBC adapter/connection to allow it to work
+      # with the shared PostgreSQL code.
+      module AdapterMethods
+        include Sequel::Postgres::AdapterMethods
+        
+        # Give the JDBC adapter a direct execute method, which creates
+        # a statement with the given sql and executes it.
+        def execute(sql, args=nil)
+          method = block_given? ? :executeQuery : :execute
+          stmt = createStatement
+          begin
+            rows = @db.log_yield(sql){stmt.send(method, sql)}
+            yield(rows) if block_given?
+          rescue NativeException => e
+            raise_error(e)
+          ensure
+            stmt.close
+          end
+        end
+        
+        private
+        
+        # JDBC specific method of getting specific values from a result set.
+        def single_value(r)
+          unless r.nil?
+            r.next
+            r.getString(1) unless r.getRow == 0
+          end
+        end
+      end
+    
+      # Methods to add to Database instances that access PostgreSQL via
+      # JDBC.
+      module DatabaseMethods
+        include Sequel::Postgres::DatabaseMethods
+        
+        # Add the primary_keys and primary_key_sequences instance variables,
+        # so we can get the correct return values for inserted rows.
+        def self.extended(db)
+          db.instance_eval do
+            @primary_keys = {}
+            @primary_key_sequences = {}
+          end
+        end
+        
+        # Return instance of Sequel::JDBC::Postgres::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Postgres::Dataset.new(self, opts)
+        end
+        
+        # Run the INSERT sql on the database and return the primary key
+        # for the record.
+        def execute_insert(sql, opts={})
+          super(sql, {:type=>:insert}.merge(opts))
+        end
+        
+        private
+        
+        # Extend the adapter with the JDBC PostgreSQL AdapterMethods
+        def setup_connection(conn)
+          conn = super(conn)
+          conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
+          conn.db = self
+          conn.apply_connection_settings
+          conn
+        end
+        
+        # Call insert_result with the table and values specified in the opts.
+        def last_insert_id(conn, opts)
+          insert_result(conn, opts[:table], opts[:values])
+        end
+        
+        # Override shared postgresql adapter method to actually log,
+        # since on JDBC the first argument is a statement and not a
+        # connection, so it wouldn't be logged otherwise.
+        def log_connection_execute(stmt, sql) 
+          log_yield(sql){stmt.execute(sql)}
+        end
+      end
+      
+      # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Postgres::DatasetMethods
+
+        # Add the shared PostgreSQL prepared statement methods
+        def prepare(*args)
+          ps = super
+          ps.extend(::Sequel::Postgres::DatasetMethods::PreparedStatementMethods)
+          ps
+        end
+        
+        # Literalize strings similar to the native postgres adapter
+        def literal_string(v)
+          db.synchronize{|c| "'#{c.escape_string(v)}'"}
+        end
+      end
+    end
+  end
+end