sequel 3.21.0 → 3.28.0

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

@@ -358,6 +358,11 @@ module Sequel
         @supports_prepared_transactions = self['SHOW max_prepared_transactions'].get.to_i > 0
       end
 
+      # PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
+      def supports_create_table_if_not_exists?
+        server_version >= 90100
+      end
+
       # PostgreSQL supports savepoints
       def supports_savepoints?
         true
@@ -368,30 +373,24 @@ module Sequel
         true
       end
 
-      # Whether the given table exists in the database
+      # Array of symbols specifying table names in the current database.
+      # The dataset used is yielded to the block if one is provided,
+      # otherwise, an array of symbols of table names is returned.  
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def table_exists?(table, opts={})
-        im = input_identifier_meth
-        schema, table = schema_and_table(table)
-        opts[:schema] ||= schema
-        tables(opts){|ds| !ds.first(:relname=>im.call(table)).nil?}
+      def tables(opts={}, &block)
+        pg_class_relname('r', opts, &block)
       end
-      
-      # Array of symbols specifying table names in the current database.
-      # The dataset used is yielded to the block if one is provided,
-      # otherwise, an array of symbols of table names is returned.  
+
+      # Array of symbols specifying view names in the current database.
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def tables(opts={})
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
-        ds = filter_schema(ds, opts)
-        m = output_identifier_meth
-        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      def views(opts={})
+        pg_class_relname('v', opts)
       end
 
       private
@@ -454,11 +453,6 @@ module Sequel
         "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
       end
 
-      # Always CASCADE the table drop
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_schema_table(name)} CASCADE"
-      end
-      
       # SQL for dropping a trigger from the database.
       def drop_trigger_sql(table, name, opts={})
         "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"
@@ -540,6 +534,14 @@ module Sequel
         conn.execute(sql)
       end
       
+      # Backbone of the tables and views support.
+      def pg_class_relname(type, opts)
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
+        ds = filter_schema(ds, opts)
+        m = output_identifier_meth
+        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      end
+
       # Use a dollar sign instead of question mark for the argument
       # placeholder.
       def prepared_arg_placeholder
@@ -628,10 +630,14 @@ module Sequel
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from using where')
+      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values')
+      INSERT_CLAUSE_METHODS_82 = Dataset.clause_methods(:insert, %w'into columns values returning')
+      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with into columns values returning')
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
@@ -645,17 +651,23 @@ module Sequel
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set from where')
+      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with table set from where returning')
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
+        def run(&block)
+          if @prepared_type == :insert && supports_insert_select?
+            fetch_rows(prepared_sql){|r| return r.values.first}
+          else
+            super
+          end
+        end
+
         def prepared_sql
           return @prepared_sql if @prepared_sql
+          @opts[:returning] = insert_pk if @prepared_type == :insert && supports_insert_select?
           super
-          if @prepared_type == :insert and !@opts[:disable_insert_returning] and server_version >= 80200
-            @prepared_sql = insert_returning_pk_sql(*@prepared_modify_values)
-            meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
-          end
           @prepared_sql
         end
       end
@@ -709,25 +721,20 @@ module Sequel
       end
       
       # Insert given values into the database.
-      def insert(*values)
-        if @opts[:sql]
-          execute_insert(insert_sql(*values))
-        elsif @opts[:disable_insert_returning] || server_version < 80200
-          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
+      def insert(*values, &block)
+        if @opts[:sql] || @opts[:returning]
+          super
+        elsif supports_insert_select?
+          returning(insert_pk).insert(*values){|r| return r.values.first}
         else
-          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
+          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
         end
       end
 
-      # Use the RETURNING clause to return the columns listed in returning.
-      def insert_returning_sql(returning, *values)
-        "#{insert_sql(*values)} RETURNING #{column_list(Array(returning))}"
-      end
-
       # Insert a record returning the record inserted
       def insert_select(*values)
