sequel 5.8.0 → 5.38.0

data/lib/sequel/dataset/features.rb

@@ -178,11 +178,29 @@ module Sequel
       true
     end
     
+    # Whether the dataset supports the WINDOW clause to define windows used by multiple
+    # window functions, false by default.
+    def supports_window_clause?
+      false
+    end
+
     # Whether the dataset supports window functions, false by default.
     def supports_window_functions?
       false
     end
     
+    # Whether the dataset supports the given window function option.  True by default.
+    # This should only be called if supports_window_functions? is true. Possible options
+    # are :rows, :range, :groups, :offset, :exclude.
+    def supports_window_function_frame_option?(option)
+      case option
+      when :rows, :range, :offset
+        true
+      else
+        false
+      end
+    end
+    
     # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
     # that use 1 for true), true by default.
     def supports_where_true?
@@ -197,11 +215,27 @@ module Sequel
       true
     end
 
+    # Whether the dataset needs ESCAPE for LIKE for correct behavior.
+    def requires_like_escape?
+      true
+    end
+
+    # Whether ORDER BY col NULLS FIRST/LAST must be emulated.
+    def requires_emulating_nulls_first?
+      false
+    end
+
     # Whether common table expressions are supported in UNION/INTERSECT/EXCEPT clauses.
     def supports_cte_in_compounds?
       supports_cte_in_subqueries?
     end
 
+    # Whether the dataset supports the FILTER clause for aggregate functions.
+    # If not, support is emulated using CASE.
+    def supports_filtered_aggregates?
+      false
+    end
+
     # Whether the database supports quoting function names.
     def supports_quoted_function_names?
       false

data/lib/sequel/dataset/graph.rb

@@ -21,7 +21,7 @@ module Sequel
         raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
       end
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select_append(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>Hash[ga].merge!(graph_aliases).freeze).freeze)
+      select_append(*columns).clone(:graph => graph.merge(:column_aliases=>ga.merge(graph_aliases).freeze).freeze)
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -96,10 +96,30 @@ module Sequel
       
       table_alias_qualifier = qualifier_from_alias_symbol(table_alias, table)
       implicit_qualifier = options[:implicit_qualifier]
+      joined_dataset = joined_dataset?
       ds = self
+      graph = opts[:graph]
+
+      if !graph && (select = @opts[:select]) && !select.empty?
+        select_columns = nil
+
+        unless !joined_dataset && select.length == 1 && (select[0].is_a?(SQL::ColumnAll))
+          force_from_self = false
+          select_columns = select.map do |sel|
+            unless col = _hash_key_symbol(sel)
+              force_from_self = true
+              break
+            end
+
+            [sel, col]
+          end
+
+          select_columns = nil if force_from_self
+        end
+      end
 
       # Use a from_self if this is already a joined table (or from_self specifically disabled for graphs)
-      if (@opts[:graph_from_self] != false && !@opts[:graph] && joined_dataset?)
+      if (@opts[:graph_from_self] != false && !graph && (joined_dataset || force_from_self))
         from_selfed = true
         implicit_qualifier = options[:from_self_alias] || first_source
         ds = ds.from_self(:alias=>implicit_qualifier)
@@ -115,7 +135,7 @@ module Sequel
       # Whether to include the table in the result set
       add_table = options[:select] == false ? false : true
 
-      if graph = opts[:graph]
+      if graph
         graph = graph.dup
         select = opts[:select].dup
         [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
@@ -137,12 +157,8 @@ module Sequel
         # Keep track of the alias numbers used
         ca_num = graph[:column_alias_num] = Hash.new(0)
 
-        # All columns in the master table are never
-        # aliased, but are not included if set_graph_aliases
-        # has been used.
-        if (select = @opts[:select]) && !select.empty? && !(select.length == 1 && (select.first.is_a?(SQL::ColumnAll)))
-          select = select.map do |sel|
-            raise Error, "can't figure out alias to use for graphing for #{sel.inspect}" unless column = _hash_key_symbol(sel)
+        select = if select_columns
+          select_columns.map do |sel, column|
             column_aliases[column] = [master, column]
             if from_selfed
               # Initial dataset was wrapped in subselect, selected all
@@ -155,7 +171,7 @@ module Sequel
             end
           end
         else
-          select = columns.map do |column|
+          columns.map do |column|
             column_aliases[column] = [master, column]
             SQL::QualifiedIdentifier.new(qualifier, column)
           end
@@ -228,7 +244,7 @@ module Sequel
     def set_graph_aliases(graph_aliases)
       columns, graph_aliases = graph_alias_columns(graph_aliases)
       if graph = opts[:graph]
-        select(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>graph_aliases.freeze).freeze)
+        select(*columns).clone(:graph => graph.merge(:column_aliases=>graph_aliases.freeze).freeze)
       else
         raise Error, "cannot call #set_graph_aliases on an ungraphed dataset"
       end

