sequel 4.26.0 → 4.29.0

data/lib/sequel/dataset/actions.rb

@@ -12,7 +12,7 @@ module Sequel
       << [] all avg count columns columns! delete each
       empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
-      single_record single_value sum to_hash to_hash_groups truncate update
+      single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
     METHS
 
     # Inserts the given argument into the database.  Returns self so it
@@ -637,22 +637,51 @@ module Sequel
       _select_map(column, true, &block)
     end
 
-    # Returns the first record in the dataset, or nil if the dataset
-    # has no records. Users should probably use +first+ instead of
-    # this method.
+    # 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:
+    #
+    #   DB[:test].single_record # SELECT * FROM test LIMIT 1
+    #   # => {:column_name=>'value'}
     def single_record
-      clone(:limit=>1).each{|r| return r}
-      nil
+      clone(:limit=>1).single_record!
+    end
+
+    # Returns the first record in dataset, without limiting the dataset. Returns nil if
+    # the dataset has no records. Users should probably use +first+ instead of this method.
+    # This should only be used if you know the dataset is already limited to a single record.
+    # This method may be desirable to use for performance reasons, as it does not clone the
+    # receiver. Example:
+    #
+    #   DB[:test].single_record! # SELECT * FROM test
+    #   # => {:column_name=>'value'}
+    def single_record!
+      with_sql_first(select_sql)
     end
 
     # Returns the first value of the first record in the dataset.
     # Returns nil if dataset is empty.  Users should generally use
-    # +get+ instead of this method.
+    # +get+ instead of this method. Example:
+    #
+    #   DB[:test].single_value # SELECT * FROM test LIMIT 1
+    #   # => 'value'
     def single_value
       if r = ungraphed.naked.single_record
-        r.values.first
+        r.each{|_, v| return v}
       end
     end
+
+    # Returns the first value of the first record in the dataset, without limiting the dataset.
+    # Returns nil if the dataset is empty. Users should generally use +get+ instead of this
+    # method.  Should not be used on graphed datasets or datasets that have row_procs that
+    # don't return hashes.  This method may be desirable to use for performance reasons, as
+    # it does not clone the receiver.
+    #
+    #   DB[:test].single_value! # SELECT * FROM test
+    #   # => 'value'
+    def single_value!
+      with_sql_single_value(select_sql)
+    end
     
     # Returns the sum for the given column/expression.
     # Uses a virtual row block if no column is given.
@@ -818,7 +847,7 @@ module Sequel
     # only a single value.  See with_sql_each.
     def with_sql_single_value(sql)
       if r = with_sql_first(sql)
-        r.values.first
+        r.each{|_, v| return v}
       end
     end
 

data/lib/sequel/dataset/sql.rb

@@ -46,12 +46,11 @@ module Sequel
       end
 
       if values.is_a?(Array) && values.empty? && !insert_supports_empty_values? 
-        columns = [columns().last]
-        values = [DEFAULT]
+        columns, values = insert_empty_columns_values
       end
       clone(:columns=>columns, :values=>values).send(:_insert_sql)
     end
-    
+
     # Append a literal representation of a value to the given SQL string.
     # 
     # If an unsupported object is given, an +Error+ is raised.
@@ -1116,6 +1115,12 @@ module Sequel
       end 
     end
 
+    # The columns and values to use for an empty insert if the database doesn't support
+    # INSERT with DEFAULT VALUES.
+    def insert_empty_columns_values
+      [[columns.last], [DEFAULT]]
+    end
+    
     def insert_insert_sql(sql)
       sql << INSERT
     end

data/lib/sequel/extensions/date_arithmetic.rb

@@ -66,6 +66,9 @@ module Sequel
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
+          if defined?(super)
+            return super
+          end
           h = da.interval
           expr = da.expr
           cast = case db_type = db.database_type

data/lib/sequel/extensions/pg_json_ops.rb

@@ -50,6 +50,7 @@
 #   j.each_text              # json_each_text(json_column)
 #   j.keys                   # json_object_keys(json_column)
 #   j.typeof                 # json_typeof(json_column)
+#   j.strip_nulls            # json_strip_nulls(json_column)
 #
 #   j.populate(:a)           # json_populate_record(:a, json_column)
 #   j.populate_set(:a)       # json_populate_recordset(:a, json_column)
