sequel 5.83.0 → 5.106.0

data/lib/sequel/database/query.rb

@@ -170,7 +170,7 @@ module Sequel
         c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type]) unless c.has_key?(:ruby_default)
         if c[:primary_key] && !auto_increment_set
           # If adapter didn't set it, assume that integer primary keys are auto incrementing
-          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/io)
+          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/i)
         end
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
@@ -269,7 +269,7 @@ module Sequel
     def column_schema_to_ruby_default(default, type)
       return default unless default.is_a?(String)
       if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
-        if /now|today|CURRENT|getdate|\ADate\(\)\z/i.match(default)
+        if /now|today|CURRENT|getdate|\ADate\(\)\z/i =~ default
           if type == :date
             return Sequel::CURRENT_DATE
           else
@@ -390,25 +390,25 @@ module Sequel
     # such as :integer or :string.
     def schema_column_type(db_type)
       case db_type
-      when /\A(character( varying)?|n?(var)?char|n?text|string|clob)/io
+      when /\A(character( varying)?|n?(var)?char|n?text|string|clob)/i
         :string
-      when /\A(int(eger)?|(big|small|tiny)int)/io
+      when /\A(int(eger)?|(big|small|tiny)int)/i
         :integer
-      when /\Adate\z/io
+      when /\Adate\z/i
         :date
-      when /\A((small)?datetime|timestamp(\(\d\))?( with(out)? time zone)?)\z/io
+      when /\A((small)?datetime(\(\d\))?|timestamp(\(\d\))?( with(out)? time zone)?)\z/i
         :datetime
-      when /\Atime( with(out)? time zone)?\z/io
+      when /\Atime( with(out)? time zone)?\z/i
         :time
-      when /\A(bool(ean)?)\z/io
+      when /\A(bool(ean)?)\z/i
         :boolean
-      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/i
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/i
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
-      when /bytea|blob|image|(var)?binary/io
+      when /bytea|blob|image|(var)?binary/i
         :blob
-      when /\Aenum/io
+      when /\Aenum/i
         :enum
       end
     end

data/lib/sequel/database/schema_generator.rb

@@ -3,6 +3,33 @@
 module Sequel
   # The Schema module holds the schema generators.
   module Schema
+    module ColumnOptionMerger
+      private
+
+      # Merge given options into the column's default options. For backwards compatibility,
+      # the options take priority, but in cases where the option value overrides the argument
+      # value, and the values are different, we warn as this is likely to be an error in the
+      # code.
+      def _merge_column_options(defaults, opts)
+        defaults.merge!(opts) do |k, defv, v|
+          unless defv == v
+            # :nocov:
+            if RUBY_VERSION >= "3.2"
+            # :nocov:
+              caller_loc = Thread.each_caller_location do |loc|
+                break loc unless loc.path == __FILE__
+              end
+              caller_loc &&= "#{caller_loc.path}:#{caller_loc.lineno}: "
+            end
+            warn("#{caller_loc}#{k.inspect} option value (#{v.inspect}) overrides argument value (#{defv.inspect})")
+          end
+
+          v
+        end
+      end
+    end
+    private_constant :ColumnOptionMerger
+
     # Schema::CreateTableGenerator is an internal class that the user is not expected
     # to instantiate directly.  Instances are created by Database#create_table.
     # It is used to specify table creation parameters.  It takes a Database
@@ -17,6 +44,8 @@ module Sequel
     # For more information on Sequel's support for schema modification, see
     # the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     class CreateTableGenerator
+      include ColumnOptionMerger
+
       # Classes specifying generic types that Sequel will convert to database-specific types.
       GENERIC_TYPES=%w'String Integer Float Numeric BigDecimal Date DateTime Time File TrueClass FalseClass'.freeze
       
@@ -118,6 +147,11 @@ module Sequel
       #         that this column references.  Unnecessary if this column
       #         references the primary key of the associated table, except if you are
       #         using MySQL.
