sequel 3.30.0 → 3.31.0

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

@@ -345,6 +345,7 @@ module Sequel
       INSERT = Dataset::INSERT
       COMMA = Dataset::COMMA
       LIMIT = Dataset::LIMIT
+      GROUP_BY = Dataset::GROUP_BY
       REGEXP = 'REGEXP'.freeze
       LIKE = 'LIKE'.freeze
       BINARY = 'BINARY '.freeze
@@ -361,6 +362,7 @@ module Sequel
       ON_DUPLICATE_KEY_UPDATE = " ON DUPLICATE KEY UPDATE ".freeze
       EQ_VALUES = '=VALUES('.freeze
       EQ = '='.freeze
+      WITH_ROLLUP = ' WITH ROLLUP'.freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -423,8 +425,9 @@ module Sequel
       end
       
       # MySQL specific full text search syntax.
-      def full_text_sql(cols, term, opts = {})
-        "MATCH #{literal(Array(cols))} AGAINST (#{literal(Array(term).join(' '))}#{" IN BOOLEAN MODE" if opts[:boolean]})"
+      def full_text_sql(cols, terms, opts = {})
+        terms = terms.join(' ') if terms.is_a?(Array)
+        SQL::PlaceholderLiteralString.new("MATCH ? AGAINST (?#{" IN BOOLEAN MODE" if opts[:boolean]})", [Array(cols), terms], true)
       end
 
       # MySQL allows HAVING clause on ungrouped datasets.
@@ -518,6 +521,11 @@ module Sequel
         true
       end
 
+      # MySQL supports GROUP BY WITH ROLLUP (but not CUBE)
+      def supports_group_rollup?
+        true
+      end
+
       # MySQL does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
@@ -661,6 +669,15 @@ module Sequel
         SELECT_CLAUSE_METHODS
       end
       
+      # MySQL supports ROLLUP via nonstandard SQL syntax
+      def select_group_sql(sql)
+        if group = @opts[:group]
+          sql << GROUP_BY
+          expression_list_append(sql, group)
+          sql << WITH_ROLLUP if @opts[:group_options] == :rollup
+        end
+      end
+
       # Support FOR SHARE locking when using the :share lock style.
       def select_lock_sql(sql)
         @opts[:lock] == :share ? (sql << FOR_SHARE) : super

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

@@ -247,8 +247,10 @@ module Sequel
         compound_clone(:minus, dataset, opts)
       end
 
+      # Use a custom expression with EXISTS to determine whether a dataset
+      # is empty.
       def empty?
-        db[:dual].where(unordered.exists).get(1) == nil
+        db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
       end
 
       # Oracle requires SQL standard datetimes
@@ -283,6 +285,16 @@ module Sequel
         true
       end
 
+      # Oracle supports GROUP BY CUBE
+      def supports_group_cube?
+        true
+      end
+
+      # Oracle supports GROUP BY ROLLUP
+      def supports_group_rollup?
+        true
+      end
+
       # Oracle does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false

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

@@ -345,8 +345,11 @@ module Sequel
           (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
         unless @server_version
-          m = /PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/.match(fetch('SELECT version()').single_value)
-          @server_version = (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+          @server_version = if m = /PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/.match(fetch('SELECT version()').single_value)
+            (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
+          else
+            0
+          end
         end
         @server_version
       end
@@ -493,7 +496,7 @@ module Sequel
         filter = " WHERE #{filter_expr(filter)}" if filter
         case index_type
         when :full_text
-          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{dataset.send(:full_text_string_join, cols)}))"
+          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{literal(dataset.send(:full_text_string_join, cols))}))"
           index_type = :gin
         when :spatial
           index_type = :gist
@@ -577,7 +580,8 @@ module Sequel
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
             SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
-            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key)).
+            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key),
+            :pg_namespace__nspname).
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
@@ -589,7 +593,16 @@ module Sequel
           filter(:pg_class__relname=>m2.call(table_name)).
           order(:pg_attribute__attnum)
         ds = filter_schema(ds, opts)
+        current_schema = nil
         ds.map do |row|
+          sch = row.delete(:nspname)
+          if current_schema
+            if sch != current_schema
+              raise Error, "columns from tables in two separate schema were returned (please specify a schema): #{current_schema.inspect}, #{sch.inspect}"
+            end
+          else
+            current_schema = sch
+          end
           row[:default] = nil if blank_object?(row[:default])
           row[:type] = schema_column_type(row[:db_type])
           [m.call(row.delete(:name)), row]