@@ -58,11 +59,16 @@
 #
 # There are additional methods are are only supported on JSONBOp instances:
 #
-#   j.contain_all(:a)  # (jsonb_column ?& a)
-#   j.contain_any(:a)  # (jsonb_column ?| a)
-#   j.contains(:h)     # (jsonb_column @> h)
-#   j.contained_by(:h) # (jsonb_column <@ h)
-#   j.has_key?('a')    # (jsonb_column ? 'a')
+#   j - 1                  # (jsonb_column - 1)
+#   j.concat(:h)           # (jsonb_column || h)
+#   j.contain_all(:a)      # (jsonb_column ?& a)
+#   j.contain_any(:a)      # (jsonb_column ?| a)
+#   j.contains(:h)         # (jsonb_column @> h)
+#   j.contained_by(:h)     # (jsonb_column <@ h)
+#   j.delete_path(%w'0 a') # (jsonb_column #- ARRAY['0','a'])
+#   j.has_key?('a')        # (jsonb_column ? 'a')
+#   j.pretty               # jsonb_pretty(jsonb_column)
+#   j.set(%w'0 a', :h)     # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
@@ -192,6 +198,13 @@ module Sequel
         SQL::Function.new(function_name(:populate_recordset), arg, self)
       end
 
+      # Returns a json value stripped of all internal null values.
+      #
+      #   json_op.strip_nulls # json_strip_nulls(json)
+      def strip_nulls
+        self.class.new(function(:strip_nulls))
+      end
+
       # Builds arbitrary record from json object.  You need to define the
       # structure of the record using #as on the resulting object:
       #
@@ -266,12 +279,30 @@ module Sequel
     #
     #   jsonb_op = Sequel.pg_jsonb(:jsonb)
     class JSONBOp < JSONBaseOp
+      CONCAT = ["(".freeze, " || ".freeze, ")".freeze].freeze
       CONTAIN_ALL = ["(".freeze, " ?& ".freeze, ")".freeze].freeze
       CONTAIN_ANY = ["(".freeze, " ?| ".freeze, ")".freeze].freeze
       CONTAINS = ["(".freeze, " @> ".freeze, ")".freeze].freeze
       CONTAINED_BY = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
+      DELETE_PATH = ["(".freeze, " #- ".freeze, ")".freeze].freeze
       HAS_KEY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
 
+      # jsonb expression for deletion of the given argument from the
+      # current jsonb.
+      #
+      #   jsonb_op - "a" # (jsonb - 'a')
+      def -(other)
+        self.class.new(super)
+      end
+
+      # jsonb expression for concatenation of the given jsonb into
+      # the current jsonb.
+      #
+      #   jsonb_op.concat(:h) # (jsonb || h)
+      def concat(other)
+        json_op(CONCAT, wrap_input_jsonb(other))
+      end
+
       # Check if the receiver contains all of the keys in the given array:
       #
       #   jsonb_op.contain_all(:a) # (jsonb ?& a)
@@ -300,6 +331,13 @@ module Sequel
         bool_op(CONTAINED_BY, wrap_input_jsonb(other))
       end
 
+      # Check if the other jsonb contains all entries in the receiver:
+      #
+      #   jsonb_op.delete_path(:h) # (jsonb #- h)
+      def delete_path(other)
+        json_op(DELETE_PATH, wrap_input_array(other))
+      end
+
       # Check if the receiver contains the given key:
       #
       #   jsonb_op.has_key?('a') # (jsonb ? 'a')
@@ -313,6 +351,21 @@ module Sequel
         self
       end
 
+      # Returns a json value for the object at the given path.
+      #
+      #   jsonb_op.pretty # jsonb_pretty(jsonb)
+      def pretty
+        Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
+      end
+
+      # Returns a json value for the object at the given path.
+      #
+      #   jsonb_op.set(['a', 'b'], h) # jsonb_set(jsonb, ARRAY['a', 'b'], h, true)
+      #   jsonb_op.set(['a', 'b'], h, false) # jsonb_set(jsonb, ARRAY['a', 'b'], h, false)
+      def set(path, other, create_missing=true)
+        self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
+      end
+
       private
 
       # Return a placeholder literal with the given str and args, wrapped

data/lib/sequel/extensions/schema_dumper.rb

@@ -166,6 +166,14 @@ END_MIG
         type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
         if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