+      # :not_null :: Similar to setting <tt>null: false</tt>, but you can provide a hash value
+      #              to specify options for the NOT NULL constraint on PostgreSQL 18+:
+      #              :name :: The name of the NOT NULL constraint
+      #              :no_inherit :: Set NO INHERIT on the constraint, so it will not propogate to
+      #                             child tables.
       # :null :: Mark the column as allowing NULL values (if true),
       #          or not allowing NULL values (if false).  The default is to allow NULL values.
       # :on_delete :: Specify the behavior of this column when being deleted
@@ -126,21 +160,34 @@ module Sequel
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should not
       #                 be used if you want a single autoincrementing primary key column
-      #                 (use the primary_key method in that case).
-      # :primary_key_constraint_name :: The name to give the primary key constraint
-      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
-      #                            if :primary_key is used.
+      #                 (use the primary_key method in that case).  Can be a hash to provide
+      #                 options for the constraint:
+      #                 :name :: The name to give the primary key constraint.
+      #                 :deferrable :: Sets whether the primary key constraint is deferrable.
+      #                 :include :: Include additional columns in the underlying index, to
+      #                             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :primary_key_constraint_name :: Older option to name primary key constraint.
+      # :primary_key_deferrable :: Older option to set primary key constraint as deferrable.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
-      #            creating a unique index on the column.
-      # :unique_constraint_name :: The name to give the unique key constraint
-      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
-      #                       is used.
+      #            creating a unique index on the column. Can be a hash to provide options for
+      #            the constraint:
+      #            :name :: The name to give the unique constraint.
+      #            :deferrable :: Sets whether the unique constraint is deferrable.
+      #            :include :: Include additional columns in the underlying index, to
+      #                        allow for index-only scans in more cases (PostgreSQL 11+).
+      #            :nulls_not_distinct :: Use NULLS NOT DISTINCT to setup a constraint where NULL
+      #                                   entries are considered distinct (PostgreSQL 15+)
+      # :unique_constraint_name :: Older option to name unique constraint.
+      # :unique_deferrable :: Older option to set unique constraint as deferrable.
       #
       # PostgreSQL specific options:
       #
       # :identity :: Create an identity column.
+      # :virtual :: When using :generated_always_as, create a VIRTUAL column instead of a STORED
+      #             column (PostgreSQL 18+). VIRTUAL is the default if not specified on
+      #             PostgreSQL 18+, but for backwards compatibility, Sequel's default is STORED.
       #
       # MySQL specific options:
       #
@@ -155,13 +202,13 @@ module Sequel
       # :clustered :: When using :primary_key or :unique, marks the primary key or unique
       #               constraint as CLUSTERED (if true), or NONCLUSTERED (if false).
       def column(name, type, opts = OPTS)
-        columns << {:name => name, :type => type}.merge!(opts)
+        columns << _merge_column_options({:name => name, :type => type}, opts)
         if index_opts = opts[:index]
           index(name, index_opts.is_a?(Hash) ? index_opts : OPTS)
         end
         nil
       end
-      
+
       # Adds a named CHECK constraint (or unnamed if name is nil),
       # with the given block or args. To provide options for the constraint, pass
       # a hash as the first argument.
@@ -178,6 +225,9 @@ module Sequel
       # :deferrable :: Whether the CHECK constraint should be marked DEFERRABLE.
       #
       # PostgreSQL specific options:
+      # :no_inherit :: Set NO INHERIT on the constraint, so it will not propogate to
+      #                child tables.
+      # :not_enforced :: Whether the CHECK constraint should be marked NOT ENFORCED.
       # :not_valid :: Whether the CHECK constraint should be marked NOT VALID.
       def constraint(name, *args, &block)
         opts = name.is_a?(Hash) ? name : {:name=>name}
@@ -197,9 +247,21 @@ module Sequel
       #
       # :foreign_key_constraint_name :: The name to give the foreign key constraint
       #