-        return if opts[:disable_insert_returning] || server_version < 80200
-        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
+        return unless supports_insert_select?
+        returning.insert(*values){|r| return r}
       end
 
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with
@@ -752,6 +759,12 @@ module Sequel
         [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
+      # PostgreSQL supports using the WITH clause in subqueries if it
+      # supports using WITH at all (i.e. on PostgreSQL 8.4+).
+      def supports_cte_in_subqueries?
+        supports_cte?
+      end
+
       # DISTINCT ON is a PostgreSQL extension
       def supports_distinct_on?
         true
@@ -762,6 +775,14 @@ module Sequel
         true
       end
 
+      def supports_returning?(type)
+        if type == :insert
+          server_version >= 80200 && !opts[:disable_insert_returning]
+        else
+          server_version >= 90100
+        end
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true
@@ -781,7 +802,7 @@ module Sequel
       
       # PostgreSQL allows deleting from joined datasets
       def delete_clause_methods
-        DELETE_CLAUSE_METHODS
+        server_version >= 90100 ? DELETE_CLAUSE_METHODS_91 : DELETE_CLAUSE_METHODS
       end 
 
       # Only include the primary table in the main delete clause
@@ -794,12 +815,23 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
-      # Use the RETURNING clause to return the primary key of the inserted record, if it exists
-      def insert_returning_pk_sql(*values)
+      # PostgreSQL allows a RETURNING clause.
+      def insert_clause_methods
+        if server_version >= 90100
+          INSERT_CLAUSE_METHODS_91
+        elsif server_version >= 80200
+          INSERT_CLAUSE_METHODS_82
+        else
+          INSERT_CLAUSE_METHODS
+        end
+      end
+
+      # Return the primary key to use for RETURNING in an INSERT statement
+      def insert_pk
         pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
+        pk ? Sequel::SQL::Identifier.new(pk) : NULL
       end
-      
+
       # For multiple table support, PostgreSQL requires at least
       # two from tables, with joins allowed.
       def join_from_sql(type, sql)
@@ -866,7 +898,7 @@ module Sequel
 
       # PostgreSQL splits the main table from the joined tables
       def update_clause_methods
-        UPDATE_CLAUSE_METHODS
+        server_version >= 90100 ? UPDATE_CLAUSE_METHODS_91 : UPDATE_CLAUSE_METHODS
       end
 
       # Use FROM to specify additional tables in an update query

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

@@ -7,9 +7,10 @@ module Sequel
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
-      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
+      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'".freeze
       TEMP_STORE = [:default, :file, :memory].freeze
-      
+      VIEWS_FILTER = "type = 'view'".freeze
+
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
       def alter_table(name, generator=nil, &block)
@@ -96,11 +97,29 @@ module Sequel
         end
       end
       
+      # SQLite supports CREATE TABLE IF NOT EXISTS syntax since 3.3.0.
+      def supports_create_table_if_not_exists?
+        sqlite_version >= 30300
+      end
+      
       # SQLite 3.6.8+ supports savepoints. 
       def supports_savepoints?
         sqlite_version >= 30608
       end
 
+      # Override the default setting for whether to use timezones in timestamps.
+      # For backwards compatibility, it is set to +true+ by default.
+      # Anyone wanting to use SQLite's datetime functions should set it to +false+
+      # using this method.  It's possible that the default will change in a future version,
+      # so anyone relying on timezones in timestamps should set this to +true+.
+      attr_writer :use_timestamp_timezones
+
+      # SQLite supports timezones in timestamps, since it just stores them as strings,
+      # but it breaks the usage of SQLite's datetime functions.
+      def use_timestamp_timezones?
+        defined?(@use_timestamp_timezones) ? @use_timestamp_timezones : (@use_timestamp_timezones = true)
+      end
+
       # A symbol signifying the value of the synchronous PRAGMA.
       def synchronous
         SYNCHRONOUS[pragma_get(:synchronous).to_i]
@@ -118,8 +137,7 @@ module Sequel
       # Options:
       # * :server - Set the server to use.
       def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(TABLES_FILTER).map{|r| m.call(r[:name])}
+        tables_and_views(TABLES_FILTER, opts)
       end
       
       # A symbol signifying the value of the temp_store PRAGMA.
@@ -134,6 +152,14 @@ module Sequel
         pragma_set(:temp_store, value)
       end
       
+      # Array of symbols specifying the view names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use.
+      def views(opts={})
+        tables_and_views(VIEWS_FILTER, opts)
+      end
+
       private
 
       # SQLite supports limited table modification.  You can add a column
@@ -306,6 +332,12 @@ module Sequel
         end
       end
       
+      # Backbone of the tables and views support.
+      def tables_and_views(filter, opts)
+        m = output_identifier_meth
+        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(filter).map{|r| m.call(r[:name])}
+      end
+      
       # SQLite uses the integer data type even for bignums.  This is because they
       # are both stored internally as text, and converted when returned from
       # the database.  Using an integer type instead of bigint makes it more likely
@@ -320,7 +352,8 @@ module Sequel
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
       COMMA_SEPARATOR = ', '.freeze
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
-    
+      EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}
+
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
       # ILIKE.
