sequel 2.7.1 → 2.8.0

data/lib/sequel_core/dataset/stored_procedures.rb

@@ -0,0 +1,75 @@
+module Sequel 
+  class Dataset
+    module StoredProcedureMethods
+      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
+      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
+      
+      # The name of the stored procedure to call
+      attr_accessor :sproc_name
+      
+      # Call the prepared statement
+      def call(*args, &block)
+        @sproc_args = args
+        case @sproc_type
+        when :select, :all
+          all(&block)
+        when :first
+          first
+        when :insert
+          insert
+        when :update
+          update
+        when :delete
+          delete
+        end
+      end
+      
+      # Programmer friendly string showing this is a stored procedure,
+      # showing the name of the procedure.
+      def inspect
+        "<#{self.class.name}/StoredProcedure name=#{@sproc_name}>"
+      end
+      
+      # Set the type of the sproc and override the corresponding _sql
+      # method to return the empty string (since the result will be
+      # ignored anyway).
+      def sproc_type=(type)
+        @sproc_type = type
+        meta_def("#{sql_query_type}_sql"){|*a| ''}
+      end
+      
+      private
+      
+      # The type of query (:select, :insert, :delete, :update).
+      def sql_query_type
+        SQL_QUERY_TYPE[@sproc_type]
+      end
+    end
+  
+    module StoredProcedures
+      # For the given type (:select, :first, :insert, :update, or :delete),
+      # run the database stored procedure with the given name with the given
+      # arguments.
+      def call_sproc(type, name, *args)
+        prepare_sproc(type, name).call(*args)
+      end
+      
+      # Transform this dataset into a stored procedure that you can call
+      # multiple times with new arguments.
+      def prepare_sproc(type, name)
+        sp = clone
+        prepare_extend_sproc(sp)
+        sp.sproc_type = type
+        sp.sproc_name = name
+        sp
+      end
+      
+      private
+      
+      # Extend the dataset with the stored procedure methods.
+      def prepare_extend_sproc(ds)
+        ds.extend(StoredProcedureMethods)
+      end
+    end
+  end
+end

data/lib/sequel_core/dataset/unsupported.rb

@@ -0,0 +1,31 @@
+class Sequel::Dataset
+  # This module should be included in the dataset class for all databases that
+  # don't support INTERSECT or EXCEPT.
+  module UnsupportedIntersectExcept
+    # Raise an Error if EXCEPT is used
+    def except(ds, all=false)
+      raise(Sequel::Error, "EXCEPT not supported")
+    end
+
+    # Raise an Error if INTERSECT is used
+    def intersect(ds, all=false)
+      raise(Sequel::Error, "INTERSECT not supported")
+    end
+  end
+
+  # This module should be included in the dataset class for all databases that
+  # don't support INTERSECT ALL or EXCEPT ALL.
+  module UnsupportedIntersectExceptAll
+    # Raise an Error if EXCEPT is used
+    def except(ds, all=false)
+      raise(Sequel::Error, "EXCEPT ALL not supported") if all
+      super(ds)
+    end
+
+    # Raise an Error if INTERSECT is used
+    def intersect(ds, all=false)
+      raise(Sequel::Error, "INTERSECT ALL not supported") if all
+      super(ds)
+    end
+  end
+end

data/lib/sequel_core/exceptions.rb

@@ -31,4 +31,10 @@ module Sequel
   # Generic error raised by the database adapters, indicating a
   # problem originating from the database server.
   class DatabaseError < Error; end
+
+  # Error that should be raised by adapters when they determine that the connection
+  # to the database has been lost.  Instructs the connection pool code to 
+  # remove that connection from the pool so that other connections can be acquired
+  # automatically.
+  class DatabaseDisconnectError < DatabaseError; end
 end

data/lib/sequel_core/schema/generator.rb

@@ -127,9 +127,10 @@ module Sequel
       # optional middle argument denotes the type.
       # 
       # Examples:
-      #   primary_key(:id) primary_key(:name, :text)
+      #   primary_key(:id)
       #   primary_key(:zip_code, :null => false)
       #   primary_key([:street_number, :house_number])
