sequel 3.27.0 → 3.28.0

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

@@ -10,7 +10,7 @@ module Sequel
       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)
@@ -107,6 +107,19 @@ module Sequel
         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]
@@ -339,23 +352,7 @@ 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}
-
-      # Ugly hack.  Really, SQLite uses 0 for false and 1 for true
-      # but then you can't differentiate between integers and booleans.
-      # In filters, SQL::BooleanConstants are used more, while in other places
-      # the ruby true/false values are used more, so use 1/0 for SQL::BooleanConstants.
-      # The correct fix for this would require separate literalization paths for
-      # filters compared to other values, but that's more work than I want to do right now.
-      def boolean_constant_sql(constant)
-        case constant
-        when true
-          '1'
-        when false
-          '0'
-        else
-          super
-        end
-      end
+      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
@@ -367,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
@@ -418,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.
@@ -431,22 +443,6 @@ module Sequel
         "#{expression} AS #{literal(aliaz.to_s)}"
       end
       
-      # Special case when true or false is provided directly to filter.
-      def filter_expr(expr)
-        if block_given?
-          super
-        else
-          case expr
-          when true
-            1
-          when false
-            0
-          else
-            super
-          end
-        end
-      end
-      
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)

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

data/lib/sequel/adapters/tinytds.rb

@@ -124,9 +124,13 @@ module Sequel
           [v, 'double precision']
         when Numeric
           [v, 'numeric']
-        when SQLTime
-          [literal(v), 'time']
-        when DateTime, Time
+        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']

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

data/lib/sequel/core.rb

@@ -188,7 +188,7 @@ module Sequel
   # This is used to ensure that the files loaded are from the same version of
   # Sequel as this file.
   def self.require(files, subdir=nil)
