sequel 3.6.0 → 3.7.0

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

@@ -107,11 +107,29 @@ module Sequel
         db[:dual].where(exists).get(1) == nil
       end
 
+      # If this dataset is associated with a sequence, return the most recently
+      # inserted sequence value.
+      def insert(*args)
+        r = super
+        if s = opts[:sequence]
+          with_sql("SELECT #{literal(s)}.currval FROM dual").single_value.to_i
+        else
+          r
+        end
+      end
+
       # Oracle requires SQL standard datetimes
       def requires_sql_standard_datetimes?
         true
       end
 
+      # Create a copy of this dataset associated to the given sequence name,
+      # which will be used when calling insert to find the most recently
+      # inserted value for the sequence.
+      def sequence(s)
+        clone(:sequence=>s)
+      end
+
       # Oracle does not support DISTINCT ON
       def supports_distinct_on?
         false

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

@@ -335,7 +335,7 @@ module Sequel
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
-        {:primary_key => true, :type => :serial}
+        {:primary_key => true, :serial => true, :type=>Integer}
       end
       
       # The version of the PostgreSQL server, used for determining capability.
@@ -551,11 +551,21 @@ module Sequel
         "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"
       end
       
+      # Handle bigserial type if :serial option is present
+      def type_literal_generic_bignum(column)
+        column[:serial] ? :bigserial : super
+      end
+
       # PostgreSQL uses the bytea data type for blobs
       def type_literal_generic_file(column)
         :bytea
       end
 
+      # Handle serial type if :serial option is present
+      def type_literal_generic_integer(column)
+        column[:serial] ? :serial : super
+      end
+
       # PostgreSQL prefers the text datatype.  If a fixed size is requested,
       # the char type is used.  If the text type is specifically
       # disallowed or there is a size specified, use the varchar type.
