sequel 2.8.0 → 2.9.0

data/lib/sequel_core/adapters/shared/progress.rb

@@ -12,7 +12,7 @@ module Sequel
     module DatasetMethods
       include Dataset::UnsupportedIntersectExcept
 
-      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having union'.freeze
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having compounds'.freeze
 
       private
 

data/lib/sequel_core/adapters/shared/sqlite.rb

@@ -18,16 +18,15 @@ module Sequel
       # the column inside of a transaction.
       def alter_table_sql(table, op)
         case op[:op]
-        when :add_column
+        when :add_column, :add_index, :drop_index
           super
-        when :add_index
-          index_definition_sql(table, op)
         when :drop_column
           columns_str = (schema_parse_table(table, {}).map{|c| c[0]} - Array(op[:name])).join(",")
-           ["CREATE TEMPORARY TABLE #{table}_backup(#{columns_str})",
+          defined_columns_str = column_list_sql parse_pragma(table, {}).reject{ |c| c[:name] == op[:name].to_s}
+          ["CREATE TEMPORARY TABLE #{table}_backup(#{defined_columns_str})",
            "INSERT INTO #{table}_backup SELECT #{columns_str} FROM #{table}",
            "DROP TABLE #{table}",
-           "CREATE TABLE #{table}(#{columns_str})",
+           "CREATE TABLE #{table}(#{defined_columns_str})",
            "INSERT INTO #{table} SELECT #{columns_str} FROM #{table}_backup",
            "DROP TABLE #{table}_backup"]
         else
@@ -94,6 +93,12 @@ module Sequel
       # SQLite supports schema parsing using the table_info PRAGMA, so
       # parse the output of that into the format Sequel expects.
       def schema_parse_table(table_name, opts)
+        parse_pragma(table_name, opts).map do |row|
+          [row.delete(:name).to_sym, row]
+        end
+      end
+
+      def parse_pragma(table_name, opts)
         self["PRAGMA table_info(?)", table_name].map do |row|
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
@@ -102,7 +107,7 @@ module Sequel
           row[:default] = nil if row[:default].blank?
           row[:db_type] = row.delete(:type)
           row[:type] = schema_column_type(row[:db_type])
-          [row.delete(:name).to_sym, row]
+          row
         end
       end
     end

data/lib/sequel_core/adapters/sqlite.rb

@@ -31,6 +31,7 @@ module Sequel
         db = ::SQLite3::Database.new(opts[:database])
         db.busy_timeout(opts.fetch(:timeout, 5000))
         db.type_translation = true
+        
         # Handle datetime's with Sequel.datetime_class
         prok = proc do |t,v|
           v = Time.at(v.to_i).iso8601 if UNIX_EPOCH_TIME_FORMAT.match(v)
@@ -38,6 +39,13 @@ module Sequel
         end
         db.translator.add_translator("timestamp", &prok)
         db.translator.add_translator("datetime", &prok)
+        
+        # Handle numeric values with BigDecimal
+        prok = proc{|t,v| BigDecimal.new(v) rescue v}
+        db.translator.add_translator("numeric", &prok)
+        db.translator.add_translator("decimal", &prok)
+        db.translator.add_translator("money", &prok)
+        
         db
       end
       

data/lib/sequel_core/dataset/sql.rb

@@ -6,13 +6,13 @@ module Sequel
     COLUMN_REF_RE1 = /\A([\w ]+)__([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
-    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit]
+    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
     DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
     QUESTION_MARK = '?'.freeze
     STOCK_COUNT_OPTS = {:select => ["COUNT(*)".lit], :order => nil}.freeze
-    SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having intersect union except order limit'.freeze
+    SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
     TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
     WILDCARD = '*'.freeze
@@ -104,7 +104,7 @@ module Sequel
     #   DB[:items].except(DB[:other_items]).sql
     #   #=> "SELECT * FROM items EXCEPT SELECT * FROM other_items"
     def except(dataset, all = false)
-      clone(:except => dataset, :except_all => all)
+      compound_clone(:except, dataset, all)
     end
 
     # Performs the inverse of Dataset#filter.
@@ -316,7 +316,7 @@ module Sequel
     #   DB[:items].intersect(DB[:other_items]).sql
     #   #=> "SELECT * FROM items INTERSECT SELECT * FROM other_items"
     def intersect(dataset, all = false)
-      clone(:intersect => dataset, :intersect_all => all)
+      compound_clone(:intersect, dataset, all)
     end
 
     # Inverts the current filter
@@ -471,7 +471,9 @@ module Sequel
       when Integer, Float
         v.to_s
       when BigDecimal
-        v.to_s("F")
+        d = v.to_s("F")
+        d = "'#{d}'" if v.nan? || v.infinite?
+        d
       when NilClass
         NULL
       when TrueClass
@@ -680,7 +682,7 @@ module Sequel
     #   DB[:items].union(DB[:other_items]).sql
     #   #=> "SELECT * FROM items UNION SELECT * FROM other_items"
     def union(dataset, all = false)
-      clone(:union => dataset, :union_all => all)
+      compound_clone(:union, dataset, all)
     end
 
     # Returns a copy of the dataset with the distinct option.
@@ -769,6 +771,11 @@ module Sequel
       end
     end
     
+    # Add the dataset to the list of compounds
+    def compound_clone(type, dataset, all)
+      clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset, all]])
+    end
+    
     # Converts an array of expressions into a comma separated string of
     # expressions.
     def expression_list(columns)
