sequel 4.9.0 → 4.10.0

data/lib/sequel/dataset/features.rb

@@ -44,7 +44,7 @@ module Sequel
     # If given, +type+ can be :select, :insert, :update, or :delete, in which case it
     # determines whether WITH is supported for the respective statement type.
     def supports_cte?(type=:select)
-      send(:"#{type}_clause_methods").include?(:"#{type}_with_sql")
+      false
     end
 
     # Whether the dataset supports common table expressions (the WITH clause)
@@ -99,6 +99,11 @@ module Sequel
     def supports_lateral_subqueries?
       false
     end
+
+    # Whether limits are supported in correlated subqueries.  True by default.
+    def supports_limits_in_correlated_subqueries?
+      true
+    end
     
     # Whether modifying joined datasets is supported.
     def supports_modifying_joins?
@@ -111,6 +116,11 @@ module Sequel
       true
     end
 
+    # Whether offsets are supported in correlated subqueries, true by default.
+    def supports_offsets_in_correlated_subqueries?
+      true
+    end
+
     # Whether the dataset supports or can fully emulate the DISTINCT ON clause,
     # including respecting the ORDER BY clause, false by default
     def supports_ordered_distinct_on?
@@ -130,7 +140,7 @@ module Sequel
     # Whether the RETURNING clause is supported for the given type of query.
     # +type+ can be :insert, :update, or :delete.
     def supports_returning?(type)
-      send(:"#{type}_clause_methods").include?(:"#{type}_returning_sql")
+      false
     end
 
     # Whether the database supports SELECT *, column FROM table

data/lib/sequel/dataset/mutation.rb

@@ -58,6 +58,7 @@ module Sequel
     # Set the method to call on identifiers going into the database for this dataset
     def identifier_input_method=(v)
       raise_if_frozen!
+      skip_symbol_cache!
       @identifier_input_method = v
     end
     
@@ -77,6 +78,7 @@ module Sequel
     # Set whether to quote identifiers for this dataset
     def quote_identifiers=(v)
       raise_if_frozen!
+      skip_symbol_cache!
       @quote_identifiers = v
     end
 

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -54,7 +54,11 @@ module Sequel
         # Record the SQL query offset, argument position, and transforming block where the
         # argument should be literalized.
         def sql_literal_append(ds, sql)
-          @recorder.use(sql, @pos, @transformer)
+          if ds.opts[:placeholder_literal_null]
+            ds.send(:literal_append, sql, nil)
+          else
+            @recorder.use(sql, @pos, @transformer)
+          end
         end
 
         # Return a new Argument object for the same recorder and argument position, but with a
@@ -74,7 +78,7 @@ module Sequel
           @argn = -1
           @args = []
           ds = yield self, dataset
-          sql = ds.sql
+          sql = ds.clone(:placeholder_literalizer=>self).sql
 
           last_offset = 0
           fragments = @args.map do |used_sql, offset, arg, t|
@@ -150,8 +154,12 @@ module Sequel
         ds = @dataset
         @fragments.each do |sql, i, transformer|
           s << sql
-          v = args.fetch(i)
-          v = transformer.call(v) if transformer
+          if i.is_a?(Integer)
+            v = args.fetch(i)
+            v = transformer.call(v) if transformer
+          else
+            v = i.call
+          end
           ds.literal_append(s, v)
         end
         if sql = @final_sql

data/lib/sequel/dataset/prepared_statements.rb

@@ -165,6 +165,12 @@ module Sequel
         @opts[:bind_vars].has_key?(k)
       end
 
+      # The symbol cache should always be skipped, since placeholders
+      # are symbols.
+      def skip_symbol_cache?
+        true
+      end
+
       # Use a clone of the dataset extended with prepared statement
       # support and using the same argument hash so that you can use
       # bind variables/prepared arguments in subselects.

data/lib/sequel/dataset/query.rb

@@ -892,7 +892,7 @@ module Sequel
     #   DB[:items].with(:items, DB[:syx].where(:name.like('A%')))
     #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%')) SELECT * FROM items
     def with(name, dataset, opts=OPTS)
-      raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
+      raise(Error, 'This dataset does not support common table expressions') unless supports_cte?
       if hoist_cte?(dataset)
         s, ds = hoist_cte(dataset)
         s.with(name, ds, opts)