@@ -746,7 +759,8 @@ module Sequel
       # in 8.3 by default, and available for earlier versions as an add-on).
       def full_text_search(cols, terms, opts = {})
         lang = opts[:language] || 'simple'
-        filter("to_tsvector(#{literal(lang)}, #{full_text_string_join(cols)}) @@ to_tsquery(#{literal(lang)}, #{literal(Array(terms).join(' | '))})")
+        terms = terms.join(' | ') if terms.is_a?(Array)
+        filter("to_tsvector(?, ?) @@ to_tsquery(?, ?)", lang, full_text_string_join(cols), lang, terms)
       end
       
       # Insert given values into the database.
@@ -756,7 +770,14 @@ module Sequel
         elsif !@opts[:sql] && supports_insert_select?
           returning(insert_pk).insert(*values){|r| return r.values.first}
         elsif (f = opts[:from]) && !f.empty?
-          execute_insert(insert_sql(*values), :table=>f.first, :values=>values.size == 1 ? values.first : values)
+          v = if values.size == 1
+            values.first
+          elsif values.size == 2 && values.all?{|v0| v0.is_a?(Array)}
+            Hash[*values.first.zip(values.last).flatten]
+          else
+            values
+          end
+          execute_insert(insert_sql(*values), :table=>f.first, :values=>v)
         else
           super
         end
@@ -812,7 +833,7 @@ module Sequel
         if type == :insert
           server_version >= 80200 && !opts[:disable_insert_returning]
         else
-          server_version >= 90100
+          server_version >= 80200
         end
       end
 
@@ -831,6 +852,29 @@ module Sequel
         clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
       end
       
+      protected
+
+      # If returned primary keys are requested, use RETURNING unless already set on the
+      # dataset.  If RETURNING is already set, use existing returning values.  If RETURNING
+      # is only set to return a single columns, return an array of just that column.
+      # Otherwise, return an array of hashes.
+      def _import(columns, values, opts={})
+        if server_version >= 80200
+          if opts[:return] == :primary_key && !@opts[:returning]
+            returning(insert_pk)._import(columns, values, opts)
+          elsif @opts[:returning]
+            statements = multi_insert_sql(columns, values)
+            @db.transaction(opts.merge(:server=>@opts[:server])) do
+              statements.map{|st| returning_fetch_rows(st)}
+            end.first.map{|v| v.length == 1 ? v.values.first : v}
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
       private
       
       # PostgreSQL allows deleting from joined datasets
@@ -948,7 +992,7 @@ module Sequel
         cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, EMPTY_STRING)}
         cols = cols.zip([SPACE] * cols.length).flatten
         cols.pop
-        literal(SQL::StringExpression.new(:'||', *cols))
+        SQL::StringExpression.new(:'||', *cols)
       end
 
       # PostgreSQL splits the main table from the joined tables

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

@@ -405,7 +405,7 @@ module Sequel
       AS = Dataset::AS
       APOS = Dataset::APOS
       EXTRACT_OPEN = "CAST(strftime(".freeze
-      EXRACT_CLOSE = ') AS '.freeze
+      EXTRACT_CLOSE = ') AS '.freeze
       NUMERIC = 'NUMERIC'.freeze
       INTEGER = 'INTEGER'.freeze
       BACKTICK = '`'.freeze
@@ -435,13 +435,14 @@ module Sequel
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
           sql << EXTRACT_OPEN << format << COMMA
           literal_append(sql, args.at(1))
-          sql << EXRACT_CLOSE << (part == :second ? NUMERIC : INTEGER) << PAREN_CLOSE
+          sql << EXTRACT_CLOSE << (part == :second ? NUMERIC : INTEGER) << PAREN_CLOSE
         else
           super
         end
       end
       
-      # MSSQL doesn't support the SQL standard CURRENT_DATE or CURRENT_TIME
+      # SQLite has CURRENT_TIMESTAMP and related constants in UTC instead
+      # of in localtime, so convert those constants to local time.
       def constant_sql_append(sql, constant)
         if c = CONSTANT_MAP[constant]
           sql << c

data/lib/sequel/adapters/utils/stored_procedures.rb

@@ -1,9 +1,6 @@
 module Sequel 
   class Dataset
     module StoredProcedureMethods
-      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
-      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
-      
       # The name of the stored procedure to call
       attr_accessor :sproc_name
       
