sequel 2.8.0 → 2.9.0

data/CHANGELOG

@@ -1,3 +1,37 @@
+=== 2.9.0 (2009-01-12)
+
+* Add -L option to sequel command line tool to load all .rb files in the given directory (pkondzior, jeremyevans)
+
+* Fix Dataset#destroy for model datasets that can't handle nested queries (jeremyevans)
+
+* Improve the error messages in parts of Sequel::Model (jeremyevans, pusewicz)
+
+* Much better support for Dataset#{union,except,intersect}, allowing chaining and respecting order (jeremyevans)
+
+* Default to logging only WARNING level messages when connecting to PostgreSQL (jeremyevans)
+
+* Fix add_foreign_key for MySQL (jeremyevans, aphyr)
+
+* Correctly literalize BigDecimal NaN and (+-)Infinity values (#256) (jeremyevans)
+
+* Make Sequel raise an Error if you attempt to subclass Sequel::Model before setting up a database connection (jeremyevans)
+
+* Add Sequel::BeforeHookFailed exception to be raised when a record fails because a before hook fails (bougyman)
+
+* Add Sequel::ValidationFailed exception to be raised when a record fails because a validation fails (bougyman)
+
+* Make Database#schema raise an error if given a table that doesn't exist (jeremyevans) (#255)
+
+* Make Model#inspect call Model#inspect_values private method for easier overloading (bougyman)
+
+* Add methods to create and drop functions, triggers, and procedural languages on PostgreSQL (jeremyevans)
+
+* Fix Dataset#count when using UNION, EXCEPT, or INTERSECT (jeremyevans)
+
+* Make SQLite keep table's primary key information when dropping columns (jmhodges)
+
+* Support dropping indicies on SQLite (jmhodges)
+
 === 2.8.0 (2008-12-05)
 
 * Support drop column operations inside a transaction on sqlite (jeremyevans)

data/COPYING

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008 Jeremy Evans
+Copyright (c) 2008-2009 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/Rakefile

@@ -12,7 +12,7 @@ require "fileutils"
 include FileUtils
 
 NAME = 'sequel'
-VERS = '2.8.0'
+VERS = '2.9.0'
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage", "www/public/*.html"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'Sequel: The Database Toolkit for Ruby', '--main', 'README']

data/bin/sequel

@@ -10,6 +10,7 @@ env = nil
 logfile = nil
 migrate_dir = nil
 migrate_ver = nil
+load_dir = nil
 
 opts = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
@@ -29,10 +30,6 @@ opts = OptionParser.new do |opts|
     exit
   end
 
-  opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    logfile = v
-  end
-  
   opts.on("-e", "--env ENV", "use environment config for database") do |v|
     env = v
   end
@@ -41,6 +38,14 @@ opts = OptionParser.new do |opts|
     echo = true
   end
   
+  opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
+    logfile = v
+  end
+  
+  opts.on("-L", "--load-dir DIR", "loads all *.rb from specifed directory") do |v|
+    load_dir = v
+  end
+  
   opts.on("-m", "--migrate-directory DIR", "run the migrations in directory") do |v|
     migrate_dir = v
   end
@@ -48,7 +53,7 @@ opts = OptionParser.new do |opts|
   opts.on("-M", "--migrate-version VER", "migrate the database to version given") do |v|
     migrate_ver = Integer(v)
   end
-  
+
   opts.on_tail("-v", "--version", "Show version") do
     class << Gem; attr_accessor :loaded_specs; end
     begin
@@ -101,6 +106,8 @@ rescue => e
   exit 1
 end
 
+Dir["#{load_dir}/**/*.rb"].each{|f| load(f)} if load_dir
+
 require 'irb'
 puts "Your database is stored in DB..."
 IRB.start

data/doc/advanced_associations.rdoc

@@ -229,7 +229,7 @@ Sequel::Model:
   @author.books
 
 If you use an association other than belongs_to in the associated model, things
-are a bit more involved:
+are a bit more involved (has_many :through a has_many association):
 
 ActiveRecord:
 
@@ -317,8 +317,18 @@ firm.invoices.first.client doesn't do another query to get the firm/client.
 
 ===Polymorphic Associations
 
-Polymorphic associations are really a design flaw, but if you are stuck with
-them, Sequel can handle it.
+Polymorphic associations are really a design flaw.  The only advantage
+polymorphic associations offer is that they require fewer join tables.
+
+Proof by Reductio ad absurdum: If fewer join tables are preferable, then surely
+fewer tables and columns are preferrable, so you might as well store all of
+your data in a single column in a single table if you think polymorphic
+associations are a good idea.
+
+Compelling Argument: Polymorphic associations are more complex than normal
+associations, and they break referential integrity, so the only reason you
+should use them is if you are already stuck with an existing design that
+uses them.  You should never use them in new code.
 
 ActiveRecord:
 
@@ -426,6 +436,10 @@ powerful.
 
 ===many_to_one/one_to_many not referencing primary key
 
+This can now be handled easily in Sequel using the :primary_key association
+option.  However, this example shows how the association was possible before
+the introduction of that option.
+
 Let's say you have two tables, invoices and clients, where each client is
 associated with many invoices.  However, instead of using the client's primary
 key, the invoice is associated to the client by name (this is bad database

data/lib/sequel_core/adapters/informix.rb

@@ -37,7 +37,7 @@ module Sequel
     class Dataset < Sequel::Dataset
       include UnsupportedIntersectExcept
 
-      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group union order'.freeze
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group compounds order'.freeze
 
       def literal(v)
         case v

data/lib/sequel_core/adapters/postgres.rb

@@ -79,8 +79,6 @@ rescue LoadError => e
 end
 
 module Sequel
-  # Top level module for holding all PostgreSQL-related modules and classes
-  # for Sequel.
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
     
@@ -105,12 +103,19 @@ module Sequel
     }
     
     @use_iso_date_format = true
+    @client_min_messages = :warning
 
     # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
     # the date in a known format that Sequel can parse faster.  This can be turned off
     # if you require a date style other than ISO.
     metaattr_accessor :use_iso_date_format
     
+    # By default, Sequel sets the minimum level of log messages sent to the client
+    # to WARNING, where PostgreSQL uses a default of NOTICE.  This is to avoid a lot
+    # of mostly useless messages when running migrations, such as a couple of lines
+    # for every serial primary key field.
+    metaattr_accessor :client_min_messages
+    
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
@@ -127,6 +132,11 @@ module Sequel
           @db.log_info(sql)
           execute(sql)
         end
+        if cmm = Postgres.client_min_messages
+          sql = "SET client_min_messages = '#{cmm.to_s.upcase}'"
+          @db.log_info(sql)
+          execute(sql)
+        end
       end
 
       # Execute the given SQL with this connection.  If a block is given,

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

@@ -37,7 +37,7 @@ module Sequel
     module DatasetMethods
       include Dataset::UnsupportedIntersectExcept
 
-      SELECT_CLAUSE_ORDER = %w'limit distinct columns from with join where group order having union'.freeze
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from with join where group order having compounds'.freeze
 
       def complex_expression_sql(op, args)
         case op
@@ -54,6 +54,8 @@ module Sequel
       
       def literal(v)
         case v
+        when LiteralString
+          v
         when String
           "N#{super}"
         when Time

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

@@ -1,4 +1,10 @@
 module Sequel
+  module Schema
+    module SQL
+      # Keep default column_references_sql for add_foreign_key support
+      alias default_column_references_sql column_references_sql
+    end
+  end
   module MySQL
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
@@ -15,6 +21,14 @@ module Sequel
       # drop index cases.
       def alter_table_sql(table, op)
         case op[:op]
+        when :add_column
+          if related = op.delete(:table)
+            sql = super(table, op)
+            op[:table] = related
+            [sql, "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{default_column_references_sql(op)}"]
+          else
+            super(table, op)
+          end
         when :rename_column
           "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{quote_identifier(op[:new_name])} #{type_literal(op)}"
         when :set_column_type

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

@@ -15,7 +15,13 @@ module Sequel
     module DatasetMethods
       include Dataset::UnsupportedIntersectExceptAll
 
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having union intersect except order limit'.freeze
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+
+      # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
+      def except(dataset, all = false)
+        raise(Sequel::Error, "EXCEPT ALL not supported") if all
+        compound_clone(:minus, dataset, all)
+      end
 
       def empty?
         db[:dual].where(exists).get(1) == nil
@@ -41,11 +47,6 @@ module Sequel
         end
       end
 
-      # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
-      def select_except_sql(sql, opts)
-        sql << " MINUS #{opts[:except].sql}" if opts[:except]
-      end
-
       # Oracle requires a subselect to do limit and offset
       def select_limit_sql(sql, opts)
         if limit = opts[:limit]

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

@@ -1,4 +1,32 @@
 module Sequel
+  # Top level module for holding all PostgreSQL-related modules and classes
+  # for Sequel.  There are a few module level accessors that are added via
+  # metaprogramming.  These are:
+  # * client_min_messages (only available when using the native adapter) -
+  #   Change the minimum level of messages that PostgreSQL will send to the
+  #   the client.  The PostgreSQL default is NOTICE, the Sequel default is
+  #   WARNING.  Set to nil to not change the server default.
+  # * force_standard_strings - Set to false to not force the use of
+  #   standard strings
+  # * use_iso_date_format (only available when using the native adapter) -
+  #   Set to false to not change the date format to
+  #   ISO.  This disables one of Sequel's optimizations.
+  #
+  # Changes in these settings only affect future connections.  To make
+  # sure that they are applied, they should generally be called right
+  # after the Database object is instantiated and before a connection
+  # is actually made. For example, to use whatever the server defaults are:
+  #
+  #   DB = Sequel.postgres(...)
+  #   Sequel::Postgres.client_min_messages = nil
+  #   Sequel::Postgres.force_standard_strings = false
+  #   Sequel::Postgres.use_iso_date_format = false
+  #   # A connection to the server is not made until here
+  #   DB[:t].all
+  #
+  # The reason they can't be done earlier is that the Sequel::Postgres
+  # module is not loaded until a Database object which uses PostgreSQL
+  # is created.
   module Postgres
     # Array of exceptions that need to be converted.  JDBC
     # uses NativeExceptions, the native adapter uses PGError.
@@ -7,7 +35,7 @@ module Sequel
     @force_standard_strings = true
 
     # By default, Sequel forces the use of standard strings, so that
-    # '\\' is interpreted as '\\' and not '\\'.  While PostgreSQL defaults
+    # '\\' is interpreted as \\ and not \.  While PostgreSQL defaults
     # to interpreting plain strings as extended strings, this will change
     # in a future version of PostgreSQL.  Sequel assumes that SQL standard
     # strings will be used.
@@ -127,12 +155,122 @@ module Sequel
       SQL_ROLLBACK = 'ROLLBACK'.freeze
       SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
+
+      # Creates the function in the database.  See create_function_sql for arguments.
+      def create_function(*args)
+        self << create_function_sql(*args)
+      end
+      
+      # SQL statement to create database function. Arguments:
+      # * name : name of the function to create
+      # * definition : string definition of the function, or object file for a dynamically loaded C function.
+      # * opts : options hash:
+      #   * :args : function arguments, can be either a symbol or string specifying a type or an array of 1-3 elements:
+      #     * element 1 : argument data type
+      #     * element 2 : argument name
+      #     * element 3 : argument mode (e.g. in, out, inout)
+      #   * :behavior : Should be IMMUTABLE, STABLE, or VOLATILE.  PostgreSQL assumes VOLATILE by default.
+      #   * :cost : The estimated cost of the function, used by the query planner.
+      #   * :language : The language the function uses.  SQL is the default.
+      #   * :link_symbol : For a dynamically loaded see function, the function's link symbol if different from the definition argument.
+      #   * :returns : The data type returned by the function.  If you are using OUT or INOUT argument modes, this is ignored.
+      #     Otherwise, if this is not specified, void is used by default to specify the function is not supposed to return a value.
+      #   * :rows : The estimated number of rows the function will return.  Only use if the function returns SETOF something.
+      #   * :security_definer : Makes the privileges of the function the same as the privileges of the user who defined the function instead of
+      #     the privileges of the user who runs the function.  There are security implications when doing this, see the PostgreSQL documentation.
+      #   * :set : Configuration variables to set while the function is being run, can be a hash or an array of two pairs.  search_path is
+      #     often used here if :security_definer is used.
+      #   * :strict : Makes the function return NULL when any argument is NULL.
+      def create_function_sql(name, definition, opts={})
+        args = opts[:args]
+        if !opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 and %w'OUT INOUT'.include?(a[2].to_s)}
+          returns = opts[:returns] || 'void'
+        end
+        language = opts[:language] || 'SQL'
+        <<-END
+        CREATE#{' OR REPLACE' if opts[:replace]} FUNCTION #{name}#{sql_function_args(args)}
+        #{"RETURNS #{returns}" if returns}
+        LANGUAGE #{language}
+        #{opts[:behavior].to_s.upcase if opts[:behavior]}
+        #{'STRICT' if opts[:strict]}
+        #{'SECURITY DEFINER' if opts[:security_definer]}
+        #{"COST #{opts[:cost]}" if opts[:cost]}
+        #{"ROWS #{opts[:rows]}" if opts[:rows]}
+        #{opts[:set].map{|k,v| " SET #{k} = #{v}"}.join("\n") if opts[:set]}
+        AS #{literal(definition.to_s)}#{", #{literal(opts[:link_symbol].to_s)}" if opts[:link_symbol]}
+        END
+      end
+      
+      # Create the procedural language in the database.  See create_language_sql for arguments.
+      def create_language(*args)
+        self << create_language_sql(*args)
+      end
+      
+      # SQL for creating a procedural language. Arguments:
+      # * name : Name of the procedural language (e.g. plpgsql)
+      # * opts : options hash:
+      #   * :handler : The name of a previously registered function used as a call handler for this language.
+      #   * :trusted : Marks the language being created as trusted, allowing unprivileged users to create functions using this language.
+      #   * :validator : The name of previously registered function used as a validator of functions defined in this language.
+      def create_language_sql(name, opts={})
+        "CREATE#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
+      end
+      
+      # Create a trigger in the database.  See create_trigger_sql for arguments.
+      def create_trigger(*args)
+        self << create_trigger_sql(*args)
+      end
+      
+      # SQL for creating a database trigger. Arguments:
+      # * table : the table on which this trigger operates
+      # * name : the name of this trigger
+      # * function : the function to call for this trigger, which should return type trigger.
+      # * opts : options hash:
+      #   * :after : Calls the trigger after execution instead of before.
+      #   * :args : An argument or array of arguments to pass to the function.
+      #   * :each_row : Calls the trigger for each row instead of for each statement.
+      #   * :events : Can be :insert, :update, :delete, or an array of any of those. Calls the trigger whenever that type of statement is used.  By default,
+      #     the trigger is called for insert, update, or delete.
+      def create_trigger_sql(table, name, function, opts={})
+        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
+        whence = opts[:after] ? 'AFTER' : 'BEFORE'
+        "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
+      end
       
       # The default schema to use if none is specified (default: public)
       def default_schema
         @default_schema ||= :public
       end
       