+          type_hash.delete(:type)
+        end
+
+        unless gen.columns.empty?
+          type_hash[:keep_order] = true
+        end
+
+        if type_hash.empty?
           gen.primary_key(name)
         else
           gen.primary_key(name, type_hash)
@@ -378,7 +386,7 @@ END_MIG
           x.delete(:on_delete) if x[:on_delete] == :no_action
           x.delete(:on_update) if x[:on_update] == :no_action
         end
-        if pkn = primary_key_name
+        if (pkn = primary_key_name) && !@primary_key[:keep_order]
           cols.delete_if{|x| x[:name] == pkn}
           pk = @primary_key.dup
           pkname = pk.delete(:name)
@@ -391,6 +399,9 @@ END_MIG
           strings << if table = c.delete(:table)
             c.delete(:type) if c[:type] == Integer || c[:type] == 'integer'
             "foreign_key #{name.inspect}, #{table.inspect}#{opts_inspect(c)}"
+          elsif pkn == name
+            @db.serial_primary_key_options.each{|k,v| c.delete(k) if v == c[k]}
+            "primary_key #{name.inspect}#{opts_inspect(c)}"
           else
             type = c.delete(:type)
             opts = opts_inspect(c)

data/lib/sequel/model/base.rb

@@ -1743,6 +1743,32 @@ module Sequel
 
       private
       
+      # Run code directly after the INSERT query, before after_create.
+      # This is only a temporary API, it should not be overridden by external code.
+      def _after_create(pk)
+        @this = nil
+        @new = false
+        @was_new = true
+      end
+
+      # Run code after around_save returns, before calling after_commit.
+      # This is only a temporary API, it should not be overridden by external code.
+      def _after_save(pk)
+        if @was_new
+          @was_new = nil
+          pk ? _save_refresh : changed_columns.clear
+        else
+          @columns_updated = nil
+        end
+        @modified = false
+      end
+
+      # Run code directly after the UPDATE query, before after_update.
+      # This is only a temporary API, it should not be overridden by external code.
+      def _after_update
+        @this = nil
+      end
+
       # Run code before any validation is done, but also run it before saving
       # even if validation is skipped.  This is a private hook.  It exists so that
       # plugins can set values automatically before validation (as the values
@@ -1841,7 +1867,7 @@ module Sequel
       # Refresh using a particular dataset, used inside save to make sure the same server
       # is used for reading newly inserted values from the database
       def _refresh(dataset)
-        _refresh_set_values(_refresh_get(dataset) || raise(Error, "Record not found"))
+        _refresh_set_values(_refresh_get(dataset) || raise(NoExistingObject, "Record not found"))
         changed_columns.clear
       end
 
@@ -1860,7 +1886,6 @@ module Sequel
       def _save(opts)
         sh = {:server=>this_server}
         db.after_rollback(sh){after_rollback} if uacr = use_after_commit_rollback
-        was_new = false
         pk = nil
         called_save = false
         called_cu = false
@@ -1868,14 +1893,11 @@ module Sequel
           called_save = true
           raise_hook_failure(:before_save) if before_save == false
           if new?
-            was_new = true
             around_create do
               called_cu = true
               raise_hook_failure(:before_create) if before_create == false
               pk = _insert
-              @this = nil
-              @new = false
-              @was_new = true
+              _after_create(pk)
               after_create
               true
             end
@@ -1898,7 +1920,7 @@ module Sequel
                 changed_columns.reject!{|c| columns.include?(c)}
               end
               _update_columns(@columns_updated)
-              @this = nil
+              _after_update
               after_update
               true
             end
@@ -1908,22 +1930,16 @@ module Sequel
           true
         end
         raise_hook_failure(:around_save) unless called_save
-        if was_new
-          @was_new = nil
-          pk ? _save_refresh : changed_columns.clear
-        else
-          @columns_updated = nil
-        end
-        @modified = false
+        _after_save(pk)
         db.after_commit(sh){after_commit} if uacr
         self
       end
-
+      
       # Refresh the object after saving it, used to get
       # default values of all columns.  Separated from _save so it
       # can be overridden to avoid the refresh.
       def _save_refresh
-        _save_set_values(_refresh_get(this.server?(:default)) || raise(Error, "Record not found"))
+        _save_set_values(_refresh_get(this.server?(:default)) || raise(NoExistingObject, "Record not found"))
         changed_columns.clear
       end
 

