sequel 3.2.0 → 3.3.0

data/lib/sequel/model/base.rb

@@ -288,7 +288,13 @@ module Sequel
           @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
         end
         @dataset.model = self if @dataset.respond_to?(:model=)
-        @db_schema = (inherited ? superclass.db_schema : get_db_schema) rescue nil
+        begin
+          @db_schema = (inherited ? superclass.db_schema : get_db_schema)
+        rescue Sequel::DatabaseConnectionError
+          raise
+        rescue
+          nil
+        end
         self
       end
       alias dataset= set_dataset
@@ -390,7 +396,15 @@ module Sequel
         ds_opts = dataset.opts
         single_table = ds_opts[:from] && (ds_opts[:from].length == 1) \
           && !ds_opts.include?(:join) && !ds_opts.include?(:sql)
-        get_columns = proc{columns rescue []}
+        get_columns = proc do
+          begin
+            columns
+          rescue Sequel::DatabaseConnectionError
+            raise
+          rescue
+            []
+          end
+        end
         if single_table && (schema_array = (db.schema(table_name, :reload=>reload) rescue nil))
           schema_array.each{|k,v| schema_hash[k] = v}
           if ds_opts.include?(:select)
@@ -405,9 +419,12 @@ module Sequel
             # returned by the schema.
             cols = schema_array.collect{|k,v| k}
             set_columns(cols)
-            # Set the primary key(s) based on the schema information
-            pks = schema_array.collect{|k,v| k if v[:primary_key]}.compact
-            pks.length > 0 ? set_primary_key(*pks) : no_primary_key
+            # Set the primary key(s) based on the schema information,
+            # if the schema information includes primary key information
+            if schema_array.all?{|k,v| v.has_key?(:primary_key)}
+              pks = schema_array.collect{|k,v| k if v[:primary_key]}.compact
+              pks.length > 0 ? set_primary_key(*pks) : no_primary_key
+            end
             # Also set the columns for the dataset, so the dataset
             # doesn't have to do a query to get them.
             dataset.instance_variable_set(:@columns, cols)
@@ -819,13 +836,14 @@ module Sequel
         else
           return save_failure(:update) if before_update == false
           if columns.empty?
-            @columns_updated = opts[:changed] ? @values.reject{|k,v| !changed_columns.include?(k)} : @values
+            @columns_updated = opts[:changed] ? @values.reject{|k,v| !changed_columns.include?(k)} : @values.dup
             changed_columns.clear
           else # update only the specified columns
             @columns_updated = @values.reject{|k, v| !columns.include?(k)}
             changed_columns.reject!{|c| columns.include?(c)}
           end
-          this.update(@columns_updated)
+          Array(primary_key).each{|x| @columns_updated.delete(x)}
+          this.update(@columns_updated) unless @columns_updated.empty?
           after_update
           after_save
           @columns_updated = nil

data/lib/sequel/plugins/association_proxies.rb

@@ -0,0 +1,41 @@
+module Sequel
+  module Plugins
+    # Sequel by default does not use proxies for associations.  The association
+    # method for *_to_many associations returns an array, and the association_dataset
+    # method returns a dataset.  This plugin makes the association method return a proxy
+    # that will load the association and call a method on the association array if sent
+    # an array method, and otherwise send the method to the association's dataset.
+    module AssociationProxies
+      # A proxy for the association.  Calling an array method will load the
+      # associated objects and call the method on the associated object array.
+      # Calling any other method will call that method on the association's dataset.
+      class AssociationProxy < BasicObject
+        # Empty array used to check if an array responds to the given method.
+        ARRAY = []
+
+        # Set the association reflection to use, and whether the association should be
+        # reloaded if an array method is called.
+        def initialize(instance, reflection, reload=nil)
+          @instance = instance
+          @reflection = reflection
+          @reload = reload
+        end
+
+        # Call the method given on the array of associated objects if the method
+        # is an array method, otherwise call the method on the association's dataset.
+        def method_missing(meth, *args, &block)
+          (ARRAY.respond_to?(meth) ? @instance.send(:load_associated_objects, @reflection, @reload) : @instance.send(@reflection.dataset_method)).
+            send(meth, *args, &block)
+        end
+      end
+
+      module ClassMethods
+        # Changes the association method to return a proxy instead of the associated objects
+        # directly.
+        def def_association_method(opts)
+          opts.returns_array? ? association_module_def(opts.association_method){|*r| AssociationProxy.new(self, opts, r[0])} : super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/many_through_many.rb

