sequel 4.9.0 → 4.10.0

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

@@ -3,6 +3,14 @@ Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
+    class TypeConvertor
+      def SqlAnywhereBoolean(r, i)
+        if v = Short(r, i)
+          v != 0
+        end
+      end
+    end
+
     module SqlAnywhere
       # Database instance methods for Sybase databases accessed via JDBC.
       module DatabaseMethods
@@ -23,6 +31,11 @@ module Sequel
             rs.getInt(1)
           end
         end
+
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[:SqlAnywhereBoolean] = TypeConvertor::INSTANCE.method(:SqlAnywhereBoolean)
+        end
       end
 
       #Dataset class for Sybase datasets accessed via JDBC.
@@ -31,26 +44,15 @@ module Sequel
 
         private
 
-        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          def sqla_boolean(i) i != 0 end
-        end
-
-        BOOLEAN_METHOD =  TYPE_TRANSLATOR_INSTANCE.method(:sqla_boolean)
+        SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
 
-        def convert_type_proc(v, ctn=nil)
-          case
-          when ctn && ctn =~ SqlAnywhere::DatabaseMethods::SMALLINT_RE
-            BOOLEAN_METHOD
+        def type_convertor(map, meta, type, i)
+          if convert_smallint_to_bool && type == SMALLINT_TYPE
+            map[:SqlAnywhereBoolean]
           else
-            super(v, ctn)
+            super
           end
         end
-
-        # SQLAnywhere needs the column info if it is converting smallint to bool,
-        # since the JDBC adapter always returns smallint as integer.
-        def convert_type_proc_uses_column_info?
-          convert_smallint_to_bool
-        end
       end
     end
   end

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

@@ -59,6 +59,13 @@ module Sequel
           end
           conn
         end
+
+        # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
+        end
       end
     end
   end

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

@@ -19,39 +19,19 @@ module Sequel
         # than getObject() for this column avoids the problem.
         # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
         module MetadataDatasetMethods
-          def process_result_set_convert(cols, result)
-            while result.next
-              row = {}
-              cols.each do |n, i, ctn, p|
-                v = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
-                row[n] = if v
-                  if p
-                    p.call(v)
-                  elsif p.nil?
-                    cols[i-1][3] = p = convert_type_proc(v, ctn)
-                    if p
-                      p.call(v)
-                    else
-                      v
-                    end
-                  else
-                    v
-                  end
-                else
-                  v
-                end
-              end
-              yield row
+          def type_convertor(map, meta, type, i)
+            if output_identifier(meta.getColumnLabel(i)) == :is_autoincrement
+              map[Java::JavaSQL::Types::VARCHAR]
+            else
+              super
             end
           end
 
-          def process_result_set_no_convert(cols, result)
-            while result.next
-              row = {}
-              cols.each do |n, i|
-                row[n] = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
-              end
-              yield row
+          def basic_type_convertor(map, meta, type, i)
+            if output_identifier(meta.getColumnLabel(i)) == :is_autoincrement
+              map[Java::JavaSQL::Types::VARCHAR]
+            else
+              super
             end
           end
         end

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

@@ -47,14 +47,13 @@ module Sequel
       def begin_transaction(conn, opts=OPTS)
         if supports_savepoints?
           th = _trans(conn)
-          if sps = th[:savepoints]
+          if sps = th[:savepoint_objs]
             sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
           else
             log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-            th[:savepoints] = []
+            th[:savepoint_objs] = []
             set_transaction_isolation(conn, opts)
           end
-          th[:savepoint_level] += 1
         else
           log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
           set_transaction_isolation(conn, opts)
@@ -64,7 +63,7 @@ module Sequel
       # Use JDBC connection's commit method to commit transactions
       def commit_transaction(conn, opts=OPTS)
         if supports_savepoints?
-          sps = _trans(conn)[:savepoints]
+          sps = _trans(conn)[:savepoint_objs]
           if sps.empty?
             log_yield(TRANSACTION_COMMIT){conn.commit}
           elsif supports_releasing_savepoints?
