sequel 3.23.0 → 3.24.0

data/lib/sequel/plugins/many_through_many.rb

@@ -224,7 +224,7 @@ module Sequel
         private
 
         # Use a subquery to filter rows to those related to the given associated object
-        def many_through_many_association_filter_expression(ref, obj)
+        def many_through_many_association_filter_expression(op, ref, obj)
           lpks = ref[:left_primary_keys]
           lpks = lpks.first if lpks.length == 1
           edges = ref.edges
@@ -238,8 +238,13 @@ module Sequel
             last_join = ds.opts[:join].last
             last_join.table_alias || last_join.table
           end
-          ds = ds.where(Array(ref[:final_edge][:left]).map{|x| ::Sequel::SQL::QualifiedIdentifier.new(last_alias, x)}.zip(ref.right_primary_keys.map{|k| obj.send(k)}))
-          SQL::BooleanExpression.from_value_pairs(lpks=>ds)
+          exp = association_filter_key_expression(Array(ref[:final_edge][:left]).map{|x| ::Sequel::SQL::QualifiedIdentifier.new(last_alias, x)}, ref.right_primary_keys, obj)
+          if exp == SQL::Constants::FALSE
+            association_filter_handle_inversion(op, exp, Array(lpks))
+          else
+            ds = ds.where(exp).exclude(SQL::BooleanExpression.from_value_pairs(ds.opts[:select].zip([]), :OR))
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>ds), Array(lpks))
+          end
         end
       end
     end

data/lib/sequel/plugins/prepared_statements.rb