+      #   primary_key(:id, :string, :auto_increment => false)
       def primary_key(name, *args)
         return composite_primary_key(name, *args) if name.is_a?(Array)
         @primary_key = @db.serial_primary_key_options.merge({:name => name})
@@ -276,8 +277,8 @@ module Sequel
       end
 
       # Modify a column's type in the DDL for the table.
-      def set_column_type(name, type)
-        @operations << {:op => :set_column_type, :name => name, :type => type}
+      def set_column_type(name, type, opts={})
+        @operations << {:op => :set_column_type, :name => name, :type => type}.merge(opts)
       end
       
       # Modify a column's NOT NULL constraint.

data/lib/sequel_core/schema/sql.rb

@@ -29,7 +29,7 @@ module Sequel
         when :rename_column
           "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
         when :set_column_type
-          "ALTER COLUMN #{quoted_name} TYPE #{op[:type]}"
+          "ALTER COLUMN #{quoted_name} TYPE #{type_literal(op)}"
         when :set_column_default
           "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
         when :set_column_null
@@ -187,9 +187,9 @@ module Sequel
         end
       end
       
+      # Proxy the quote_schema_table method to the dataset
       def quote_schema_table(table)
-        schema, table = schema_and_table(table)
-        "#{"#{quote_identifier(schema)}." if schema}#{quote_identifier(table)}"
+        schema_utility_dataset.quote_schema_table(table)
       end
       
       # Proxy the quote_identifier method to the dataset, used for quoting tables and columns.
@@ -202,7 +202,7 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"
       end
 
-      # Parse the schema from the database using the SQL standard INFORMATION_SCHEMA.
+      # Parse the schema from the database.
       # If the table_name is not given, returns the schema for all tables as a hash.
       # If the table_name is given, returns the schema for a single table as an
       # array with all members being arrays of length 2.  Available options are:
@@ -212,11 +212,17 @@ module Sequel
       #   unless you are sure that schema has not been called before with a
       #   table_name, otherwise you may only getting the schemas for tables
       #   that have been requested explicitly.
-      def schema(table_name = nil, opts={})
-        table_name = table_name.to_sym if table_name
+      # * :schema - An explicit schema to use.  It may also be implicitly provided
+      #   via the table name.
+      def schema(table = nil, opts={})
+        if table
+          sch, table_name = schema_and_table(table)
+          quoted_name = quote_schema_table(table)
+        end
+        opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema)
         if opts[:reload] && @schemas
           if table_name
-            @schemas.delete(table_name)
+            @schemas.delete(quoted_name)
           else
             @schemas = nil
           end
@@ -224,26 +230,31 @@ module Sequel
 
         if @schemas
           if table_name
-            return @schemas[table_name] if @schemas[table_name]
+            return @schemas[quoted_name] if @schemas[quoted_name]
           else
             return @schemas
           end
         end
+        
+        @schemas ||= Hash.new do |h,k|
+          quote_name = quote_schema_table(k)
+          h[quote_name] if h.include?(quote_name)
+        end
 
         if table_name
-          @schemas ||= {}
           if respond_to?(:schema_parse_table, true)
-            @schemas[table_name] ||= schema_parse_table(table_name, opts)
+            @schemas[quoted_name] = schema_parse_table(table_name, opts)
           else
             raise Error, 'schema parsing is not implemented on this database'
           end
         else
           if respond_to?(:schema_parse_tables, true)
-            @schemas = schema_parse_tables(opts)
+            @schemas.merge!(schema_parse_tables(opts))
           elsif respond_to?(:schema_parse_table, true) and respond_to?(:tables, true)
-            tables.each{|t| schema(t, opts)}
+            tables.each{|t| @schemas[quote_identifier(t)] = schema_parse_table(t.to_s, opts)}
             @schemas
           else
+            @schemas = nil
             raise Error, 'schema parsing is not implemented on this database'
           end
         end
@@ -256,30 +267,37 @@ module Sequel
       
       private
 
+      # Remove the cached schema for the given schema name
+      def remove_cached_schema(table)
+        @schemas.delete(quote_schema_table(table)) if @schemas
+      end
+
       # Match the database's column type to a ruby type via a
       # regular expression.  The following ruby types are supported:
       # integer, string, date, datetime, boolean, and float.
       def schema_column_type(db_type)
         case db_type