-    Array(files).each{|f| super("#{File.dirname(__FILE__)}/#{"#{subdir}/" if subdir}#{f}")}
+    Array(files).each{|f| super("#{File.dirname(__FILE__).untaint}/#{"#{subdir}/" if subdir}#{f}")}
   end
   
   # Set whether to set the single threaded mode for all databases by default. By default,

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite db2 dbi do firebird informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite db2 dbi do firebird ibmdb informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
 
     # Whether to use the single threaded connection pool by default
     @@single_threaded = false

data/lib/sequel/database/misc.rb

@@ -275,15 +275,16 @@ module Sequel
     # Typecast the value to a Time
     def typecast_value_time(value)
       case value
-      when SQLTime
-        value
       when Time
-        SQLTime.local(value.year, value.month, value.day, value.hour, value.min, value.sec, value.respond_to?(:nsec) ? value.nsec : value.usec)
+        if value.is_a?(SQLTime)
+          value
+        else
+          SQLTime.create(value.hour, value.min, value.sec, value.respond_to?(:nsec) ? value.nsec/1000.0 : value.usec)
+        end
       when String
         Sequel.string_to_time(value)
       when Hash
-        t = Time.now
-        SQLTime.local(t.year, t.month, t.day, *[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.create(*[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end

data/lib/sequel/database/query.rb

@@ -471,7 +471,7 @@ module Sequel
         :float
       when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+)\))?)|(?:small)?money)\z/io
         $1 && $1 == '0' ? :integer : :decimal
-      when /bytea|blob|image|(var)?binary/io
+      when /bytea|[bc]lob|image|(var)?binary/io
         :blob
       when /\Aenum/io
         :enum

data/lib/sequel/database/schema_generator.rb

@@ -86,7 +86,8 @@ module Sequel
       # :index :: Create an index on this column.
       # :key :: For foreign key columns, the column in the associated table
       #         that this column references.  Unnecessary if this column
-      #         references the primary key of the associated table.
+      #         references the primary key of the associated table, except if you are
+      #         using MySQL.
       # :null :: Mark the column as allowing NULL values (if true),
       #          or not allowing NULL values (if false).  If unspecified, will default
       #          to whatever the database default is.

data/lib/sequel/dataset/actions.rb

@@ -101,10 +101,15 @@ module Sequel
     #
     #   DB[:table].delete # DELETE * FROM table
     #   # => 3
-    def delete
-      execute_dui(delete_sql)
+    def delete(&block)
+      sql = delete_sql
+      if uses_returning?(:delete)
+        returning_fetch_rows(sql, &block)
+      else
+        execute_dui(sql)
+      end
     end
-    
+
     # Iterates over the records in the dataset as they are yielded from the
     # database adapter, and returns self.
     #
@@ -279,8 +284,13 @@ module Sequel
     #
     #   DB[:items].insert([:a, :b], DB[:old_items])
     #   # INSERT INTO items (a, b) SELECT * FROM old_items
-    def insert(*values)
-      execute_insert(insert_sql(*values))
+    def insert(*values, &block)
+      sql = insert_sql(*values)
+      if uses_returning?(:insert)
+        returning_fetch_rows(sql, &block)
+      else
+        execute_insert(sql)
+      end
     end
     
     # Inserts multiple values. If a block is given it is invoked for each
@@ -336,10 +346,19 @@ module Sequel
     #
     #   DB[:table].map{|r| r[:id] * 2} # SELECT * FROM table
     #   # => [2, 4, 6, ...]
+    #
+    # You can also provide an array of column names:
+    #
+    #   DB[:table].map([:id, :name]) # SELECT * FROM table
+    #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def map(column=nil, &block)
       if column
         raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        super(){|r| r[column]}
+        if column.is_a?(Array)
+          super(){|r| column.map{|c| r[c]}}
+        else
+          super(){|r| r[column]}
+        end
       else
         super(&block)
       end
@@ -395,8 +414,24 @@ module Sequel
     #
     #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
+    #
+    # You can also provide an array of column names for either the key_column,
+    # the value column, or both:
+    #
+    #   DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
+    #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
     def select_hash(key_column, value_column)
-      select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
+      if key_column.is_a?(Array)
+        if value_column.is_a?(Array)
+          select(*(key_column + value_column)).to_hash(key_column.map{|c| hash_key_symbol(c)}, value_column.map{|c| hash_key_symbol(c)})
+        else
+          select(*(key_column + [value_column])).to_hash(key_column.map{|c| hash_key_symbol(c)}, hash_key_symbol(value_column))
+        end
+      elsif value_column.is_a?(Array)
+        select(key_column, *value_column).to_hash(hash_key_symbol(key_column), value_column.map{|c| hash_key_symbol(c)})
+      else
+        select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
+      end
     end
     
     # Selects the column given (either as an argument or as a block), and
@@ -410,35 +445,32 @@ module Sequel
     #
     #   DB[:table].select_map{id * 2} # SELECT (id * 2) FROM table
     #   # => [6, 10, 16, 2, ...]
+    #
+    # You can also provide an array of column names:
+    #
+    #   DB[:table].select_map([:id, :name]) # SELECT id, name FROM table
+    #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def select_map(column=nil, &block)
-      ds = naked.ungraphed
-      ds = if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        ds.select(column)
-      else
-        ds.select(&block)
-      end
-      ds.map{|r| r.values.first}
+      _select_map(column, false, &block)
     end
+
     
     # The same as select_map, but in addition orders the array by the column.
     #
     #   DB[:table].select_order_map(:id) # SELECT id FROM table ORDER BY id
     #   # => [1, 2, 3, 4, ...]
     #
-    #   DB[:table].select_order_map{abs(id)} # SELECT (id * 2) FROM table ORDER BY (id * 2)
+    #   DB[:table].select_order_map{id * 2} # SELECT (id * 2) FROM table ORDER BY (id * 2)
     #   # => [2, 4, 6, 8, ...]
+    #
+    # You can also provide an array of column names:
+    #
+    #   DB[:table].select_order_map([:id, :name]) # SELECT id, name FROM table ORDER BY id, name
+    #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
     def select_order_map(column=nil, &block)
-      ds = naked.ungraphed
-      ds = if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        ds.select(column).order(unaliased_identifier(column))
-      else
-        ds.select(&block).order(&block)
-      end
-      ds.map{|r| r.values.first}
+      _select_map(column, true, &block)
     end
-  
+
     # Alias for update, but not aliased directly so subclasses
     # don't have to override both methods.
     def set(*args)
@@ -502,11 +534,37 @@ module Sequel
     #
     #   DB[:table].to_hash(:id) # SELECT * FROM table
     #   # {1=>{:id=>1, :name=>'Jim'}, 2=>{:id=>2, :name=>'Bob'}, ...}
+    #
+    # You can also provide an array of column names for either the key_column,
+    # the value column, or both:
+    #
+    #   DB[:table].to_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
+    #   # {[1, 3]=>['Jim', 'bo'], [2, 4]=>['Bob', 'be'], ...}
+    #
+    #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
+    #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob'=>{:id=>2, :name=>'Bob'}, ...}
     def to_hash(key_column, value_column = nil)
-      inject({}) do |m, r|
-        m[r[key_column]] = value_column ? r[value_column] : r
-        m
+      h = {}
+      if value_column
+        if value_column.is_a?(Array)
+          if key_column.is_a?(Array)
+            each{|r| h[key_column.map{|c| r[c]}] = value_column.map{|c| r[c]}}
+          else
+            each{|r| h[r[key_column]] = value_column.map{|c| r[c]}}
+          end
+        else
+          if key_column.is_a?(Array)
+            each{|r| h[key_column.map{|c| r[c]}] = r[value_column]}
+          else
+            each{|r| h[r[key_column]] = r[value_column]}
+          end
+        end
+      elsif key_column.is_a?(Array)
+        each{|r| h[key_column.map{|c| r[c]}] = r}
+      else
+        each{|r| h[r[key_column]] = r}
       end
+      h
     end
 
     # Truncates the dataset.  Returns nil.
@@ -527,12 +585,38 @@ module Sequel
     #
     #   DB[:table].update(:x=>:x+1, :y=>0) # UPDATE table SET x = (x + 1), y = 0
     #   # => 10
-    def update(values={})
-      execute_dui(update_sql(values))
+    def update(values={}, &block)
+      sql = update_sql(values)
+      if uses_returning?(:update)
+        returning_fetch_rows(sql, &block)
+      else
+        execute_dui(sql)
+      end
     end
 
     private
     
+    # Internals of +select_map+ and +select_order_map+
+    def _select_map(column, order, &block)
+      ds = naked.ungraphed
+      if column
+        raise(Error, ARG_BLOCK_ERROR_MSG) if block
+        columns = Array(column)
+        select_cols = order ? columns.map{|c| c.is_a?(SQL::OrderedExpression) ? c.expression : c} : columns
+        ds = ds.select(*select_cols)
+        ds = ds.order(*columns.map{|c| unaliased_identifier(c)}) if order
+      else
+        ds = ds.select(&block)
+        ds = ds.order(&block) if order
+      end
+      if ds.opts[:select].length > 1
+        ret_cols = select_cols.map{|c| hash_key_symbol(c)}
+        ds.map{|r| ret_cols.map{|c| r[c]}}
+      else
+        ds.map{|r| r.values.first}
+      end
+    end
+  
     # Set the server to use to :default unless it is already set in the passed opts
     def default_server_opts(opts)
       {:server=>@opts[:server] || :default}.merge(opts)
@@ -564,9 +648,19 @@ module Sequel
     # specifying the symbol that is likely to be used as the hash key
     # for the column when records are returned.
     def hash_key_symbol(s)
-      raise(Error, "#{s.inspect} is not a symbol") unless s.is_a?(Symbol)
-      _, c, a = split_symbol(s)
-      (a || c).to_sym
+      case s
+      when Symbol
+        _, c, a = split_symbol(s)
+        (a || c).to_sym
+      when SQL::Identifier
+        hash_key_symbol(s.value)
+      when SQL::QualifiedIdentifier
+        hash_key_symbol(s.column)
+      when SQL::AliasedExpression
+        hash_key_symbol(s.aliaz)
+      else
+        raise(Error, "#{s.inspect} is not supported, should be a Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression") 
+      end
     end
     
     # Modify the identifier returned from the database based on the
@@ -583,6 +677,20 @@ module Sequel
     def post_load(all_records)
     end
 
+    # Called by insert/update/delete when returning is used.
+    # Yields each row as a plain hash to the block if one is given, or returns
+    # an array of plain hashes for all rows if a block is not given
+    def returning_fetch_rows(sql, &block)
+      if block
+        default_server.fetch_rows(sql, &block)
+        nil
+      else
+        rows = []
+        default_server.fetch_rows(sql){|r| rows << r}
+        rows
+      end
+    end
+    
     # Return the unaliased part of the identifier.  Handles both
     # implicit aliases in symbols, as well as SQL::AliasedExpression
     # objects.  Other objects are returned as is.
@@ -593,6 +701,14 @@ module Sequel
         c_table ? SQL::QualifiedIdentifier.new(c_table, column.to_sym) : column.to_sym
       when SQL::AliasedExpression
         c.expression
+      when SQL::OrderedExpression
+        expr = c.expression
+        if expr.is_a?(Symbol)
+          expr = unaliased_identifier(expr)
+          SQL::OrderedExpression.new(unaliased_identifier(c.expression), c.descending, :nulls=>c.nulls)
+        else
+          c
+        end
       else
         c
       end