sequel 3.33.0 → 3.34.0

data/lib/sequel/dataset/actions.rb

@@ -11,8 +11,8 @@ module Sequel
     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
+      map max min multi_insert range select_hash select_hash_groups select_map select_order_map
+      set single_record single_value sum to_csv to_hash to_hash_groups truncate update
     METHS
 
     # Inserts the given argument into the database.  Returns self so it
@@ -124,13 +124,13 @@ module Sequel
     # running additional queries inside the provided block.  If you are
     # running queries inside the block, you should use +all+ instead of +each+
     # for the outer queries, or use a separate thread or shard inside +each+:
-    def each(&block)
+    def each
       if @opts[:graph]
-        graph_each(&block)
+        graph_each{|r| yield r}
       elsif row_proc = @row_proc
         fetch_rows(select_sql){|r| yield row_proc.call(r)}
       else
-        fetch_rows(select_sql, &block)
+        fetch_rows(select_sql){|r| yield r}
       end
       self
     end
@@ -421,7 +421,7 @@ module Sequel
     end
     
     # Returns a hash with key_column values as keys and value_column values as
-    # values.  Similar to to_hash, but only selects the two columns.
+    # values.  Similar to to_hash, but only selects the columns given.
     #
     #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
@@ -436,19 +436,28 @@ module Sequel
     # that Sequel can determine.  Usually you can do this by calling the #as method
     # on the expression and providing an alias.
     def select_hash(key_column, 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
+      _select_hash(:to_hash, key_column, value_column)
     end
     
+    # Returns a hash with key_column values as keys and an array of value_column values.
+    # Similar to to_hash_groups, but only selects the columns given.
+    #
+    #   DB[:table].select_hash(:name, :id) # SELECT id, name FROM table
+    #   # => {'a'=>[1, 4, ...], 'b'=>[2, ...], ...}
+    #
+    # You can also provide an array of column names for either the key_column,
+    # the value column, or both:
+    #
+    #   DB[:table].select_hash([:first, :middle], [:last, :id]) # SELECT * FROM table
+    #   # {['a', 'b']=>[['c', 1], ['d', 2], ...], ...}
+    #
+    # When using this method, you must be sure that each expression has an alias
+    # that Sequel can determine.  Usually you can do this by calling the #as method
+    # on the expression and providing an alias.
+    def select_hash_groups(key_column, value_column)
+      _select_hash(:to_hash_groups, key_column, value_column)
+    end
+
     # Selects the column given (either as an argument or as a block), and
     # returns an array of all values of that column in the dataset.  If you
     # give a block argument that returns an array with multiple entries,
@@ -472,7 +481,6 @@ module Sequel
     def select_map(column=nil, &block)
       _select_map(column, false, &block)
     end
-
     
     # The same as select_map, but in addition orders the array by the column.
     #
@@ -591,6 +599,49 @@ module Sequel
       h
     end
 
+    # Returns a hash with one column used as key and the values being an
+    # array of column values. If the value_column is not given or nil, uses
+    # the entire hash as the value.
+    #
+    #   DB[:table].to_hash(:name, :id) # SELECT * FROM table
+    #   # {'Jim'=>[1, 4, 16, ...], 'Bob'=>[2], ...}
+    #
+    #   DB[:table].to_hash(:name) # SELECT * FROM table
+    #   # {'Jim'=>[{:id=>1, :name=>'Jim'}, {:id=>4, :name=>'Jim'}, ...], 'Bob'=>[{: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([:first, :middle], [:last, :id]) # SELECT * FROM table
+    #   # {['Jim', 'Bob']=>[['Smith', 1], ['Jackson', 4], ...], ...}
+    #
+    #   DB[:table].to_hash([:first, :middle]) # SELECT * FROM table
+    #   # {['Jim', 'Bob']=>[{:id=>1, :first=>'Jim', :middle=>'Bob', :last=>'Smith'}, ...], ...}
+    def to_hash_groups(key_column, value_column = nil)
+      h = {}
+      if value_column
+        return naked.to_hash_groups(key_column, value_column) if row_proc
+        if value_column.is_a?(Array)
+          if key_column.is_a?(Array)
+            each{|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
+          else
+            each{|r| (h[r[key_column]] ||= []) << r.values_at(*value_column)}
+          end
+        else
+          if key_column.is_a?(Array)
+            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[r.values_at(*key_column)] ||= []) << r}
+      else
+        each{|r| (h[r[key_column]] ||= []) << r}
+      end
+      h
+    end
+
     # Truncates the dataset.  Returns nil.
     #
     #   DB[:table].truncate # TRUNCATE table
