sequel 4.41.0 → 4.42.0

data/lib/sequel/plugins/association_pks.rb

@@ -71,11 +71,11 @@ module Sequel
             lambda do
               h = {}
               lk.zip(lpk).each{|k, pk| h[k] = get_column_value(pk)}
-              _join_table_dataset(opts).filter(h).select_map(rk)
+              _join_table_dataset(opts).where(h).select_map(rk)
             end
           else
             lambda do
-              _join_table_dataset(opts).filter(lk=>get_column_value(lpk)).select_map(rk)
+              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select_map(rk)
             end
           end
 
@@ -91,7 +91,7 @@ module Sequel
                   lpkv = get_column_value(lpk)
                   cond = {lk=>lpkv}
                 end
-                ds = _join_table_dataset(opts).filter(cond)
+                ds = _join_table_dataset(opts).where(cond)
                 ds.exclude(rk=>pks).delete
                 pks -= ds.select_map(rk)
                 lpkv = Array(lpkv)
@@ -139,7 +139,7 @@ module Sequel
 
               checked_transaction do
                 ds = send(opts.dataset_method)
-                ds.unfiltered.filter(pkh).update(h)
+                ds.unfiltered.where(pkh).update(h)
                 ds.exclude(pkh).update(nh)
               end
             end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -280,7 +280,7 @@ module Sequel
             @sti_dataset = ds.join(table, pk=>pk).select_append(*sel_app)
             set_dataset(@sti_dataset)
             set_columns(self.columns)
-            dataset.row_proc = lambda{|r| subclass.sti_load(r)}
+            @dataset = @dataset.with_row_proc(lambda{|r| subclass.sti_load(r)})
             (columns - [pk]).each{|a| define_lazy_attribute_getter(a, :dataset=>dataset, :table=>table)}
 
             @cti_models += [self]
@@ -323,7 +323,7 @@ module Sequel
         private
 
         def cti_this(model)
-          use_server(model.cti_instance_dataset.filter(model.primary_key_hash(pk)))
+          use_server(model.cti_instance_dataset.where(model.primary_key_hash(pk)))
         end
 
         # Set the sti_key column based on the sti_key_map.

data/lib/sequel/plugins/constraint_validations.rb

@@ -117,8 +117,7 @@ module Sequel
           end
 
           if @dataset
-            ds = @dataset.clone
-            ds.quote_identifiers = false
+            ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
             @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}

data/lib/sequel/plugins/csv_serializer.rb

@@ -31,7 +31,7 @@ module Sequel
     # all objects in the dataset:
     #
     #   Album.to_csv
-    #   Album.filter(:artist_id=>1).to_csv
+    #   Album.where(:artist_id=>1).to_csv
     #
     # If you have an existing array of model instance you want to convert to
     # CSV, you can call the class to_csv method with the :array option:
@@ -48,7 +48,7 @@ module Sequel
     # The array_from_csv class method exists to parse arrays of model instances
     # from CSV:
     #
-    #   csv = Album.filter(:artist_id=>1).to_csv
+    #   csv = Album.where(:artist_id=>1).to_csv
     #   albums = Album.array_from_csv(csv)
     #
     # These do not necessarily round trip, since doing so would let users

data/lib/sequel/plugins/dataset_associations.rb

@@ -12,7 +12,7 @@ module Sequel
     #     plugin :dataset_associations
     #     one_to_many :albums
     #   end
-    #   Artist.filter(id=>1..100).albums
+    #   Artist.where(id=>1..100).albums
     #   # SELECT * FROM albums
     #   # WHERE (albums.artist_id IN (
     #   #   SELECT id FROM artists
@@ -27,7 +27,7 @@ module Sequel
     # As the dataset methods return datasets, you can easily chain the
     # methods to get associated datasets of associated datasets:
     #
-    #   Artist.filter(id=>1..100).albums.filter{name < 'M'}.tags
+    #   Artist.where(id=>1..100).albums.where{name < 'M'}.tags
     #   # SELECT tags.* FROM tags
     #   # WHERE (tags.id IN (
     #   #   SELECT albums_tags.tag_id FROM albums
@@ -83,15 +83,15 @@ module Sequel
           sds = opts[:limit] ? self : unordered
           ds = case r[:type]
           when :many_to_one