data/lib/sequel/plugins/active_model.rb

@@ -44,6 +44,13 @@ module Sequel
           @destroyed = true
         end
 
+        # Mark current instance as destroyed if the transaction in which this
+        # instance is created is rolled back.
+        def before_create
+          db.after_rollback{@destroyed = true}
+          super
+        end
+
         # Return ::ActiveModel::Name instance for the class.
         def model_name
           model.model_name

data/lib/sequel/plugins/before_after_save.rb

@@ -0,0 +1,48 @@
+module Sequel
+  module Plugins
+    # The before_after_save plugin reorders some internal
+    # Sequel operations so they happen before after_create,
+    # after_update, and after_save are called, instead of
+    # after.  These operations are:
+    # 
+    # * Resetting the explicit modified flag
+    # * Refreshing the model or clearing changed columns after creation
+    #
+    # This behavior will become the default in Sequel 5.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses perform the operations before after_save
+    #   Sequel::Model.plugin :before_after_save
+    #
+    #   # Make the Album class perform the operations before after_save
+    #   Album.plugin :before_after_save
+    module BeforeAfterSave
+      module InstanceMethods
+        private
+
+        # Refresh and reset modified flag right after INSERT query.
+        def _after_create(pk)
+          super
+          @modified = false
+          pk ? _save_refresh : changed_columns.clear
+        end
+
+        # Don't refresh or reset modified flag, as it was already done.
+        def _after_save(pk)
+          if @was_new
+            @was_new = nil
+          else
+            @columns_updated = nil
+          end
+        end
+
+        # Refresh and reset modified flag right after UPDATE query.
+        def _after_update
+          super
+          @modified = false
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/boolean_subsets.rb

@@ -0,0 +1,56 @@
+module Sequel
+  module Plugins
+    # The boolean_subsets plugin allows for the automatic creation of subsets for
+    # for boolean columns, which can DRY up model classes that define such subsets
+    # manually.  By default, subsets are created for all columns of type :boolean,
+    # with the subset name being the same as column name, and the conditions being
+    # <tt>column IS TRUE</tt> (assuming the database supports that syntax).
+    #
+    # You can provide a block to the plugin, which will be called with column name
+    # symbol, and should return an array of arguments to pass to +subset+.
+    # Using this, you can change the method name and arguments for each column.
+    # This block is executed in the context of the model class.
+    #
+    # Usage:
+    #
+    #   # Add boolean subset methods for all columns of type :boolean
+    #   # in all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :boolean_subsets
+    #
+    #   # Add subsets for all boolean columns in the Album class
+    #   Album.plugin(:boolean_subsets)
+    #
+    #   # Remove is_ from the front of the column name when creating the subset
+    #   # method name, and use (column = 'Y') as the filter conditions
+    #   Sequel::Model.plugin :boolean_subsets do |column|
+    #     [column.to_s.sub(/\Ais_/, ''), {column=>'Y'}]
+    #   end
+    module BooleanSubsets
+      # Add the boolean_attribute? class method to the model, and create
+      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      def self.configure(model, &block)
+        model.instance_eval do
+          (class << self; self; end).send(:define_method, :boolean_subset_args, &block) if block
+          send(:create_boolean_subsets) if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :create_boolean_subsets)
+
+        private
+
+        # The arguments to use when automatically defining a boolean subset for the given column.
+        def boolean_subset_args(c)
+          [c, {c=>true}]
+        end
+
+        # Add subset methods for all of the boolean columns in this model.
+        def create_boolean_subsets
+          cs = columns rescue return
+          cs.each{|c| subset(*boolean_subset_args(c)) if db_schema[c][:type] == :boolean}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/csv_serializer.rb

@@ -163,7 +163,7 @@ module Sequel
 
           CSV.generate(opts) do |csv|
             items.each do |object|
-              csv << opts[:headers].map{|header| object[header]}
+              csv << opts[:headers].map{|header| object.send(header) }
             end
           end
         end

data/lib/sequel/plugins/defaults_setter.rb

@@ -1,12 +1,16 @@
 module Sequel
   module Plugins
-    # DefaultsSetter is a simple plugin that sets non-nil/NULL default values upon
-    # initialize:
+    # The defaults_setter plugin makes the column getter methods return the default
+    # values for new objects, if the values have not already been set.  Example:
     #
     #   # column a default NULL
     #   # column b default 2