@@ -44,14 +41,7 @@ module Sequel
       # ignored anyway).
       def sproc_type=(type)
         @sproc_type = type
-        meta_def("#{sql_query_type}_sql"){|*a| ''}
-      end
-      
-      private
-      
-      # The type of query (:select, :insert, :delete, :update).
-      def sql_query_type
-        SQL_QUERY_TYPE[@sproc_type]
+        @opts[:sql] = ''
       end
     end
   

data/lib/sequel/database/schema_generator.rb

@@ -125,6 +125,13 @@ module Sequel
       #   foreign_key(:artist_id) # artist_id INTEGER
       #   foreign_key(:artist_id, :artists) # artist_id INTEGER REFERENCES artists
       #   foreign_key(:artist_id, :artists, :key=>:id) # artist_id INTEGER REFERENCES artists(id)
+      #
+      # If you want a foreign key constraint without adding a column (usually because it is a
+      # composite foreign key), you can provide an array of columns as the first argument, and
+      # you can provide the :name option to name the constraint:
+      #
+      #   foreign_key([:artist_name, :artist_location], :artists, :name=>:artist_fk)
+      #   # ADD CONSTRAINT artist_fk FOREIGN KEY (artist_name, artist_location) REFERENCES artists
       def foreign_key(name, table=nil, opts = {})
         opts = case table
         when Hash
@@ -282,8 +289,8 @@ module Sequel
       # to the DDL for the table.  See Generator#column for the available options.
       #
       # You can also pass an array of column names for creating composite foreign
-      # keys. In this case, it will assume the columns exists and will only add
-      # the constraint.
+      # keys. In this case, it will assume the columns exist and will only add
+      # the constraint.  You can provide a :name option to name the constraint.
       #
       # NOTE: If you need to add a foreign key constraint to a single existing column
       # use the composite key syntax even if it is only one column.

data/lib/sequel/dataset/actions.rb

@@ -137,10 +137,10 @@ module Sequel
     
     # Returns true if no records exist in the dataset, false otherwise
     #
-    #   DB[:table].empty? # SELECT 1 FROM table LIMIT 1
+    #   DB[:table].empty? # SELECT 1 AS one FROM table LIMIT 1
     #   # => false
     def empty?
-      get(1).nil?
+      get(Sequel::SQL::AliasedExpression.new(1, :one)).nil?
     end
 
     # Executes a select query and fetches records, yielding each record to the
@@ -229,31 +229,33 @@ module Sequel
     #   DB[:table].import([:x, :y], DB[:table2].select(:a, :b))
     #   # INSERT INTO table (x, y) SELECT a, b FROM table2 
     #
-    # The method also accepts a :slice or :commit_every option that specifies
-    # the number of records to insert per transaction. This is useful especially
-    # when inserting a large number of records, e.g.:
-    #
-    #   # this will commit every 50 records
-    #   dataset.import([:x, :y], [[1, 2], [3, 4], ...], :slice => 50)
+    # Options:
+    # :commit_every :: Open a new transaction for every given number of records.
+    #                  For example, if you provide a value of 50, will commit
+    #                  after every 50 records.
+    # :server :: Set the server/shard to use for the transaction and insert
+    #            queries.
+    # :slice :: Same as :commit_every, :commit_every takes precedence.
     def import(columns, values, opts={})
       return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
 
       return if values.empty?
       raise(Error, IMPORT_ERROR_MSG) if columns.empty?
+      ds = opts[:server] ? server(opts[:server]) : self
       
       if slice_size = opts[:commit_every] || opts[:slice]
         offset = 0
-        loop do
-          @db.transaction(opts){multi_insert_sql(columns, values[offset, slice_size]).each{|st| execute_dui(st)}}
+        rows = []
+        while offset < values.length
+          rows << ds._import(columns, values[offset, slice_size], opts)
           offset += slice_size
-          break if offset >= values.length
         end
+        rows.flatten
       else
-        statements = multi_insert_sql(columns, values)
-        @db.transaction{statements.each{|st| execute_dui(st)}}
+        ds._import(columns, values, opts)
       end
     end
-  
+
     # Inserts values into the associated table.  The returned value is generally
     # the value of the primary key for the inserted row, but that is adapter dependent.
     #
@@ -300,21 +302,24 @@ module Sequel
     
     # Inserts multiple values. If a block is given it is invoked for each
     # item in the given array before inserting it.  See +multi_insert+ as