@@ -880,9 +887,16 @@ module Sequel
       end
     end
 
-    # Modify the sql to add a dataset to the EXCEPT clause
-    def select_except_sql(sql, opts)
-      sql << " EXCEPT#{' ALL' if opts[:except_all]} #{opts[:except].sql}" if opts[:except]
+    # Modify the sql to add a dataset to the via an EXCEPT, INTERSECT, or UNION clause.
+    # This uses a subselect for the compound datasets used, because using parantheses doesn't
+    # work on all databases.  I consider this an ugly hack, but can't I think of a better default.
+    def select_compounds_sql(sql, opts)
+      return unless opts[:compounds]
+      opts[:compounds].each do |type, dataset, all|
+        compound_sql = subselect_sql(dataset)
+        compound_sql = "SELECT * FROM (#{compound_sql})" if dataset.opts[:compounds]
+        sql.replace("#{sql} #{type.to_s.upcase}#{' ALL' if all} #{compound_sql}")
+      end
     end
 
     # Modify the sql to add the list of tables to select FROM
@@ -900,11 +914,6 @@ module Sequel
       sql << " HAVING #{literal(opts[:having])}" if opts[:having]
     end
 
-    # Modify the sql to add a dataset to the INTERSECT clause
-    def select_intersect_sql(sql, opts)
-      sql << " INTERSECT#{' ALL' if opts[:intersect_all]} #{opts[:intersect].sql}" if opts[:intersect]
-    end
-
     # Modify the sql to add the list of tables to JOIN to
     def select_join_sql(sql, opts)
       opts[:join].each{|j| sql << literal(j)} if opts[:join]
@@ -921,11 +930,6 @@ module Sequel
       sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
     end
 
-    # Modify the sql to add a dataset to the UNION clause
-    def select_union_sql(sql, opts)
-      sql << " UNION#{' ALL' if opts[:union_all]} #{opts[:union].sql}" if opts[:union]
-    end
-
     # Modify the sql to add the filter criteria in the WHERE clause
     def select_where_sql(sql, opts)
       sql << " WHERE #{literal(opts[:where])}" if opts[:where]

data/lib/sequel_core/dataset/unsupported.rb

@@ -11,6 +11,18 @@ class Sequel::Dataset
     def intersect(ds, all=false)
       raise(Sequel::Error, "INTERSECT not supported")
     end
+    
+    private
+    
+    # Since EXCEPT and INTERSECT are not supported, and order shouldn't matter
+    # when UNION is used, don't worry about parantheses.  This may potentially
+    # give incorrect results if UNION ALL is used.
+    def select_compounds_sql(sql, opts)
+      return unless opts[:compounds]
+      opts[:compounds].each do |type, dataset, all|
+        sql << " #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)}"
+      end
+    end
   end
 
   # This module should be included in the dataset class for all databases that

data/lib/sequel_core/schema/sql.rb

@@ -243,7 +243,9 @@ module Sequel
 
         if table_name
           if respond_to?(:schema_parse_table, true)