@@ -331,6 +364,15 @@ module Sequel
         when :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
           # SQLite is case insensitive for ASCII, and non case sensitive for other character sets
           "#{'NOT ' if [:'NOT LIKE', :'NOT ILIKE'].include?(op)}(#{literal(args.at(0))} LIKE #{literal(args.at(1))})"
+        when :^
+          a = literal(args.at(0))
+          b = literal(args.at(1))
+          "((~(#{a} & #{b})) & (#{a} | #{b}))"
+        when :extract
+          part = args.at(0)
+          raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
+          expr = args.at(1)
+          "CAST(strftime(#{format}, #{literal(expr)}) AS #{part == :second ? 'NUMERIC' : 'INTEGER'})"
         else
           super(op, args)
         end
@@ -382,11 +424,17 @@ module Sequel
       end
       
       # SQLite supports timezones in literal timestamps, since it stores them
-      # as text.
+      # as text.  But using timezones in timestamps breaks SQLite datetime
+      # functions, so we allow the user to override the default per database.
       def supports_timestamp_timezones?
-        true
+        db.use_timestamp_timezones?
       end
 
+      # SQLite cannot use WHERE 't'.
+      def supports_where_true?
+        false
+      end
+      
       private
       
       # SQLite uses string literals instead of identifiers in AS clauses.
@@ -406,7 +454,7 @@ module Sequel
         v.each_byte{|x| blob << sprintf('%02x', x)}
         "X'#{blob}'"
       end
-      
+
       # SQLite does not support the SQL WITH clause
       def select_clause_methods
         SELECT_CLAUSE_METHODS

data/lib/sequel/adapters/sqlite.rb

@@ -13,26 +13,22 @@ module Sequel
     TYPE_TRANSLATOR = tt = Class.new do
       FALSE_VALUES = %w'0 false f no n'.freeze
       def boolean(s) !FALSE_VALUES.include?(s.downcase) end
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
       def integer(s) s.to_i end
       def float(s) s.to_f end
       def numeric(s) ::BigDecimal.new(s) rescue s end