data/lib/sequel/dataset/sql.rb

@@ -5,16 +5,6 @@ module Sequel
     # These are methods you can call to see what SQL will be generated by the dataset.
     # ---------------------
     
-    # Returns a DELETE SQL query string.  See +delete+.
-    # 
-    #   dataset.filter{|o| o.price >= 100}.delete_sql
-    #   # => "DELETE FROM items WHERE (price >= 100)"
-    def delete_sql
-      return static_sql(opts[:sql]) if opts[:sql]
-      check_modification_allowed!
-      clause_sql(:delete)
-    end
-    
     # Returns an EXISTS clause for the dataset as a +LiteralString+.
     #
     #   DB.select(1).where(DB[:items].exists)
@@ -59,7 +49,7 @@ module Sequel
         columns = [columns().last]
         values = [DEFAULT]
       end
-      clone(:columns=>columns, :values=>values)._insert_sql
+      clone(:columns=>columns, :values=>values).send(:_insert_sql)
     end
     
     # Append a literal representation of a value to the given SQL string.
@@ -68,7 +58,16 @@ module Sequel
     def literal_append(sql, v)
       case v
       when Symbol
-        literal_symbol_append(sql, v)
+        if skip_symbol_cache?
+          literal_symbol_append(sql, v)
+        else 
+          unless l = db.literal_symbol(v)
+            l = ''
+            literal_symbol_append(l, v)
+            db.literal_symbol_set(v, l)
+          end
+          sql << l
+        end
       when String
         case v
         when LiteralString
@@ -116,17 +115,32 @@ module Sequel
     # This method should be overridden by descendants if the support
     # inserting multiple records in a single SQL statement.
     def multi_insert_sql(columns, values)
-      values.map{|r| insert_sql(columns, r)}
+      case multi_insert_sql_strategy
+      when :values
+        sql = LiteralString.new('VALUES ')
+        expression_list_append(sql, values.map{|r| Array(r)})
+        [insert_sql(columns, sql)]
+      when :union
+        c = false
+        sql = LiteralString.new('')
+        u = UNION_ALL_SELECT
+        f = empty_from_sql
+        values.each do |v|
+          if c
+            sql << u
+          else
+            sql << SELECT << SPACE
+            c = true
+          end
+          expression_list_append(sql, v)
+          sql << f if f
+        end
+        [insert_sql(columns, sql)]
+      else
+        values.map{|r| insert_sql(columns, r)}
+      end
     end
     
-    # Returns a SELECT SQL query string.
-    #
-    #   dataset.select_sql # => "SELECT * FROM items"
-    def select_sql
-      return static_sql(@opts[:sql]) if @opts[:sql]
-      clause_sql(:select)
-    end
-
     # Same as +select_sql+, not aliased directly to make subclassing simpler.
     def sql
       select_sql
@@ -157,7 +171,7 @@ module Sequel
     def update_sql(values = OPTS)
       return static_sql(opts[:sql]) if opts[:sql]
       check_modification_allowed!
-      clone(:values=>values)._update_sql
+      clone(:values=>values).send(:_update_sql)
     end
     
     # ---------------------
@@ -171,6 +185,47 @@ module Sequel
       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
     end
 
+    # Define a dataset literalization method for the given type in the given module,
+    # using the given clauses.
+    #
+    # Arguments:
+    # mod :: Module in which to define method
+    # type :: Type of SQL literalization method to create, either :select, :insert, :update, or :delete
+    # clauses :: array of clauses that make up the SQL query for the type.  This can either be a single
+    #            array of symbols/strings, or it can be an array of pairs, with the first element in
+    #            each pair being an if/elsif/else code fragment, and the second element in each pair
+    #            being an array of symbol/strings for the appropriate branch.
+    def self.def_sql_method(mod, type, clauses)
+      priv = type == :update || type == :insert
+
+      lines = []
+      lines << 'private' if priv
+      lines << "def #{'_' if priv}#{type}_sql"
+      lines << 'if sql = opts[:sql]; return static_sql(sql) end' unless priv
+      lines << 'check_modification_allowed!' if type == :delete
+      lines << 'sql = @opts[:append_sql] || sql_string_origin'
+
+      if clauses.all?{|c| c.is_a?(Array)}
+        clauses.each do |i, cs|
+          lines << i
+          lines.concat(clause_methods(type, cs).map{|x| "#{x}(sql)"}) 
+        end 
+        lines << 'end'
+      else
+        lines.concat(clause_methods(type, clauses).map{|x| "#{x}(sql)"})
+      end
+
+      lines << 'sql'
+      lines << 'end'
+
+      mod.class_eval lines.join("\n"), __FILE__, __LINE__
+    end
+
+    def_sql_method(self, :delete, %w'delete from where')
+    def_sql_method(self, :insert, %w'insert into columns values')
+    def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order limit lock')
+    def_sql_method(self, :update, %w'update table set where')
+
     # Map of emulated function names to native function names.
     EMULATED_FUNCTION_MAP = {}
 