-            @schemas[quoted_name] = schema_parse_table(table_name, opts)
+            cols = schema_parse_table(table_name, opts)
+            raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.blank?
+            @schemas[quoted_name] = cols
           else
             raise Error, 'schema parsing is not implemented on this database'
           end

data/lib/sequel_model.rb

@@ -1,6 +1,6 @@
 require 'sequel_core'
 %w"inflector base hooks record schema association_reflection dataset_methods 
-  associations caching plugins validations eager_loading".each do |f|
+  associations caching plugins validations eager_loading exceptions".each do |f|
   require "sequel_model/#{f}"
 end
 

data/lib/sequel_model/associations.rb

@@ -388,7 +388,7 @@ module Sequel::Model::Associations
     association_module_private_def(opts._setter_method){|o| send(:"#{key}=", (o.send(opts.primary_key) if o))}
 
     association_module_def(opts.setter_method) do |o|  
-      raise(Sequel::Error, 'model object does not have a primary key') if o && !o.pk
+      raise(Sequel::Error, "model object #{model} does not have a primary key") if o && !o.pk
       old_val = send(opts.association_method)
       return o if old_val == o
       return if old_val and run_association_callbacks(opts, :before_remove, old_val) == false

data/lib/sequel_model/base.rb

@@ -208,6 +208,7 @@ module Sequel
         subclass.instance_variable_set(iv, sup_class_value)
       end
       unless ivs.include?("@dataset")
+        db
         begin
           if sup_class == Model
             subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.blank?
@@ -491,7 +492,7 @@ module Sequel
 
     # Module that the class includes that holds methods the class adds for column accessors and
     # associations so that the methods can be overridden with super
-    def self.overridable_methods_module
+    def self.overridable_methods_module # :nodoc:
       include(@overridable_methods_module = Module.new) unless @overridable_methods_module
       @overridable_methods_module
     end

data/lib/sequel_model/dataset_methods.rb

@@ -8,7 +8,7 @@ module Sequel::Model::DatasetMethods
   def destroy
     raise(Error, "No model associated with this dataset") unless @opts[:models]
     count = 0
-    @db.transaction {each {|r| count += 1; r.destroy}}
+    @db.transaction{all{|r| count += 1; r.destroy}}
     count
   end
 

data/lib/sequel_model/eager_loading.rb

@@ -55,7 +55,7 @@ module Sequel::Model::Associations::EagerLoading
   # need to filter based on columns in associated tables, look at #eager_graph
   # or join the tables you need to filter on manually. 
   #
-  # Each association's order, if definied, is respected. Eager also works
+  # Each association's order, if defined, is respected. Eager also works
   # on a limited dataset, but does not use any :limit options for associations.
   # If the association uses a block or has an :eager_block argument, it is used.
   def eager(*associations)

data/lib/sequel_model/exceptions.rb

@@ -0,0 +1,7 @@
+module Sequel
+  # This exception will be raised when raise_on_save_failure is set and a validation fails
+  class ValidationFailed < Error;end
+
+  # This exception will be raised when raise_on_save_failure is set and a before hook fails
+  class BeforeHookFailed < Error;end
+end

data/lib/sequel_model/record.rb

@@ -135,7 +135,7 @@ module Sequel
     # Returns a string representation of the model instance including
     # the class name and values.
     def inspect
-      "#<#{model.name} @values=#{@values.inspect}>"
+      "#<#{model.name} @values=#{inspect_values}>"
     end
 
     # Returns attribute names as an array of symbols.
@@ -187,8 +187,7 @@ module Sequel
     # Otherwise, returns self. You can provide an optional list of
     # columns to update, in which case it only updates those columns.
     def save(*columns)
-      return save_failure(:save) unless valid?
-      save!(*columns)
+      valid? ? save!(*columns) : save_failure(:invalid)
     end
 
     # Creates or updates the record, without attempting to validate
@@ -342,7 +341,7 @@ module Sequel
 
     # Backbone behind association_dataset
     def _dataset(opts)
-      raise(Sequel::Error, 'model object does not have a primary key') if opts.dataset_need_primary_key? && !pk
+      raise(Sequel::Error, "model object #{model} does not have a primary key") if opts.dataset_need_primary_key? && !pk
       ds = send(opts._dataset_method)
       opts[:extend].each{|m| ds.extend(m)}
       ds = ds.select(*opts.select) if opts.select