-            ds.filter(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
+            ds.where(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
           when :one_to_one, :one_to_many
-            r.send(:apply_filter_by_associations_limit_strategy, ds.filter(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
+            r.send(:apply_filter_by_associations_limit_strategy, ds.where(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
           when :many_to_many, :one_through_one
             mds = r.associated_class.dataset.
               join(r[:join_table], r[:right_keys].zip(r.right_primary_keys)).
               select(*Array(r.qualified_right_key)).
               where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+            ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :many_through_many, :one_through_many
             fe, *edges = r.edges
             edges << r.final_edge
@@ -109,11 +109,11 @@ module Sequel
               select(*Array(r.qualify(table, left))).
               where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
-            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+            ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
-            ds.filter(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])
+            ds.where(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])
           when :many_to_pg_array
-            ds.filter(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
+            ds.where(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
           else
             raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
           end

data/lib/sequel/plugins/eager_each.rb

@@ -30,9 +30,9 @@ module Sequel
     module EagerEach 
       module DatasetMethods
         # Don't call #all when attempting to load the columns.
-        def columns
+        def columns!
           if use_eager_all?
-            clone(:all_called=>true).columns
+            clone(:all_called=>true).columns!
           else
             super
           end

data/lib/sequel/plugins/instance_filters.rb

@@ -100,7 +100,7 @@ module Sequel
         
         # Apply the instance filters to the given dataset
         def apply_instance_filters(ds)
-          instance_filters.inject(ds){|ds1, i| ds1.filter(*i[0], &i[1])}
+          instance_filters.inject(ds){|ds1, i| ds1.where(*i[0], &i[1])}
         end
         
         # Clear the instance filters.

data/lib/sequel/plugins/json_serializer.rb

@@ -55,7 +55,7 @@ module Sequel
     # of which return all objects in the dataset:
     #
     #   Album.to_json
-    #   Album.filter(:artist_id=>1).to_json(:include=>:tags)
+    #   Album.where(:artist_id=>1).to_json(:include=>:tags)
     #
     # If you have an existing array of model instances you want to convert to
     # JSON, you can call the class to_json method with the :array option:
@@ -72,7 +72,7 @@ module Sequel
     # The array_from_json class method exists to parse arrays of model instances
     # from json:
     #
-    #   json = Album.filter(:artist_id=>1).to_json
+    #   json = Album.where(:artist_id=>1).to_json
     #   albums = Album.array_from_json(json)
     #
     # These does not necessarily round trip, since doing so would let users

data/lib/sequel/plugins/lazy_attributes.rb

@@ -13,7 +13,7 @@ module Sequel
     # get the reviews for all of those albums:
     #
     #   Album.plugin :lazy_attributes, :review
-    #   Album.filter{id<100}.all do |a|
+    #   Album.where{id<100}.all do |a|
     #     a.review
     #   end
     #

data/lib/sequel/plugins/list.rb

@@ -62,10 +62,10 @@ module Sequel
         model.scope_proc = case scope = opts[:scope]
         when Symbol
           model.dataset = model.dataset.order_prepend(scope)
-          proc{|obj| obj.model.filter(scope=>obj.send(scope))}
+          proc{|obj| obj.model.where(scope=>obj.send(scope))}
         when Array
           model.dataset = model.dataset.order_prepend(*scope)
-          proc{|obj| obj.model.filter(scope.map{|s| [s, obj.get_column_value(s)]})}
+          proc{|obj| obj.model.where(scope.map{|s| [s, obj.get_column_value(s)]})}
         else
           scope
         end
@@ -123,11 +123,11 @@ module Sequel
               ds = list_dataset
               op, ds = if target < current
                 target = 1 if target < 1
-                [:+, ds.filter(position_field=>target...current)]
+                [:+, ds.where(position_field=>target...current)]
               else
                 lp ||= last_position
                 target = lp if target > lp
-                [:-, ds.filter(position_field=>(current + 1)..target)]
+                [:-, ds.where(position_field=>(current + 1)..target)]
               end
               ds.update(position_field => Sequel::SQL::NumericExpression.new(op, position_field, 1))
               update(position_field => target)

data/lib/sequel/plugins/prepared_statements.rb

@@ -67,9 +67,7 @@ module Sequel
         # Create a prepared statement based on the given dataset with a unique name for the given
         # type of query and values.
         def prepare_statement(ds, type, vals=OPTS)
-          ps = ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
-          ps.log_sql = true
-          ps
+          ds.clone(:log_sql=>true).prepare(type, :"smpsp_#{NEXT.call}", vals)
         end
 
         # Return a sorted array of columns for use as a hash key.
@@ -102,7 +100,7 @@ module Sequel
 
         # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
         def prepared_refresh
-          cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)}
+          cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).where(prepared_statement_key_array(primary_key)), :first)}
         end
 
         # Return an array of two element arrays with the column symbol as the first entry and the

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -77,9 +77,7 @@ module Sequel
                 end
                 ds = ds.bind(h)
               end
-              ps = ds.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
-              ps.log_sql = true
-              ps
+              ds.clone(:log_sql=>true).prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
             end
           end
         end

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -33,7 +33,7 @@ module Sequel
         # Return a prepared statement that can be used to lookup a row given a dataset for the row matching
         # the primary key.
         def prepared_lookup_dataset(ds)
-          cached_prepared_statement(:lookup_sql, ds.sql){prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)}
+          cached_prepared_statement(:lookup_sql, ds.sql){prepare_statement(ds.where(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)}
         end
       end
 

data/lib/sequel/plugins/rcte_tree.rb

@@ -56,12 +56,12 @@ module Sequel
     #   
     #   # Eager loading - also populates the :parent and children associations
     #   # for all ancestors and descendants
-    #   Model.filter(:id=>[1, 2]).eager(:ancestors, :descendants).all
+    #   Model.where(:id=>[1, 2]).eager(:ancestors, :descendants).all
     #   
     #   # Eager loading children and grand children
-    #   Model.filter(:id=>[1, 2]).eager(:descendants=>2).all
+    #   Model.where(:id=>[1, 2]).eager(:descendants=>2).all
     #   # Eager loading children, grand children, and great grand children
-    #   Model.filter(:id=>[1, 2]).eager(:descendants=>3).all
+    #   Model.where(:id=>[1, 2]).eager(:descendants=>3).all
     #
     # = Options
     #
@@ -150,11 +150,11 @@ module Sequel
         a[:read_only] = true unless a.has_key?(:read_only)
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
-          base_ds = model.filter(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
+          base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
             (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -196,13 +196,13 @@ module Sequel
             obj.associations[parent] = nil
           end
           r = model.association_reflection(ancestors)
-          base_case = model.filter(prkey=>id_map.keys).
+          base_case = model.where(prkey=>id_map.keys).
            select(*ancestor_base_case_columns)
           recursive_case = model.join(t, key_array.zip(prkey_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
             (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -245,11 +245,11 @@ module Sequel
         d[:read_only] = true unless d.has_key?(:read_only)
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
-          base_ds = model.filter(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
+          base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
             (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -294,21 +294,21 @@ module Sequel
             obj.associations[childrena] = []
           end
           r = model.association_reflection(descendants)
-          base_case = model.filter(key=>id_map.keys).
+          base_case = model.where(key=>id_map.keys).
            select(*descendant_base_case_columns)
           recursive_case = model.join(t, prkey_array.zip(key_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
             (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           if associations.is_a?(Integer)
             level = associations
             no_cache_level = level - 1
             associations = {}
-            base_case = base_case.select_more(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
-            recursive_case = recursive_case.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).filter(SQL::QualifiedIdentifier.new(t, la) < level - 1)
+            base_case = base_case.select_append(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
+            recursive_case = recursive_case.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).where(SQL::QualifiedIdentifier.new(t, la) < level - 1)
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           ds = model.from(SQL::AliasedExpression.new(t, table_alias)).

data/lib/sequel/plugins/sharding.rb

@@ -111,7 +111,7 @@ module Sequel
         def server(s)
           ds = super
           if rp = row_proc
-            ds.row_proc = proc{|r| rp.call(r).set_server(s)}
+            ds = ds.with_row_proc(proc{|r| rp.call(r).set_server(s)})
           end
           ds
         end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -119,7 +119,8 @@ module Sequel
             lambda{|klass| klass.name.to_s}
           end
           @sti_key_chooser = opts[:key_chooser] || lambda{|inst| Array(inst.model.sti_key_map[inst.model]).last }
-          dataset.row_proc = lambda{|r| model.sti_load(r)}
+
+          @dataset = @dataset.with_row_proc(model.method(:sti_load))
         end
       end
 
@@ -158,9 +159,9 @@ module Sequel
           key = Array(sti_key_map[subclass]).dup
           sti_subclass_added(key)
           rp = dataset.row_proc
-          subclass.set_dataset(sti_dataset.filter(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>key), :inherited=>true)
+          subclass.set_dataset(sti_dataset.where(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>Sequel.delay{key}), :inherited=>true)
           subclass.instance_eval do
-            dataset.row_proc = rp
+            @dataset = @dataset.with_row_proc(rp)
             @sti_key_array = key
             self.simple_table = nil
           end
@@ -187,7 +188,11 @@ module Sequel
         # If calling set_dataset manually, make sure to set the dataset
         # row proc to one that handles inheritance correctly.
         def set_dataset_row_proc(ds)
-          ds.row_proc = @dataset.row_proc if @dataset
+          if @dataset
+            ds.with_row_proc(@dataset.row_proc)
+          else
+            super
+          end
         end
 
         # Return a class object.  If a class is given, return it directly.

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -16,7 +16,7 @@ module Sequel
     #
     # Basically, this allows the following code to issue only two queries:
     #
-    #   Album.filter{id<100}.all do |a|
+    #   Album.where{id<100}.all do |a|
     #     a.artists
     #   end
     #   # SELECT * FROM albums WHERE (id < 100)
@@ -30,7 +30,7 @@ module Sequel
     # objects that the current object was retrieved with:
     #
     #   # SELECT * FROM albums WHERE (id < 100)
-    #   albums = Album.filter{id<100}.all
+    #   albums = Album.where{id<100}.all
     #
     #   # Eagerly load all artists for these albums
     #   # SELECT * FROM artists WHERE id IN (...)
@@ -45,7 +45,7 @@ module Sequel
     # You can also use the :eager option to specify dependent associations
     # to eager load:
     #
-    #  albums = Album.filter{id<100}.all
+    #  albums = Album.where{id<100}.all
     #
     #   # Eager load all artists for these albums, and all albums for those artists
     #   # SELECT * FROM artists WHERE id IN (...)
@@ -54,7 +54,7 @@ module Sequel
     #
     # You can also use :eager to specify an eager callback. For example:
     #
-    #   albums = Album.filter{id<100}.all
+    #   albums = Album.where{id<100}.all
     #
     #   # Eagerly load all artists whose name starts with A-M for these albums
     #   # SELECT * FROM artists WHERE name > 'N' AND id IN (...)

data/lib/sequel/plugins/validation_class_methods.rb

@@ -378,7 +378,7 @@ module Sequel
             a = Array(a)
             v = Array(v)
             next if v.empty? || !v.all?
-            ds = o.class.filter(a.zip(v))
+            ds = o.class.where(a.zip(v))
             num_dups = ds.count
             allow = if num_dups == 0
               # No unique value in the database

data/lib/sequel/plugins/validation_helpers.rb

@@ -204,7 +204,7 @@ module Sequel
         # must be unique. So if you are doing a soft delete of records, in which
         # the name must be unique, but only for active records:
         #
-        #   validates_unique(:name){|ds| ds.filter(:active)}
+        #   validates_unique(:name){|ds| ds.where(:active)}
         #
         # You should also add a unique index in the
         # database, as this suffers from a fairly obvious race condition.

data/lib/sequel/plugins/xml_serializer.rb

@@ -63,7 +63,7 @@ module Sequel
     # of which return all objects in the dataset:
     #
     #   Album.to_xml
-    #   Album.filter(:artist_id=>1).to_xml(:include=>:tags)
+    #   Album.where(:artist_id=>1).to_xml(:include=>:tags)
     #
     # If you have an existing array of model instances you want to convert to
     # XML, you can call the class to_xml method with the :array option:
@@ -80,7 +80,7 @@ module Sequel
     # The array_from_xml class method exists to parse arrays of model instances
     # from xml:
     #
-    #   xml = Album.filter(:artist_id=>1).to_xml
+    #   xml = Album.where(:artist_id=>1).to_xml
     #   albums = Album.array_from_xml(xml)
     #
     # These does not necessarily round trip, since doing so would let users