data/lib/sequel/dataset/misc.rb

@@ -226,7 +226,7 @@ module Sequel
       used_aliases += opts[:join].map{|j| j.table_alias ? alias_alias_symbol(j.table_alias) : alias_symbol(j.table)} if opts[:join]
       if used_aliases.include?(table_alias)
         i = 0
-        loop do
+        while true
           ta = :"#{table_alias}_#{i}"
           return ta unless used_aliases.include?(ta)
           i += 1 
@@ -309,13 +309,27 @@ module Sequel
       loader
     end
 
+    # Return a cached placeholder literalizer for the key, unless where_block is
+    # nil and where_args is an empty array or hash.  This is designed to guard
+    # against placeholder literalizer use when passing arguments to where
+    # in the uncached case and filter_expr if a cached placeholder literalizer
+    # is used.
+    def cached_where_placeholder_literalizer(where_args, where_block, key, &block)
+      where_args = where_args[0] if where_args.length == 1
+      unless where_block
+        return if where_args == OPTS || where_args == EMPTY_ARRAY
+      end
+
+      cached_placeholder_literalizer(key, &block)
+    end
+
     # Set the columns for the current dataset.
     def columns=(v)
       cache_set(:_columns, v)
     end
 
     # Set the db, opts, and cache for the copy of the dataset.
-    def initialize_copy(c)
+    def initialize_clone(c, _=nil)
       @db = c.db
       @opts = Hash[c.opts]
       if cols = c.cache_get(:_columns)
@@ -324,7 +338,7 @@ module Sequel
         @cache = {}
       end
     end
-    alias initialize_clone initialize_copy
+    alias initialize_copy initialize_clone
 
     # Internal recursive version of unqualified_column_for, handling Strings inside
     # of other objects.

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -77,23 +77,8 @@ module Sequel
         # Yields the receiver and the dataset to the block, which should
         # call #arg on the receiver for each placeholder argument, and
         # return the dataset that you want to load.
-        def loader(dataset)
-          @argn = -1
-          @args = []
-          ds = yield self, dataset
-          sql = ds.clone(:placeholder_literalizer=>self).sql
-
-          last_offset = 0
-          fragments = @args.map do |used_sql, offset, arg, t|
-            raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
-            a = [sql[last_offset...offset], arg, t]
-            last_offset = offset
-            a
-          end
-          final_sql = sql[last_offset..-1]
-
-          arity = @argn+1
-          PlaceholderLiteralizer.new(ds.clone, fragments, final_sql, arity)
+        def loader(dataset, &block)
+          PlaceholderLiteralizer.new(*process(dataset, &block))
         end
 
         # Return an Argument with the specified position, or the next position. In
@@ -111,6 +96,49 @@ module Sequel
         def use(sql, arg, transformer)
           @args << [sql, sql.length, arg, transformer]
         end
+
+        private
+
+        # Return an array with two elements, the first being an
+        # SQL string with interpolated prepared argument placeholders
+        # (suitable for inspect), the the second being an array of
+        # SQL fragments suitable for using for creating a 
+        # Sequel::SQL::PlaceholderLiteralString. Designed for use with
+        # emulated prepared statements.
+        def prepared_sql_and_frags(dataset, prepared_args, &block)
+          _, frags, final_sql, _ = process(dataset, &block)
+
+          frags = frags.map(&:first)
+          prepared_sql = String.new
+          frags.each_with_index do |sql, i|
+            prepared_sql << sql
+            prepared_sql << "$#{prepared_args[i]}"
+          end
+          frags << final_sql
+          prepared_sql << final_sql
+
+          [prepared_sql, frags]
+        end
+
+        # Internals of #loader and #prepared_sql_and_frags.
+        def process(dataset)
+          @argn = -1
+          @args = []
+          ds = yield self, dataset
+          sql = ds.clone(:placeholder_literalizer=>self).sql
+
+          last_offset = 0
+          fragments = @args.map do |used_sql, offset, arg, t|
+            raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
+            a = [sql[last_offset...offset], arg, t]
+            last_offset = offset
+            a
+          end
+          final_sql = sql[last_offset..-1]
+
+          arity = @argn+1
+          [ds, fragments, final_sql, arity]
+        end
       end
 
       # Create a PlaceholderLiteralizer by yielding a Recorder and dataset to the
