sequel 3.28.0 → 3.29.0

data/lib/sequel/database/schema_methods.rb

@@ -71,11 +71,11 @@ module Sequel
     # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
     def alter_table(name, generator=nil, &block)
       generator ||= Schema::AlterTableGenerator.new(self, &block)
-      alter_table_sql_list(name, generator.operations).flatten.each {|sql| execute_ddl(sql)}
       remove_cached_schema(name)
+      apply_alter_table(name, generator.operations)
       nil
     end
-    
+
     # Creates a table with the columns given in the provided block:
     #
     #   DB.create_table :posts do
@@ -231,6 +231,11 @@ module Sequel
 
     private
 
+    # Apply the changes in the given alter table ops to the table given by name.
+    def apply_alter_table(name, ops)
+      alter_table_sql_list(name, ops).flatten.each{|sql| execute_ddl(sql)}
+    end
+    
     # The SQL to execute to modify the DDL for the given table name.  op
     # should be one of the operations returned by the AlterTableGenerator.
     def alter_table_sql(table, op)

data/lib/sequel/dataset/actions.rb

@@ -8,15 +8,20 @@ module Sequel
     # ---------------------
     
     # Action methods defined by Sequel that execute code on the database.
-    ACTION_METHODS = %w'<< [] []= all avg count columns columns! delete each
-    empty? fetch_rows first get import insert insert_multiple interval last
-    map max min multi_insert range select_hash select_map select_order_map
-    set single_record single_value sum to_csv to_hash truncate update'.map{|x| x.to_sym}
+    ACTION_METHODS = (<<-METHS).split.map{|x| x.to_sym}
+      << [] []= all avg count columns columns! delete each
+      empty? fetch_rows first get import insert insert_multiple interval last
+      map max min multi_insert range select_hash select_map select_order_map
+      set single_record single_value sum to_csv to_hash truncate update
+    METHS
 
-    # Alias for insert, but not aliased directly so subclasses
-    # don't have to override both methods.
-    def <<(*args)
-      insert(*args)
+    # Inserts the given argument into the database.  Returns self so it
+    # can be used safely when chaining:
+    # 
+    #   DB[:items] << {:id=>0, :name=>'Zero'} << DB[:old_items].select(:id, name)
+    def <<(arg)
+      insert(arg)
+      self
     end
     
     # Returns the first record matching the conditions. Examples:
@@ -72,7 +77,7 @@ module Sequel
     #   # => [:id, :name]
     def columns
       return @columns if @columns
-      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1)
+      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1, :offset=>nil)
       ds.each{break}
       @columns = ds.instance_variable_get(:@columns)
       @columns || []
@@ -354,8 +359,9 @@ module Sequel
     def map(column=nil, &block)
       if column
         raise(Error, ARG_BLOCK_ERROR_MSG) if block
+        return naked.map(column) if row_proc
         if column.is_a?(Array)
-          super(){|r| column.map{|c| r[c]}}
+          super(){|r| r.values_at(*column)}
         else
           super(){|r| r[column]}
         end
@@ -546,21 +552,22 @@ module Sequel
     def to_hash(key_column, value_column = nil)
       h = {}
       if value_column
+        return naked.to_hash(key_column, value_column) if row_proc
         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]}}
+            each{|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
           else
-            each{|r| h[r[key_column]] = value_column.map{|c| r[c]}}
+            each{|r| h[r[key_column]] = r.values_at(*value_column)}
           end
         else
           if key_column.is_a?(Array)
-            each{|r| h[key_column.map{|c| r[c]}] = r[value_column]}
+            each{|r| h[r.values_at(*key_column)] = 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}
+        each{|r| h[r.values_at(*key_column)] = r}
       else
         each{|r| h[r[key_column]] = r}
       end
@@ -594,6 +601,18 @@ module Sequel
       end
     end
 
+    protected
+
+    # Return an array of arrays of values given by the symbols in ret_cols.
+    def _select_map_multiple(ret_cols)
+      map{|r| r.values_at(*ret_cols)}
+    end
+  
+    # Returns an array of the first value in each row.
+    def _select_map_single
+      map{|r| r.values.first}
+    end
+  
     private
     
     # Internals of +select_map+ and +select_order_map+
@@ -609,14 +628,13 @@ module Sequel
         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]}}
