sequel 3.17.0 → 3.18.0

data/lib/sequel/extensions/to_dot.rb

@@ -0,0 +1,137 @@
+# This adds a <tt>Sequel::Dataset#to_dot</tt> method.  The +to_dot+ method
+# returns a string that can be processed by graphviz's +dot+ program in
+# order to get a visualization of the dataset.  Basically, it shows a version
+# of the dataset's abstract syntax tree.
+
+module Sequel
+  class Dataset
+    # The option keys that should be included in the dot output.
+    TO_DOT_OPTIONS = [:with, :distinct, :select, :from, :join, :where, :group, :having, :compounds, :order, :limit, :offset, :lock].freeze
+
+    # Return a string that can be processed by the +dot+ program (included
+    # with graphviz) in order to see a visualization of the dataset's
+    # abstract syntax tree.
+    def to_dot
+      i = 0
+      dot = ["digraph G {", "#{i} [label=\"self\"];"]
+      _to_dot(dot, "", i, self, i)
+      dot << "}"
+      dot.join("\n")
+    end
+
+    private
+
+    # Internal recursive version that handles all object types understood
+    # by Sequel.  Arguments:
+    # * dot :: An array of strings representing the lines in the returned
+    #          output.  This function just pushes strings onto this array.
+    # * l :: The transition label from the parent node of the AST to the
+    #        current node.
+    # * c :: An integer representing the parent node of the AST.
+    # * e :: The current node of the AST.
+    # * i :: The integer representing the last created node of the AST.
+    #
+    # The basic algorithm is that the +i+ is incremented to get the current
+    # node's integer.  Then the transition from the parent node to the
+    # current node is added to the +dot+ array.  Finally, the current node
+    # is added to the +dot+ array, and if it is a compound node with children,
+    # its children are then added by recursively calling this method. The
+    # return value is the integer representing the last created node.
+    def _to_dot(dot, l, c, e, i)
+      i += 1
+      dot << "#{c} -> #{i} [label=\"#{l}\"];" if l
+      c = i
+      case e
+      when LiteralString
+        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}.lit\"];"
+        i
+      when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
+        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}\"];"
+        i
+      when Array
+        dot << "#{i} [label=\"Array\"];"
+        e.each_with_index do |v, j|
+          i = _to_dot(dot, j, c, v, i)
+        end
+      when Hash
+        dot << "#{i} [label=\"Hash\"];"
+        e.each do |k, v|
+          i = _to_dot(dot, k, c, v, i)
+        end
+      when SQL::ComplexExpression 
+        dot << "#{i} [label=\"ComplexExpression: #{e.op}\"];"
+        e.args.each_with_index do |v, j|
+          i = _to_dot(dot, j, c, v, i)
+        end
+      when SQL::Identifier
+        dot << "#{i} [label=\"Identifier\"];"
+        i = _to_dot(dot, :value, c, e.value, i)
+      when SQL::QualifiedIdentifier
+        dot << "#{i} [label=\"QualifiedIdentifier\"];"
+        i = _to_dot(dot, :table, c, e.table, i)
+        i = _to_dot(dot, :column, c, e.column, i)
+      when SQL::OrderedExpression
+        dot << "#{i} [label=\"OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}\"];"
+        i = _to_dot(dot, :expression, c, e.expression, i)
+      when SQL::AliasedExpression
+        dot << "#{i} [label=\"AliasedExpression\"];"
+        i = _to_dot(dot, :expression, c, e.expression, i)
+        i = _to_dot(dot, :alias, c, e.aliaz, i)
+      when SQL::CaseExpression
+        dot << "#{i} [label=\"CaseExpression\"];"
+        i = _to_dot(dot, :expression, c, e.expression, i) if e.expression
+        i = _to_dot(dot, :conditions, c, e.conditions, i)
+        i = _to_dot(dot, :default, c, e.default, i)
+      when SQL::Cast
+        dot << "#{i} [label=\"Cast\"];"
+        i = _to_dot(dot, :expr, c, e.expr, i)
+        i = _to_dot(dot, :type, c, e.type, i)
+      when SQL::Function
+        dot << "#{i} [label=\"Function: #{e.f}\"];"
+        e.args.each_with_index do |v, j|
+          i = _to_dot(dot, j, c, v, i)
+        end
+      when SQL::Subscript 
+        dot << "#{i} [label=\"Subscript: #{e.f}\"];"
+        i = _to_dot(dot, :f, c, e.f, i)
+        i = _to_dot(dot, :sub, c, e.sub, i)
+      when SQL::WindowFunction
+        dot << "#{i} [label=\"WindowFunction\"];"
+        i = _to_dot(dot, :function, c, e.function, i)
+        i = _to_dot(dot, :window, c, e.window, i)
+      when SQL::Window
+        dot << "#{i} [label=\"Window\"];"
+        i = _to_dot(dot, :opts, c, e.opts, i)
+      when SQL::PlaceholderLiteralString
+        str = e.str
+        str = "(#{str})" if e.parens
+        dot << "#{i} [label=\"PlaceholderLiteralString: #{str.inspect.gsub('"', '\\"')}\"];"
+        i = _to_dot(dot, :args, c, e.args, i)
+      when SQL::JoinClause
+        str = "#{e.join_type.to_s.upcase} JOIN"
+        if e.is_a?(SQL::JoinOnClause)
+          str << " ON"
+        elsif e.is_a?(SQL::JoinUsingClause)
+          str << " USING"
+        end
+        dot << "#{i} [label=\"#{str}\"];"
+        i = _to_dot(dot, :table, c, e.table, i)
+        i = _to_dot(dot, :alias, c, e.table_alias, i) if e.table_alias
+        if e.is_a?(SQL::JoinOnClause)
+          i = _to_dot(dot, :on, c, e.on, i)
+        elsif e.is_a?(SQL::JoinUsingClause)
+          i = _to_dot(dot, :using, c, e.using, i)
+        end
+      when Dataset
+        dot << "#{i} [label=\"Dataset\"];"
+        TO_DOT_OPTIONS.each do |k|
+          next unless e.opts[k]
+          i = _to_dot(dot, k, c, e.opts[k], i)
+        end
+      else
+        dot << "#{i} [label=\"Unhandled: #{e.inspect.gsub('"', "''")}\"];"
+      end
+      i
+    end
+  end
+end