-    #   album = Album.new.values # {:b => 2}
-    #   album = Album.new(:a=>1, :b=>3).values # {:a => 1, :b => 3}
+    #   album = Album.new
+    #   album.a # => nil
+    #   album.b # => 2
+    #   album = Album.new(:a=>1, :b=>3)
+    #   album.a # => 1
+    #   album.b # => 3
     # 
     # Usage:
     #

data/lib/sequel/plugins/json_serializer.rb

@@ -36,6 +36,12 @@ module Sequel
     #   album.to_json(:root => true)
     #   # => '{"album":{"id":1,"name":"RF","artist_id":2}}'
     #
+    # You can specify JSON serialization options to use later:
+    #
+    #   album.json_serializer_opts(:root => true)
+    #   [album].to_json
+    #   # => '[{"album":{"id":1,"name":"RF","artist_id":2}}]'
+    #
     # Additionally, +to_json+ also exists as a class and dataset method, both
     # of which return all objects in the dataset:
     #
@@ -239,6 +245,20 @@ module Sequel
           self
         end
 
+        # Set the json serialization options that will be used by default
+        # in future calls to +to_json+.  This is designed for cases where
+        # the model object will be used inside another data structure
+        # which to_json is called on, and as such will not allow passing
+        # of arguments to +to_json+.
+        #
+        # Example:
+        #
+        #   obj.json_serializer_opts(:only=>:name)
+        #   [obj].to_json # => '[{"name":"..."}]'
+        def json_serializer_opts(opts=OPTS)
+          @json_serializer_opts = Hash[@json_serializer_opts||OPTS].merge!(opts)
+        end
+
         # Return a string in JSON format.  Accepts the following
         # options:
         #
@@ -257,12 +277,13 @@ module Sequel
         #          string is given, use the string as the key, otherwise
         #          use an underscored version of the model's name.
         def to_json(*a)
-          if opts = a.first.is_a?(Hash)
-            opts = model.json_serializer_opts.merge(a.first)
+          opts = model.json_serializer_opts
+          opts = Hash[opts].merge!(@json_serializer_opts) if @json_serializer_opts
+          if (arg_opts = a.first).is_a?(Hash)
+            opts = Hash[opts].merge!(arg_opts)
             a = []
-          else
-            opts = model.json_serializer_opts
           end
+
           vals = values
           cols = if only = opts[:only]
             Array(only)

data/lib/sequel/plugins/list.rb

@@ -87,15 +87,6 @@ module Sequel
           list_dataset.first(position_field => p)
         end
 
-        # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
-        def before_create
-          unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
-          end
-          super
-        end
-
         # When destroying an instance, move all entries after the instance down
         # one position, so that there aren't any gaps
         def after_destroy
@@ -179,6 +170,15 @@ module Sequel
 
         private
 
+        # Set the value of the position_field to the maximum value plus 1 unless the
+        # position field already has a value.
+        def _before_validation
+          unless get_column_value(position_field)
+            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
+          end
+          super
+        end
+
         # The model's position field, an instance method for ease of use.
         def position_field
           model.position_field

data/lib/sequel/plugins/subset_conditions.rb

@@ -0,0 +1,36 @@
+module Sequel
+  module Plugins
+    # The subset_conditions plugin creates an additional *_conditions method
+    # for every subset created, which returns the filter conditions the subset
+    # uses.  This can be useful if you want to use the conditions for a separate
+    # filter or combine them with OR.
+    #
+    # Usage:
+    #
+    #   # Add subset_conditions in the Album class
+    #   Album.plugin :subset_conditions
+    #
+    #   # This will now create a published_conditions method
+    #   Album.subset :published, :published => true
+    #
+    #   Album.where(Album.published_conditions).sql
+    #   # SELECT * FROM albums WHERE (published IS TRUE)
+    #
+    #   Album.exclude(Album.published_conditions).sql
+    #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
+    #
+    #   Album.where(Sequel.|(Album.published_conditions, :ready=>true)).sql
+    #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
+    module SubsetConditions
+      module ClassMethods
+        # Also create a method that returns the conditions the filter uses.
+        def subset(name, *args, &block)
+          super
+          cond = args
+          cond = cond.first if cond.size == 1
+          def_dataset_method(:"#{name}_conditions"){filter_expr(cond, &block)}
+        end
+      end
+    end
+  end
+end