@@ -125,7 +125,6 @@ module Sequel
           name = opts[:name]
           model = self
           opts[:read_only] = true
-          opts[:class_name] ||= camelize(singularize(name))
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
           opts[:cartesian_product_number] ||= 2
           opts[:through] = opts[:through].map do |e|

data/lib/sequel/sql.rb

@@ -1,4 +1,10 @@
 module Sequel
+  if RUBY_VERSION < '1.9.0'
+    class BasicObject
+      (instance_methods - %w"__id__ __send__ instance_eval == equal?").each{|m| undef_method(m)}
+    end
+  end
+
   class LiteralString < ::String
   end
 
@@ -776,15 +782,6 @@ module Sequel
       to_s_method :subscript_sql
     end
 
-    if RUBY_VERSION >= '1.9.0'
-      class VirtualRow < BasicObject
-      end
-    else
-      class VirtualRow
-        (instance_methods - %w"__id__ __send__ instance_eval == equal?").each{|m| undef_method(m)}
-      end
-    end
-
     # The purpose of this class is to allow the easy creation of SQL identifiers and functions
     # without relying on methods defined on Symbol.  This is useful if another library defines
     # the methods defined by Sequel, or if you are running on ruby 1.9.
@@ -830,7 +827,7 @@ module Sequel
     #   ds.select{rank(:over){}} # SELECT rank() OVER () FROM t
     #   ds.select{count(:over, :*=>true){}} # SELECT count(*) OVER () FROM t
     #   ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}} # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM t
-    class VirtualRow
+    class VirtualRow < BasicObject
       WILDCARD = LiteralString.new('*').freeze
       QUESTION_MARK = LiteralString.new('?').freeze
       COMMA_SEPARATOR = LiteralString.new(', ').freeze
@@ -888,7 +885,7 @@ module Sequel
     end
 
     # A WindowFunction is a grouping of a function with a window over which it operates.
-    class WindowFunction < Expression
+    class WindowFunction < GenericExpression
       # The function to use, should be an SQL::Function.
       attr_reader :function
 

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 2
+  MINOR = 3
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mysql_spec.rb

@@ -65,48 +65,52 @@ context "MySQL", '#create_table' do
 end
 
 context "A MySQL database" do
-  before do
-    @db = MYSQL_DB
-    @db.create_table(:booltest){TrueClass :value}
-  end
-  after do
-    Sequel.convert_tinyint_to_bool = true
-    @db.drop_table(:booltest)
-  end
-
   specify "should provide the server version" do
-    @db.server_version.should >= 40000
+    MYSQL_DB.server_version.should >= 40000
   end
+end
 
-  specify "should correctly parse the schema" do
-    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}]]
-    
-    Sequel.convert_tinyint_to_bool = false
-    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}]]
-  end
-  
-  specify "should accept and return tinyints as bools or integers when configured to do so" do
-    MYSQL_DB[:booltest].delete
-    MYSQL_DB[:booltest] << {:value=>true}
-    MYSQL_DB[:booltest].all.should == [{:value=>true}]
-    MYSQL_DB[:booltest].delete
-    MYSQL_DB[:booltest] << {:value=>false}
-    MYSQL_DB[:booltest].all.should == [{:value=>false}]
+if MYSQL_DB.class.adapter_scheme == :mysql
+  context "Sequel::MySQL.convert_tinyint_to_bool" do
+    before do
+      @db = MYSQL_DB
+      @db.create_table(:booltest){column :b, 'tinyint(1)'; column :i, 'tinyint(4)'}
+      @ds = @db[:booltest]
+    end
+    after do
+      Sequel::MySQL.convert_tinyint_to_bool = true
+      @db.drop_table(:booltest)
+    end
     