@@ -81,7 +80,7 @@ module Sequel
           conn.setTransactionIsolation(jdbc_level)
         end
         if supports_savepoints?
-          sps = _trans(conn)[:savepoints]
+          sps = _trans(conn)[:savepoint_objs]
           conn.setAutoCommit(true) if sps.empty?
           sps.pop
         else
@@ -94,7 +93,7 @@ module Sequel
       # Use JDBC connection's rollback method to rollback transactions
       def rollback_transaction(conn, opts=OPTS)
         if supports_savepoints?
-          sps = _trans(conn)[:savepoints]
+          sps = _trans(conn)[:savepoint_objs]
           if sps.empty?
             log_yield(TRANSACTION_ROLLBACK){conn.rollback}
           else

data/lib/sequel/adapters/openbase.rb

@@ -29,7 +29,7 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
+      def_sql_method(self, :select, %w'select distinct columns from join where group having compounds order limit')
 
       Database::DatasetClass = self
       
@@ -48,12 +48,6 @@ module Sequel
         end
         self
       end
-      
-      private
-      
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
     end
   end
 end

data/lib/sequel/adapters/postgres.rb

@@ -108,7 +108,7 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
-      DISCONNECT_ERROR_RE = /\Acould not receive data from server/
+      DISCONNECT_ERROR_RE = /\A(?:could not receive data from server|no connection to the server|connection not open)/
       
       self.translate_results = false if respond_to?(:translate_results=)
       

data/lib/sequel/adapters/shared/access.rb

@@ -88,9 +88,11 @@ module Sequel
     end
   
     module DatasetMethods
+      include(Module.new do
+        Dataset.def_sql_method(self, :select, %w'select distinct limit columns into from join where group order having compounds')
+      end)
       include EmulateOffsetWithReverseAndCount
 
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct limit columns into from join where group order having compounds')
       DATE_FORMAT = '#%Y-%m-%d#'.freeze
       TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
       TOP = " TOP ".freeze
@@ -295,11 +297,6 @@ module Sequel
       def quoted_identifier_append(sql, v)
         sql << BRACKET_OPEN << v.to_s << BRACKET_CLOSE
       end
-
-      # Access requires the limit clause come before other clauses
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
     end
   end
 end

data/lib/sequel/adapters/shared/cubrid.rb

@@ -165,12 +165,14 @@ module Sequel
     end
     
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Sequel::Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
-      LIMIT = Sequel::Dataset::LIMIT
       COMMA = Sequel::Dataset::COMMA
+      LIMIT = Sequel::Dataset::LIMIT
       BOOL_FALSE = '0'.freeze
       BOOL_TRUE = '1'.freeze
 
+      # Hope you don't have more than 2**32 + offset rows in your dataset
+      ONLY_OFFSET = ",4294967295".freeze
+
       def supports_join_using?
         false
       end
@@ -200,23 +202,36 @@ module Sequel
         BOOL_TRUE
       end
      
-      # CUBRID doesn't support CTEs or FOR UPDATE.
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
+      # CUBRID supports multiple rows in INSERT.
+      def multi_insert_sql_strategy
+        :values
       end
 
       # CUBRID requires a limit to use an offset,
       # and requires a FROM table if a limit is used.
       def select_limit_sql(sql)
-        if @opts[:from] && (l = @opts[:limit])
+        return unless @opts[:from]
+        l = @opts[:limit]
+        o = @opts[:offset]
+        if l || o
           sql << LIMIT
-          if o = @opts[:offset]
+          if o
             literal_append(sql, o)
-            sql << COMMA
+            if l
+              sql << COMMA
+              literal_append(sql, l)
+            else
+              sql << ONLY_OFFSET
+            end
+          else
+            literal_append(sql, l)
           end
-          literal_append(sql, l)
         end
       end
+
+      # CUBRID doesn't support FOR UPDATE.
+      def select_lock_sql(sql)
+      end
     end
   end
 end

data/lib/sequel/adapters/shared/db2.rb