+      # PostgreSQL specific options:
+      #
+      # :not_enforced :: Whether the foreign key constraint should be marked NOT ENFORCED.
+      #
       # 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:
+      # composite foreign key), you can provide an array of columns as the first argument.
+      # This changes the method to accept constraint options instead of column options.
+      # You can provide the :name option to name the constraint.
+      #
+      # PostgreSQL specific options:
+      #
+      # :not_enforced :: Whether the foreign key constraint should be marked NOT ENFORCED.
+      # :period :: Use PERIOD to setup a constraint where the final column is a range
+      #            or multirange column, and the range or multirange is covered by
+      #            existing ranges in the referenced table (which can be in separate rows).
       #
       #   foreign_key([:artist_name, :artist_location], :artists, name: :artist_fk)
       #   # ADD CONSTRAINT artist_fk FOREIGN KEY (artist_name, artist_location) REFERENCES artists
@@ -213,7 +275,7 @@ module Sequel
           opts.merge(:table=>table)
         end
         return composite_foreign_key(name, opts) if name.is_a?(Array)
-        column(name, Integer, opts)
+        column(name, opts.fetch(:type, Integer), opts)
       end
 
       # Add a full text index on the given columns.
@@ -266,6 +328,7 @@ module Sequel
       # :opclass :: Set an opclass to use for all columns (per-column opclasses require
       #             custom SQL).
       # :tablespace :: Specify tablespace for index.
+      # :only :: Create index only for given table, not for any child tables (PostgreSQL 11+)
       #
       # Microsoft SQL Server specific options:
       #
@@ -303,6 +366,13 @@ module Sequel
       # :keep_order :: For non-composite primary keys, respects the existing order of
       #                columns, overriding the default behavior of making the primary
       #                key the first column.
+      #
+      # PostgreSQL specific options:
+      #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite primary keys only).
       # 
       # Examples:
       #   primary_key(:id)
@@ -346,6 +416,15 @@ module Sequel
       #
       # Supports the same :deferrable option as #column. The :name option can be used
       # to name the constraint.
+      #
+      # PostgreSQL specific options:
+      #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :nulls_not_distinct :: Use NULLS NOT DISTINCT to setup a constraint where NULL
+      #                        entries are considered distinct (PostgreSQL 15+)
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite unique only).
       def unique(columns, opts = OPTS)
         constraints << {:type => :unique, :columns => Array(columns)}.merge!(opts)
         nil
@@ -379,6 +458,8 @@ module Sequel
     # For more information on Sequel's support for schema modification, see
     # the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     class AlterTableGenerator
+      include ColumnOptionMerger
+
       # An array of operations to perform
       attr_reader :operations
       
@@ -404,7 +485,7 @@ module Sequel
       # :after :: The name of an existing column that the new column should be positioned after
       # :first :: Create this new column before all other existing columns
       def add_column(name, type, opts = OPTS)
-        op = {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        op = _merge_column_options({:op => :add_column, :name => name, :type => type}, opts)
         index_opts = op.delete(:index)
         @operations << op
         add_index(name, index_opts.is_a?(Hash) ? index_opts : OPTS) if index_opts
@@ -430,6 +511,16 @@ module Sequel
       #   add_unique_constraint(:name, name: :unique_name) # ADD CONSTRAINT unique_name UNIQUE (name)
       #
       # Supports the same :deferrable option as CreateTableGenerator#column.
+      #
+      # PostgreSQL specific options:
+      #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :nulls_not_distinct :: Use NULLS NOT DISTINCT to setup a constraint where NULL
+      #                        entries are considered distinct (PostgreSQL 15+)
+      # :using_index :: Use the USING INDEX clause to specify an existing unique index
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite unique constraints only).
       def add_unique_constraint(columns, opts = OPTS)
         @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge!(opts)
         nil