@@ -140,7 +168,10 @@ module Sequel
       # receiver's dataset to the block, and the block should return the new dataset
       # to use.
       def with_dataset
-        dup.instance_exec{@dataset = yield @dataset; self}.freeze
+        dataset = yield @dataset
+        other = dup
+        other.instance_variable_set(:@dataset, dataset)
+        other.freeze
       end
 
       # Return an array of all objects by running the SQL query for the given arguments.
@@ -180,9 +211,7 @@ module Sequel
           end
           ds.literal_append(s, v)
         end
-        if sql = @final_sql
-          s << sql
-        end
+        s << @final_sql
         s
       end
     end

data/lib/sequel/dataset/prepared_statements.rb

@@ -52,7 +52,7 @@ module Sequel
       end
 
       # Set the bind arguments based on the hash and call super.
-      def call(bind_vars={}, &block)
+      def call(bind_vars=OPTS, &block)
         sql = prepared_sql
         prepared_args.freeze
         ps = bind(bind_vars)
@@ -67,6 +67,14 @@ module Sequel
         end
         cache_set(:_prepared_sql, super)
       end
+
+      private
+
+      # Report that prepared statements are not emulated, since
+      # all adapters that use this use native prepared statements.
+      def emulate_prepared_statements?
+        false
+      end
     end
 
     # Backbone of the prepared statement support.  Grafts bind variable
@@ -83,7 +91,7 @@ module Sequel
       end
       
       # The type of prepared statement, should be one of :select, :first,
-      # :insert, :update, or :delete
+      # :insert, :update, :delete, or :single_value
       def prepared_type
         @opts[:prepared_type]
       end
@@ -106,7 +114,7 @@ module Sequel
 
       # Sets the prepared_args to the given hash and runs the
       # prepared statement.
-      def call(bind_vars={}, &block)
+      def call(bind_vars=OPTS, &block)
         bind(bind_vars).run(&block)
       end
 
@@ -136,7 +144,7 @@ module Sequel
         when :select, :all, :each
           # Most common scenario, so listed first.
           select_sql
-        when :first
+        when :first, :single_value
           clone(:limit=>1).select_sql
         when :insert_select
           insert_select_sql(*prepared_modify_values)
@@ -155,13 +163,8 @@ module Sequel
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
       def literal_symbol_append(sql, v)
-        if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
-          s = match[1].to_sym
-          if prepared_arg?(s)
-            literal_append(sql, prepared_arg(s))
-          else
-            sql << v.to_s
-          end
+        if @opts[:bind_vars] && /\A\$(.*)\z/ =~ v
+          literal_append(sql, prepared_arg($1.to_sym))
         else
           super
         end
@@ -202,6 +205,8 @@ module Sequel
           when :map, :as_hash, :to_hash, :to_hash_groups
             public_send(*prepared_type, &block) 
           end
+        when :single_value
+          single_value
         else
           raise Error, "unsupported prepared statement type used: #{prepared_type.inspect}"
         end
@@ -214,11 +219,6 @@ module Sequel
         @opts[:bind_vars][k]
       end
 
-      # Whether there is a bound value for the given key.
-      def prepared_arg?(k)
-        @opts[:bind_vars].has_key?(k)
-      end
-
       # The symbol cache should always be skipped, since placeholders are symbols.
       def skip_symbol_cache?
         true
@@ -228,9 +228,12 @@ module Sequel
       # support and using the same argument hash so that you can use
       # bind variables/prepared arguments in subselects.
       def subselect_sql_append(sql, ds)