@@ -210,7 +265,6 @@ module Sequel
     DEFAULT = LiteralString.new('DEFAULT').freeze
     DEFAULT_VALUES = " DEFAULT VALUES".freeze
     DELETE = 'DELETE'.freeze
-    DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'delete from where')
     DESC = ' DESC'.freeze
     DISTINCT = " DISTINCT".freeze
     DOT = '.'.freeze
@@ -234,7 +288,6 @@ module Sequel
     GROUP_BY = " GROUP BY ".freeze
     HAVING = " HAVING ".freeze
     INSERT = "INSERT".freeze
-    INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'insert into columns values')
     INTO = " INTO ".freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
@@ -263,7 +316,6 @@ module Sequel
     QUOTE_RE = /"/.freeze
     RETURNING = " RETURNING ".freeze
     SELECT = 'SELECT'.freeze
-    SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with select distinct columns from join where group having compounds order limit lock')
     SET = ' SET '.freeze
     SPACE = ' '.freeze
     SQL_WITH = "WITH ".freeze
@@ -275,8 +327,8 @@ module Sequel
     REGEXP_OPERATORS = ::Sequel::SQL::ComplexExpression::REGEXP_OPERATORS
     UNDERSCORE = '_'.freeze
     UPDATE = 'UPDATE'.freeze
-    UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'update table set where')
     USING = ' USING ('.freeze
+    UNION_ALL_SELECT = ' UNION ALL SELECT '.freeze
     VALUES = " VALUES ".freeze
     V190 = '1.9.0'.freeze
     WHERE = " WHERE ".freeze
@@ -463,7 +515,11 @@ module Sequel
     # Append literalization of delayed evaluation to SQL string,
     # causing the delayed evaluation proc to be evaluated.
     def delayed_evaluation_sql_append(sql, callable)
-      literal_append(sql, callable.call)
+      if recorder = @opts[:placeholder_literalizer]
+        recorder.use(sql, callable, nil)
+      else
+        literal_append(sql, callable.call)
+      end
     end
 
     # Append literalization of emulated function call to SQL string.
@@ -718,16 +774,6 @@ module Sequel
 
     protected
 
-    # Formats in INSERT statement using the stored columns and values.
-    def _insert_sql
-      clause_sql(:insert)
-    end
-
-    # Formats an UPDATE statement using the stored values.
-    def _update_sql
-      clause_sql(:update)
-    end
-
     # Return a from_self dataset if an order or limit is specified, so it works as expected
     # with UNION, EXCEPT, and INTERSECT clauses.
     def compound_from_self
@@ -828,13 +874,6 @@ module Sequel
       check_modification_allowed!
     end
 
-    # Prepare an SQL statement by calling all clause methods for the given statement type.
-    def clause_sql(type)
-      sql = @opts[:append_sql] || sql_string_origin
-      send("#{type}_clause_methods").each{|x| send(x, sql)}
-      sql
-    end
-
     # Append column list to SQL string.
     # Converts an array of column names into a comma seperated string of 
     # column names. If the array is empty, a wildcard (*) is returned.
@@ -904,15 +943,23 @@ module Sequel
       requires_sql_standard_datetimes? ? STANDARD_TIMESTAMP_FORMAT : TIMESTAMP_FORMAT
     end
 
-    # The order of methods to call to build the DELETE SQL statement
-    def delete_clause_methods
-      DELETE_CLAUSE_METHODS
-    end
-
     def delete_delete_sql(sql)
       sql << DELETE
     end
 
