sequel 3.42.0 → 3.43.0

data/lib/sequel/extensions/pg_row_ops.rb

@@ -20,7 +20,8 @@
 #   r = Sequel.expr(:row_column).pg_row
 #
 # If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
-# you can also call Symbol#pg_row:
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Symbol#pg_row:
 #
 #   r = :row_column.pg_row
 #
@@ -180,3 +181,11 @@ if Sequel.core_extensions?
     include Sequel::Postgres::PGRowOp::ExpressionMethods
   end
 end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::PGRowOp::ExpressionMethods
+    end
+  end
+end

data/lib/sequel/extensions/query.rb

@@ -5,6 +5,8 @@
 # To load the extension, do:
 #
 #   Sequel.extension :query
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
 
 module Sequel
   class Database

data/lib/sequel/model/associations.rb

@@ -69,11 +69,6 @@ module Sequel
           :"#{self[:name]}_dataset"
         end
       
-        # Name symbol for the _helper internal association method
-        def dataset_helper_method
-          :"_#{self[:name]}_dataset_helper"
-        end
-      
         # Whether the dataset needs a primary key to function, true by default.
         def dataset_need_primary_key?
           true
@@ -1096,9 +1091,6 @@ module Sequel
       
         # Adds the association dataset methods to the association methods module.
         def def_association_dataset_methods(opts)
-          # If a block is given, define a helper method for it, because it takes
-          # an argument.  This is unnecessary in Ruby 1.9, as that has instance_exec.
-          association_module_private_def(opts.dataset_helper_method, opts, &opts[:block]) if opts[:block]
           association_module_private_def(opts._dataset_method, opts, &opts[:dataset])
           association_module_def(opts.dataset_method, opts){_dataset(opts)}
           def_association_method(opts)
@@ -1122,10 +1114,10 @@ module Sequel
           lcpks = opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
-          raise(Error, "mismatched number of left composite keys: #{lcks.inspect} vs #{lcpks.inspect}") unless lcks.length == lcpks.length
+          raise(Error, "mismatched number of left keys: #{lcks.inspect} vs #{lcpks.inspect}") unless lcks.length == lcpks.length
           if opts[:right_primary_key]
             rcpks = Array(opts[:right_primary_key])
-            raise(Error, "mismatched number of right composite keys: #{rcks.inspect} vs #{rcpks.inspect}") unless rcks.length == rcpks.length
+            raise(Error, "mismatched number of right keys: #{rcks.inspect} vs #{rcpks.inspect}") unless rcks.length == rcpks.length
           end
           uses_lcks = opts[:uses_left_composite_keys] = lcks.length > 1
           uses_rcks = opts[:uses_right_composite_keys] = rcks.length > 1
@@ -1221,7 +1213,7 @@ module Sequel
           opts[:qualified_key] = opts.qualify_cur(key)
           if opts[:primary_key]
             cpks = Array(opts[:primary_key])