@@ -618,6 +669,13 @@ module Sequel
       end
     end
 
+    # Execute the given SQL and return the number of rows deleted.  This exists
+    # solely as an optimization, replacing with_sql(sql).delete.  It's significantly
+    # faster as it does not require cloning the current dataset.
+    def with_sql_delete(sql)
+      execute_dui(sql)
+    end
+
     protected
 
     # Internals of #import.  If primary key values are requested, use
@@ -645,6 +703,21 @@ module Sequel
   
     private
     
+    # Internals of +select_hash+ and +select_hash_groups+
+    def _select_hash(meth, key_column, value_column)
+      if key_column.is_a?(Array)
+        if value_column.is_a?(Array)
+          select(*(key_column + value_column)).send(meth, key_column.map{|c| hash_key_symbol(c)}, value_column.map{|c| hash_key_symbol(c)})
+        else
+          select(*(key_column + [value_column])).send(meth, 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).send(meth, hash_key_symbol(key_column), value_column.map{|c| hash_key_symbol(c)})
+      else
+        select(key_column, value_column).send(meth, hash_key_symbol(key_column), hash_key_symbol(value_column))
+      end
+    end
+    
     # Internals of +select_map+ and +select_order_map+
     def _select_map(column, order, &block)
       ds = naked.ungraphed

data/lib/sequel/dataset/features.rb

@@ -165,5 +165,10 @@ module Sequel
     def uses_returning?(type)
       opts[:returning] && !@opts[:sql] && supports_returning?(type)
     end
+    
+    # Whether the dataset uses WITH ROLLUP/CUBE instead of ROLLUP()/CUBE().
+    def uses_with_rollup?
+      false
+    end
   end
 end

data/lib/sequel/dataset/prepared_statements.rb

@@ -17,7 +17,7 @@ module Sequel
       
       # The bind arguments to use for running this prepared statement
       attr_accessor :bind_arguments
-      
+
       # Set the bind arguments based on the hash and call super.
       def call(bind_vars={}, &block)
         ds = bind(bind_vars)
@@ -46,6 +46,10 @@ module Sequel
     module PreparedStatementMethods
       PLACEHOLDER_RE = /\A\$(.*)\z/
       
+      # Whether to log the full SQL query.  By default, just the prepared statement
+      # name is generally logged on adapters that support native prepared statements.
+      attr_accessor :log_sql
+      
       # The type of prepared statement, should be one of :select, :first,
       # :insert, :update, or :delete
       attr_accessor :prepared_type
@@ -139,7 +143,7 @@ module Sequel
           delete
         when Array
           case @prepared_type.at(0)
-          when :map, :to_hash
+          when :map, :to_hash, :to_hash_groups
             send(*@prepared_type, &block) 
           end
         else

data/lib/sequel/dataset/sql.rb

@@ -20,7 +20,7 @@ module Sequel
     #   DB.select(1).where(DB[:items].exists)
     #   # SELECT 1 WHERE (EXISTS (SELECT * FROM items))
     def exists
-      SQL::PlaceholderLiteralString.new("EXISTS ?", [self], true)
+      SQL::PlaceholderLiteralString.new(EXISTS, [self], true)
     end
     
     # Returns an INSERT SQL query string.  See +insert+.
@@ -63,7 +63,7 @@ module Sequel
 
       if values.is_a?(Array) && values.empty? && !insert_supports_empty_values? 
         columns = [columns().last]
-        values = ['DEFAULT'.lit]
+        values = [DEFAULT]
       end
       clone(:columns=>columns, :values=>values)._insert_sql
     end
@@ -182,6 +182,7 @@ module Sequel
       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
     end
 
+    WILDCARD = LiteralString.new('*').freeze
     ALL = ' ALL'.freeze
     AND_SEPARATOR = " AND ".freeze
     APOS = "'".freeze
@@ -200,7 +201,6 @@ module Sequel
     CASE_THEN = " THEN ".freeze
     CASE_WHEN = " WHEN ".freeze
     CAST_OPEN = 'CAST('.freeze
-    COLUMN_ALL = '.*'.freeze
     COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
     COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
     COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
@@ -209,8 +209,9 @@ module Sequel
     CONDITION_FALSE = '(1 = 0)'.freeze
     CONDITION_TRUE = '(1 = 1)'.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
-    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
+    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, WILDCARD).as(:count)
     DATASET_ALIAS_BASE_NAME = 't'.freeze