+      # Drops the function from the database.  See drop_function_sql for arguments.
+      def drop_function(*args)
+        self << drop_function_sql(*args)
+      end
+      
+      # SQL for dropping a function from the database.  Arguments:
+      # * name : name of the function to drop
+      # * opts : options hash:
+      #   * :args : The arguments for the function.  See create_function_sql.
+      #   * :cascade : Drop other objects depending on this function.
+      #   * :if_exists : Don't raise an error if the function doesn't exist.
+      def drop_function_sql(name, opts={})
+        "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
+      end
+      
+      # Drops a procedural language from the database.  See drop_language_sql for arguments.
+      def drop_language(*args)
+        self << drop_language_sql(*args)
+      end
+      
+      # SQL for dropping a procedural language from the database.  Arguments:
+      # * name : name of the procedural language to drop
+      # * opts : options hash:
+      #   * :cascade : Drop other objects depending on this function.
+      #   * :if_exists : Don't raise an error if the function doesn't exist.
+      def drop_language_sql(name, opts={})
+        "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
+      end
+
       # Remove the cached entries for primary keys and sequences when dropping a table.
       def drop_table(*names)
         names.each do |name|
@@ -148,6 +286,21 @@ module Sequel
         "DROP TABLE #{quote_schema_table(name)} CASCADE"
       end
       