-      def date(s) ::Sequel.string_to_date(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
     end.new
 
     # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
     {
-      %w'timestamp datetime' => tt.method(:timestamp),
-      %w'date' => tt.method(:date),
-      %w'time' => tt.method(:time),
+      %w'timestamp datetime' => ::Sequel.method(:database_to_application_timestamp),
+      %w'date' => ::Sequel.method(:string_to_date),
+      %w'time' => ::Sequel.method(:string_to_time),
       %w'bit bool boolean' => tt.method(:boolean),
       %w'integer smallint mediumint int bigint' => tt.method(:integer),
       %w'numeric decimal money' => tt.method(:numeric),
       %w'float double real dec fixed' + ['double precision'] => tt.method(:float),
-      %w'blob' => tt.method(:blob)
+      %w'blob' => ::Sequel::SQL::Blob.method(:new)
     }.each do |k,v|
       k.each{|n| SQLITE_TYPES[n] = v}
     end
@@ -173,7 +169,7 @@ module Sequel
           end
         end
         unless cps
-          cps = conn.prepare(sql)
+          cps = log_yield("Preparing #{name}: #{sql}"){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
         if block
@@ -217,7 +213,7 @@ module Sequel
         # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
-          hash.each{|k,v| args[k.to_s] = v}
+          hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
           args
         end
         
@@ -226,7 +222,12 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          LiteralString.new("#{prepared_arg_placeholder}#{k}")
+          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
         end
       end
       

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

@@ -25,6 +25,15 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          log_yield(sql){conn.execute(sql)} unless opts[:auto_is_null]
+          conn
+        end
       end
       
       # Dataset class for MySQL datasets accessed via Swift.

data/lib/sequel/adapters/tinytds.rb

@@ -11,8 +11,8 @@ module Sequel
       # :dataserver and :username options.
       def connect(server)
         opts = server_opts(server)
-        opts[:dataserver] = opts[:host]
         opts[:username] = opts[:user]
+        set_mssql_unicode_strings
         TinyTds::Client.new(opts)
       end
       
@@ -32,13 +32,36 @@ module Sequel
           begin
             m = opts[:return]
             r = nil
-            log_yield(sql) do
-              r = c.execute(sql)
-              return r.send(m) if m
+            if (args = opts[:arguments]) && !args.empty?
+              types = []
+              values = []
+              args.each_with_index do |(k, v), i|
+                v, type = ps_arg_type(v)
+                types << "@#{k} #{type}"
+                values << "@#{k} = #{v}"
+              end
+              case m
+              when :do
+                sql = "#{sql}; SELECT @@ROWCOUNT AS AffectedRows"
+                single_value = true
+              when :insert
+                sql = "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+                single_value = true
+              end
+              sql = "EXEC sp_executesql N'#{c.escape(sql)}', N'#{c.escape(types.join(', '))}', #{values.join(', ')}"
+              log_yield(sql) do
+                r = c.execute(sql)
+                r.each{|row| return row.values.first} if single_value
+              end
+            else
+              log_yield(sql) do
+                r = c.execute(sql)
+                return r.send(m) if m
+              end
             end
             yield(r) if block_given?
           rescue TinyTds::Error => e
-            raise_error(e)
+            raise_error(e, :disconnect=>!c.active?)
           ensure
            r.cancel if r && c.sqlsent?
           end
@@ -74,15 +97,112 @@ module Sequel
         super
       end
 
+      # tiny_tds uses TinyTds::Error as the base error class.
+      def database_error_classes
+        [TinyTds::Error]
+      end
+
       # Close the TinyTds::Client object.
       def disconnect_connection(c)
         c.close
       end
+
+      # Return true if the :conn argument is present and not active.
+      def disconnect_error?(e, opts)
+        super || (opts[:conn] && !opts[:conn].active?)
+      end
+
+      # Return a 2 element array with the literal value and type to use
+      # in the prepared statement call for the given value and connection.
+      def ps_arg_type(v)
+        case v
+        when Fixnum
+          [v, 'int']
+        when Bignum
+          [v, 'bigint']
+        when Float
+          [v, 'double precision']
+        when Numeric
+          [v, 'numeric']
+        when Time
+          if v.is_a?(SQLTime)
+            [literal(v), 'time']
+          else
+            [literal(v), 'datetime']
+          end
+        when DateTime
+          [literal(v), 'datetime']
+        when Date
+          [literal(v), 'date']
+        when nil
+          ['NULL', 'nvarchar(max)']
+        when true
+          ['1', 'int']
+        when false
+          ['0', 'int']
+        when SQL::Blob
+          [literal(v), 'varbinary(max)']
+        else
+          [literal(v), 'nvarchar(max)']
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
       
+      # SQLite already supports named bind arguments, so use directly.
+      module ArgumentMapper
+        include Sequel::Dataset::ArgumentMapper
+        
+        protected
+        
+        # Return a hash with the same values as the given hash,
+        # but with the keys converted to strings.
+        def map_to_prepared_args(hash)
+          args = {}
+          hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
+          args
+        end
+        
+        private
+        
+        # SQLite uses a : before the name of the argument for named
+        # arguments.
+        def prepared_arg(k)
+          LiteralString.new("@#{k.to_s.gsub('.', '__')}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
+        end
+      end
+      
+      # SQLite prepared statement uses a new prepared statement each time
+      # it is called, but it does use the bind arguments.
+      module PreparedStatementMethods
+        include ArgumentMapper
+        
+        private
+        
+        # Run execute_select on the database with the given SQL and the stored
+        # bind arguments.
+        def execute(sql, opts={}, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_insert(sql, opts={}, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+      end
+      
       # Yield hashes with symbol keys, attempting to optimize for
       # various cases.
       def fetch_rows(sql)
@@ -107,18 +227,30 @@ module Sequel
                 yield r
               end
             else
-              result.each(each_opts, &block)
+              result.each(each_opts, &Proc.new)
             end
           end
         end
         self
       end
       
+      # Create a named prepared statement that is stored in the
+      # database (and connection) for reuse.
+      def prepare(type, name=nil, *values)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
+      end
+      
       private
       
       # Properly escape the given string +v+.
       def literal_string(v)
-        db.synchronize{|c| "N'#{c.escape(v)}'"}
+        s = db.synchronize{|c| "#{'N' if mssql_unicode_strings}'#{c.escape(v)}'"}
       end
     end
   end

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -0,0 +1,55 @@
+module Sequel
+  module EmulateOffsetWithRowNumber
+    # When a subselect that uses :offset is used in IN or NOT IN,
+    # use a nested subselect that only includes the first column
+    # instead of the ROW_NUMBER column added by the emulated offset support.
+    def complex_expression_sql(op, args)
+      case op
+      when :IN, :"NOT IN"
+        ds = args.at(1)
+        if ds.is_a?(Sequel::Dataset) && ds.opts[:offset]
+          c = ds.opts[:select].first
+          case c
+          when Symbol
+            t, cl, a = split_symbol(c)
+            if a
+              c = SQL::Identifier.new(a)
+            elsif t
+              c = SQL::Identifier.new(cl)
+            end
+          when SQL::AliasedExpression
+            c = SQL::Identifier.new(c.aliaz)
+          when SQL::QualifiedIdentifier
+            c = SQL::Identifier.new(c.column)
+          end
+          super(op, [args.at(0), ds.from_self.select(c)])
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    # Emulate OFFSET support with the ROW_NUMBER window function
+    # 
+    # The implementation is ugly, cloning the current dataset and modifying
+    # the clone to add a ROW_NUMBER window function (and some other things),
+    # then using the modified clone in a subselect which is selected from.
+    #
+    # If offset is used, an order must be provided, because the use of ROW_NUMBER
+    # requires an order.
+    def select_sql
+      return super unless o = @opts[:offset]
+      raise(Error, "#{db.database_type} requires an order be provided if using an offset") unless order = @opts[:order]
+      dsa1 = dataset_alias(1)
+      rn = row_number_column
+      subselect_sql(unlimited.
+        unordered.
+        select_append{ROW_NUMBER(:over, :order=>order){}.as(rn)}.
+        from_self(:alias=>dsa1).
+        limit(@opts[:limit]).
+        where(SQL::Identifier.new(rn) > o))
+    end
+  end
+end