sequel 3.28.0 → 3.29.0

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

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::Informix::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::Informix::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Informix::Dataset.new(self, opts)
-        end
-        
         private
         
         # TODO: implement

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

@@ -8,11 +8,6 @@ module Sequel
       # Database instance methods for JTDS databases accessed via JDBC.
       module DatabaseMethods
         include Sequel::JDBC::MSSQL::DatabaseMethods
-        
-        # Return instance of Sequel::JDBC::JTDS::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::JTDS::Dataset.new(self, opts)
-        end
       end
       
       # Dataset class for JTDS datasets accessed via JDBC.

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

@@ -9,11 +9,6 @@ module Sequel
       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
@@ -71,11 +66,6 @@ module Sequel
       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))

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

@@ -9,16 +9,83 @@ module Sequel
       module DatabaseMethods
         include Sequel::Oracle::DatabaseMethods
         include Sequel::JDBC::Transactions
+
+        def self.extended(db)
+          db.instance_eval do
+            @autosequence = opts[:autosequence]
+            @primary_key_sequences = {}
+          end
+        end
         
-        # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::Oracle::Dataset.new(self, opts)
+        private
+
+        def last_insert_id(conn, opts)
+          unless sequence = opts[:sequence]
+            if t = opts[:table]
+              sequence = sequence_for_table(t)
+            end
+          end
+          if sequence
+            sql = "SELECT #{literal(sequence)}.currval FROM dual"
+            statement(conn) do |stmt|
+              begin
+                rs = log_yield(sql){stmt.executeQuery(sql)}
+                rs.next
+                rs.getInt(1)
+              rescue java.sql.SQLException
+                nil
+              end
+            end
+          end
+        end
+
+        def schema_parse_table(*)
+          sch = super
+          sch.each do |c, s|
+            if s[:type] == :decimal && s[:scale] == -127
+              s[:type] = :integer
+            elsif s[:db_type] == 'DATE'
+              s[:type] = :datetime
+            end
+          end
+          sch
+        end
+
+        def schema_parse_table_skip?(h, schema)
+          super || (h[:table_schem] != current_user unless schema)
+        end
+
+        # As of Oracle 9.2, releasing savepoints is no longer supported.
+        def supports_releasing_savepoints?
+          false
         end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::Oracle::DatasetMethods
+
+        private
+
+        def convert_type(v)
+          case v
+          when Java::JavaMath::BigDecimal
+            if v.scale == 0
+              i = v.long_value
+              if v.equals(Java::JavaMath::BigDecimal.new(i))
+                i
+              else
+                super
+              end
+            else
+              super
+            end
+          when Java::OracleSql::TIMESTAMP
+            db.to_application_timestamp(v.to_string)
+          else
+            super
+          end
+        end
       end
     end
   end

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

@@ -47,17 +47,6 @@ module Sequel
           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
         
         # Use setNull for nil arguments as the default behavior of setString

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

@@ -8,11 +8,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         
-        # Return Sequel::JDBC::SQLite::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::SQLite::Dataset.new(self, opts)
-        end
-        
         private
         
         # Use last_insert_rowid() to get the last inserted id.

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

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::JDBC::MSSQL::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::SQLServer::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::SQLServer::Dataset.new(self, opts)
-        end
-        
         def metadata_dataset
           ds = super
           # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata

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

@@ -3,30 +3,79 @@ module Sequel
     module Transactions
       TRANSACTION_BEGIN = 'Transaction.begin'.freeze
       TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+      TRANSACTION_RELEASE_SP = 'Transaction.release_savepoint'.freeze
       TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+      TRANSACTION_ROLLBACK_SP = 'Transaction.rollback_savepoint'.freeze
+      TRANSACTION_SAVEPOINT= 'Transaction.savepoint'.freeze
+
+      # Check the JDBC DatabaseMetaData for savepoint support
+      def supports_savepoints?
+        return @supports_savepoints if defined?(@supports_savepoints)
+        @supports_savepoints = synchronize{|c| c.get_meta_data.supports_savepoints}
+      end
 
       private
 
+      # Most JDBC drivers that support savepoints support releasing them.
+      def supports_releasing_savepoints?
+        true
+      end
+
       # Use JDBC connection's setAutoCommit to false to start transactions
       def begin_transaction(conn, opts={})
-        log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-        conn
+        if supports_savepoints?
+          th = @transactions[conn]
+          if sps = th[:savepoints]
+            sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
+          else
+            log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+            th[:savepoints] = []
+          end
+          th[:savepoint_level] += 1
+        else
+          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+        end
       end
       
       # Use JDBC connection's commit method to commit transactions
       def commit_transaction(conn, opts={})