@@ -0,0 +1,140 @@
+module Sequel
+  module Plugins
+    # The prepared_statements plugin modifies the model to use prepared statements for
+    # instance level deletes and saves, as well as class level lookups by
+    # primary key.
+    #
+    # Note that this plugin is unsafe in some circumstances, as it can allow up to
+    # 2^N prepared statements to be created for each type of insert and update query, where
+    # N is the number of colums in the table. It is recommended that you use the
+    # +prepared_statements_safe+ plugin in addition to this plugin to reduce the number
+    # of prepared statements that can be created, unless you tightly control how your
+    # model instances are saved.
+    # 
+    # This plugin probably does not work correctly with the instance filters plugin.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses use prepared statements  (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements
+    #
+    #   # Make the Album class use prepared statements
+    #   Album.plugin :prepared_statements
+    module PreparedStatements
+      # Synchronize access to the integer sequence so that no two calls get the same integer.
+      MUTEX = Mutex.new
+      
+      i = 0
+      # This plugin names prepared statements uniquely using an integer sequence, this
+      # lambda returns the next integer to use.
+      NEXT = lambda{MUTEX.synchronize{i += 1}}
+
+      # Setup the datastructure used to hold the prepared statements in the model.
+      def self.apply(model)
+        model.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{})
+      end
+
+      module ClassMethods
+        # Setup the datastructure used to hold the prepared statements in the subclass.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{})
+        end
+
+        private
+
+        # 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={})
+          ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
+        end
+
+        # Return a sorted array of columns for use as a hash key.
+        def prepared_columns(cols)
+          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by{|c| c.to_s}
+        end
+
+        # Return a prepared statement that can be used to delete a row from this model's dataset.
+        def prepared_delete
+          @prepared_statements[:delete] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)
+        end
+
+        # Return a prepared statement that can be used to insert a row using the given columns.
+        def prepared_insert(cols)
+          @prepared_statements[:insert][prepared_columns(cols)] ||= prepare_statement(dataset, :insert, prepared_statement_key_hash(cols))
+        end
+
+        # Return a prepared statement that can be used to insert a row using the given columns
+        # and return that column values for the row created.
+        def prepared_insert_select(cols)
+          if dataset.supports_insert_select?
+            @prepared_statements[:insert_select][prepared_columns(cols)] ||= prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))
+          end
+        end
+
+        # Return a prepared statement that can be used to lookup a row solely based on the primary key.
+        def prepared_lookup
+          @prepared_statements[:lookup] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :first)
+        end
+
+        # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
+        def prepared_refresh
+          @prepared_statements[:refresh] ||= prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(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
+        # placeholder symbol as the second entry.
+        def prepared_statement_key_array(keys)
+          Array(keys).map{|k| [k, :"$#{k}"]}
+        end
+
+        # Return a hash mapping column symbols to placeholder symbols.
+        def prepared_statement_key_hash(keys)
+          Hash[*(prepared_statement_key_array(keys).flatten)]
+        end
+
+        # Return a prepared statement that can be used to update row using the given columns.
+        def prepared_update(cols)
+          @prepared_statements[:update][prepared_columns(cols)] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))
+        end
+
+        # Use a prepared statement to query the database for the row matching the given primary key.
+        def primary_key_lookup(pk)
+          prepared_lookup.call(primary_key_hash(pk))
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Use a prepared statement to delete the row.
+        def _delete_without_checking
+          model.send(:prepared_delete).call(pk_hash)
+        end
+
+        # Use a prepared statement to insert the values into the model's dataset.
+        def _insert_raw(ds)
+          model.send(:prepared_insert, @values.keys).call(@values)
+        end
+
+        # Use a prepared statement to insert the values into the model's dataset
+        # and return the new column values.
+        def _insert_select_raw(ds)
+          if ps = model.send(:prepared_insert_select, @values.keys)
+            ps.call(@values)
+          end
+        end
+
+        # Use a prepared statement to refresh this model's column values.
+        def _refresh_get(ds)
+          model.send(:prepared_refresh).call(pk_hash)
+        end
+
+        # Use a prepared statement to update this model's columns in the database.
+        def _update_without_checking(columns)
+          model.send(:prepared_update, columns.keys).call(columns.merge(pk_hash))
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -0,0 +1,84 @@
+module Sequel
+  module Plugins
+    # The prepared_statements_associations plugin modifies the regular association
+    # load method to use a cached prepared statement to load the associations.
+    # It will not work on all associations, but it should skip the use of prepared
+    # statements for associations where it will not work, assuming you load the
+    # plugin before defining the associations.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses more safe when using prepared statements (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements_associations
+    #
+    #   # Make the Album class more safe when using prepared statements
+    #   Album.plugin :prepared_statements_associations
+    module PreparedStatementsAssociations
+      # Synchronize access to the integer sequence so that no two calls get the same integer.
+      MUTEX = Mutex.new
+
+      i = 0
+      # This plugin names prepared statements uniquely using an integer sequence, this
+      # lambda returns the next integer to use.
+      NEXT = lambda{MUTEX.synchronize{i += 1}}
+
+      module ClassMethods
+        # Disable prepared statement use if a block is given, or the :dataset or :conditions
+        # options are used, or you are cloning an association.
+        def associate(type, name, opts = {}, &block)
+          if block || opts[:dataset] || opts[:conditions] || (opts[:clone] && association_reflection(opts[:clone])[:prepared_statement] == false)
+            opts = opts.merge(:prepared_statement=>false)
+          end
+          super(type, name, opts, &block)
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Return a bound variable hash that maps the keys in +ks+ (qualified by the +table+)
+        # to the values of the results of sending the methods in +vs+.
+        def association_bound_variable_hash(table, ks, vs)
+          Hash[*ks.zip(vs).map{|k, v| [:"#{table}.#{k}", send(v)]}.flatten]
+        end
+
+        # Given an association reflection, return a bound variable hash for the given
+        # association for this instance's values.
+        def association_bound_variables(opts)
+          case opts[:type]
+          when :many_to_one
+            association_bound_variable_hash(opts.associated_class.table_name, opts.primary_keys, opts[:keys])
+          when :one_to_many
+            association_bound_variable_hash(opts.associated_class.table_name, opts[:keys], opts[:primary_keys])
+          when :many_to_many
+            association_bound_variable_hash(opts[:join_table], opts[:left_keys], opts[:left_primary_keys])
+          when :many_through_many
+            opts.reverse_edges
+            association_bound_variable_hash(opts[:final_reverse_edge][:alias], Array(opts[:left_key]), opts[:left_primary_keys])
+          end
+        end
+
+        # Given an association reflection, return and cache a prepared statement for this association such
+        # that, given appropriate bound variables, the prepared statement will work correctly for any
+        # instance.
+        def association_prepared_statement(opts)
+          opts[:prepared_statement] ||= _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
+        end
+
+        # If a prepared statement can be used to load the associated objects, execute it to retrieve them.  Otherwise,
+        # fall back to the default implementation.
+        def _load_associated_objects(opts, dynamic_opts={})
+          if !opts.can_have_associated_objects?(self) || dynamic_opts[:callback] || (ps = opts[:prepared_statement]) == false
+            super
+          else 
+            if bv = association_bound_variables(opts)
+              (ps || association_prepared_statement(opts)).call(bv)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -0,0 +1,72 @@
+module Sequel
+  module Plugins
+    # The prepared_statements_safe plugin modifies the model to reduce the number of
+    # prepared statements that can be created, by setting as many columns as possible
+    # before creating, and by changing +save_changes+ to save all columns instead of
+    # just the changed ones.
+    #
+    # This plugin depends on the +prepared_statements+ plugin.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses more safe when using prepared statements (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements_safe
+    #
+    #   # Make the Album class more safe when using prepared statements
+    #   Album.plugin :prepared_statements_safe
+    module PreparedStatementsSafe
+      # Depend on the prepared_statements plugin
+      def self.apply(model)
+        model.plugin(:prepared_statements)
+      end
+
+      # Set the column defaults to use when creating on the model.
+      def self.configure(model)
+        model.send(:set_prepared_statements_column_defaults)
+      end
+
+      module ClassMethods
+        # A hash with column symbol keys and default values.  Instance's
+        # values are merged into this hash before creating to reduce the
+        # number of free columns (columns that may or may not be present
+        # in the INSERT statement), as the number of prepared statements
+        # that can be created is 2^N (where N is the number of free columns).
+        attr_reader :prepared_statements_column_defaults
+        
+        # Set the column defaults to use when creating on the subclass.
+        def inherited(subclass)
+          super
+          subclass.send(:set_prepared_statements_column_defaults)
+        end
+
+        private
+
+        # Set the column defaults based on the database schema.  All columns
+        # are set to a default value unless they are a primary key column or
+        # they don't have a parseable default.
+        def set_prepared_statements_column_defaults
+          h = {}
+          db_schema.each do |k, v|
+            h[k] = v[:ruby_default] if (v[:ruby_default] || !v[:default]) && !v[:primary_key]
+          end
+          @prepared_statements_column_defaults = h
+        end
+      end
+
+      module InstanceMethods
+        # Merge the current values into the default values to reduce the number
+        # of free columns.
+        def before_create
+          set_values(model.prepared_statements_column_defaults.merge(values))
+          super
+        end
+
+        # Always do a full save of all columns to reduce the number of prepared
+        # statements that can be used.
+        def save_changes(opts={})
+          save(opts) || false if modified?
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -0,0 +1,59 @@
+module Sequel
+  module Plugins
+    # The prepared_statements_with_pk plugin allows Dataset#with_pk for model datasets
+    # to use prepared statements by extract the values of previously bound variables
+    # using <tt>Dataset#unbind</tt>, and attempting to use a prepared statement if the
+    # variables can be unbound correctly. See  +Unbinder+ for details about what types of
+    # dataset filters can be unbound correctly.
+    #
+    # This plugin depends on the +prepared_statements+ plugin and should be considered unsafe.
+    # Unbinding dataset values cannot be done correctly in all cases, and use of this plugin
+    # in cases where not there are variables that are not unbound can lead to an denial of
+    # service attack by allocating an arbitrary number of prepared statements.  You have been
+    # warned.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use prepared statements for Dataset#with_pk (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements_with_pk
+    #
+    #   # Make the Album class use prepared statements for Dataset#with_pk
+    #   Album.plugin :prepared_statements_with_pk
+    module PreparedStatementsWithPk
+      # Depend on the prepared_statements plugin
+      def self.apply(model)
+        model.plugin(:prepared_statements)
+      end
+
+      module ClassMethods
+        private
+
+        # 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)
+          @prepared_statements[:lookup_sql][ds.sql] ||= prepare_statement(ds.filter(prepared_statement_key_array(primary_key)), :first)
+        end
+      end
+
+      module DatasetMethods
+        # Use a prepared statement to find a row with the matching primary key
+        # inside this dataset.
+        def with_pk(pk)
+          begin
+            ds, bv = unbind
+          rescue UnbindDuplicate
+            super
+          else
+            begin
+              bv = bv.merge!(model.primary_key_hash(pk)){|k, v1, v2| ((v1 == v2) ? v1 : raise(UnbindDuplicate))}
+            rescue UnbindDuplicate
+              super
+            else
+              model.send(:prepared_lookup_dataset, ds).call(bv)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/sql.rb