data/lib/sequel/model/base.rb

@@ -553,7 +553,7 @@ module Sequel
         single_table = ds_opts[:from] && (ds_opts[:from].length == 1) \
           && !ds_opts.include?(:join) && !ds_opts.include?(:sql)
         get_columns = proc{check_non_connection_error{columns} || []}
-        if single_table && (schema_array = (db.schema(table_name, :reload=>reload) rescue nil))
+        if single_table && (schema_array = (db.schema(dataset.first_source_table, :reload=>reload) rescue nil))
           schema_array.each{|k,v| schema_hash[k] = v}
           if ds_opts.include?(:select)
             # We don't remove the columns from the schema_hash,

data/lib/sequel/plugins/instance_hooks.rb

@@ -10,7 +10,12 @@ module Sequel
     # after calling super.  If any of the instance level before hook blocks return
     # false, no more instance level before hooks are called and false is returned.
     #
-    # Instance level hooks are cleared when the object is saved successfully.
+    # Instance level hooks for before and after are cleared after all related
+    # after level instance hooks have run.  This means that if you add a before_create
+    # and before_update instance hooks to a new object, the before_create hook will
+    # be run the first time you save the object (creating it), and the before_update
+    # hook will be run the second time you save the object (updating it), and no
+    # hooks will be run the third time you save the object.
     # 
     # Usage:
     #
@@ -27,14 +32,14 @@ module Sequel
         HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block) end", __FILE__, __LINE__)}
         
         BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