+      if column.is_a?(Array)
+        ds._select_map_multiple(select_cols.map{|c| hash_key_symbol(c)})
       else
-        ds.map{|r| r.values.first}
+        ds._select_map_single
       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)

data/lib/sequel/dataset/features.rb

@@ -24,12 +24,24 @@ module Sequel
       true
     end
     
+    # Whether you must use a column alias list for recursive CTEs (false by
+    # default).
+    def recursive_cte_requires_column_aliases?
+      false
+    end
+
     # Whether the dataset requires SQL standard datetimes (false by default,
     # as most allow strings with ISO 8601 format).
     def requires_sql_standard_datetimes?
       false
     end
 
+    # Whether type specifiers are required for prepared statement/bound
+    # variable argument placeholders (i.e. :bv__integer)
+    def requires_placeholder_type_specifiers?
+      false
+    end
+
     # Whether the dataset supports common table expressions (the WITH clause).
     # If given, +type+ can be :select, :insert, :update, or :delete, in which case it
     # determines whether WITH is supported for the respective statement type.
@@ -126,6 +138,18 @@ module Sequel
 
     private
 
+    # Whether insert(nil) or insert({}) must be emulated by
+    # using at least one value, false by default.
+    def insert_supports_empty_values?
+      true
+    end
+
+    # Whether using an offset returns an extra row number column that should be
+    # eliminated, false by default.
+    def offset_returns_row_number_column?
+      false
+    end
+
     # Whether the RETURNING clause is used for the given dataset.
     # +type+ can be :insert, :update, or :delete.
     def uses_returning?(type)

data/lib/sequel/dataset/graph.rb

@@ -113,6 +113,8 @@ module Sequel
       add_table = options[:select] == false ? false : true
       # Whether to add the columns to the list of column aliases
       add_columns = !ds.opts.include?(:graph_aliases)
+      # columns to select
+      select = (opts[:select] || []).dup
 
       # Setup the initial graph data structure if it doesn't exist
       unless graph = opts[:graph]
@@ -130,7 +132,6 @@ module Sequel
         # aliased, but are not included if set_graph_aliases
         # has been used.
         if add_columns
-          select = opts[:select] = []
           columns.each do |column|
             column_aliases[column] = [master, column]
             select.push(SQL::QualifiedIdentifier.new(master, column))
@@ -147,7 +148,6 @@ module Sequel
 
       # Add the columns to the selection unless we are ignoring them
       if add_table && add_columns
-        select = opts[:select]
         column_aliases = graph[:column_aliases]
         ca_num = graph[:column_alias_num]
         # Which columns to add to the result set
@@ -165,15 +165,16 @@ module Sequel
               column_alias = :"#{column_alias}_#{column_alias_num}" 
               ca_num[column_alias] += 1
             end
-            [column_alias, SQL::QualifiedIdentifier.new(table_alias, column).as(column_alias)]
+            [column_alias, SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(table_alias, column), column_alias)]
           else
-            [column, SQL::QualifiedIdentifier.new(table_alias, column)]
+            ident = SQL::QualifiedIdentifier.new(table_alias, column)
+            [column, ident]
           end
           column_aliases[col_alias] = [table_alias, column]
           select.push(identifier)
         end
       end
-      ds
+      ds.select(*select)
     end
 
     # This allows you to manually specify the graph aliases to use
@@ -225,7 +226,7 @@ module Sequel
         column ||= col_alias
         gas[col_alias] = [table, column]
         identifier = value || SQL::QualifiedIdentifier.new(table, column)