@@ -459,7 +550,7 @@ module Sequel
       #               sense when using an array of columns.
       def add_foreign_key(name, table, opts = OPTS)
         return add_composite_foreign_key(name, table, opts) if name.is_a?(Array)
-        add_column(name, Integer, {:table=>table}.merge!(opts))
+        add_column(name, opts.fetch(:type, Integer), {:table=>table}.merge!(opts))
       end
       
       # Add a full text index on the given columns.
@@ -483,6 +574,14 @@ module Sequel
       #
       #   add_primary_key(:id) # ADD COLUMN id serial PRIMARY KEY
       #   add_primary_key([:artist_id, :name]) # ADD PRIMARY KEY (artist_id, name)
+      #
+      # PostgreSQL specific options:
+      #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :using_index :: Use the USING INDEX clause to specify an existing unique index
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite primary keys only).
       def add_primary_key(name, opts = OPTS)
         return add_composite_primary_key(name, opts) if name.is_a?(Array)
         opts = @db.serial_primary_key_options.merge(opts)
@@ -589,9 +688,11 @@ module Sequel
         nil
       end
 
-      # Modify the type of one of the table's column.
+      # Modify the type of one of the table's column. The given options are considered when
+      # determining the new type.
       #
       #   set_column_type(:artist_name, 'char(10)') # ALTER COLUMN artist_name TYPE char(10)
+      #   set_column_type(:artist_name, String, size: 10) # ALTER COLUMN artist_name TYPE varchar(10)
       #
       # PostgreSQL specific options:
       #

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,8 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :using :: Create a VIRTUAL table with the given USING clause. The value should be
+    #           a string, as it is used directly in the SQL query.
     # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
     #                   'rowid' column, that uniquely identifies that row within the table.
     #                   If this option is used, the 'rowid' column is omitted, which can
@@ -484,7 +486,9 @@ module Sequel
     end
 
     def alter_table_set_column_type_sql(table, op)
-      "ALTER COLUMN #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
+      sql = "ALTER COLUMN #{quote_identifier(op[:name])} TYPE #{type_literal(op)}".dup
+      column_definition_collate_sql(sql, op)
+      sql
     end
 
     def alter_table_set_column_default_sql(table, op)
@@ -590,7 +594,12 @@ module Sequel
     
     # Add null/not null SQL fragment to column creation SQL.
     def column_definition_null_sql(sql, column)
-      null = column.fetch(:null, column[:allow_null])
+      null = if column[:not_null]
+        false
+      else
+        column.fetch(:null, column[:allow_null])
+      end
+
       if null.nil? && !can_add_primary_key_constraint_on_nullable_columns? && column[:primary_key]
         null = false
       end
@@ -603,36 +612,71 @@ module Sequel
       end
     end
 
-    # Add primary key SQL fragment to column creation SQL.
+    # Add primary key SQL fragment to column creation SQL if column is a primary key.
     def column_definition_primary_key_sql(sql, column)