-            raise(Error, "mismatched number of composite keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
+            raise(Error, "mismatched number of keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           end
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
           qualify = opts[:qualify] != false
@@ -1281,7 +1273,7 @@ module Sequel
           cpks = opts[:primary_keys] = Array(primary_key)
           pkc = opts[:primary_key_column] ||= primary_key
           pkcs = opts[:primary_key_columns] ||= Array(pkc)
-          raise(Error, "mismatched number of composite keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
+          raise(Error, "mismatched number of keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:dataset] ||= proc do
             opts.associated_class.filter(opts.predicate_keys.zip(cpks.map{|k| send(k)}))
@@ -1452,7 +1444,7 @@ module Sequel
           ds = ds.eager(*opts[:eager]) if opts[:eager]
           ds = ds.distinct if opts[:distinct]
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
-          ds = send(opts.dataset_helper_method, ds) if opts[:block]
+          ds = instance_exec(ds, &opts[:block]) if opts[:block]
           ds
         end
 

data/lib/sequel/model/base.rb

@@ -2,8 +2,6 @@ module Sequel
   class Model
     extend Enumerable
     extend Inflections
-    extend Metaprogramming
-    include Metaprogramming
 
     # Class methods for Sequel::Model that implement basic model functionality.
     #
@@ -686,7 +684,7 @@ module Sequel
         if meth.to_s =~ NORMAL_METHOD_NAME_REGEXP
           instance_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
         else
-          meta_def(meth){|*args, &block| dataset.send(meth, *args, &block)}
+          (class << self; self; end).send(:define_method, meth){|*args, &block| dataset.send(meth, *args, &block)}
         end
       end
 
@@ -1085,11 +1083,11 @@ module Sequel
       def hash
         case primary_key
         when Array
-          [model, !pk.all? ? @values.sort_by{|k,v| k.to_s} : pk].hash
+          [model, !pk.all? ? @values : pk].hash
         when Symbol
-          [model, pk.nil? ? @values.sort_by{|k,v| k.to_s} : pk].hash
+          [model, pk.nil? ? @values : pk].hash
         else
-          [model, @values.sort_by{|k,v| k.to_s}].hash
+          [model, @values].hash
         end
       end
   

data/lib/sequel/plugins/boolean_readers.rb

@@ -26,8 +26,10 @@ module Sequel
       # 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.meta_def(:boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
-        model.instance_eval{send(:create_boolean_readers) if @dataset}
+        model.instance_eval do
+          (class << self; self; end).send(:define_method, :boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+          send(:create_boolean_readers) if @dataset
+        end
       end
 
       module ClassMethods

data/lib/sequel/plugins/many_through_many.rb

@@ -13,6 +13,29 @@ module Sequel
     #
     # Which will give you the tags for all of the artist's albums.
     #
+    # Let's break down the 2nd argument of the many_through_many call:
+    #
+    #   [[:albums_artists, :artist_id, :album_id],
+    #    [:albums, :id, :id],
+    #    [:albums_tags, :album_id, :tag_id]]
+    #
+    # This argument is an array of arrays with three elements.  Each entry in the main array represents a JOIN in SQL:
+    #
+    # * The first element in each array represents the name of the table to join.
+    # * The second element in each array represents the column used to join to the previous table.
+    # * The third element in each array represents the column used to join to the next table.
+    #
+    # So the "Artist.many_through_many :tags" is translated into something similar to:
+    #
+    #   FROM artists
+    #   JOIN albums_artists ON (artists.id = albums_artists.artist_id)
+    #   JOIN albums ON (albums_artists.album_id = albums.id)
+    #   JOIN albums_tags ON (albums.id = albums_tag.album_id)
+    #   JOIN tags ON (albums_tags.tag_id = tags.id)
+    #
+    # The "artists.id" and "tags.id" criteria come from other association options (defaulting to the primary keys of the current and
+    # associated tables), but hopefully you can see how each argument in the array is used in the JOIN clauses.
+    #
     # Here are some more examples:
     #
     #   # Same as Artist.many_to_many :albums

data/lib/sequel/plugins/string_stripper.rb

@@ -1,10 +1,18 @@
 module Sequel
   module Plugins
-    # StringStripper is a very simple plugin that strips all input strings
+    # StringStripper is a plugin that strips all input strings
     # when assigning to the model's values. Example:
     #
     #   album = Album.new(:name=>' A ')
     #   album.name # => 'A'
+    #
+    # SQL::Blob instances and all non-strings are not modified by
+    # this plugin.  Additionally, strings passed to a blob column
+    # setter are also not modified.  You can explicitly set
+    # other columns to skip the stripping:
+    #
+    #   Album.skip_string_stripping :foo
+    #   Album.new(:foo=>' A ').foo # => ' A '
     # 
     # Usage:
     #
@@ -14,11 +22,53 @@ module Sequel
     #   # Make the Album class strip strings
     #   Album.plugin :string_stripper
     module StringStripper
+      # Set blob columns as skipping stripping when plugin is loaded.
+      def self.configure(model)
+        model.instance_variable_set(:@skipped_string_stripping_columns, [])
+        model.send(:set_skipped_string_stripping_columns)
+      end
+
+      module ClassMethods
+        # Copy skipped stripping columns from superclass into subclass.
+        def inherited(subclass)
+          subclass.instance_variable_set(:@skipped_string_stripping_columns, @skipped_string_stripping_columns.dup)
+          super
+        end
+
+        # Set blob columns as skipping stripping when plugin is loaded.
+        def set_dataset(*)
+          super
+          set_skipped_string_stripping_columns
+        end
+
+        # Skip stripping for the given columns.
+        def skip_string_stripping(*columns)
+          @skipped_string_stripping_columns.concat(columns).uniq!
+        end
+
+        # Return true if the column should not have values stripped.
+        def skip_string_stripping?(column)
+          @skipped_string_stripping_columns.include?(column)
+        end
+
+        private
+
+        # Automatically skip stripping of blob columns
+        def set_skipped_string_stripping_columns
+          if @db_schema
+            blob_columns = @db_schema.map{|k,v| k if v[:type] == :blob}.compact
+            skip_string_stripping(*blob_columns)
+          end
+        end
+      end
+
       module InstanceMethods
-        # Strip value if it is a string, before attempting to assign
+        # Strip value if it is a non-blob string and the model hasn't been set
+        # to skip stripping for the column, before attempting to assign
         # it to the model's values.
         def []=(k, v)
-          v.is_a?(String) ? super(k, v.strip) : super
+          v = v.strip if v.is_a?(String) && !v.is_a?(SQL::Blob) && !model.skip_string_stripping?(k)
+          super(k, v)
         end
       end
     end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -51,6 +51,11 @@ module Sequel
           def method_missing(m, *args, &block)
             @receiver.send(:"validates_#{m}", *args, &block)
           end
+
+          # This object responds to all validates_* methods the model responds to.
+          def respond_to_missing?(meth, include_private)
+            @receiver.respond_to?(:"validates_#{meth}", include_private)
+          end
         end
     
         # Returns true if validations are defined.

data/lib/sequel/sql.rb

@@ -6,7 +6,7 @@ module Sequel
     class BasicObject
       # The instance methods to not remove from the class when removing
       # other methods.
-      KEEP_METHODS = %w"__id__ __send__ __metaclass__ instance_eval == equal? initialize method_missing"
+      KEEP_METHODS = %w"__id__ __send__ __metaclass__ instance_eval instance_exec == equal? initialize method_missing"
 
       # Remove all but the most basic instance methods from the class.  A separate
       # method so that it can be called again if necessary if you load libraries
@@ -655,7 +655,7 @@ module Sequel
       #   Sequel.function(:func).cast_numeric # CAST(func() AS integer)
       #   Sequel.function(:func).cast_numeric(Float) # CAST(func() AS double precision)
       def cast_numeric(sql_type = nil)
-        cast(sql_type || Integer).sql_number
+        Cast.new(self, sql_type || Integer).sql_number
       end
 
       # Cast the reciever to the given SQL type (or the database's default String type if none given),
@@ -665,7 +665,7 @@ module Sequel
       #   Sequel.function(:func).cast_string # CAST(func() AS varchar(255))
       #   Sequel.function(:func).cast_string(:text) # CAST(func() AS text)
       def cast_string(sql_type = nil)
-        cast(sql_type || String).sql_string
+        Cast.new(self, sql_type || String).sql_string
       end
     end
 

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 = 42
+  MINOR = 43
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/db2_spec.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# coding: utf-8
 #Author: Roy L Zuo (roylzuo at gmail dot com)
 #Description: 
 
@@ -39,21 +38,33 @@ describe Sequel::Database do
 end
 
 describe "Simple Dataset operations" do
-  before do
+  before(:all) do
+    Sequel::DB2.use_clob_as_blob = false
     DB2_DB.create_table!(:items) do
       Integer :id, :primary_key => true
       Integer :number
+      column  :bin_string, 'varchar(20) for bit data'
+      column  :bin_blob, 'blob'
     end
     @ds = DB2_DB[:items]
-    @ds.insert(:number=>10, :id => 1 )
   end
-  after do
+  after(:each) do
+    @ds.delete
+  end
+  after(:all) do
+    Sequel::DB2.use_clob_as_blob = true
     DB2_DB.drop_table(:items)
   end
-  cspecify "should insert with a primary key specified", :mssql do
-    @ds.insert(:id=>100, :number=>20)
-    @ds.count.should == 2
-    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+
+  specify "should insert with a primary key specified" do
+    @ds.insert(:id => 1,   :number => 10)
+    @ds.insert(:id => 100, :number => 20)
+    @ds.select_hash(:id, :number).should == {1 => 10, 100 => 20}
+  end
+
+  specify "should insert into binary columns" do
+    @ds.insert(:id => 1, :bin_string => Sequel.blob("\1"), :bin_blob => Sequel.blob("\2"))
+    @ds.select(:bin_string, :bin_blob).first.should == {:bin_string => "\1", :bin_blob => "\2"}
   end
 end
 

data/spec/adapters/mssql_spec.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 require ENV['SEQUEL_MSSQL_SPEC_REQUIRE'] if ENV['SEQUEL_MSSQL_SPEC_REQUIRE']
@@ -391,7 +390,7 @@ describe "MSSSQL::Dataset#insert" do
   end
   
   specify "should have insert_select return nil if the server version is not 2005+" do
-    @ds.meta_def(:server_version){8000760}
+    def @ds.server_version() 8000760 end
     @ds.insert_select(:value=>10).should == nil
   end
 

data/spec/adapters/mysql_spec.rb

@@ -150,8 +150,8 @@ if [:mysql, :mysql2].include?(MYSQL_DB.adapter_scheme)
     specify "should allow disabling the conversion on a per-dataset basis" do
       @db.convert_tinyint_to_bool = true
       ds = @ds.clone
-      ds.meta_def(:cast_tinyint_integer?){|f| true} # mysql
-      ds.meta_def(:convert_tinyint_to_bool?){false} # mysql2
+      def ds.cast_tinyint_integer?(f) true end #mysql
+      def ds.convert_tinyint_to_bool?() false end #mysql2
       ds.delete
       ds << {:b=>true, :i=>10}
       ds.all.should == [{:b=>1, :i=>10}]

data/spec/adapters/postgres_spec.rb

@@ -539,6 +539,25 @@ describe "A PostgreSQL database" do
     @db[:posts].insert.should == 21
     @db[:posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
   end
+    
+  specify "should support resetting the primary key sequence with default_schema" do
+    begin
+      @db.run("DROP SCHEMA p") rescue nil
+      @db.run("CREATE SCHEMA p")
+      @db.default_schema = :p
+      @db.create_table(:posts){primary_key :a}
+      @db[:p__posts].insert(:a=>20).should == 20
+      @db[:p__posts].insert.should == 1
+      @db[:p__posts].insert.should == 2
+      @db[:p__posts].insert(:a=>10).should == 10
+      @db.reset_primary_key_sequence(:posts).should == 21
+      @db[:p__posts].insert.should == 21
+      @db[:p__posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
+    ensure
+      @db.default_schema = nil
+      @db.run("DROP SCHEMA p CASCADE")
+    end
+  end
 
   specify "should support specifying Integer/Bignum/Fixnum types in primary keys and have them be auto incrementing" do
     @db.create_table(:posts){primary_key :a, :type=>Integer}
@@ -1295,6 +1314,13 @@ if ((POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || POST
       end
     end
 
+    specify "should handle database errors with a rollback of copied data and still have a usable connection" do
+      2.times do
+        proc{@db.copy_into(:test_copy, :data=>["1\t2\n", "3\ta\n"])}.should raise_error(Sequel::DatabaseError)
+        @ds.select_map([:x, :y]).should == []
+      end
+    end
+
     specify "should raise an Error if both :data and a block are provided" do
       proc{@db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"]){}}.should raise_error(Sequel::Error)
     end
@@ -2524,7 +2550,7 @@ describe 'PostgreSQL interval types' do
     v.should == ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
     v.parts.sort_by{|k,v| k.to_s}.should == [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]].sort_by{|k,v| k.to_s}
   end
-end if ((require 'active_support/duration'; require 'active_support/inflector'; require 'active_support/core_ext/string/inflections'; true) rescue false)
+end if (begin require 'active_support/duration'; require 'active_support/inflector'; require 'active_support/core_ext/string/inflections'; true; rescue LoadError; false end)
 
 describe 'PostgreSQL row-valued/composite types' do
   before(:all) do
@@ -2547,8 +2573,8 @@ describe 'PostgreSQL row-valued/composite types' do
       column :employees, 'person[]'
     end
     @db.register_row_type(:address)
-    @db.register_row_type(:person)
-    @db.register_row_type(:company)
+    @db.register_row_type(Sequel.qualify(:public, :person))
+    @db.register_row_type(:public__company)
 
     @native = POSTGRES_DB.adapter_scheme == :postgres
   end

data/spec/core/dataset_spec.rb

@@ -2686,6 +2686,40 @@ describe "Dataset#get" do
     @d.get(false).should == "SELECT 'f' FROM test LIMIT 1"
     @d.get(nil).should == "SELECT NULL FROM test LIMIT 1"
   end
+
+  specify "should support an array of expressions to get an array of results" do
+    @d._fetch = {:name=>1, :abc=>2}
+    @d.get([:name, :abc]).should == [1, 2]
+    @d.db.sqls.should == ['SELECT name, abc FROM test LIMIT 1']
+  end
+  
+  specify "should support an array with a single expression" do
+    @d.get([:name]).should == ['SELECT name FROM test LIMIT 1']
+  end
+  
+  specify "should handle an array with aliases" do
+    @d._fetch = {:name=>1, :abc=>2}
+    @d.get([:n___name, Sequel.as(:a, :abc)]).should == [1, 2]
+    @d.db.sqls.should == ['SELECT n AS name, a AS abc FROM test LIMIT 1']
+  end
+  
+  specify "should raise an Error if an alias cannot be determined" do
+    @d._fetch = {:name=>1, :abc=>2}
+    proc{@d.get([Sequel.+(:a, 1), :a])}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should support an array of expressions in a virtual row" do
+    @d._fetch = {:name=>1, :abc=>2}
+    @d.get{[name, n__abc]}.should == [1, 2]
+    @d.db.sqls.should == ['SELECT name, n.abc FROM test LIMIT 1']
+  end
+  
+  specify "should work with static SQL" do
+    @d.with_sql('SELECT foo').get(:name).should == "SELECT foo"
+    @d._fetch = {:name=>1, :abc=>2}
+    @d.with_sql('SELECT foo').get{[name, n__abc]}.should == [1, 2]
+    @d.db.sqls.should == ['SELECT foo'] * 2
+  end
 end
 
 describe "Dataset#set_row_proc" do
@@ -4414,3 +4448,76 @@ describe "Dataset extensions" do
     proc{@ds.extension(:foo2)}.should raise_error(Sequel::Error)
   end
 end
+
+describe "Dataset#schema_and_table" do
+  before do
+    @ds = Sequel.mock[:test]
+  end
+
+  it "should correctly handle symbols" do
+    @ds.schema_and_table(:s).should == [nil, 's']
+    @ds.schema_and_table(:s___a).should == [nil, 's']
+    @ds.schema_and_table(:t__s).should == ['t', 's']
+    @ds.schema_and_table(:t__s___a).should == ['t', 's']
+  end
+
+  it "should correctly handle strings" do
+    @ds.schema_and_table('s').should == [nil, 's']
+  end
+
+  it "should correctly handle identifiers" do
+    @ds.schema_and_table(Sequel.identifier(:s)).should == [nil, 's']
+  end
+
+  it "should correctly handle qualified identifiers" do
+    @ds.schema_and_table(Sequel.qualify(:t, :s)).should == ['t', 's']
+  end
+
+  it "should respect default_schema" do
+    @ds.db.default_schema = :foo
+    @ds.schema_and_table(:s).should == ['foo', 's']
+    @ds.schema_and_table(:s, nil).should == [nil, 's']
+  end
+end
+
+describe "Dataset#split_qualifiers" do
+  before do
+    @ds = Sequel.mock[:test]
+  end
+
+  it "should correctly handle symbols" do
+    @ds.split_qualifiers(:s).should == ['s']
+    @ds.split_qualifiers(:s___a).should == ['s']
+    @ds.split_qualifiers(:t__s).should == ['t', 's']
+    @ds.split_qualifiers(:t__s___a).should == ['t', 's']
+  end
+
+  it "should correctly handle strings" do
+    @ds.split_qualifiers('s').should == ['s']
+  end
+
+  it "should correctly handle identifiers" do
+    @ds.split_qualifiers(Sequel.identifier(:s)).should == ['s']
+  end
+
+  it "should correctly handle simple qualified identifiers" do
+    @ds.split_qualifiers(Sequel.qualify(:t, :s)).should == ['t', 's']
+  end
+
+  it "should correctly handle complex qualified identifiers" do
+    @ds.split_qualifiers(Sequel.qualify(:d__t, :s)).should == ['d', 't', 's']
+    @ds.split_qualifiers(Sequel.qualify(Sequel.qualify(:d, :t), :s)).should == ['d', 't', 's']
+    @ds.split_qualifiers(Sequel.qualify(:d, :t__s)).should == ['d', 't', 's']
+    @ds.split_qualifiers(Sequel.qualify(:d, Sequel.qualify(:t, :s))).should == ['d', 't', 's']
+    @ds.split_qualifiers(Sequel.qualify(:d__t, :s__s2)).should == ['d', 't', 's', 's2']
+    @ds.split_qualifiers(Sequel.qualify(Sequel.qualify(:d, :t), Sequel.qualify(:s, :s2))).should == ['d', 't', 's', 's2']
+  end
+
+  it "should respect default_schema" do
+    @ds.db.default_schema = :foo
+    @ds.split_qualifiers(:s).should == ['foo', 's']
+    @ds.split_qualifiers(:s, nil).should == ['s']
+    @ds.split_qualifiers(Sequel.qualify(:d__t, :s)).should == ['d', 't', 's']
+  end
+end
+