-        identifier = SQL::AliasedExpression.new(identifier, col_alias) if value or column != col_alias
+        identifier = SQL::AliasedExpression.new(identifier, col_alias) if value || column != col_alias
         identifier
       end
       [identifiers, gas]

data/lib/sequel/dataset/misc.rb

@@ -137,7 +137,9 @@ module Sequel
     # Returns a string representation of the dataset including the class name 
     # and the corresponding SQL select statement.
     def inspect
-      "#<#{self.class}: #{sql.inspect}>"
+      c = self.class
+      c = c.superclass while c.name.nil? || c.name == ''
+      "#<#{c.name}: #{sql.inspect}>"
     end
     
     # The alias to use for the row_number column, used when emulating OFFSET
@@ -170,6 +172,10 @@ module Sequel
     # used, where N is an integer starting at 0 and increasing until an
     # unused one is found.
     #
+    # You can provide a second addition array argument containing symbols
+    # that should not be considered valid table aliases.  The current aliases
+    # for the FROM and JOIN tables are automatically included in this array.
+    #
     #   DB[:table].unused_table_alias(:t)
     #   # => :t
     #
@@ -178,9 +184,11 @@ module Sequel
     #
     #   DB[:table, :table_0].unused_table_alias(:table)
     #   # => :table_1
-    def unused_table_alias(table_alias)
+    #
+    #   DB[:table, :table_0].unused_table_alias(:table, [:table_1, :table_2])
+    #   # => :table_3
+    def unused_table_alias(table_alias, used_aliases = [])
       table_alias = alias_symbol(table_alias)
-      used_aliases = []
       used_aliases += opts[:from].map{|t| alias_symbol(t)} if opts[:from]
       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)

data/lib/sequel/dataset/mutation.rb

@@ -29,9 +29,8 @@ module Sequel
     # Whether to quote identifiers for this dataset
     attr_writer :quote_identifiers
     
-    # The row_proc for this database, should be a Proc that takes
-    # a single hash argument and returns the object you want
-    # each to return.
+    # The row_proc for this database, should be any object that responds to +call+ with
+    # a single hash argument and returns the object you want #each to return.
     attr_accessor :row_proc
     
     # Add a mutation method to this dataset instance.

data/lib/sequel/dataset/prepared_statements.rb

@@ -35,7 +35,7 @@ module Sequel
         return @prepared_sql if @prepared_sql
         @prepared_args ||= []
         @prepared_sql = super
-        meta_def("#{sql_query_type}_sql"){|*args| prepared_sql}
+        @opts[:sql] = @prepared_sql
         @prepared_sql
       end
       
@@ -121,8 +121,7 @@ module Sequel
         when :select, :all
           all(&block)
         when :insert_select
-          meta_def(:select_sql){prepared_sql}
-          first
+          with_sql(prepared_sql).first
         when :first
           first
         when :insert
@@ -211,7 +210,10 @@ module Sequel
     end
     
     # Prepare an SQL statement for later execution.  Takes a type similar to #call,
-    # and the name symbol of the prepared statement.
+    # and the +name+ symbol of the prepared statement.  While +name+ defaults to +nil+,
+    # it should always be provided as a symbol for the name of the prepared statement,
+    # as some databases require that prepared statements have names.
+    #
     # This returns a clone of the dataset extended with PreparedStatementMethods,
     # which you can +call+ with the hash of bind variables to use.
     # The prepared statement is also stored in

data/lib/sequel/dataset/query.rb

@@ -28,12 +28,14 @@ module Sequel
     JOIN_METHODS = (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES).map{|x| "#{x}_join".to_sym} + [:join, :join_table]
     
     # Methods that return modified datasets