+    def delete_from_sql(sql)
+      if f = @opts[:from]
+        sql << FROM
+        source_list_append(sql, f)
+      end
+    end
+
+    # An SQL FROM clause to use in SELECT statements where the dataset has
+    # no from tables.
+    def empty_from_sql
+      nil
+    end
+
     # Append literalization of array of expressions to SQL string.
     def expression_list_append(sql, columns)
       c = false
@@ -1001,11 +1048,6 @@ module Sequel
       source_list_append(sql, @opts[:from])
     end
 
-    # The order of methods to call to build the INSERT SQL statement
-    def insert_clause_methods
-      INSERT_CLAUSE_METHODS
-    end
-
     def insert_columns_sql(sql)
       columns = opts[:columns]
       if columns && !columns.empty?
@@ -1191,6 +1233,14 @@ module Sequel
       BOOL_TRUE
     end
 
+    # What strategy to use for import/multi_insert.  While SQL-92 defaults
+    # to allowing multiple rows in a VALUES clause, there are enough databases
+    # that don't allow that that it can't be the default.  Use separate queries
+    # by default, which works everywhere.
+    def multi_insert_sql_strategy
+      :separate
+    end
+
     # Get the native function name given the emulated function name.
     def native_function_name(emulated_function)
       self.class.const_get(:EMULATED_FUNCTION_MAP).fetch(emulated_function, emulated_function)
@@ -1222,11 +1272,6 @@ module Sequel
       Qualifier.new(self, table).transform(e)
     end
 
-    # The order of methods to call to build the SELECT SQL statement
-    def select_clause_methods
-      SELECT_CLAUSE_METHODS
-    end
-
     def select_columns_sql(sql)
       sql << SPACE
       column_list_append(sql, @opts[:select])
@@ -1260,9 +1305,10 @@ module Sequel
       if f = @opts[:from]
         sql << FROM
         source_list_append(sql, f)
+      elsif f = empty_from_sql
+        sql << f
       end
     end
-    alias delete_from_sql select_from_sql
 
     def select_group_sql(sql)
       if group = @opts[:group]
@@ -1299,13 +1345,15 @@ module Sequel
       if l = @opts[:limit]
         sql << LIMIT
         literal_append(sql, l)
-      end
-      if o = @opts[:offset]
-        sql << OFFSET
-        literal_append(sql, o)
+        if o = @opts[:offset]
+          sql << OFFSET
+          literal_append(sql, o)
+        end
+      elsif @opts[:offset]
+        select_only_offset_sql(sql)
       end
     end
-  
+
     def select_lock_sql(sql)
       case l = @opts[:lock]
       when :update
@@ -1315,6 +1363,14 @@ module Sequel
       end
     end
 
+    # Used only if there is an offset and no limit, making it easier to override
+    # in the adapter, as many databases do not support just a plain offset with
+    # no limit.
+    def select_only_offset_sql(sql)
+      sql << OFFSET
+      literal_append(sql, @opts[:offset])
+    end
+  
     def select_order_sql(sql)
       if o = @opts[:order]
         sql << ORDER_BY
@@ -1338,6 +1394,7 @@ module Sequel
     alias update_where_sql select_where_sql
     
     def select_with_sql(sql)
+      return unless supports_cte?
       ws = opts[:with]
       return if !ws || ws.empty?
       sql << select_with_sql_base
@@ -1366,6 +1423,16 @@ module Sequel
       SQL_WITH
     end
 
+    # Whether the symbol cache should be skipped when literalizing the dataset
+    def skip_symbol_cache?
+      @skip_symbol_cache
+    end
+
+    # Set the dataset to skip the symbol cache
+    def skip_symbol_cache!
+      @skip_symbol_cache = true
+    end
+
     # Append literalization of array of sources/tables to SQL string, raising an Error if there
     # are no sources.
     def source_list_append(sql, sources)
@@ -1409,11 +1476,6 @@ module Sequel
       ds.clone(:append_sql=>sql).sql
     end
 
-    # The order of methods to call to build the UPDATE SQL statement
-    def update_clause_methods
-      UPDATE_CLAUSE_METHODS
-    end
-
     def update_table_sql(sql)
       sql << SPACE
       source_list_append(sql, @opts[:from])