-    # a possible faster version that inserts multiple records in one
-    # SQL statement.
+    # a possibly faster version that may be able to insert multiple
+    # records in one SQL statement (if supported by the database).
+    # Returns an array of primary keys of inserted rows.
     #
     #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}])
+    #   # => [4, 5]
     #   # INSERT INTO table (x) VALUES (1)
     #   # INSERT INTO table (x) VALUES (2)
     #
     #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2}
+    #   # => [6, 7]
     #   # INSERT INTO table (x, y) VALUES (1, 2)
     #   # INSERT INTO table (x, y) VALUES (2, 4)
     def insert_multiple(array, &block)
       if block
-        array.each {|i| insert(block[i])}
+        array.map{|i| insert(block.call(i))}
       else
-        array.each {|i| insert(i)}
+        array.map{|i| insert(i)}
       end
     end
     
@@ -397,7 +402,7 @@ module Sequel
     # otherwise some columns could be missed or set to null instead of to default
     # values.
     #
-    # You can also use the :slice or :commit_every option that import accepts.
+    # This respects the same options as #import.
     def multi_insert(hashes, opts={})
       return if hashes.empty?
       columns = hashes.first.keys
@@ -603,6 +608,19 @@ module Sequel
 
     protected
 
+    # Internals of #import.  If primary key values are requested, use
+    # separate insert commands for each row.  Otherwise, call #multi_insert_sql
+    # and execute each statement it gives separately.
+    def _import(columns, values, opts)
+      trans_opts = opts.merge(:server=>@opts[:server])
+      if opts[:return] == :primary_key
+        @db.transaction(trans_opts){values.map{|v| insert(columns, v)}}
+      else
+        stmts = multi_insert_sql(columns, values)
+        @db.transaction(trans_opts){stmts.each{|st| execute_dui(st)}}
+      end
+    end
+  
     # 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)}

data/lib/sequel/dataset/features.rb

@@ -61,6 +61,16 @@ module Sequel
       false
     end
 
+    # Whether the dataset supports CUBE with GROUP BY.
+    def supports_group_cube?
+      false
+    end
+
+    # Whether the dataset supports ROLLUP with GROUP BY.
+    def supports_group_rollup?
+      false
+    end
+
     # Whether this dataset supports the +insert_select+ method for returning all columns values
     # directly from an insert query.
     def supports_insert_select?

data/lib/sequel/dataset/prepared_statements.rb

@@ -12,9 +12,6 @@ module Sequel
     # native database support for bind variables and prepared
     # statements (as opposed to the emulated ones used by default).
     module ArgumentMapper
-      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
-      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
-      
       # The name of the prepared statement, if any.
       attr_accessor :prepared_statement_name
       
@@ -38,13 +35,6 @@ module Sequel
         @opts[:sql] = @prepared_sql
         @prepared_sql
       end
-      
-      private
-      
-      # The type of query (:select, :insert, :delete, :update).
-      def sql_query_type
-        SQL_QUERY_TYPE[@prepared_type]
-      end
     end
 
     # Backbone of the prepared statement support.  Grafts bind variable

data/lib/sequel/dataset/query.rb

@@ -218,7 +218,7 @@ module Sequel
         when Symbol
           sch, table, aliaz = split_symbol(s)
           if aliaz
-            s = sch ? SQL::QualifiedIdentifier.new(sch.to_sym, table.to_sym) : SQL::Identifier.new(table.to_sym)
+            s = sch ? SQL::QualifiedIdentifier.new(sch, table) : SQL::Identifier.new(table)
             sources << SQL::AliasedExpression.new(s, aliaz.to_sym)
           else
             sources << s
@@ -337,6 +337,18 @@ module Sequel
       select_group(*columns, &block).select_more(COUNT_OF_ALL_AS_COUNT)
     end
 
+    # Adds the appropriate CUBE syntax to GROUP BY.
+    def group_cube
+      raise Error, "GROUP BY CUBE not supported on #{db.database_type}" unless supports_group_cube?
+      clone(:group_options=>:cube)
+    end
+
+    # Adds the appropriate ROLLUP syntax to GROUP BY.
+    def group_rollup
+      raise Error, "GROUP BY ROLLUP not supported on #{db.database_type}" unless supports_group_rollup?
+      clone(:group_options=>:rollup)
+    end
+
     # Returns a copy of the dataset with the HAVING conditions changed. See #filter for argument types.
     #
     #   DB[:items].group(:sum).having(:sum=>10)