-        when /\Atinyint/
+        when /\Atinyint/io
           Sequel.convert_tinyint_to_bool ? :boolean : :integer
-        when /\A(int(eger)?|bigint|smallint)/
-          :integer
-        when /\A(character( varying)?|varchar|text)/
+        when /\Ainterval\z/io
+          :interval
+        when /\A(character( varying)?|varchar|text)/io
           :string
-        when /\Adate\z/
+        when /\A(int(eger)?|bigint|smallint)/io
+          :integer
+        when /\Adate\z/io
           :date
-        when /\A(datetime|timestamp( with(out)? time zone)?)\z/
+        when /\A(datetime|timestamp( with(out)? time zone)?)\z/io
           :datetime
-        when /\Atime( with(out)? time zone)?\z/
+        when /\Atime( with(out)? time zone)?\z/io
           :time
-        when "boolean"
+        when /\Aboolean\z/io
           :boolean
-        when /\A(real|float|double( precision)?)\z/
+        when /\A(real|float|double( precision)?)\z/io
           :float
-        when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/
+        when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/io
           :decimal
-        when "bytea"
+        when /\Abytea\z/io
           :blob
         end
       end

data/lib/sequel_core/sql.rb

@@ -685,6 +685,34 @@ module Sequel
       end
     end
 
+    # Represents a literal string with placeholders and arguments.
+    # This is necessary to ensure delayed literalization of the arguments
+    # required for the prepared statement support
+    class PlaceholderLiteralString < SpecificExpression
+      # The arguments that will be subsituted into the placeholders.
+      attr_reader :args
+
+      # The literal string containing placeholders
+      attr_reader :str
+
+      # Whether to surround the expression with parantheses
+      attr_reader :parens
+
+      # Create an object with the given conditions and
+      # default value.
+      def initialize(str, args, parens=false)
+        @str = str
+        @args = args
+        @parens = parens
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.placeholder_literal_string_sql(self)
+      end
+    end
+
     # Subclass of ComplexExpression where the expression results
     # in a numeric value in SQL.
     class NumericExpression < ComplexExpression
@@ -831,7 +859,7 @@ module Sequel
   # LiteralString is used to represent literal SQL expressions. A 
   # LiteralString is copied verbatim into an SQL statement. Instances of
   # LiteralString can be created by calling String#lit.
-  # LiteralStrings can use all of the SQL::ColumnMethods and the 
+  # LiteralStrings can also use all of the SQL::OrderMethods and the 
   # SQL::ComplexExpressionMethods.
   class LiteralString < ::String
     include SQL::OrderMethods

data/lib/sequel_model/associations.rb

@@ -394,7 +394,7 @@ module Sequel::Model::Associations
       return if old_val and run_association_callbacks(opts, :before_remove, old_val) == false
       return if o and run_association_callbacks(opts, :before_add, o) == false
       send(opts._setter_method, o)
-      @associations[name] = o
+      associations[name] = o
       remove_reciprocal_object(opts, old_val) if old_val
       add_reciprocal_object(opts, o) if o
       run_association_callbacks(opts, :after_add, o) if o

data/lib/sequel_model/record.rb

@@ -4,15 +4,6 @@ module Sequel
     # to be called automatically via set.
     RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure= raise_on_typecast_failure="
 
-    # The current cached associations.  A hash with the keys being the
-    # association name symbols and the values being the associated object
-    # or nil (many_to_one), or the array of associated objects (*_to_many).
-    attr_reader :associations
-
-    # The columns that have been updated.  This isn't completely accurate,
-    # see Model#[]=.
-    attr_reader :changed_columns
-
     # The hash of attribute values.  Keys are symbols with the names of the
     # underlying database columns.
     attr_reader :values
@@ -32,9 +23,7 @@ module Sequel
     #   string keys will work if from_db is false.
     # * from_db - should only be set by Model.load, forget it
     #   exists.
-    def initialize(values = {}, from_db = false, &block)
-      @associations = {}
-      @changed_columns = []
+    def initialize(values = {}, from_db = false)
       if from_db
         @new = false
         @values = values