-    Sequel.convert_tinyint_to_bool = false
-    MYSQL_DB[:booltest].delete
-    MYSQL_DB[:booltest] << {:value=>true}
-    MYSQL_DB[:booltest].all.should == [{:value=>1}]
-    MYSQL_DB[:booltest].delete
-    MYSQL_DB[:booltest] << {:value=>false}
-    MYSQL_DB[:booltest].all.should == [{:value=>0}]
+    specify "should consider tinyint(1) datatypes as boolean if set, but not larger tinyints" do
+      @db.schema(:booltest, :reload=>true).should == [[:b, {:type=>:boolean, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(1)"}, ], [:i, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}, ]]
+      Sequel::MySQL.convert_tinyint_to_bool = false
+      @db.schema(:booltest, :reload=>true).should == [[:b, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(1)"}, ], [:i, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}, ]]
+    end
     
-    MYSQL_DB[:booltest].delete
-    MYSQL_DB[:booltest] << {:value=>1}
-    MYSQL_DB[:booltest].all.should == [{:value=>1}]
-    MYSQL_DB[:booltest].delete
-    MYSQL_DB[:booltest] << {:value=>0}
-    MYSQL_DB[:booltest].all.should == [{:value=>0}]
+    specify "should return tinyints as bools when set" do
+      @ds.delete
+      @ds << {:b=>true, :i=>10}
+      @ds.all.should == [{:b=>true, :i=>true}]
+      @ds.delete
+      @ds << {:b=>false, :i=>0}
+      @ds.all.should == [{:b=>false, :i=>false}]
+      
+      Sequel::MySQL.convert_tinyint_to_bool = false
+      @ds.delete
+      @ds << {:b=>true, :i=>10}
+      @ds.all.should == [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds << {:b=>false, :i=>0}
+      @ds.all.should == [{:b=>0, :i=>0}]
+      
+      @ds.delete
+      @ds << {:b=>1, :i=>10}
+      @ds.all.should == [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds << {:b=>0, :i=>0}
+      @ds.all.should == [{:b=>0, :i=>0}]
+    end
   end
 end
 
@@ -411,7 +415,7 @@ context "A MySQL database" do
   
   specify "should support defaults for boolean columns" do
     @db.create_table(:items){TrueClass :active1, :default=>true; FalseClass :active2, :default => false}
-    @db.sqls.should == ["CREATE TABLE items (active1 tinyint DEFAULT 1, active2 tinyint DEFAULT 0)"]
+    @db.sqls.should == ["CREATE TABLE items (active1 tinyint(1) DEFAULT 1, active2 tinyint(1) DEFAULT 0)"]
   end
   
   specify "should correctly format CREATE TABLE statements with foreign keys" do

data/spec/adapters/sqlite_spec.rb

@@ -377,10 +377,6 @@ context "A SQLite database" do
     @db[:test3_backup2].columns.should == [:l]
   end
   
-  specify "should not support set_column_type operations" do
-    proc {@db.set_column_type :test2, :value, :integer}.should raise_error(Sequel::Error)
-  end
-  
   specify "should support add_index" do
     @db.add_index :test2, :value, :unique => true
     @db.add_index :test2, [:name, :value]

data/spec/core/database_spec.rb

@@ -839,13 +839,34 @@ context "A Database adapter with a scheme" do
   end
 
   specify "should be accessible through Sequel.connect with URL parameters" do
-    c = Sequel.connect 'ccc://localhost/db?host=/tmp&user=test'
+    c = Sequel.connect 'ccc:///db?host=/tmp&user=test'
     c.should be_a_kind_of(CCC)
     c.opts[:host].should == '/tmp'
     c.opts[:database].should == 'db'
     c.opts[:user].should == 'test'
   end
+  
+  specify "should have URL parameters take precedence over fixed URL parts" do
+    c = Sequel.connect 'ccc://localhost/db?host=a&database=b'
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == 'a'
+    c.opts[:database].should == 'b'
+  end
+  
+  specify "should have hash options take predence over URL parameters or parts" do
+    c = Sequel.connect 'ccc://localhost/db?host=/tmp', :host=>'a', :database=>'b', :user=>'c'
+    c.should be_a_kind_of(CCC)
+    c.opts[:host].should == 'a'
+    c.opts[:database].should == 'b'
+    c.opts[:user].should == 'c'
+  end
 
+  specify "should unescape values of URL parameters and parts" do
+    c = Sequel.connect 'ccc:///d%5bb%5d?host=domain%5cinstance'
+    c.should be_a_kind_of(CCC)
+    c.opts[:database].should == 'd[b]'
+    c.opts[:host].should == 'domain\\instance'
+  end
 end
 
 context "Sequel::Database.connect" do

data/spec/core/dataset_spec.rb

@@ -92,6 +92,16 @@ context "Dataset" do
     @dataset.identifier_output_method = :reverse
     @dataset.send(:output_identifier, "at_b_C").should == :C_b_ta
   end
+  
+  specify "should have output_identifier handle empty identifiers" do
+    @dataset.send(:output_identifier, "").should == :untitled
+    @dataset.identifier_output_method = :upcase
+    @dataset.send(:output_identifier, "").should == :UNTITLED
+    @dataset.identifier_output_method = :downcase
+    @dataset.send(:output_identifier, "").should == :untitled
+    @dataset.identifier_output_method = :reverse
+    @dataset.send(:output_identifier, "").should == :deltitnu
+  end
 end
 
 context "Dataset#clone" do
@@ -1008,24 +1018,20 @@ context "Dataset#order" do
 end
 
 context "Dataset#unfiltered" do
-  before do
-    @dataset = Sequel::Dataset.new(nil).from(:test)
-  end
-  
   specify "should remove filtering from the dataset" do
-    @dataset.filter(:score=>1).unfiltered.sql.should ==
-      'SELECT * FROM test'
+    Sequel::Dataset.new(nil).from(:test).filter(:score=>1).unfiltered.sql.should == 'SELECT * FROM test'
   end
 end
 
-context "Dataset#unordered" do
-  before do
-    @dataset = Sequel::Dataset.new(nil).from(:test)
+context "Dataset#unlimited" do
+  specify "should remove limit and offset from the dataset" do
+    Sequel::Dataset.new(nil).from(:test).limit(1, 2).unlimited.sql.should == 'SELECT * FROM test'
   end
-  
+end
+
+context "Dataset#unordered" do
   specify "should remove ordering from the dataset" do
-    @dataset.order(:name).unordered.sql.should ==
-      'SELECT * FROM test'
+    Sequel::Dataset.new(nil).from(:test).order(:name).unordered.sql.should == 'SELECT * FROM test'
   end
 end
 
@@ -1389,6 +1395,25 @@ context "Dataset#empty?" do
   end
 end
 
+context "Dataset#from_self" do
+  before do
+    @ds = Sequel::Dataset.new(nil).from(:test).select(:name).limit(1)
+  end
+  specify "should set up a default alias" do
+    @ds.from_self.sql.should == 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
+  end
+  specify "should modify only the new dataset" do
+    @ds.from_self.select(:bogus).sql.should == 'SELECT bogus FROM (SELECT name FROM test LIMIT 1) AS t1'
+  end
+  specify "should use the user-specified alias" do
+    @ds.from_self(:alias=>:some_name).sql.should == 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS some_name'
+  end
+  specify "should use the user-specified alias for joins" do
+    @ds.from_self(:alias=>:some_name).inner_join(:posts, :alias=>:name).sql.should == \
+      'SELECT * FROM (SELECT name FROM test LIMIT 1) AS some_name INNER JOIN posts ON (posts.alias = some_name.name)'
+  end
+end
+
 context "Dataset#join_table" do
   before do
     @d = MockDataset.new(nil).from(:items)

data/spec/core/expression_filters_spec.rb

@@ -520,6 +520,10 @@ context Sequel::SQL::VirtualRow do
     @d.l{rank(:over, :frame=>:rows){}}.should == 'rank() OVER (ROWS UNBOUNDED PRECEDING)'
   end
 
+  it "should raise an error if an invalid :frame option is used" do
+    proc{@d.l{rank(:over, :frame=>:blah){}}}.should raise_error(Sequel::Error)
+  end
+
   it "should support all these options together" do
     @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS UNBOUNDED PRECEDING)'
   end
@@ -527,5 +531,6 @@ context Sequel::SQL::VirtualRow do
   it "should raise an error if window functions are not supported" do
     @d.meta_def(:supports_window_functions?){false}
     proc{@d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.should raise_error(Sequel::Error)
+    proc{Sequel::Dataset.new(nil).filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
   end
 end

data/spec/core/schema_spec.rb

@@ -107,16 +107,18 @@ context "DB#create_table" do
     @db.create_table(:cats) do
       integer :id
       text :name, :null => false
+      text :name2, :allow_null => false
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NOT NULL)"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NOT NULL, name2 text NOT NULL)"]
   end
   
   specify "should accept null definition" do
     @db.create_table(:cats) do
       integer :id
       text :name, :null => true
+      text :name2, :allow_null => true
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NULL)"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NULL, name2 text NULL)"]
   end
   
   specify "should accept unique definition" do
@@ -744,9 +746,6 @@ context "Schema Parser" do
     @sqls = []
     @db = Sequel::Database.new
   end
-  after do
-    Sequel.convert_tinyint_to_bool = true
-  end
 
   specify "should raise an error if there are no columns" do
     @db.meta_def(:schema_parse_table) do |t, opts|
@@ -788,9 +787,7 @@ context "Schema Parser" do
     @db.meta_def(:schema_parse_table) do |t, opts|
       [[:x, {:type=>schema_column_type(t.to_s)}]]
     end
-    @db.schema(:tinyint).first.last[:type].should == :boolean
-    Sequel.convert_tinyint_to_bool = false
-    @db.schema(:tinyint, :reload=>true).first.last[:type].should == :integer
+    @db.schema(:tinyint).first.last[:type].should == :integer
     @db.schema(:interval).first.last[:type].should == :interval
     @db.schema(:int).first.last[:type].should == :integer
     @db.schema(:integer).first.last[:type].should == :integer
@@ -810,6 +807,7 @@ context "Schema Parser" do
     @db.schema(:"time with time zone").first.last[:type].should == :time
     @db.schema(:"time without time zone").first.last[:type].should == :time
     @db.schema(:boolean).first.last[:type].should == :boolean
+    @db.schema(:bit).first.last[:type].should == :boolean
     @db.schema(:real).first.last[:type].should == :float
     @db.schema(:float).first.last[:type].should == :float
     @db.schema(:double).first.last[:type].should == :float
@@ -818,5 +816,14 @@ context "Schema Parser" do
     @db.schema(:decimal).first.last[:type].should == :decimal
     @db.schema(:money).first.last[:type].should == :decimal
     @db.schema(:bytea).first.last[:type].should == :blob
+    @db.schema(:blob).first.last[:type].should == :blob
+    @db.schema(:image).first.last[:type].should == :blob
+    @db.schema(:nchar).first.last[:type].should == :string
+    @db.schema(:nvarchar).first.last[:type].should == :string
+    @db.schema(:ntext).first.last[:type].should == :string
+    @db.schema(:smalldatetime).first.last[:type].should == :datetime
+    @db.schema(:smallmoney).first.last[:type].should == :decimal
+    @db.schema(:binary).first.last[:type].should == :blob
+    @db.schema(:varbinary).first.last[:type].should == :blob
   end
 end