@@ -270,6 +270,10 @@ module Sequel
         end
       end
 
+      def supports_cte?(type=:select)
+        type == :select
+      end
+
       # DB2 supports GROUP BY CUBE
       def supports_group_cube?
         true
@@ -317,6 +321,10 @@ module Sequel
 
       private
 
+      def empty_from_sql
+        EMPTY_FROM_TABLE
+      end
+
       # DB2 needs the standard workaround to insert all default values into
       # a table with more than one column.
       def insert_supports_empty_values?
@@ -342,16 +350,16 @@ module Sequel
         end
       end
 
+      # DB2 can insert multiple rows using a UNION
+      def multi_insert_sql_strategy
+        :union
+      end
+
       # DB2 does not require that ROW_NUMBER be ordered.
       def require_offset_order?
         false
       end
 
-      # Add a fallback table for empty from situation
-      def select_from_sql(sql)
-        @opts[:from] ? super : (sql << EMPTY_FROM_TABLE)
-      end
-
       # Modify the sql to limit the number of rows returned
       # Note: 
       #

data/lib/sequel/adapters/shared/firebird.rb

@@ -152,12 +152,13 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       NULL = LiteralString.new('NULL').freeze
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns from join where group having compounds order')
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values returning')
       FIRST = " FIRST ".freeze
       SKIP = " SKIP ".freeze
       DEFAULT_FROM = " FROM RDB$DATABASE"
       
+      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns from join where group having compounds order')
+      Dataset.def_sql_method(self, :insert, %w'insert into columns values returning')
+
       # Insert given values into the database.
       def insert(*values)
         if @opts[:sql] || @opts[:returning]
@@ -176,6 +177,10 @@ module Sequel
         true
       end
 
+      def supports_cte?(type=:select)
+        type == :select
+      end
+
       def supports_insert_select?
         true
       end
@@ -185,10 +190,14 @@ module Sequel
         false
       end
 
+      def supports_returning?(type)
+        type == :insert
+      end
+
       private
 
-      def insert_clause_methods
-        INSERT_CLAUSE_METHODS
+      def empty_from_sql
+        DEFAULT_FROM
       end
 
       def insert_pk(*values)
@@ -204,19 +213,10 @@ module Sequel
         BOOL_TRUE
       end
 
-      # The order of clauses in the SELECT SQL statement
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
+      # Firebird can insert multiple rows using a UNION
+      def multi_insert_sql_strategy
+        :union
       end
-      
-        # Use a default FROM table if the dataset does not contain a FROM table.
-        def select_from_sql(sql)
-          if @opts[:from]
-            super
-          else
-            sql << DEFAULT_FROM
-          end
-        end
 
       def select_limit_sql(sql)
         if l = @opts[:limit]

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

@@ -25,20 +25,17 @@ module Sequel
     end
     
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where having group compounds order')
       FIRST = " FIRST ".freeze
       SKIP = " SKIP ".freeze
 
-      private
+      Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where having group compounds order')
 
       # Informix does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
+      private
 
       def select_limit_sql(sql)
         if o = @opts[:offset]

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

@@ -37,39 +37,73 @@ module Sequel
       # Execute the given stored procedure with the given name.
       #
       # Options:
-      # :args :: Array of arguments to stored procedure.  Output parameters to
-      #          the function are specified using :output.  You can also name
-      #          output parameters and provide a type by using an array containing
-      #          :output, the type name, and the parameter name.
+      # :args :: Arguments to stored procedure.  For named argumetns, this should be a
+      #          hash keyed by argument named.  For unnamed arguments, this should be an
+      #          array.  Output parameters to the function are specified using :output.
+      #          You can also name output parameters and provide a type by using an
+      #          array containing :output, the type name, and the parameter name.
       # :server :: The server/shard on which to execute the procedure.
       #