-        ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
-          send(:to_prepared_statement, :select, nil, :extend=>prepared_statement_modules).
-          prepared_sql
+        subselect_sql_dataset(sql, ds).prepared_sql
+      end
+
+      def subselect_sql_dataset(sql, ds)
+        super.clone(:prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+          send(:to_prepared_statement, :select, nil, :extend=>prepared_statement_modules)
       end
     end
     
@@ -258,11 +261,63 @@ module Sequel
         prepared_args << k
         prepared_arg_placeholder
       end
+    end
+    
+    # Prepared statements emulation support for adapters that don't
+    # support native prepared statements.  Uses a placeholder
+    # literalizer to hold the prepared sql with the ability to
+    # interpolate arguments to prepare the final SQL string.
+    module EmulatePreparedStatementMethods
+      include UnnumberedArgumentMapper
+
+      def run(&block)
+        if @opts[:prepared_sql_frags]
+          sql = literal(Sequel::SQL::PlaceholderLiteralString.new(@opts[:prepared_sql_frags], @opts[:bind_arguments], false))
+          clone(:prepared_sql_frags=>nil, :sql=>sql, :prepared_sql=>sql).run(&block)
+        else
+          super
+        end
+      end
+
+      private
       
-      # Always assume there is a prepared arg in the argument mapper.
-      def prepared_arg?(k)
+      # Turn emulation of prepared statements back on, since ArgumentMapper
+      # turns it off.
+      def emulate_prepared_statements?
         true
       end
+        
+      def emulated_prepared_statement(type, name, values)
+        prepared_sql, frags = Sequel::Dataset::PlaceholderLiteralizer::Recorder.new.send(:prepared_sql_and_frags, self, prepared_args) do |pl, ds|
+          ds = ds.clone(:recorder=>pl)
+
+          case type
+          when :first, :single_value
+            ds.limit(1)
+          when :update, :insert, :insert_select, :delete
+            ds.with_sql(:"#{type}_sql", *values)
+          when :insert_pk
+            ds.with_sql(:insert_sql, *values)
+          else
+            ds
+          end
+        end
+
+        prepared_args.freeze
+        clone(:prepared_sql_frags=>frags, :prepared_sql=>prepared_sql, :sql=>prepared_sql)
+      end
+
+      # Associates the argument with name k with the next position in
+      # the output array.
+      def prepared_arg(k)
+        prepared_args << k
+        @opts[:recorder].arg
+      end
+
+      def subselect_sql_dataset(sql, ds)
+        super.clone(:recorder=>@opts[:recorder]).
+          with_extend(EmulatePreparedStatementMethods)
+      end
     end
     
     # Set the bind variables to use for the call.  If bind variables have
@@ -272,9 +327,9 @@ module Sequel
     #   DB[:table].where(id: :$id).bind(id: 1).call(:first)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
-    def bind(bind_vars={})
+    def bind(bind_vars=OPTS)
       bind_vars = if bv = @opts[:bind_vars]
-        Hash[bv].merge!(bind_vars).freeze
+        bv.merge(bind_vars).freeze
       else
         if bind_vars.frozen?
           bind_vars
@@ -286,14 +341,14 @@ module Sequel
       clone(:bind_vars=>bind_vars)
     end
     
-    # For the given type (:select, :first, :insert, :insert_select, :update, or :delete),
+    # For the given type (:select, :first, :insert, :insert_select, :update, :delete, or :single_value),
     # run the sql with the bind variables specified in the hash.  +values+ is a hash passed to
     # insert or update (if one of those types is used), which may contain placeholders.
     #
     #   DB[:table].where(id: :$id).call(:first, id: 1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
-    def call(type, bind_variables={}, *values, &block)
+    def call(type, bind_variables=OPTS, *values, &block)
       to_prepared_statement(type, values, :extend=>bound_variable_modules).call(bind_variables, &block)
     end
     
@@ -315,7 +370,16 @@ module Sequel
     #   DB.call(:select_by_name, name: 'Blah') # Same thing
     def prepare(type, name, *values)
       ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules, :no_delayed_evaluations=>true)
-      ps.prepared_sql
+
+      ps = if ps.send(:emulate_prepared_statements?)
+        ps = ps.with_extend(EmulatePreparedStatementMethods)
+        ps.send(:emulated_prepared_statement, type, name, values)
+      else
+        sql = ps.prepared_sql
+        ps.prepared_args.freeze
+        ps.clone(:prepared_sql=>sql, :sql=>sql)
+      end
+
       db.set_prepared_statement(name, ps)
       ps
     end
@@ -344,6 +408,12 @@ module Sequel
       prepared_statement_modules
     end
 
+    # Whether prepared statements should be emulated.  True by
+    # default so that adapters have to opt in.
+    def emulate_prepared_statements?
+      true
+    end
+
     def prepared_statement_modules
       []
     end