@@ -595,6 +595,8 @@ module Sequel
           end
         when StringExpression, NumericExpression
           raise(Sequel::Error, "cannot invert #{ce.inspect}")
+        when Constant
+          CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
         else
           BooleanExpression.new(:NOT, ce)
         end
@@ -706,6 +708,12 @@ module Sequel
       NOTNULL = NegativeBooleanConstant.new(nil)
     end
 
+    class ComplexExpression
+      # A hash of the opposite for each constant, used for inverting constants.
+      CONSTANT_INVERSIONS = {Constants::TRUE=>Constants::FALSE, Constants::FALSE=>Constants::TRUE,
+                             Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}
+    end
+
     # Represents an SQL function call.
     class Function < GenericExpression
       # The array of arguments to pass to the function (may be blank)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 23
+  MINOR = 24
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -909,7 +909,7 @@ describe "Postgres::Database functions, languages, and triggers" do
   after do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true)
     @d.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>%w'integer integer')
-    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
     @d.drop_table(:test) rescue nil
   end
 
@@ -940,19 +940,19 @@ describe "Postgres::Database functions, languages, and triggers" do
   
   specify "#create_language and #drop_language should create and drop languages" do
     @d.send(:create_language_sql, :plpgsql).should == 'CREATE LANGUAGE plpgsql'