@@ -42,8 +31,8 @@ module Sequel
         @values = {}
         @new = true
         set(values)
-        @changed_columns.clear 
-        yield self if block
+        changed_columns.clear 
+        yield self if block_given?
       end
       after_initialize
     end
@@ -61,7 +50,7 @@ module Sequel
       # If the column isn't in @values, we can't assume it is
       # NULL in the database, so assume it has changed.
       if new? || !@values.include?(column) || value != @values[column]
-        @changed_columns << column unless @changed_columns.include?(column)
+        changed_columns << column unless changed_columns.include?(column)
         @values[column] = typecast_value(column, value)
       end
     end
@@ -84,6 +73,19 @@ module Sequel
     # self.class.
     alias_method :model, :class
 
+    # The current cached associations.  A hash with the keys being the
+    # association name symbols and the values being the associated object
+    # or nil (many_to_one), or the array of associated objects (*_to_many).
+    def associations
+      @associations ||= {}
+    end
+
+    # The columns that have been updated.  This isn't completely accurate,
+    # see Model#[]=.
+    def changed_columns
+      @changed_columns ||= []
+    end
+
     # Deletes and returns self.  Does not run destroy hooks.
     # Look into using destroy instead.
     def delete
@@ -171,7 +173,8 @@ module Sequel
     # exists in the database.
     def refresh
       @values = this.first || raise(Error, "Record not found")
-      @associations.clear
+      changed_columns.clear
+      associations.clear
       self
     end
     alias_method :reload, :refresh
@@ -220,12 +223,12 @@ module Sequel
       else
         return save_failure(:update) if before_update == false
         if columns.empty?
-          vals = opts[:changed] ? @values.reject{|k,v| !@changed_columns.include?(k)} : @values
+          vals = opts[:changed] ? @values.reject{|k,v| !changed_columns.include?(k)} : @values
           this.update(vals)
-          @changed_columns = []
+          changed_columns.clear
         else # update only the specified columns
-          this.update(@values.reject {|k, v| !columns.include?(k)})
-          @changed_columns.reject! {|c| columns.include?(c)}
+          this.update(@values.reject{|k, v| !columns.include?(k)})
+          changed_columns.reject!{|c| columns.include?(c)}
         end
         after_update
       end
@@ -237,7 +240,7 @@ module Sequel
     # chanaged.  If no columns have been changed, returns nil.  If unable to
     # save, returns false unless raise_on_save_failure is true.
     def save_changes
-      save(:changed=>true) || false unless @changed_columns.empty?
+      save(:changed=>true) || false unless changed_columns.empty?
     end
 
     # Updates the instance with the supplied values with support for virtual
@@ -357,7 +360,7 @@ module Sequel
       raise(Sequel::Error, 'associated object 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])
+      associations[opts[:name]].push(o) if associations.include?(opts[:name])
       add_reciprocal_object(opts, o)
       run_association_callbacks(opts, :after_add, o)
       o
@@ -378,8 +381,8 @@ module Sequel
     # Load the associated objects using the dataset
     def load_associated_objects(opts, reload=false)
       name = opts[:name]
-      if @associations.include?(name) and !reload
-        @associations[name]
+      if associations.include?(name) and !reload
+        associations[name]
       else
         objs = if opts.returns_array?
           send(opts.dataset_method).all
@@ -393,7 +396,7 @@ module Sequel
         run_association_callbacks(opts, :after_load, objs)
         # Only one_to_many associations should set the reciprocal object
         objs.each{|o| add_reciprocal_object(opts, o)} if opts.set_reciprocal_to_self?
-        @associations[name] = objs
+        associations[name] = objs
       end
     end
 
@@ -401,8 +404,8 @@ module Sequel
     def remove_all_associated_objects(opts)
       raise(Sequel::Error, 'model object 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]] = []
+      ret = associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if associations.include?(opts[:name])
+      associations[opts[:name]] = []
       ret
     end
 
@@ -412,7 +415,7 @@ module Sequel
       raise(Sequel::Error, 'associated object 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])
+      associations[opts[:name]].delete_if{|x| o === x} if associations.include?(opts[:name])
       remove_reciprocal_object(opts, o)
       run_association_callbacks(opts, :after_remove, o)
       o