-      if column[:primary_key]
-        if name = column[:primary_key_constraint_name]
-          sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << " " << primary_key_constraint_sql_fragment(column)
-        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
-      end
+      column_definition_add_primary_key_sql(sql, column) if column[:primary_key]
+    end
+
+    # Add primary key SQL fragment to column creation SQL (column should be a primary key).
+    def column_definition_add_primary_key_sql(sql, column)
+      constraint = column_definition_constraint_hash(column, :primary_key)
+      append_named_constraint_prefix_sql(sql, constraint[:name])
+      column_definition_append_primary_key_sql(sql, constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
+    end
+
+    def column_definition_append_primary_key_sql(sql, constraint)
+      sql << " " << primary_key_constraint_sql_fragment(constraint)
     end
     
-    # Add foreign key reference SQL fragment to column creation SQL.
+    # Add foreign key reference SQL fragment to column creation SQL if column is a foreign key.
     def column_definition_references_sql(sql, column)
-      if column[:table]
-        if name = column[:foreign_key_constraint_name]
-         sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << column_references_column_constraint_sql(column)
-      end
+      column_definition_add_references_sql(sql, column) if column[:table]
+    end
+
+    # Add foreign key reference SQL fragment to column creation SQL (column should be a foreign key).
+    def column_definition_add_references_sql(sql, column)
+      append_named_constraint_prefix_sql(sql, column[:foreign_key_constraint_name])
+      sql << column_references_column_constraint_sql(column)
     end
     
-    # Add unique constraint SQL fragment to column creation SQL.
+    # Add unique constraint SQL fragment to column creation SQL if column has a unique constraint.
     def column_definition_unique_sql(sql, column)
-      if column[:unique]
-        if name = column[:unique_constraint_name]
-          sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << ' ' << unique_constraint_sql_fragment(column)
-        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
+      column_definition_add_unique_sql(sql, column) if column[:unique]
+    end
+
+    # Add unique constraint SQL fragment to column creation SQL (column should have unique constraint).
+    def column_definition_add_unique_sql(sql, column)
+      constraint = column_definition_constraint_hash(column, :unique)
+      append_named_constraint_prefix_sql(sql, constraint[:name])
+      column_definition_append_unique_sql(sql, constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
+    end
+
+    def column_definition_append_unique_sql(sql, constraint)
+      sql << ' ' << unique_constraint_sql_fragment(constraint)
+    end
+
+    # Add the name of the constraint to the column creation SQL.
+    def append_named_constraint_prefix_sql(sql, name)
+      sql << " CONSTRAINT #{quote_identifier(name)}" if name
+    end
+
+    # Return a hash of constraint options for the primary key or column
+    # unique constraint.
+    def column_definition_constraint_hash(column, prefix)
+      constraint = column[prefix]
+      constraint = constraint.is_a?(Hash) ? constraint.dup : {}
+
+      if name = column[:"#{prefix}_constraint_name"]
+        constraint[:name] = name
+      end
+
+      if column.has_key?(:"#{prefix}_deferrable")
+        constraint[:deferrable] = column[:"#{prefix}_deferrable"]
       end
+
+      constraint
     end
     
     # SQL for all given columns, used inside a CREATE TABLE block.
@@ -649,12 +693,16 @@ module Sequel
     def column_references_sql(column)
       sql = String.new
       sql << " REFERENCES #{quote_schema_table(column[:table])}"
-      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(', ')})" if column[:key]
+      column_references_append_key_sql(sql, column) if column[:key]
       sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
       sql << " ON UPDATE #{on_update_clause(column[:on_update])}" if column[:on_update]
       constraint_deferrable_sql_append(sql, column[:deferrable])
       sql
     end
+
+    def column_references_append_key_sql(sql, column)
+      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(', ')})"
+    end
   
     # SQL fragment for table foreign key references (table constraints)
     def column_references_table_constraint_sql(constraint)
@@ -675,7 +723,7 @@ module Sequel
         check = constraint[:check]
         check = check.first if check.is_a?(Array) && check.length == 1
         check = filter_expr(check)
-        check = "(#{check})" unless check[0..0] == '(' && check[-1..-1] == ')'
+        check = "(#{check})" unless check.start_with?('(') && check.end_with?(')')
         sql << "CHECK #{check}"
       when :primary_key
         sql << "#{primary_key_constraint_sql_fragment(constraint)} #{literal(constraint[:columns])}"
@@ -731,17 +779,24 @@ module Sequel
     def create_table_sql(name, generator, options)
       unless supports_named_column_constraints?
         # Split column constraints into table constraints if they have a name
+        fk_opt_keys = [:key, :on_delete, :on_update, :deferrable]
         generator.columns.each do |c|
           if (constraint_name = c.delete(:foreign_key_constraint_name)) && (table = c.delete(:table))
             opts = {}
             opts[:name] = constraint_name