-    QUERY_METHODS = %w'add_graph_aliases and distinct except exclude exclude_having exclude_where
-    filter for_update from from_self graph grep group group_and_count group_by having intersect invert
-    limit lock_style naked or order order_append order_by order_more order_prepend paginate qualify query
-    reverse reverse_order select select_all select_append select_group select_more server
-    set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
-    unlimited unordered where with with_recursive with_sql'.collect{|x| x.to_sym} + JOIN_METHODS
+    QUERY_METHODS = (<<-METHS).split.map{|x| x.to_sym} + JOIN_METHODS
+      add_graph_aliases and distinct except exclude exclude_having exclude_where
+      filter for_update from from_self graph grep group group_and_count group_by having intersect invert
+      limit lock_style naked or order order_append order_by order_more order_prepend paginate qualify query
+      reverse reverse_order select select_all select_append select_group select_more server
+      set_defaults set_graph_aliases set_overrides unfiltered ungraphed ungrouped union
+      unlimited unordered where with with_recursive with_sql
+    METHS
 
     # Adds an further filter to an existing filter using AND. If no filter 
     # exists an error is raised. This method is identical to #filter except
@@ -201,11 +203,17 @@ module Sequel
     def from(*source)
       table_alias_num = 0
       sources = []
+      ctes = nil
       source.each do |s|
         case s
         when Hash
           s.each{|k,v| sources << SQL::AliasedExpression.new(k,v)}
         when Dataset
+          if hoist_cte?(s)
+            ctes ||= []
+            ctes += s.opts[:with]
+            s = s.clone(:with=>nil)
+          end
           sources << SQL::AliasedExpression.new(s, dataset_alias(table_alias_num+=1))
         when Symbol
           sch, table, aliaz = split_symbol(s)
@@ -220,6 +228,7 @@ module Sequel
         end
       end
       o = {:from=>sources.empty? ? nil : sources}
+      o[:with] = (opts[:with] || []) + ctes if ctes
       o[:num_dataset_sources] = table_alias_num if table_alias_num > 0
       clone(o)
     end
@@ -433,7 +442,7 @@ module Sequel
     #   # SELECT * FROM a NATURAL JOIN b INNER JOIN c
     #   #   ON ((c.d > b.e) AND (c.f IN (SELECT g FROM b)))
     def join_table(type, table, expr=nil, options={}, &block)
-      if table.is_a?(Dataset) && table.opts[:with] && !supports_cte_in_subqueries?
+      if hoist_cte?(table)
         s, ds = hoist_cte(table)
         return s.join_table(type, ds, expr, options, &block)
       end
@@ -881,7 +890,12 @@ module Sequel
     #   # WITH items AS (SELECT * FROM syx WHERE (name LIKE 'A%')) SELECT * FROM items
     def with(name, dataset, opts={})
       raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
-      clone(:with=>(@opts[:with]||[]) + [opts.merge(:name=>name, :dataset=>dataset)])
+      if hoist_cte?(dataset)
+        s, ds = hoist_cte(dataset)
+        s.with(name, ds, opts)
+      else
+        clone(:with=>(@opts[:with]||[]) + [opts.merge(:name=>name, :dataset=>dataset)])
+      end
     end
 
     # Add a recursive common table expression (CTE) with the given name, a dataset that
@@ -903,7 +917,15 @@ module Sequel
     #   # SELECT i AS id, pi AS parent_id FROM t
     def with_recursive(name, nonrecursive, recursive, opts={})
       raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
-      clone(:with=>(@opts[:with]||[]) + [opts.merge(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))])
+      if hoist_cte?(nonrecursive)
+        s, ds = hoist_cte(nonrecursive)
+        s.with_recursive(name, ds, recursive, opts)
+      elsif hoist_cte?(recursive)
+        s, ds = hoist_cte(recursive)
+        s.with_recursive(name, nonrecursive, ds, opts)
+      else
+        clone(:with=>(@opts[:with]||[]) + [opts.merge(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))])
+      end
     end
     
     # Returns a copy of the dataset with the static SQL used.  This is useful if you want
@@ -929,6 +951,16 @@ module Sequel
     
     protected
 