-        log_yield(TRANSACTION_COMMIT){conn.commit}
+        if supports_savepoints?
+          sps = @transactions[conn][:savepoints]
+          if sps.empty?
+            log_yield(TRANSACTION_COMMIT){conn.commit}
+          elsif supports_releasing_savepoints?
+            log_yield(TRANSACTION_RELEASE_SP){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+          end
+        else
+          log_yield(TRANSACTION_COMMIT){conn.commit}
+        end
       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)
+      def remove_transaction(conn, committed)
+        if supports_savepoints?
+          sps = @transactions[conn][:savepoints]
+          conn.setAutoCommit(true) if sps.empty?
+          sps.pop
+        else
+          conn.setAutoCommit(true)
+        end
+      ensure
+        super
       end
       
       # Use JDBC connection's rollback method to rollback transactions
       def rollback_transaction(conn, opts={})
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        if supports_savepoints?
+          sps = @transactions[conn][:savepoints]
+          if sps.empty?
+            log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+          else
+            log_yield(TRANSACTION_ROLLBACK_SP){conn.rollback(sps.last)}
+          end
+        else
+          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        end
       end
     end
   end

data/lib/sequel/adapters/mock.rb

@@ -0,0 +1,315 @@
+module Sequel
+  module Mock
+    # Connection class for Sequel's mock adapter.
+    class Connection
+      # Sequel::Mock::Database object that created this connection
+      attr_reader :db
+
+      # Shard this connection operates on, when using Sequel's
+      # sharding support (always :default for databases not using
+      # sharding).
+      attr_reader :server
+
+      # The specific database options for this connection.
+      attr_reader :opts
+
+      # Store the db, server, and opts.
+      def initialize(db, server, opts)
+        @db = db
+        @server = server
+        @opts = opts
+      end
+
+      # Delegate to the db's #_execute method.
+      def execute(sql)
+        @db.send(:_execute, self, sql) 
+      end
+    end
+
+    # Database class for Sequel's mock adapter.
+    class Database < Sequel::Database
+      set_adapter_scheme :mock
+
+      # Set the autogenerated primary key integer
+      # to be returned when running an insert query.
+      # Argument types supported:
+      #
+      # nil :: Return nil for all inserts
+      # Integer :: Starting integer for next insert, with
+      #            futher inserts getting an incremented
+      #            value
+      # Array :: First insert gets the first value in the
+      #          array, second gets the second value, etc.
+      # Proc :: Called with the insert SQL query, uses
+      #         the value returned
+      # Class :: Should be an Exception subclass, will create a new
+      #          instance an raise it wrapped in a DatabaseError.
+      attr_writer :autoid
+
+      # Set the columns to set in the dataset when the dataset fetches
+      # rows.  Argument types supported:
+      # nil :: Set no columns
+      # Array of Symbols: Used for all datasets
+      # Array (otherwise): First retrieval gets the first value in the
+      #                    array, second gets the second value, etc.
+      # Proc :: Called with the select SQL query, uses the value
+      #         returned, which should be an array of symbols
+      attr_writer :columns
+
+      # Set the hashes to yield by execute when retrieving rows.
+      # Argument types supported:
+      #
+      # nil :: Yield no rows
+      # Hash :: Always yield a single row with this hash
+      # Array of Hashes :: Yield separately for each hash in this array
+      # Array (otherwise) :: First retrieval gets the first value
+      #          in the array, second gets the second value, etc.
+      # Proc :: Called with the select SQL query, uses
+      #         the value returned, which should be a hash or
+      #         array of hashes.
+      # Class :: Should be an Exception subclass, will create a new
+      #          instance an raise it wrapped in a DatabaseError.
+      attr_writer :fetch
+
+      # Set the number of rows to return from update or delete.
+      # Argument types supported:
+      #
+      # nil :: Return 0 for all updates and deletes
+      # Integer :: Used for all updates and deletes
+      # Array :: First update/delete gets the first value in the
+      #          array, second gets the second value, etc.
+      # Proc :: Called with the update/delete SQL query, uses
+      #         the value returned.
+      # Class :: Should be an Exception subclass, will create a new
+      #          instance an raise it wrapped in a DatabaseError.
+      attr_writer :numrows
+
+      # Additional options supported:
+      #
+      # :autoid :: Call #autoid= with the value
+      # :columns :: Call #columns= with the value
+      # :fetch ::  Call #fetch= with the value
+      # :numrows :: Call #numrows= with the value
+      # :extend :: A module the object is extended with.
+      # :sqls :: The array to store the SQL queries in.
+      def initialize(opts=nil)
+        super
+        self.autoid = opts[:autoid]
+        self.columns = opts[:columns]
+        self.fetch = opts[:fetch]
+        self.numrows = opts[:numrows]
+        extend(opts[:extend]) if opts[:extend]
+        @sqls = opts[:sqls] || []
+      end
+
+      # Return a related Connection option connecting to the given shard.
+      def connect(server)
+        Connection.new(self, server, server_opts(server))
+      end
+
+      # Store the sql used for later retrieval with #sqls, and return
+      # the appropriate value using either the #autoid, #fetch, or
+      # #numrows methods.
+      def execute(sql, opts={}, &block)
+        synchronize(opts[:server]){|c| _execute(c, sql, opts, &block)} 
+      end
+      alias execute_ddl execute
+
+      # Store the sql used, and return the value of the #numrows method.
+      def execute_dui(sql, opts={})
+        execute(sql, opts.merge(:meth=>:numrows))
+      end
+
+      # Store the sql used, and return the value of the #autoid method.
+      def execute_insert(sql, opts={})
+        execute(sql, opts.merge(:meth=>:autoid))
+      end
+
+      # Return all stored SQL queries, and clear the cache
+      # of SQL queries.
+      def sqls
+        s = @sqls.dup
+        @sqls.clear
+        s
+      end
+
+      # Enable use of savepoints.
+      def supports_savepoints?
+        true
+      end
+
+      private
+
+      def _autoid(sql, v, ds=nil)
+        case v
+        when Integer
+          if ds
+            ds.autoid += 1 if ds.autoid.is_a?(Integer)
+          else
+            @autoid += 1
+          end
+          v
+        else
+          _nextres(v, sql, nil)
+        end
+      end
+
+      def _execute(c, sql, opts={}, &block)
+        sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
+        sql += " -- #{@opts[:append]}" if @opts[:append]
+        sql += " -- #{c.server}" if c.server != :default
+        log_info(sql)
+        @sqls << sql 
+
+        ds = opts[:dataset]
+        begin
+          if block
+            columns(ds, sql) if ds
+            _fetch(sql, ds._fetch || @fetch, &block)
+          elsif meth = opts[:meth]
+            if meth == :numrows
+              _numrows(sql, ds.numrows || @numrows)
+            else
+              v = ds.autoid
+              _autoid(sql, v || @autoid, (ds if v))
+            end
+          end
+        rescue => e
+          raise_error(e)
+        end
+      end
+
+      def _fetch(sql, f, &block)
+        case f
+        when Hash
+          yield f.dup
+        when Array
+          if f.all?{|h| h.is_a?(Hash)}
+            f.each{|h| yield h.dup}
+          else
+            _fetch(sql, f.shift, &block)
+          end
+        when Proc
+          h = f.call(sql)
+          if h.is_a?(Hash)
+            yield h.dup
+          elsif h
+            h.each{|h1| yield h1.dup}
+          end
+        when Class
+          if f < Exception
+            raise f
+          else
+            raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+          end
+        when nil
+          # nothing
+        else
+          raise Error, "Invalid @fetch attribute: #{f.inspect}"
+        end
+      end
+
+      def _nextres(v, sql, default)
+        case v
+        when Integer
+          v
+        when Array
+          v.empty? ? default : _nextres(v.shift, sql, default)
+        when Proc
+          v.call(sql)
+        when Class
+          if v < Exception
+            raise v
+          else
+            raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+          end
+        when nil
+          default
+        else
+          raise Error, "Invalid @autoid/@numrows attribute: #{v.inspect}"
+        end
+      end
+
+      def _numrows(sql, v)
+        _nextres(v, sql, 0)
+      end
+
+      def columns(ds, sql, cs=@columns)
+        case cs
+        when Array
+          unless cs.empty?
+            if cs.all?{|c| c.is_a?(Symbol)}
+              ds.columns(*cs)
+            else
+              columns(ds, sql, cs.shift)
+            end
+          end
+        when Proc
+          ds.columns(*cs.call(sql))
+        when nil
+          # nothing
+        else
+          raise Error, "Invalid @columns attribute: #{cs.inspect}"
+        end
+      end
+
+      def disconnect_connection(c)
+      end
+
+      def quote_identifiers_default
+        false
+      end
+
+      def identifier_input_method_default
+        nil
+      end
+
+      def identifier_input_method_default
+        nil
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
+      # Override the databases's autoid setting for this dataset
+      attr_accessor :autoid
+
+      # Override the databases's fetch setting for this dataset
+      attr_accessor :_fetch
+
+      # Override the databases's numrows setting for this dataset
+      attr_accessor :numrows
+
+      # If arguments are provided, use them to set the columns
+      # for this dataset and return self.  Otherwise, use the
+      # default Sequel behavior and return the columns.
+      def columns(*cs)
+        if cs.empty?
+          super
+        else
+          @columns = cs
+          self
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        execute(sql, &block)
+      end
+
+      private
+
+      def execute(sql, opts={}, &block)
+        super(sql, opts.merge(:dataset=>self), &block)
+      end
+
+      def execute_dui(sql, opts={}, &block)
+        super(sql, opts.merge(:dataset=>self), &block)
+      end
+
+      def execute_insert(sql, opts={}, &block)
+        super(sql, opts.merge(:dataset=>self), &block)
+      end
+    end
+  end
+end