@@ -578,6 +588,7 @@ module Sequel
       BOOL_FALSE = 'false'.freeze
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from using where')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
@@ -595,6 +606,7 @@ module Sequel
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set from where')
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
@@ -696,6 +708,11 @@ module Sequel
         [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
+      # PostgreSQL supports modifying joined datasets
+      def supports_modifying_joins?
+        true
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true
@@ -713,12 +730,38 @@ module Sequel
       
       private
       
+      # PostgreSQL allows deleting from joined datasets
+      def delete_clause_methods
+        DELETE_CLAUSE_METHODS
+      end 
+
+      # Only include the primary table in the main delete clause
+      def delete_from_sql(sql)
+        sql << " FROM #{source_list(@opts[:from][0..0])}"
+      end
+
+      # Use USING to specify additional tables in a delete query
+      def delete_using_sql(sql)
+        join_from_sql(:USING, sql)
+      end
+
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
       def insert_returning_pk_sql(*values)
         pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
         insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
       end
       
+      # For multiple table support, PostgreSQL requires at least
+      # two from tables, with joins allowed.
+      def join_from_sql(type, sql)
+        if(from = @opts[:from][1..-1]).empty?
+          raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
+        else
+          sql << " #{type} #{source_list(from)}"
+          select_join_sql(sql)
+        end
+      end
+
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
       def literal_blob(v)
         "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
@@ -776,6 +819,21 @@ module Sequel
         cols.pop
         literal(SQL::StringExpression.new(:'||', *cols))
       end
+
+      # PostgreSQL splits the main table from the joined tables
+      def update_clause_methods
+        UPDATE_CLAUSE_METHODS
+      end
+
+      # Use FROM to specify additional tables in an update query
+      def update_from_sql(sql)
+        join_from_sql(:FROM, sql)
+      end
+
+      # Only include the primary table in the main update clause
+      def update_table_sql(sql)
+        sql << " #{source_list(@opts[:from][0..0])}"
+      end
     end
   end
 end

data/lib/sequel/dataset/convenience.rb

@@ -3,8 +3,7 @@ module Sequel
     COMMA_SEPARATOR = ', '.freeze
     COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
     ARRAY_ACCESS_ERROR_MSG = 'You cannot call Dataset#[] with an integer or with no arguments.'.freeze
-    MAP_ERROR_MSG = 'Using Dataset#map with an argument and a block is not allowed'.freeze
-    GET_ERROR_MSG = 'must provide argument or block to Dataset#get, not both'.freeze
+    ARG_BLOCK_ERROR_MSG = 'Must use either an argument or a block, not both'.freeze
     IMPORT_ERROR_MSG = 'Using Sequel::Dataset#import an empty column array is not allowed'.freeze
 
     # Returns the first record matching the conditions. Examples:
@@ -74,7 +73,7 @@ module Sequel
     #   ds.get{|o| o.sum(:id)}
     def get(column=nil, &block)
       if column
-        raise(Error, GET_ERROR_MSG) if block
+        raise(Error, ARG_BLOCK_ERROR_MSG) if block
         select(column).single_value
       else
         select(&block).single_value
@@ -91,13 +90,9 @@ module Sequel
     #   ds.group_and_count(:first_name, :last_name).all => [{:first_name=>'a', :last_name=>'b', :count=>1}, ...]
     #   ds.group_and_count(:first_name___name).all => [{:name=>'a', :count=>1}, ...]
     def group_and_count(*columns)
-      groups = columns.map do |c|
-        c_table, column, _ = split_symbol(c)
-        c_table ? column.to_sym.qualify(c_table) : column.to_sym
-      end
-      group(*groups).select(*(columns + [COUNT_OF_ALL_AS_COUNT])).order(:count)
+      group(*columns.map{|c| unaliased_identifier(c)}).select(*(columns + [COUNT_OF_ALL_AS_COUNT])).order(:count)
     end
-    
+
     # Inserts multiple records into the associated table. This method can be
     # to efficiently insert a large amounts of records into a table. Inserts
     # are automatically wrapped in a transaction.
@@ -158,7 +153,7 @@ module Sequel
     #   ds.map{|r| r[:id] * 2} => [2, 4, 6, ...]
     def map(column=nil, &block)
       if column
-        raise(Error, MAP_ERROR_MSG) if block
+        raise(Error, ARG_BLOCK_ERROR_MSG) if block
         super(){|r| r[column]}
       else
         super(&block)
@@ -199,6 +194,32 @@ module Sequel
       end
     end
     
+    def select_hash(key_column, value_column)
+      select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
+    end
+
+    def select_map(column=nil, &block)
+      ds = naked.ungraphed
+      ds = if column
+        raise(Error, ARG_BLOCK_ERROR_MSG) if block
+        ds.select(column)
+      else
+        ds.select(&block)
+      end
+      ds.map{|r| r.values.first}
+    end
+
+    def select_order_map(column=nil, &block)
+      ds = naked.ungraphed
+      ds = if column
+        raise(Error, ARG_BLOCK_ERROR_MSG) if block
+        ds.select(column).order(unaliased_identifier(column))
+      else
+        ds.select(&block).order(&block)
+      end
+      ds.map{|r| r.values.first}
+    end
+
     # Returns the first record in the dataset.
     def single_record
       clone(:limit=>1).each{|r| return r}
@@ -208,7 +229,7 @@ module Sequel
     # Returns the first value of the first record in the dataset.
     # Returns nil if dataset is empty.
     def single_value
-      if r = naked.clone(:graph=>false).single_record
+      if r = naked.ungraphed.single_record
         r.values.first
       end
     end
@@ -245,5 +266,31 @@ module Sequel
         m
       end
     end
+
+    private
+
+    # Return a plain symbol given a potentially qualified or aliased symbol,
+    # specifying the symbol that is likely to be used as the hash key
+    # for the column when records are returned.
+    def hash_key_symbol(s)
+      raise(Error, "#{s.inspect} is not a symbol") unless s.is_a?(Symbol)
+      _, c, a = split_symbol(s)
+      (a || c).to_sym
+    end
+
+    # Return the unaliased part of the identifier.  Handles both
+    # implicit aliases in symbols, as well as SQL::AliasedExpression
+    # objects.  Other objects are returned as is.
+    def unaliased_identifier(c)
+      case c
+      when Symbol
+        c_table, column, _ = split_symbol(c)
+        c_table ? column.to_sym.qualify(c_table) : column.to_sym
+      when SQL::AliasedExpression
+        c.expression
+      else
+        c
+      end
+    end
   end
 end

data/lib/sequel/dataset/features.rb

@@ -41,6 +41,11 @@ module Sequel
       true
     end
     
+    # Whether modifying joined datasets is supported.
+    def supports_modifying_joins?
+      false
+    end
+    
     # Whether the IN/NOT IN operators support multiple columns when an
     # array of values is given.
     def supports_multiple_column_in?

data/lib/sequel/dataset/query.rb

@@ -144,8 +144,8 @@ module Sequel
     #
     #   ds = DB[:items].order(:name).select(:id, :name)
     #   ds.sql                         #=> "SELECT id,name FROM items ORDER BY name"
-    #   ds.from_self.sql               #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 't1'"
-    #   ds.from_self(:alias=>:foo).sql #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS 'foo'"
+    #   ds.from_self.sql               #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS t1"
+    #   ds.from_self(:alias=>:foo).sql #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo"
     def from_self(opts={})
       fs = {}
       @opts.keys.each{|k| fs[k] = nil unless FROM_SELF_KEEP_OPTS.include?(k)}
@@ -370,7 +370,7 @@ module Sequel
     # 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[:from_self] == false ? ds : ds.from_self(opts)
     end
 
     # SQL fragment based on the expr type.  See #filter.

data/lib/sequel/dataset/sql.rb

@@ -52,6 +52,11 @@ module Sequel
       a.empty? ? '(NULL)' : "(#{expression_list(a)})"     
     end
 
+    # SQL fragment for BooleanConstants
+    def boolean_constant_sql(constant)
+      literal(constant)
+    end
+
     # SQL fragment for specifying given CaseExpression.
     def case_expression_sql(ce)
       sql = '(CASE '
@@ -386,6 +391,11 @@ module Sequel
       values.map{|r| insert_sql(columns, r)}
     end
     
+    # SQL fragment for NegativeBooleanConstants
+    def negative_boolean_constant_sql(constant)
+      "NOT #{boolean_constant_sql(constant)}"
+    end
+
     # SQL fragment for the ordered expression, used in the ORDER BY
     # clause.
     def ordered_expression_sql(oe)
@@ -643,7 +653,7 @@ module Sequel
     # for this dataset
     def check_modification_allowed!
       raise(InvalidOperation, "Grouped datasets cannot be modified") if opts[:group]
-      raise(InvalidOperation, "Joined datasets cannot be modified") if (opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join]
+      raise(InvalidOperation, "Joined datasets cannot be modified") if !supports_modifying_joins? && joined_dataset?
     end
 
     # Prepare an SQL statement by calling all clause methods for the given statement type.
@@ -754,6 +764,11 @@ module Sequel
       "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
     end
 
+    # Whether this dataset is a joined dataset
+    def joined_dataset?
+     (opts[:from].is_a?(Array) && opts[:from].size > 1) || opts[:join]
+    end
+
     # SQL fragment for Array.  Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
     def literal_array(v)
       Sequel.condition_specifier?(v) ? literal_expression(SQL::BooleanExpression.from_value_pairs(v)) : array_sql(v)
@@ -1058,9 +1073,11 @@ module Sequel
       UPDATE_CLAUSE_METHODS
     end
 
-    # SQL fragment specifying the tables from with to delete
+    # SQL fragment specifying the tables from with to delete.
+    # Includes join table if modifying joins is allowed.
     def update_table_sql(sql)
       sql << " #{source_list(@opts[:from])}"
+      select_join_sql(sql) if supports_modifying_joins?
     end
 
     # The SQL fragment specifying the columns and values to SET.

data/lib/sequel/extensions/schema_dumper.rb

@@ -86,7 +86,12 @@ END_MIG
     # name and arguments to it to pass to a Schema::Generator to recreate the column.
     def column_schema_to_generator_opts(name, schema, options)
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
-        [:primary_key, name]
+        type_hash = column_schema_to_ruby_type(schema)
+        if type_hash == {:type=>Integer}
+          [:primary_key, name]
+        else
+          [:primary_key, name, type_hash]
+        end
       else
         col_opts = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         type = col_opts.delete(:type)

data/lib/sequel/model/base.rb

@@ -507,7 +507,7 @@ module Sequel
 
       class_attr_reader :columns, :db, :primary_key, :db_schema
       class_attr_overridable :raise_on_save_failure, :raise_on_typecast_failure, :strict_param_setting, :typecast_empty_string_to_nil, :typecast_on_assignment, :use_transactions
-      
+
       # The hash of attribute values.  Keys are symbols with the names of the
       # underlying database columns.
       attr_reader :values
@@ -607,9 +607,10 @@ module Sequel
       # If before_destroy returns false, returns false without
       # deleting the object the the database. Otherwise, deletes
       # the item from the database and returns self.  Uses a transaction
-      # if use_transactions is true.
-      def destroy
-        use_transactions ? db.transaction{_destroy} : _destroy
+      # if use_transactions is true or if the :transaction option is given and
+      # true.
+      def destroy(opts = {})
+        checked_save_failure{checked_transaction(opts){_destroy(opts)}}
       end
 
       # Iterates through all of the current values using each.
@@ -721,9 +722,11 @@ module Sequel
       # * :validate - set to false not to validate the model before saving
       def save(*columns)
         opts = columns.last.is_a?(Hash) ? columns.pop : {}
-        return save_failure(:invalid) if opts[:validate] != false and !valid?
-        use_transaction = opts.include?(:transaction) ? opts[:transaction] : use_transactions
-        use_transaction ? db.transaction(opts){_save(columns, opts)} : _save(columns, opts)
+        if opts[:validate] != false and !valid?
+          raise(ValidationFailed, errors.full_messages.join(', ')) if raise_on_save_failure 
+          return
+        end
+        checked_save_failure{checked_transaction(opts){_save(columns, opts)}}
       end
 
       # Saves only changed columns if the object has been modified.
@@ -797,7 +800,7 @@ module Sequel
       def valid?
         errors.clear
         if before_validation == false
-          save_failure(:validation)
+          save_failure(:validation) if raise_on_save_failure
           return false
         end
         validate
@@ -809,7 +812,7 @@ module Sequel
   
       # Internal destroy method, separted from destroy to
       # allow running inside a transaction
-      def _destroy
+      def _destroy(opts)
         return save_failure(:destroy) if before_destroy == false
         delete
         after_destroy
@@ -880,10 +883,30 @@ module Sequel
         self
       end
       
+      # Update this instance's dataset with the supplied column hash.
       def _update(columns)
         this.update(columns)
       end
+
+      # If raise_on_save_failure is false, check for BeforeHookFailed
+      # beind raised by yielding and swallow it.
+      def checked_save_failure
+        if raise_on_save_failure
+          yield
+        else
+          begin
+            yield
+          rescue BeforeHookFailed 
+            nil
+          end
+        end
+      end
       
+      # If transactions should be used, wrap the yield in a transaction block.
+      def checked_transaction(opts)
+        use_transaction?(opts)? db.transaction(opts){yield} : yield
+      end
+
       # Default inspection output for the values hash, overwrite to change what #inspect displays.
       def inspect_values
         @values.inspect
@@ -891,13 +914,7 @@ module Sequel
   
       # Raise an error if raise_on_save_failure is true, return nil otherwise.
       def save_failure(type)
-        if raise_on_save_failure
-          if type == :invalid
-            raise ValidationFailed, errors.full_messages.join(', ')
-          else
-            raise BeforeHookFailed, "one of the before_#{type} hooks returned false"
-          end
-        end
+        raise BeforeHookFailed, "one of the before_#{type} hooks returned false"
       end
   
       # Set the columns, filtered by the only and except arrays.
@@ -968,6 +985,13 @@ module Sequel
         set_restricted(hash, only, except)
         save_changes
       end
+      
+      # Whether to use a transaction for this action.  If the :transaction
+      # option is present in the hash, use that, otherwise, fallback to the
+      # object's default (if set), or class's default (if not).
+      def use_transaction?(opts = {})
+        opts.include?(:transaction) ? opts[:transaction] : use_transactions
+      end
     end
 
     # Dataset methods are methods that the model class extends its dataset with in