-        (AFTER_HOOKS - [:after_save]).each{|h| class_eval("def #{h}; super; run_after_instance_hooks(:#{h}) end", __FILE__, __LINE__)}
-        
-        # Clear the instance level hooks after saving the object.
-        def after_save
-          super
-          run_after_instance_hooks(:after_save)
-          @instance_hooks.clear if @instance_hooks
-        end
+        AFTER_HOOKS.each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+          def #{h}
+            super
+            run_after_instance_hooks(:#{h})
+            @instance_hooks.delete(:#{h})
+            @instance_hooks.delete(:#{h.to_s.sub('after', 'before')})
+          end
+        END
         
         private
         

data/lib/sequel/plugins/json_serializer.rb

@@ -106,10 +106,10 @@ module Sequel
           hash.each do |k, v|
             if assocs.include?(k)
               obj.associations[k.to_sym] = v
-            elsif cols.include?(k)
-              obj.values[k.to_sym] = v
             elsif meths.include?("#{k}=")
               obj.send("#{k}=", v)
+            elsif cols.include?(k)
+              obj.values[k.to_sym] = v
             else
               raise Error, "Entry in JSON hash not an association or column and no setter method exists: #{k}"
             end
@@ -171,7 +171,7 @@ module Sequel
             vals.keys - Array(opts[:except])
           end
           h = (JSON.create_id && !opts[:naked] && !opts[:root]) ? {JSON.create_id=>model.name} : {}
-          cols.each{|c| h[c.to_s] = vals[c]}
+          cols.each{|c| h[c.to_s] = send(c)}
           if inc = opts[:include]
             if inc.is_a?(Hash)
               inc.each do |k, v|

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"
+      KEEP_METHODS = %w"__id__ __send__ __metaclass__ instance_eval == 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

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

data/spec/adapters/sqlite_spec.rb

@@ -101,14 +101,13 @@ context "An SQLite database" do
   cspecify "should support timestamps and datetimes and respect datetime_class", :do, :jdbc, :amalgalite do
     @db.create_table!(:time){timestamp :t; datetime :d}
     t1 = Time.at(1)
-    @db[:time] << {:t => t1, :d => t1.to_i}
-    @db[:time] << {:t => t1.to_i, :d => t1}
-    @db[:time].map(:t).should == [t1, t1]
-    @db[:time].map(:d).should == [t1, t1]
+    @db[:time] << {:t => t1, :d => t1}
+    @db[:time].map(:t).should == [t1]
+    @db[:time].map(:d).should == [t1]
     Sequel.datetime_class = DateTime
     t2 = Sequel.string_to_datetime(t1.iso8601)
-    @db[:time].map(:t).should == [t2, t2]
-    @db[:time].map(:d).should == [t2, t2]
+    @db[:time].map(:t).should == [t2]
+    @db[:time].map(:d).should == [t2]
   end
   
   specify "should support sequential primary keys" do
@@ -412,7 +411,7 @@ context "A SQLite database" do
   
   specify "should choose a temporary table name that isn't already used when dropping or renaming columns" do
     sqls = []
-    @db.loggers << (l=Class.new{define_method(:info){|sql| sqls << sql}}.new)
+    @db.loggers << (l=Class.new{%w'info error'.each{|m| define_method(m){|sql| sqls << sql}}}.new)
     @db.create_table! :test3 do
       Integer :h
       Integer :i
@@ -459,4 +458,13 @@ context "A SQLite database" do
     @db.add_index :test2, :value, :unique => true
     @db.drop_index :test2, :value
   end
+
+  specify "should keep applicable indexes when emulating schema methods" do
+    @db.create_table!(:a){Integer :a; Integer :b}
+    @db.add_index :a, :a
+    @db.add_index :a, :b
+    @db.add_index :a, [:b, :a]
+    @db.drop_column :a, :b
+    @db.indexes(:a).should == {:a_a_index=>{:unique=>false, :columns=>[:a]}}
+  end
 end  

data/spec/core/connection_pool_spec.rb

@@ -315,7 +315,7 @@ context "Threaded Sharded Connection Pool" do
     @invoked_count = 0
     @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {@invoked_count += 1}
   end
-  
+
   it_should_behave_like "A threaded connection pool"
 end
 
@@ -418,6 +418,22 @@ context "A connection pool with multiple servers" do
     end
   end
 
+  specify "should support a :servers_hash option used for converting the server argument" do
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new(:read_only), :servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+    @pool.hold(:blah) do |c1|
+      c1.should == "read_only1"
+      @pool.hold(:blah) do |c2|
+        c2.should == c1
+        @pool.hold(:blah2) do |c3|
+          c2.should == c3
+        end
+      end
+    end
+
+    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:servers_hash=>Hash.new{|h,k| raise Sequel::Error}, :servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+    proc{@pool.hold(:blah){|c1|}}.should raise_error(Sequel::Error)
+  end
+
   specify "should use the requested server if server is given" do
     @pool.size(:read_only).should == 0
     @pool.hold(:read_only) do |c|

data/spec/core/dataset_spec.rb

@@ -1552,6 +1552,10 @@ context "Dataset#qualified_column_name" do
   specify "should not changed the qualifed column's table if given a qualified symbol" do
     @dataset.literal(@dataset.send(:qualified_column_name, :ccc__b, :items)).should == 'ccc.b'
   end
+
+  specify "should handle an aliased identifier" do
+    @dataset.literal(@dataset.send(:qualified_column_name, :ccc, :items.as(:i))).should == 'i.ccc'
+  end
 end
 
 class DummyDataset < Sequel::Dataset
@@ -1937,6 +1941,11 @@ context "Dataset#join_table" do
       'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
   end
   
+  specify "should support aliased tables using an implicit alias" do
+    @d.from('stats').join(:players.as(:p), {:id => :player_id}).sql.should ==
+      'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
+  end
+  
   specify "should support using an alias for the FROM when doing the first join with unqualified condition columns" do
     ds = MockDataset.new(nil).from(:foo => :f)
     ds.quote_identifiers = true

data/spec/extensions/instance_hooks_spec.rb

@@ -130,4 +130,50 @@ describe "InstanceHooks plugin" do
     @o.valid?.should == false
     @r.should == [4, false]
   end
+
+  it "should clear only related hooks on successful create" do
+    @o.after_destroy_hook{r 1}
+    @o.before_destroy_hook{r 2}
+    @o.after_update_hook{r 3}
+    @o.before_update_hook{r 4}
+    @o.before_save_hook{r 5}
+    @o.after_save_hook{r 6}
+    @o.before_create_hook{r 7}
+    @o.after_create_hook{r 8}
+    @o.save.should_not == nil
+    @r.should == [5, 7, 8, 6]
+    @o.instance_variable_set(:@new, false)
+    @o.save.should_not == nil
+    @r.should == [5, 7, 8, 6, 4, 3]
+    @o.save.should_not == nil
+    @r.should == [5, 7, 8, 6, 4, 3]
+    @o.destroy
+    @r.should == [5, 7, 8, 6, 4, 3, 2, 1]
+  end
+
+  it "should clear only related hooks on successful update" do
+    @x.after_destroy_hook{r 1}
+    @x.before_destroy_hook{r 2}
+    @x.before_update_hook{r 3}
+    @x.after_update_hook{r 4}
+    @x.before_save_hook{r 5}
+    @x.after_save_hook{r 6}
+    @x.save.should_not == nil
+    @r.should == [5, 3, 4, 6]
+    @x.save.should_not == nil
+    @r.should == [5, 3, 4, 6]
+    @x.destroy
+    @r.should == [5, 3, 4, 6, 2, 1]
+  end
+
+  it "should clear only related hooks on successful destroy" do
+    @x.after_destroy_hook{r 1}
+    @x.before_destroy_hook{r 2}
+    @x.before_update_hook{r 3}
+    @x.before_save_hook{r 4}
+    @x.destroy
+    @r.should == [2, 1]
+    @x.save.should_not == nil
+    @r.should == [2, 1, 4, 3]
+  end
 end

data/spec/extensions/json_serializer_spec.rb

@@ -10,12 +10,14 @@ describe "Sequel::Plugins::JsonSerializer" do
     class ::Artist < Sequel::Model
       plugin :json_serializer
       columns :id, :name
+      def_column_accessor :id, :name
       one_to_many :albums
     end
     class ::Album < Sequel::Model
       attr_accessor :blah
       plugin :json_serializer
       columns :id, :name, :artist_id
+      def_column_accessor :id, :name, :artist_id
       many_to_one :artist
     end
     @artist = Artist.load(:id=>2, :name=>'YJM')
@@ -34,6 +36,15 @@ describe "Sequel::Plugins::JsonSerializer" do
     JSON.parse(@album.to_json).should == @album
   end
 
+  it "should handle ruby objects in values" do
+    class ::Artist
+      def name=(v)
+        super(Date.parse(v))
+      end
+    end
+    JSON.parse(Artist.load(:name=>Date.today).to_json).should == Artist.load(:name=>Date.today)
+  end
+
   it "should handle the :only option" do
     JSON.parse(@artist.to_json(:only=>:name)).should == Artist.load(:name=>@artist.name)
     JSON.parse(@album.to_json(:only=>[:id, :name])).should == Album.load(:id=>@album.id, :name=>@album.name)

data/spec/extensions/migration_spec.rb

@@ -86,6 +86,113 @@ context "SimpleMigration#apply" do
   end
 end
 
+context "Reversible Migrations with Sequel.migration{change{}}" do
+  before do
+    @c = Class.new do
+      self::AT = Class.new do
+        attr_reader :actions
+        def initialize(&block)
+          @actions = []
+          instance_eval(&block)
+        end
+        def method_missing(*args)
+          @actions << args
+        end
+        self
+      end
+      attr_reader :actions
+      def initialize
+        @actions = []
+      end
+      def method_missing(*args)
+        @actions << args
+      end
+      def alter_table(*args, &block)
+        @actions << [:alter_table, self.class::AT.new(&block).actions]
+      end
+    end
+    @db = @c.new
+    @p = Proc.new do
+      create_table(:a){Integer :a}
+      add_column :a, :b, String
+      add_index :a, :b
+      rename_column :a, :b, :c
+      rename_table :a, :b
+      alter_table(:b) do
+        add_column :d, String
+        add_constraint :blah, 'd IS NOT NULL'
+        add_foreign_key :e, :b
+        add_primary_key :f, :b
+        add_index :e, :name=>'e_n'
+        add_full_text_index :e, :name=>'e_ft'
+        add_spatial_index :e, :name=>'e_s'
+        rename_column :e, :g
+      end
+      create_view(:c, 'SELECT * FROM b')
+    end
+  end
+  
+  specify "should apply up with normal actions in normal order" do
+    p = @p
+    Sequel.migration{change(&p)}.apply(@db, :up)
+    @db.actions.should == [[:create_table, :a],
+      [:add_column, :a, :b, String],
+      [:add_index, :a, :b],
+      [:rename_column, :a, :b, :c],
+      [:rename_table, :a, :b],
+      [:alter_table, [
+        [:add_column, :d, String],
+        [:add_constraint, :blah, "d IS NOT NULL"],
+        [:add_foreign_key, :e, :b],
+        [:add_primary_key, :f, :b],
+        [:add_index, :e, {:name=>"e_n"}],
+        [:add_full_text_index, :e, {:name=>"e_ft"}],
+        [:add_spatial_index, :e, {:name=>"e_s"}],
+        [:rename_column, :e, :g]]
+      ],
+      [:create_view, :c, "SELECT * FROM b"]]
+  end
+
+  specify "should execute down with reversing actions in reverse order" do
+    p = @p
+    Sequel.migration{change(&p)}.apply(@db, :down)
+    @db.actions.should == [[:drop_view, :c],
+      [:alter_table, [
+        [:rename_column, :g, :e],
+        [:drop_index, :e, {:name=>"e_s"}],
+        [:drop_index, :e, {:name=>"e_ft"}],
+        [:drop_index, :e, {:name=>"e_n"}],
+        [:drop_column, :f],
+        [:drop_column, :e],
+        [:drop_constraint, :blah],
+        [:drop_column, :d]]
+      ],
+      [:rename_table, :b, :a],
+      [:rename_column, :a, :c, :b],
+      [:drop_index, :a, :b],
+      [:drop_column, :a, :b],
+      [:drop_table, :a]]
+  end
+  
+  specify "should raise in the down direction if migration uses unsupported method" do
+    m = Sequel.migration{change{run 'SQL'}}
+    proc{m.apply(@db, :up)}.should_not raise_error(Sequel::Error)
+    proc{m.apply(@db, :down)}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should raise in the down direction if migration uses add_primary_key with an array" do
+    m = Sequel.migration{change{alter_table(:a){add_primary_key [:b]}}}
+    proc{m.apply(@db, :up)}.should_not raise_error(Sequel::Error)
+    proc{m.apply(@db, :down)}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should raise in the down direction if migration uses add_foreign_key with an array" do
+    m = Sequel.migration{change{alter_table(:a){add_foreign_key [:b]}}}
+    proc{m.apply(@db, :up)}.should_not raise_error(Sequel::Error)
+    proc{m.apply(@db, :down)}.should raise_error(Sequel::Error)
+  end
+end
+
 context "Sequel::IntegerMigrator" do
   before do
     dbc = Class.new(MockDatabase) do