-            [:key, :on_delete, :on_update, :deferrable].each{|k| opts[k] = c[k]}
+            fk_opt_keys.each{|k| opts[k] = c[k]}
             generator.foreign_key([c[:name]], table, opts)
           end
-          if (constraint_name = c.delete(:unique_constraint_name)) && c.delete(:unique)
+
+          if c[:unique].is_a?(Hash) && c[:unique][:name]
+            generator.unique(c[:name], c.delete(:unique))
+          elsif (constraint_name = c.delete(:unique_constraint_name)) && c.delete(:unique)
             generator.unique(c[:name], :name=>constraint_name)
           end
-          if (constraint_name = c.delete(:primary_key_constraint_name)) && c.delete(:primary_key)
+
+          if c[:primary_key].is_a?(Hash) && c[:primary_key][:name]
+            generator.primary_key([c[:name]], c.delete(:primary_key))
+          elsif (constraint_name = c.delete(:primary_key_constraint_name)) && c.delete(:primary_key)
             generator.primary_key([c[:name]], :name=>constraint_name)
           end
         end
@@ -764,7 +819,7 @@ module Sequel
     # SELECT sql statement.
     def create_table_as(name, sql, options)
       sql = sql.sql if sql.is_a?(Sequel::Dataset)
-      run(create_table_as_sql(name, sql, options))
+      run(create_table_as_sql(name, sql, options).freeze)
     end
     
     # SQL statement for creating a table from the result of a SELECT statement.

data/lib/sequel/dataset/actions.rb

@@ -11,11 +11,12 @@ module Sequel
     
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
-      << [] all as_hash avg count columns columns! delete each
+      << [] all as_hash as_set avg count columns columns! delete each
       empty? fetch_rows first first! get import insert last
-      map max min multi_insert paged_each select_hash select_hash_groups select_map select_order_map
-      single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
-      where_all where_each where_single_value
+      map max min multi_insert paged_each select_hash select_hash_groups
+      select_map select_order_map select_set single_record single_record!
+      single_value single_value! sum to_hash to_hash_groups
+      truncate update where_all where_each where_single_value
     METHS
 
     # The clone options to use when retrieving columns for a dataset.
@@ -51,6 +52,26 @@ module Sequel
       _all(block){|a| each{|r| a << r}}
     end
     
+    # Returns sets for column values for each record in the dataset.
+    #
+    #   DB[:table].as_set(:id) # SELECT * FROM table
+    #   # => Set[1, 2, 3, ...]
+    #
+    # You can also provide an array of column names, in which case the elements
+    # of the returned set are arrays (not sets):
+    #
+    #   DB[:table].as_set([:id, :name]) # SELECT * FROM table
+    #   # => Set[[1, 'A'], [2, 'B'], [3, 'C'], ...]
+    def as_set(column)
+      return naked.as_set(column) if row_proc
+
+      if column.is_a?(Array)
+        to_set{|r| r.values_at(*column)}
+      else
+        to_set{|r| r[column]}
+      end
+    end
+
     # Returns the average value for the given column/expression.
     # Uses a virtual row block if no argument is given.
     #
@@ -217,7 +238,7 @@ module Sequel
       case args.length
       when 0
         unless block
-          return single_record
+          return(@opts[:sql] ? single_record! : single_record)
         end
       when 1
         arg = args[0]
@@ -282,6 +303,12 @@ module Sequel
     #
     #   DB[:table].get{[sum(id).as(sum), name]} # SELECT sum(id) AS sum, name FROM table LIMIT 1
     #   # => [6, 'foo']
+    #
+    # If called on a dataset with raw SQL, returns the
+    # first value in the dataset without changing the selection or setting a limit:
+    #
+    #   DB["SELECT id FROM table"].get # SELECT id FROM table
+    #   # =>  3
     def get(column=(no_arg=true; nil), &block)
       ds = naked
       if block