+      # Drops a trigger from the database.  See drop_trigger_sql for arguments.
+      def drop_trigger(*args)
+        self << drop_trigger_sql(*args)
+      end
+      
+      # SQL for dropping a trigger from the database.  Arguments:
+      # * table : table from which to drop the trigger
+      # * name : name of the trigger to drop
+      # * opts : options hash:
+      #   * :cascade : Drop other objects depending on this function.
+      #   * :if_exists : Don't raise an error if the function doesn't exist.
+      def drop_trigger_sql(table, name, opts={})
+        "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"
+      end
+
       # PostgreSQL specific index SQL.
       def index_definition_sql(table_name, index)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
@@ -375,6 +528,11 @@ module Sequel
         end
         ds
       end
+
+      # Turns an array of argument specifiers into an SQL fragment used for function arguments.  See create_function_sql.
+      def sql_function_args(args)
+        "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"
+      end
     end
     
     # Instance methods for datasets that connect to a PostgreSQL database.
@@ -394,7 +552,7 @@ module Sequel
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having intersect union except order limit lock'.freeze
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit lock'.freeze
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
@@ -476,7 +634,7 @@ module Sequel
         when LiteralString
           v
         when SQL::Blob
-          db.synchronize{|c| "E'#{c.escape_bytea(v)}'"}
+          db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
         when String
           db.synchronize{|c| "'#{c.escape_string(v)}'"}
         when Time
@@ -526,6 +684,15 @@ module Sequel
         pk = db.primary_key(opts[:from].first)
         insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
       end
+      
+      # PostgreSQL is smart and can use parantheses around all datasets to get
+      # the correct answers.
+      def select_compounds_sql(sql, opts)
+        return unless opts[:compounds]
+        opts[:compounds].each do |type, dataset, all|
+          sql.replace("(#{sql} #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)})")
+        end
+      end
 
       # The order of clauses in the SELECT SQL statement
       def select_clause_order