+    DEFAULT = LiteralString.new('DEFAULT').freeze
     DEFAULT_VALUES = " DEFAULT VALUES".freeze
     DELETE = 'DELETE'.freeze
     DELETE_CLAUSE_METHODS = clause_methods(:delete, %w'delete from where')
@@ -221,6 +222,7 @@ module Sequel
     DOUBLE_QUOTE = '""'.freeze
     EQUAL = ' = '.freeze
     EXTRACT = 'extract('.freeze
+    EXISTS = ['EXISTS '.freeze].freeze
     FOR_UPDATE = ' FOR UPDATE'.freeze
     FORMAT_DATE = "'%Y-%m-%d'".freeze
     FORMAT_DATE_STANDARD = "DATE '%Y-%m-%d'".freeze
@@ -267,6 +269,7 @@ module Sequel
     SET = ' SET '.freeze
     SPACE = ' '.freeze
     SQL_WITH = "WITH ".freeze
+    SPACE_WITH = " WITH ".freeze
     TILDE = '~'.freeze
     TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S%N%z'".freeze
     STANDARD_TIMESTAMP_FORMAT = "TIMESTAMP #{TIMESTAMP_FORMAT}".freeze
@@ -276,8 +279,9 @@ module Sequel
     UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'update table set where')
     USING = ' USING ('.freeze
     VALUES = " VALUES ".freeze
+    V187 = '1.8.7'.freeze
+    V190 = '1.9.0'.freeze
     WHERE = " WHERE ".freeze
-    WILDCARD = LiteralString.new('*').freeze
 
     PUBLIC_APPEND_METHODS = (<<-END).split.map{|x| x.to_sym}
       literal
@@ -392,10 +396,10 @@ module Sequel
 
     # SQL fragment for specifying all columns in a given table
     def column_all_sql_append(sql, ca)
-      quote_schema_table_append(sql, ca.table)
-      sql << COLUMN_ALL
+      qualified_identifier_sql_append(sql, ca.table, WILDCARD)
     end
 
+    # SQL fragment for the complex expression.
     def complex_expression_sql_append(sql, op, args)
       case op
       when *IS_OPERATORS
@@ -509,7 +513,7 @@ module Sequel
       table_alias = jc.table_alias
       table_alias = nil if table == table_alias
       sql << SPACE << join_type_sql(jc.join_type) << SPACE
-      table_ref_append(sql, table)
+      identifier_append(sql, table)
       as_sql_append(sql, table_alias) if table_alias
     end
 
@@ -550,11 +554,11 @@ module Sequel
     # SQL fragment for a literal string with placeholders
     def placeholder_literal_string_sql_append(sql, pls)
       args = pls.args
+      str = pls.str
       sql << PAREN_OPEN if pls.parens
       if args.is_a?(Hash)
         re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
-        if RUBY_VERSION >= '1.8.7'
-          str = pls.str
+        if RUBY_VERSION >= V187
           loop do
             previous, q, str = str.partition(re)
             sql << previous
@@ -562,12 +566,17 @@ module Sequel
             break if str.empty?
           end
         else
-          sql << pls.str.gsub(re){literal(args[$1.to_sym])}
+          sql << str.gsub(re){literal(args[$1.to_sym])}
+        end
+      elsif str.is_a?(Array)
+        len = args.length
+        str.each_with_index do |s, i|
+          sql << s
+          literal_append(sql, args[i]) unless i == len
         end
       else
         i = -1
-        if RUBY_VERSION >= '1.8.7'
-          str = pls.str
+        if RUBY_VERSION >= V187
           loop do
             previous, q, str = str.partition(QUESTION_MARK)
             sql << previous
@@ -575,7 +584,7 @@ module Sequel
             break if str.empty?
           end
         else
-          sql << pls.str.gsub(QUESTION_MARK_RE){literal(args.at(i+=1))}
+          sql << str.gsub(QUESTION_MARK_RE){literal(args.at(i+=1))}
         end
       end
       sql << PAREN_CLOSE if pls.parens
@@ -583,20 +592,12 @@ module Sequel
 
     # SQL fragment for the qualifed identifier, specifying
     # a table and a column (or schema and table).
-    def qualified_identifier_sql_append(sql, qcr)
-      case t = qcr.table
-      when Symbol, SQL::QualifiedIdentifier, SQL::Identifier
-        literal_append(sql, t) 
-      else
-        quote_identifier_append(sql, t)
-      end
+    # If 3 arguments are given, the 2nd should be the table/qualifier and the third should be
+    # column/qualified.  If 2 arguments are given, the 2nd should be an SQL::QualifiedIdentifier.
+    def qualified_identifier_sql_append(sql, table, column=(c = table.column; table = table.table; c))
+      identifier_append(sql, table)
       sql << DOT