@@ -289,6 +316,8 @@ module Sequel
         ds = ds.select(&block)
         column = ds.opts[:select]
         column = nil if column.is_a?(Array) && column.length < 2
+      elsif no_arg && opts[:sql]
+        return ds.single_value!
       else
         case column
         when Array
@@ -343,6 +372,15 @@ module Sequel
     #   DB[:table].import([:x, :y], DB[:table2].select(:a, :b))
     #   # INSERT INTO table (x, y) SELECT a, b FROM table2 
     #
+    # The return value of this method is undefined and should not be used,
+    # except in two cases:
+    #
+    # * When the <tt>return: :primary_key</tt> option is used.
+    # * On PostgreSQL, when the dataset uses RETURNING. In this case, if
+    #   a single value is returned per row, the return value is an array
+    #   of those values. If multiple values are returned per row, the
+    #   return value is an array of hashes.
+    #
     # Options:
     # :commit_every :: Open a new transaction for every given number of
     #                  records. For example, if you provide a value of 50,
@@ -719,10 +757,7 @@ module Sequel
     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,
-    # the contents of the resulting array are undefined.  Raises an Error
-    # if called with both an argument and a block.
+    # returns an array of all values of that column in the dataset.
     #
     #   DB[:table].select_map(:id) # SELECT id FROM table
     #   # => [3, 5, 8, 1, ...]
@@ -760,6 +795,34 @@ module Sequel
       _select_map(column, true, &block)
     end
 
+    # Selects the column given (either as an argument or as a block), and
+    # returns a set of all values of that column in the dataset.
+    #
+    #   DB[:table].select_set(:id) # SELECT id FROM table
+    #   # => Set[3, 5, 8, 1, ...]
+    #
+    #   DB[:table].select_set{id * 2} # SELECT (id * 2) FROM table
+    #   # => Set[6, 10, 16, 2, ...]
+    #
+    # You can also provide an array of column names, which returns a set
+    # with array elements (not set elements):
+    #
+    #   DB[:table].select_map([:id, :name]) # SELECT id, name FROM table
+    #   # => Set[[1, 'A'], [2, 'B'], [3, 'C'], ...]
+    #
+    # If you provide an array of expressions, you must be sure that each entry
+    # in the array has an alias that Sequel can determine.
+    def select_set(column=nil, &block)
+      ds = ungraphed.naked
+      columns = Array(column)
+      virtual_row_columns(columns, block)
+      if column.is_a?(Array) || (columns.length > 1)
+        ds.select(*columns)._select_set_multiple(hash_key_symbols(columns))
+      else
+        ds.select(auto_alias_expression(columns.first))._select_set_single
+      end
+    end
+    
     # Limits the dataset to one record, and returns the first record in the dataset,
     # or nil if the dataset has no records. Users should probably use +first+ instead of
     # this method. Example:
@@ -1084,6 +1147,17 @@ module Sequel
       map{|r| r[k||=r.keys.first]}
     end
   
+    # Return a set of arrays of values given by the symbols in ret_cols.
+    def _select_set_multiple(ret_cols)
+      to_set{|r| r.values_at(*ret_cols)}
+    end
+  
+    # Returns a set of the first value in each row.
+    def _select_set_single
+      k = nil
+      to_set{|r| r[k||=r.keys.first]}
+    end
+  
     # A dataset for returning single values from the current dataset.
     def single_value_ds
       clone(:limit=>1).ungraphed.naked
@@ -1248,8 +1322,6 @@ module Sequel
     # receiver's current order. This yields the row and the array of order expressions
     # to the block, which should return an array of values to use.
     def ignore_values_preceding(row)
-      @opts[:order].map{|v| v.is_a?(SQL::OrderedExpression) ? v.expression : v}
-
       order_exprs = @opts[:order].map do |v|
         if v.is_a?(SQL::OrderedExpression)
           descending = v.descending