+      # This method returns a single hash with the following keys:
+      #
+      # :result :: The result code of the stored procedure
+      # :numrows :: The number of rows affected by the stored procedure
+      # output params :: Values for any output paramters, using the name given for the output parameter
+      #
       # Examples:
       #
       #     DB.call_mssql_sproc(:SequelTest, {:args => ['input arg', :output]})
       #     DB.call_mssql_sproc(:SequelTest, {:args => ['input arg', [:output, 'int', 'varname']]})
+      #
+      #     named params:
+      #     DB.call_mssql_sproc(:SequelTest, :args => {
+      #       'input_arg1_name' => 'input arg1 value',
+      #       'input_arg2_name' => 'input arg2 value',
+      #       'output_arg_name' => [:output, 'int', 'varname']
+      #     })
       def call_mssql_sproc(name, opts=OPTS)
         args = opts[:args] || []
         names = ['@RC AS RESULT', '@@ROWCOUNT AS NUMROWS']
         declarations = ['@RC int']
         values = []
 
-        args.each_with_index do |v, i|
-          if v.is_a?(Array)
-            v, type, select = v
+        if args.is_a?(Hash)
+          named_args = true
+          args = args.to_a
+          method = :each
+        else
+          method = :each_with_index
+        end
+
+        args.send(method) do |v, i|
+          if named_args
+            k = v
+            v, type, select = i
+            raise Error, "must provide output parameter name when using output parameters with named arguments" if v == :output && !select
           else
-            type = select = nil
+            v, type, select = v
           end
 
           if v == :output
-            type = "nvarchar(max)" unless type
-            varname = "var#{i}" unless varname
-            select ||= varname
+            type ||= "nvarchar(max)"
+            if named_args
+              varname = select
+            else
+              varname = "var#{i}"
+              select ||= varname
+            end
             names << "@#{varname} AS #{quote_identifier(select)}"
             declarations << "@#{varname} #{type}"
-            values << "@#{varname} OUTPUT"
+            value = "@#{varname} OUTPUT"
           else
-            values << literal(v)
+            value = literal(v)
+          end
+
+          if named_args
+            value = "@#{k}=#{value}"
           end
+
+          values << value
         end
 
         sql = "DECLARE #{declarations.join(', ')}; EXECUTE @RC = #{name} #{values.join(', ')}; SELECT #{names.join(', ')}"
@@ -159,6 +193,9 @@ module Sequel
       # SQL Server 2008 Express).
       def server_version(server=nil)
         return @server_version if @server_version
+        if @opts[:server_version]
+          return @server_version = Integer(@opts[:server_version])
+        end
         @server_version = synchronize(server) do |conn|
           (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
@@ -276,7 +313,7 @@ module Sequel
       # Commit the active transaction on the connection, does not commit/release
       # savepoints.
       def commit_transaction(conn, opts=OPTS)
-        log_connection_execute(conn, commit_transaction_sql) unless _trans(conn)[:savepoint_level] > 1
+        log_connection_execute(conn, commit_transaction_sql) unless savepoint_level(conn) > 1
       end
 
       # SQL to COMMIT a transaction.
@@ -453,16 +490,14 @@ module Sequel
     end
   
     module DatasetMethods
+      include(Module.new do
+        Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from lock join where group having order compounds')
+      end)
       include EmulateOffsetWithRowNumber
 
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with delete from output from2 where')
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with insert into columns output values')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns into from lock join where group having order compounds')
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with update limit table set output from where')
-      UPDATE_CLAUSE_METHODS_2000 = Dataset.clause_methods(:update, %w'update table set output from where')
       NOLOCK = ' WITH (NOLOCK)'.freeze
       UPDLOCK = ' WITH (UPDLOCK)'.freeze
       WILDCARD = LiteralString.new('*').freeze
@@ -484,8 +519,6 @@ module Sequel
       DATEPART_SECOND_MIDDLE = ') + datepart(ns, '.freeze
       DATEPART_SECOND_CLOSE = ")/1000000000.0) AS double precision)".freeze
       DATEPART_OPEN = "datepart(".freeze