+    # Add the dataset to the list of compounds
+    def compound_clone(type, dataset, opts)
+      if hoist_cte?(dataset)
+        s, ds = hoist_cte(dataset)
+        return s.compound_clone(type, ds, opts)
+      end
+      ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, opts[:all]]])
+      opts[:from_self] == false ? ds : ds.from_self(opts)
+    end
+
     # Return true if the dataset has a non-nil value for any key in opts.
     def options_overlap(opts)
       !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
@@ -960,12 +992,6 @@ module Sequel
       _filter_or_exclude(false, clause, *cond, &block)
     end
 
-    # Add the dataset to the list of compounds
-    def compound_clone(type, dataset, opts)
-      ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, opts[:all]]])
-      opts[:from_self] == false ? ds : ds.from_self(opts)
-    end
-
     # SQL expression object based on the expr type.  See +filter+.
     def filter_expr(expr = nil, &block)
       expr = nil if expr == []
@@ -1013,6 +1039,11 @@ module Sequel
       [clone(:with => (opts[:with] || []) + ds.opts[:with]), ds.clone(:with => nil)]
     end
 
+    # Whether CTEs need to be hoisted from the given ds into the current ds.
+    def hoist_cte?(ds)
+      ds.is_a?(Dataset) && ds.opts[:with] && !supports_cte_in_subqueries?
+    end
+
     # Inverts the given order by breaking it into a list of column references
     # and inverting them.
     #

data/lib/sequel/dataset/sql.rb

@@ -62,6 +62,10 @@ module Sequel
       end
 
       columns = columns.map{|k| literal(String === k ? k.to_sym : k)}
+      if values.is_a?(Array) && values.empty? && !insert_supports_empty_values? 
+        columns = [literal(columns().last)]
+        values = ['DEFAULT'.lit]
+      end
       clone(:columns=>columns, :values=>values)._insert_sql
     end
     
@@ -554,6 +558,28 @@ module Sequel
       (columns.nil? || columns.empty?) ? WILDCARD : expression_list(columns)
     end
     
+    # Yield each two pair of arguments to the block, which should
+    # return a string representing the SQL code for those
+    # two arguments.  If more than 2 arguments are provided, all
+    # calls to the block # after the first will have a LiteralString
+    # as the first argument, representing the application of the block to
+    # the previous arguments.
+    def complex_expression_arg_pairs(args)
+      case args.length
+      when 1
+        literal(args.at(0))
+      when 2
+        yield args.at(0), args.at(1)
+      else
+        args.inject{|m, a| LiteralString.new(yield(m, a))}
+      end
+    end
+
+    # The SQL to use for the dataset used in a UNION/INTERSECT/EXCEPT clause. 
+    def compound_dataset_sql(ds)
+      subselect_sql(ds)
+    end
+
     # The alias to use for datasets, takes a number to make sure the name is unique.
     def dataset_alias(number)
       :"#{DATASET_ALIAS_BASE_NAME}#{number}"
@@ -580,7 +606,7 @@ module Sequel
     # database supports them), and override %z to always use a numeric offset
     # of hours and minutes.
     def format_timestamp(v)
-      v2 = Sequel.application_to_database_timestamp(v)
+      v2 = db.from_application_timestamp(v)
       fmt = default_timestamp_format.gsub(/%[Nz]/) do |m|
         if m == '%N'
           format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
@@ -821,8 +847,7 @@ module Sequel
     def select_compounds_sql(sql)
       return unless @opts[:compounds]
       @opts[:compounds].each do |type, dataset, all|
-        compound_sql = subselect_sql(dataset)
-        sql << " #{type.to_s.upcase}#{' ALL' if all} #{compound_sql}"
+        sql << " #{type.to_s.upcase}#{' ALL' if all} #{compound_dataset_sql(dataset)}"
       end
     end
 
@@ -886,7 +911,6 @@ module Sequel
     alias delete_with_sql select_with_sql
     alias insert_with_sql select_with_sql
     alias update_with_sql select_with_sql
-
     
     # The base keyword to use for the SQL WITH clause
     def select_with_sql_base