-      case c = qcr.column
-      when Symbol, SQL::QualifiedIdentifier, SQL::Identifier
-        literal_append(sql, c) 
-      else
-        quote_identifier_append(sql, c)
-      end
+      identifier_append(sql, column)
     end
 
     # Adds quoting to identifiers (columns and tables). If identifiers are not
@@ -802,7 +803,7 @@ module Sequel
 
     # Prepare an SQL statement by calling all clause methods for the given statement type.
     def clause_sql(type)
-      sql = @opts[:append_sql] || ''
+      sql = @opts[:append_sql] || sql_string_origin
       send("#{type}_clause_methods").each{|x| send(x, sql)}
       sql
     end
@@ -869,7 +870,7 @@ module Sequel
         c ||= true
       end
     end
-    
+
     def empty_array_value(op, cols)
       if Sequel.empty_array_handle_nulls
         c = Array(cols)
@@ -887,7 +888,7 @@ module Sequel
       v2 = db.from_application_timestamp(v)
       fmt = default_timestamp_format.gsub(FORMAT_TIMESTAMP_RE) do |m|
         if m == FORMAT_USEC
-          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
+          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < V190 ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
         else
           if supports_timestamp_timezones?
             # Would like to just use %z format, but it doesn't appear to work on Windows
@@ -911,6 +912,24 @@ module Sequel
       sprintf(FORMAT_TIMESTAMP_USEC, usec)
     end
 
+    # Append the value, but special case regular (non-literal, non-blob) strings
+    # so that they are considered as identifiers and not SQL strings.
+    def identifier_append(sql, v)
+      if v.is_a?(String)
+        case v
+        when LiteralString
+          sql << v
+        when SQL::Blob
+          literal_append(sql, v)
+        else
+          quote_identifier_append(sql, v)
+        end
+      else
+        literal_append(sql, v)
+      end
+    end
+    alias table_ref_append identifier_append 
+    
     # Modify the identifier returned from the database based on the
     # identifier_output_method.
     def input_identifier(v)
@@ -937,11 +956,7 @@ module Sequel
         co = COMMA
         columns.each do |col|
           sql << co if c
-          if col.is_a?(String) && !col.is_a?(LiteralString)
-            quote_identifier_append(sql, col)
-          else
-            literal_append(sql, col)
-          end
+          identifier_append(sql, col)
           c ||= true
         end
         sql << PAREN_CLOSE
@@ -1058,7 +1073,7 @@ module Sequel
     def literal_integer(v)
       v.to_s
     end
-    
+
     # SQL fragment for nil
     def literal_nil
       NULL
@@ -1194,11 +1209,17 @@ module Sequel
       if group = @opts[:group]
         sql << GROUP_BY
         if go = @opts[:group_options]
-          sql << go.to_s.upcase
-          sql << PAREN_OPEN
+          if uses_with_rollup?
+            expression_list_append(sql, group)
+            sql << SPACE_WITH << go.to_s.upcase
+          else
+            sql << go.to_s.upcase << PAREN_OPEN
+            expression_list_append(sql, group)
+            sql << PAREN_CLOSE
+          end
+        else
+          expression_list_append(sql, group)
         end
-        expression_list_append(sql, group)
-        sql << PAREN_CLOSE if go
       end
     end
 
@@ -1300,7 +1321,7 @@ module Sequel
       co = COMMA
       sources.each do |s|
         sql << co if c
-        table_ref_append(sql, s)
+        identifier_append(sql, s)
         c ||= true
       end
     end
@@ -1323,6 +1344,12 @@ module Sequel
       end
     end
 
+    # The string that is appended to to create the SQL query, the empty
+    # string by default
+    def sql_string_origin
+      ''
+    end
+    
     # SQL to use if this dataset uses static SQL.  Since static SQL
     # can be a PlaceholderLiteralString in addition to a String,
     # we literalize nonstrings.
@@ -1347,16 +1374,6 @@ module Sequel
       ds.clone(:append_sql=>sql).sql
     end
 
-    # SQL fragment specifying a table name.
-    def table_ref_append(sql, t)
-      if t.is_a?(String)
-        quote_identifier_append(sql, t)
-      else
-        literal_append(sql, t)
-      end
-    end
-    alias identifier_append table_ref_append
-    
     # The order of methods to call to build the UPDATE SQL statement
     def update_clause_methods
       UPDATE_CLAUSE_METHODS