-      UNION_ALL = ' UNION ALL '.freeze
-      SELECT_SPACE = 'SELECT '.freeze
       TIMESTAMP_USEC_FORMAT = ".%03d".freeze
       OUTPUT_INSERTED = " OUTPUT INSERTED.*".freeze
       HEX_START = '0x'.freeze
@@ -507,7 +540,11 @@ module Sequel
       ROWS_ONLY = " ROWS ONLY".freeze
       FETCH_NEXT = " FETCH NEXT ".freeze
 
-      Sequel::Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
+      Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
+      Dataset.def_sql_method(self, :delete, %w'with delete from output from2 where')
+      Dataset.def_sql_method(self, :insert, %w'with insert into columns output values')
+      Dataset.def_sql_method(self, :update, [['if is_2005_or_later?', %w'with update limit table set output from where'], ['else', %w'update table set output from where']])
+
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       attr_writer :mssql_unicode_strings
@@ -604,20 +641,6 @@ module Sequel
         clone(:into => table)
       end
 
-      # MSSQL uses a UNION ALL statement to insert multiple values at once.
-      def multi_insert_sql(columns, values)
-        c = false
-        sql = LiteralString.new('')
-        u = UNION_ALL
-        values.each do |v|
-          sql << u if c
-          sql << SELECT_SPACE
-          expression_list_append(sql, v)
-          c ||= true
-        end
-        [insert_sql(columns, sql)]
-      end
-
       # Allows you to do a dirty read of uncommitted data using WITH (NOLOCK).
       def nolock
         lock_style(:dirty)
@@ -675,6 +698,10 @@ module Sequel
         db.server_version(@opts[:server])
       end
 
+      def supports_cte?(type=:select)
+        is_2005_or_later?
+      end
+
       # MSSQL 2005+ supports GROUP BY CUBE.
       def supports_group_cube?
         is_2005_or_later?
@@ -715,6 +742,11 @@ module Sequel
         false
       end
       
+      # MSSQL 2012+ supports offsets in correlated subqueries.
+      def supports_offsets_in_correlated_subqueries?
+        is_2012_or_later?
+      end
+
       # MSSQL 2005+ supports the output clause.
       def supports_output_clause?
         is_2005_or_later?
@@ -778,12 +810,6 @@ module Sequel
         DEFAULT_TIMESTAMP_FORMAT
       end
 
-      # MSSQL supports the OUTPUT clause for DELETE statements.
-      # It also allows prepending a WITH clause.
-      def delete_clause_methods
-        DELETE_CLAUSE_METHODS
-      end
-
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
         sql << FROM
@@ -817,12 +843,6 @@ module Sequel
         sprintf(TIMESTAMP_USEC_FORMAT, usec/1000)
       end
 
-      # MSSQL supports the OUTPUT clause for INSERT statements.
-      # It also allows prepending a WITH clause.
-      def insert_clause_methods
-        INSERT_CLAUSE_METHODS
-      end
-
       # Use OUTPUT INSERTED.* to return all columns of the inserted row,
       # for use with the prepared statement code.
       def insert_output_sql(sql)
@@ -873,10 +893,10 @@ module Sequel
         BOOL_TRUE
       end
       
-      # MSSQL adds the limit before the columns, except on 2012+ when using
-      # offsets on ordered queries.
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
+      # MSSQL 2008+ supports multiple rows in the VALUES clause, older versions
+      # can use UNION.
+      def multi_insert_sql_strategy
+        is_2008_or_later? ? :values : :union
       end
 
       def select_into_sql(sql)
@@ -954,17 +974,6 @@ module Sequel
       alias delete_output_sql output_sql
       alias update_output_sql output_sql
 
-      # MSSQL supports the OUTPUT and TOP clause for UPDATE statements.
-      # It also allows prepending a WITH clause.  For MSSQL 2000
-      # and below, exclude WITH and TOP.
-      def update_clause_methods
-        if is_2005_or_later?
-          UPDATE_CLAUSE_METHODS
-        else
-          UPDATE_CLAUSE_METHODS_2000
-        end
-      end
-
       # Only include the primary table in the main update clause
       def update_table_sql(sql)
         sql << SPACE