-    @d.create_language(:plpgsql, :replace=>true)
+    @d.create_language(:plpgsql, :replace=>true) if @d.server_version < 90000
     proc{@d.create_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
     @d.send(:drop_language_sql, :plpgsql).should == 'DROP LANGUAGE plpgsql'
-    @d.drop_language(:plpgsql)
-    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
+    @d.drop_language(:plpgsql) if @d.server_version < 90000
+    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError) if @d.server_version < 90000
     @d.send(:create_language_sql, :plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b).should == (@d.server_version >= 90000 ? 'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b' : 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b')
     @d.send(:drop_language_sql, :plpgsql, :if_exists=>true, :cascade=>true).should == 'DROP LANGUAGE IF EXISTS plpgsql CASCADE'
     # Make sure if exists works
-    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
   end
   
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
-    @d.create_language(:plpgsql)
+    @d.create_language(:plpgsql) if @d.server_version < 90000
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
     @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON test FOR EACH ROW EXECUTE PROCEDURE tf()'
     @d.create_table(:test){String :name; Integer :value}
@@ -973,17 +973,17 @@ describe "Postgres::Database functions, languages, and triggers" do
 end
 
 if POSTGRES_DB.adapter_scheme == :postgres
-describe "Postgres::Dataset #use_cursor" do
-  before(:all) do
-    @db = POSTGRES_DB
-    @db.create_table!(:test_cursor){Integer :x}
-    @db.sqls.clear
-    @ds = @db[:test_cursor]
-    @db.transaction{1001.times{|i| @ds.insert(i)}}
-  end
-  after(:all) do
-    @db.drop_table(:test) rescue nil
-  end
+  describe "Postgres::Dataset #use_cursor" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_cursor){Integer :x}
+      @db.sqls.clear
+      @ds = @db[:test_cursor]
+      @db.transaction{1001.times{|i| @ds.insert(i)}}
+    end
+    after(:all) do
+      @db.drop_table(:test) rescue nil
+    end
   
     specify "should return the same results as the non-cursor use" do
       @ds.all.should == @ds.use_cursor.all
@@ -1005,5 +1005,30 @@ describe "Postgres::Dataset #use_cursor" do
       @ds.check_return
       @ds.all.should == @ds.use_cursor.all
     end
-end
+  end
+
+  describe "Postgres::PG_NAMED_TYPES" do
+    before do
+      @db = POSTGRES_DB
+      Sequel::Postgres::PG_NAMED_TYPES[:interval] = lambda{|v| v.reverse}
+      @db.instance_eval do
+        disconnect
+        @conversion_procs = nil
+      end 
+    end
+    after do
+      Sequel::Postgres::PG_NAMED_TYPES.delete(:interval)
+      @db.instance_eval do
+        disconnect
+        @conversion_procs = nil
+      end
+      @db.drop_table(:foo)
+    end
+
+    specify "should look up conversion procs by name" do
+      @db.create_table!(:foo){interval :bar}
+      @db[:foo].insert('21 days')
+      @db[:foo].get(:bar).should == 'syad 12'
+    end
+  end
 end