@@ -356,8 +355,8 @@ module Sequel
 
     # Add the given associated object to the given association
     def add_associated_object(opts, o)
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk
-      raise(Sequel::Error, 'associated object does not have a primary key') if opts.need_associated_primary_key? && !o.pk
+      raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
+      raise(Sequel::Error, "associated object #{o.model} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
       return if run_association_callbacks(opts, :before_add, o) == false
       send(opts._add_method, o)
       associations[opts[:name]].push(o) if associations.include?(opts[:name])
@@ -378,6 +377,11 @@ module Sequel
       end
     end
 
+    # Default inspection output for a record, overwrite to change the way #inspect prints the @values hash
+    def inspect_values
+      @values.inspect
+    end
+
     # Load the associated objects using the dataset
     def load_associated_objects(opts, reload=false)
       name = opts[:name]
@@ -402,7 +406,7 @@ module Sequel
 
     # Remove all associated objects from the given association
     def remove_all_associated_objects(opts)
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk
+      raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
       send(opts._remove_all_method)
       ret = associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if associations.include?(opts[:name])
       associations[opts[:name]] = []
@@ -411,8 +415,8 @@ module Sequel
 
     # Remove the given associated object from the given association
     def remove_associated_object(opts, o)
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk
-      raise(Sequel::Error, 'associated object does not have a primary key') if opts.need_associated_primary_key? && !o.pk
+      raise(Sequel::Error, "model object #{model} does not have a primary key") unless pk
+      raise(Sequel::Error, "associated object #{o.model} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
       return if run_association_callbacks(opts, :before_remove, o) == false
       send(opts._remove_method, o)
       associations[opts[:name]].delete_if{|x| o === x} if associations.include?(opts[:name])
@@ -447,16 +451,21 @@ module Sequel
           raise Error, "callbacks should either be Procs or Symbols"
         end
         if res == false and stop_on_false
-          save_failure("modify association for", raise_error)
+          raise(BeforeHookFailed, "Unable to modify association for record: one of the #{callback_type} hooks returned false") if raise_error
           return false
         end
       end
     end
 
     # Raise an error if raise_on_save_failure is true
-    def save_failure(action, raise_error = nil)
-      raise_error = raise_on_save_failure if raise_error.nil?
-      raise(Error, "unable to #{action} record") if raise_error
+    def save_failure(type)
+      if raise_on_save_failure
+        if type == :invalid
+          raise ValidationFailed, errors.full_messages.join(', ')
+        else
+          raise BeforeHookFailed, "one of the before_#{type} hooks returned false"
+        end
+      end
     end
 
     # Set the columns, filtered by the only and except arrays.

data/lib/sequel_model/validations.rb

@@ -384,10 +384,14 @@ module Sequel
     # Validates the object.
     def validate
       errors.clear
-      return false if before_validation == false
-      self.class.validate(self)
-      after_validation
-      nil
+      if before_validation == false
+        save_failure(:validation)
+        false
+      else
+        self.class.validate(self)
+        after_validation
+        nil
+      end
     end
 
     # Validates the object and returns true if no errors are reported.

data/spec/adapters/mysql_spec.rb

@@ -443,6 +443,13 @@ context "A MySQL database" do
   specify "should support drop_index" do
     @db.drop_index :test2, :value
   end
+  
+  specify "should support add_foreign_key" do
+    @db.alter_table :test2 do
+      add_foreign_key :value2, :test2, :key=>:value
+    end
+    @db[:test2].columns.should == [:name, :value, :zyx, :ert, :xyz, :value2]
+  end
 end  
 
 context "A MySQL database" do
@@ -471,6 +478,16 @@ context "A MySQL database" do
     ]
   end
   
+specify "should correctly format ALTER TABLE statements with foreign keys" do
+  g = Sequel::Schema::AlterTableGenerator.new(@db) do
+    add_foreign_key :p_id, :users, :key => :id, :null => false, :on_delete => :cascade
+  end
+  @db.alter_table_sql_list(:items, g.operations).should == [[
+    "ALTER TABLE items ADD COLUMN p_id integer NOT NULL",
+    "ALTER TABLE items ADD FOREIGN KEY (p_id) REFERENCES users(id) ON DELETE CASCADE"
+  ]]
+end
+  
   specify "should accept repeated raw sql statements using Database#<<" do
     @db << 'DELETE FROM items'
     @db[:items].count.should == 0

data/spec/adapters/postgres_spec.rb

@@ -601,3 +601,72 @@ if POSTGRES_DB.server_version >= 80300
     end
   end
 end
+
+context "Postgres::Database functions, languages, and triggers" do
+  setup do
+    @d = POSTGRES_DB
+  end
+  teardown 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_trigger(:test5, :identity, :if_exists=>true, :cascade=>true)
+  end
+  
+  specify "#create_function and #drop_function should create and drop functions" do
+    proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
+    args = ['tf', 'SELECT 1', {:returns=>:integer}]
+    @d.create_function_sql(*args).should =~ /\A\s*CREATE FUNCTION tf\(\)\s+RETURNS integer\s+LANGUAGE SQL\s+AS 'SELECT 1'\s*\z/
+    @d.create_function(*args)
+    rows = @d['SELECT tf()'].all.should == [{:tf=>1}]
+    @d.drop_function_sql('tf').should == 'DROP FUNCTION tf()'
+    @d.drop_function('tf')
+    proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
+  end
+  
+  specify "#create_function and #drop_function should support options" do
+    args = ['tf', 'SELECT $1 + $2', {:args=>[[:integer, :a], :integer], :replace=>true, :returns=>:integer, :language=>'SQL', :behavior=>:immutable, :strict=>true, :security_definer=>true, :cost=>2, :set=>{:search_path => 'public'}}]
+    @d.create_function_sql(*args).should =~ /\A\s*CREATE OR REPLACE FUNCTION tf\(a integer, integer\)\s+RETURNS integer\s+LANGUAGE SQL\s+IMMUTABLE\s+STRICT\s+SECURITY DEFINER\s+COST 2\s+SET search_path = public\s+AS 'SELECT \$1 \+ \$2'\s*\z/
+    @d.create_function(*args)
+    # Make sure replace works
+    @d.create_function(*args)
+    rows = @d['SELECT tf(1, 2)'].all.should == [{:tf=>3}]
+    args = ['tf', {:if_exists=>true, :cascade=>true, :args=>[[:integer, :a], :integer]}]
+    @d.drop_function_sql(*args).should == 'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE'
+    @d.drop_function(*args)
+    # Make sure if exists works
+    @d.drop_function(*args)
+  end
+  
+  specify "#create_language and #drop_language should create and drop languages" do
+    @d.create_language_sql(:plpgsql).should == 'CREATE LANGUAGE plpgsql'
+    @d.create_language(:plpgsql)
+    proc{@d.create_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
+    @d.drop_language_sql(:plpgsql).should == 'DROP LANGUAGE plpgsql'
+    @d.drop_language(:plpgsql)
+    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
+    @d.create_language_sql(:plpgsql, :trusted=>true, :handler=>:a, :validator=>:b).should == 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b'
+    @d.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)
+  end
+  
+  specify "#create_trigger and #drop_trigger should create and drop triggers" do
+    @d.create_language(:plpgsql)
+    @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
+    @d.create_trigger_sql(:test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON public.test FOR EACH ROW EXECUTE PROCEDURE tf()'
+    @d.create_trigger(:test, :identity, :tf, :each_row=>true)
+    @d[:test].insert(:name=>'a', :value=>1)
+    @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]
+    proc{@d[:test].filter(:name=>'a').update(:value=>nil)}.should raise_error(Sequel::DatabaseError)
+    @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]
+    @d[:test].filter(:name=>'a').update(:value=>3)
+    @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>3}]
+    @d.drop_trigger_sql(:test, :identity).should == 'DROP TRIGGER identity ON public.test'
+    @d.drop_trigger(:test, :identity)
+    @d.create_trigger_sql(:test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON public.test EXECUTE PROCEDURE tf(1, \'a\')'
+    @d.drop_trigger_sql(:test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON public.test CASCADE'
+    # Make sure if exists works
+    @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
+  end
+end