sequel 2.6.0 → 2.7.0

data/lib/sequel_core/object_graph.rb

@@ -33,9 +33,7 @@ module Sequel
     #   or an object that responds to .dataset and yields a symbol or a dataset
     # * join_conditions - Any condition(s) allowed by join_table.
     # * options -  A hash of graph options.  The following options are currently used:
-    #   * :table_alias - The alias to use for the table.  If not specified, doesn't
-    #     alias the table.  You will get an error if the the alias (or table) name is
-    #     used more than once.
+    #   * :implicit_qualifier - The qualifier of implicit conditions, see #join_table.
     #   * :join_type - The type of join to use (passed to join_table).  Defaults to
     #     :left_outer.
     #   * :select - An array of columns to select.  When not used, selects
@@ -43,6 +41,9 @@ module Sequel
     #     columns and is like simply joining the tables, though graph keeps
     #     some metadata about join that makes it important to use graph instead
     #     of join.
+    #   * :table_alias - The alias to use for the table.  If not specified, doesn't
+    #     alias the table.  You will get an error if the the alias (or table) name is
+    #     used more than once.
     # * block - A block that is passed to join_table.
     def graph(dataset, join_conditions = nil, options = {}, &block)
       # Allow the use of a model, dataset, or symbol as the first argument
@@ -69,7 +70,7 @@ module Sequel
       raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
 
       # Join the table early in order to avoid cloning the dataset twice
-      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, table_alias, &block)
+      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
       opts = ds.opts
 
       # Whether to include the table in the result set
@@ -155,18 +156,31 @@ module Sequel
     #   The first element of the array should be the table alias,
     #   and the second should be the actual column name.
     def set_graph_aliases(graph_aliases)
-      cols = graph_aliases.collect do |col_alias, tc| 
-        identifier = tc[1].qualify(tc[0])
-        identifier = identifier.as(col_alias) unless tc[1] == col_alias
-        identifier
-      end
-      ds = select(*cols)
+      ds = select(*graph_alias_columns(graph_aliases))
       ds.opts[:graph_aliases] = graph_aliases
       ds
     end
 
+    # Adds the give graph aliases to the list of graph aliases to use,
+    # unlike #set_graph_aliases, which replaces the list.  See
+    # #set_graph_aliases.
+    def add_graph_aliases(graph_aliases)
+      ds = select_more(*graph_alias_columns(graph_aliases))
+      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || {}).merge(graph_aliases)
+      ds
+    end
+
     private
 
+    # Transform the hash of graph aliases to an array of columns
+    def graph_alias_columns(graph_aliases)
+      graph_aliases.collect do |col_alias, tc| 
+        identifier = tc[2] || tc[1].qualify(tc[0])
+        identifier = SQL::AliasedExpression.new(identifier, col_alias) if tc[2] or tc[1] != col_alias
+        identifier
+      end
+    end
+
     # Fetch the rows, split them into component table parts,
     # tranform and run the row_proc on each part (if applicable),
     # and yield a hash of the parts.

data/lib/sequel_core/schema/generator.rb

@@ -2,15 +2,16 @@ module Sequel
   # The Schema module holds the schema generators and the SQL code relating
   # to SQL DDL (Data Definition Language).
   module Schema
-    # Schema::Generator is used to create tables.  It takes a Database
+    # Schema::Generator is an internal class that the user is not expected
+    # to instantiate directly.  Instances are created by Database#create_table.
+    # It is used to specify table creation parameters.  It takes a Database
     # object and a block of column/index/constraint specifications, and
-    # creates a table in the database based on the specifications.
+    # gives the Database a table description, which the database uses to
+    # create a table.
     #
     # Schema::Generator has some methods but also includes method_missing,
     # allowing users to specify column type as a method instead of using
     # the column method, which makes for a nicer DSL.
-    #
-    # See Database#create_table.
     class Generator
       # Set the database in which to create the table, and evaluate the block
       # in the context of this object.
@@ -118,9 +119,17 @@ module Sequel
         name ? column(name, type, opts) : super
       end
       
-      # Add a column with the given name and primary key options to the DDL. You
-      # can optionally provide a type argument and/or an options hash argument
-      # to change the primary key options. See column for available options.
+      # Add primary key information to the DDL. Takes between one and three
+      # arguments. The last one is an options hash as for Generator#column.
+      # The first one distinguishes two modes: an array of existing column
+      # names adds a composite primary key constraint. A single symbol adds a
+      # new column of that name and makes it the primary key. In that case the
+      # optional middle argument denotes the type.
+      # 
+      # Examples:
+      #   primary_key(:id) primary_key(:name, :text)
+      #   primary_key(:zip_code, :null => false)
+      #   primary_key([:street_number, :house_number])
       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})
@@ -165,8 +174,12 @@ module Sequel
       end
     end
   
-    # The Schema::AlterTableGenerator creates DDL operations on existing tables,
-    # such as adding/removing/modifying columns/indexes/constraints.
+    # Schema::AlterTableGenerator is an internal class that the user is not expected
+    # to instantiate directly.  Instances are created by Database#alter_table.
+    # It is used to specify table alteration parameters.  It takes a Database
+    # object and a block of operations to perform on the table, and
+    # gives the Database a table an array of operations, which the database uses to
+    # alter a table's description.
     class AlterTableGenerator
       # An array of DDL operations to perform
       attr_reader :operations

data/lib/sequel_core/schema/sql.rb

@@ -20,7 +20,6 @@ module Sequel
       # The SQL to execute to modify the DDL for the given table name.  op
       # should be one of the operations returned by the AlterTableGenerator.
       def alter_table_sql(table, op)
-        quoted_table = quote_identifier(table)
         quoted_name = quote_identifier(op[:name]) if op[:name]
         alter_table_op = case op[:op]
         when :add_column
@@ -46,7 +45,7 @@ module Sequel
         else
           raise Error, "Unsupported ALTER TABLE operation"
         end
-        "ALTER TABLE #{quoted_table} #{alter_table_op}"
+        "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op}"
       end
 
       # Array of SQL DDL modification statements for the given table,
@@ -83,7 +82,7 @@ module Sequel
 
       # SQL DDL fragment for column foreign key references
       def column_references_sql(column)
-        sql = " REFERENCES #{quote_identifier(column[:table])}"
+        sql = " REFERENCES #{quote_schema_table(column[:table])}"
         sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
         sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
         sql << " ON UPDATE #{on_delete_clause(column[:on_update])}" if column[:on_update]
@@ -112,7 +111,7 @@ module Sequel
       # name and column specifications, and the others for specifying indexes on
       # the table.
       def create_table_sql_list(name, columns, indexes = nil)
-        sql = ["CREATE TABLE #{quote_identifier(name)} (#{column_list_sql(columns)})"]
+        sql = ["CREATE TABLE #{quote_schema_table(name)} (#{column_list_sql(columns)})"]
         sql.concat(index_list_sql_list(name, indexes)) if indexes && !indexes.empty?
         sql
       end
@@ -120,7 +119,8 @@ module Sequel
       # Default index name for the table and columns, may be too long
       # for certain databases.
       def default_index_name(table_name, columns)
-        "#{table_name}_#{columns.join(UNDERSCORE)}_index"
+        schema, table = schema_and_table(table_name)
+        "#{"#{schema}_" if schema and schema != default_schema}#{table}_#{columns.join(UNDERSCORE)}_index"
       end
     
       # The SQL to drop an index for the table.
@@ -130,7 +130,7 @@ module Sequel
 
       # SQL DDL statement to drop the table with the given name.
       def drop_table_sql(name)
-        "DROP TABLE #{quote_identifier(name)}"
+        "DROP TABLE #{quote_schema_table(name)}"
       end
       
       # Proxy the filter_expr call to the dataset, used for creating constraints.
@@ -187,6 +187,11 @@ module Sequel
         end
       end
       
+      def quote_schema_table(table)
+        schema, table = schema_and_table(table)
+        "#{"#{quote_identifier(schema)}." if schema}#{quote_identifier(table)}"
+      end
+      
       # Proxy the quote_identifier method to the dataset, used for quoting tables and columns.
       def quote_identifier(v)
         schema_utility_dataset.quote_identifier(v)
@@ -194,7 +199,7 @@ module Sequel
       
       # SQL DDL statement for renaming a table.
       def rename_table_sql(name, new_name)
-        "ALTER TABLE #{quote_identifier(name)} RENAME TO #{quote_identifier(new_name)}"
+        "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.
@@ -249,7 +254,6 @@ module Sequel
         @schema_utility_dataset ||= dataset
       end
       
-
       private
 
       # Match the database's column type to a ruby type via a
@@ -273,7 +277,7 @@ module Sequel
           :boolean
         when /\A(real|float|double( precision)?)\z/
           :float
-        when /\A(numeric|decimal|money)\z/
+        when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/
           :decimal
         when "bytea"
           :blob

data/lib/sequel_core/sql.rb

@@ -98,6 +98,15 @@ module Sequel
       def to_s(ds)
         ds.complex_expression_sql(@op, @args)
       end
+
+      # Returns true if the receiver is the same expression as the
+      # the +other+ expression.
+      def eql?( other )
+        return other.is_a?( self.class ) &&
+          @op.eql?( other.op ) &&
+          @args.eql?( other.args )
+      end
+      alias_method :==, :eql?
     end
 
     # The base class for expressions that can be used in multiple places in
@@ -398,6 +407,22 @@ module Sequel
       end
     end
 
+    # Represents an SQL array.  Added so it is possible to deal with a
+    # ruby array of all two pairs as an SQL array instead of an ordered
+    # hash-like conditions specifier.
+    class SQLArray < Expression
+      # Create an object with the given array.
+      def initialize(array)
+        @array = array
+      end
+
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.array_sql(@array)
+      end
+    end
+
     # Blob is used to represent binary data in the Ruby environment that is
     # stored as a blob type in the database. In PostgreSQL, the blob type is 
     # called bytea. Sequel represents binary data as a Blob object because 
@@ -438,7 +463,7 @@ module Sequel
           ce = case r
           when Range
             new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
-          when Array, ::Sequel::Dataset
+          when Array, ::Sequel::Dataset, SQLArray
             new(:IN, l, r)
           when NilClass
             new(:IS, l, r)
@@ -732,7 +757,7 @@ module Sequel
       def self.like(l, *ces)
         case_insensitive = ces.extract_options![:case_insensitive]
         ces.collect! do |ce|
-          op, expr = Regexp === ce ? [ce.casefold? || case_insensitive ? :'~*' : :~, ce.source] : [case_insensitive ? :ILIKE : :LIKE, ce.to_s]
+          op, expr = Regexp === ce ? [ce.casefold? || case_insensitive ? :'~*' : :~, ce.source] : [case_insensitive ? :ILIKE : :LIKE, ce]
           BooleanExpression.new(op, l, expr)
         end
         ces.length == 1 ? ces.at(0) : BooleanExpression.new(:OR, *ces)

data/lib/sequel_model/association_reflection.rb

@@ -1,157 +1,267 @@
-module Sequel
-  class Model
-    module Associations
-      # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
-      # provides methods to reduce internal code duplication.  It should not
-      # be instantiated by the user.
-      class AssociationReflection < Hash
-        ASSOCIATION_TYPES = [:many_to_one, :one_to_many, :many_to_many]
-        RECIPROCAL_ASSOCIATIONS = {:many_to_one=>:one_to_many, :one_to_many=>:many_to_one, :many_to_many=>:many_to_many}
-  
-        # Name symbol for _add_ internal association method
-        def _add_method
-          :"_add_#{self[:name].to_s.singularize}"
-        end
-      
-        # Name symbol for _dataset association method
-        def _dataset_method
-          :"_#{self[:name]}_dataset"
-        end
-      
-        # Name symbol for _remove_all internal association method
-        def _remove_all_method
-          :"_remove_all_#{self[:name]}"
-        end
-      
-        # Name symbol for _remove_ internal association method
-        def _remove_method
-          :"_remove_#{self[:name].to_s.singularize}"
-        end
-      
-        # Name symbol for setter association method
-        def _setter_method
-          :"_#{self[:name]}="
-        end
-      
-        # Name symbol for add_ association method
-        def add_method
-          :"add_#{self[:name].to_s.singularize}"
-        end
-      
-        # Name symbol for association method, the same as the name of the association.
-        def association_method
-          self[:name]
-        end
-      
-        # The class associated to the current model class via this association
-        def associated_class
-          self[:class] ||= self[:class_name].constantize
-        end
+module Sequel::Model::Associations
+  # Map of association type symbols to association reflection classes.
+  ASSOCIATION_TYPES = {}
+
+  # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
+  # provides methods to reduce internal code duplication.  It should not
+  # be instantiated by the user.
+  class AssociationReflection < Hash
+    # Name symbol for _add_ internal association method
+    def _add_method
+      :"_add_#{self[:name].to_s.singularize}"
+    end
   
-        # The associated class's primary key (used for caching)
-        def associated_primary_key
-         self[:associated_primary_key] ||= associated_class.primary_key
-        end
+    # Name symbol for _dataset association method
+    def _dataset_method
+      :"_#{self[:name]}_dataset"
+    end
   
-        # Name symbol for dataset association method
-        def dataset_method
-          :"#{self[:name]}_dataset"
-        end
-      
-        # Name symbol for _helper internal association method
-        def dataset_helper_method
-          :"_#{self[:name]}_dataset_helper"
-        end
-      
-        # Whether the dataset needs a primary key to function
-        def dataset_need_primary_key?
-          self[:type] != :many_to_one
-        end
+    # Name symbol for _remove_all internal association method
+    def _remove_all_method
+      :"_remove_all_#{self[:name]}"
+    end
+  
+    # Name symbol for _remove_ internal association method
+    def _remove_method
+      :"_remove_#{self[:name].to_s.singularize}"
+    end
+  
+    # Name symbol for setter association method
+    def _setter_method
+      :"_#{self[:name]}="
+    end
+  
+    # Name symbol for add_ association method
+    def add_method
+      :"add_#{self[:name].to_s.singularize}"
+    end
+  
+    # Name symbol for association method, the same as the name of the association.
+    def association_method
+      self[:name]
+    end
+  
+    # The class associated to the current model class via this association
+    def associated_class
+      self[:class] ||= self[:class_name].constantize
+    end
+  
+    # Name symbol for dataset association method
+    def dataset_method
+      :"#{self[:name]}_dataset"
+    end
+  
+    # Name symbol for _helper internal association method
+    def dataset_helper_method
+      :"_#{self[:name]}_dataset_helper"
+    end
+  
+    # Whether the dataset needs a primary key to function, true by default.
+    def dataset_need_primary_key?
+      true
+    end
 
-        # Name symbol for default join table
-        def default_join_table
-          ([self[:class_name].demodulize, self[:model].name.to_s.demodulize]. \
-            map{|i| i.pluralize.underscore}.sort.join('_')).to_sym
-        end
-      
-        # Default foreign key name symbol for key in associated table that points to
-        # current table's primary key.
-        def default_left_key
-          :"#{self[:model].name.to_s.demodulize.underscore}_id"
-        end
+    # Whether to eagerly graph a lazy dataset, true by default.
+    def eager_graph_lazy_dataset?
+      true
+    end
 
-        # Default foreign key name symbol for foreign key in current model's table that points to
-        # the given association's table's primary key.
-        def default_right_key
-          :"#{self[:type] == :many_to_one ? self[:name] : self[:name].to_s.singularize}_id"
-        end
-      
-        # Whether to eagerly graph a lazy dataset
-        def eager_graph_lazy_dataset?
-          self[:type] != :many_to_one or self[:key].nil?
-        end
+    # Whether the associated object needs a primary key to be added/removed,
+    # false by default.
+    def need_associated_primary_key?
+      false
+    end
 
-        # Whether the associated object needs a primary key to be added/removed
-        def need_associated_primary_key?
-          self[:type] == :many_to_many
+    # Returns/sets the reciprocal association variable, if one exists
+    def reciprocal
+      return self[:reciprocal] if include?(:reciprocal)
+      r_type = reciprocal_type
+      key = self[:key]
+      associated_class.all_association_reflections.each do |assoc_reflect|
+        if assoc_reflect[:type] == r_type && assoc_reflect[:key] == key
+          return self[:reciprocal] = assoc_reflect[:name]
         end
+      end
+      self[:reciprocal] = nil
+    end
 
-        # Returns/sets the reciprocal association variable, if one exists
-        def reciprocal
-          return self[:reciprocal] if include?(:reciprocal)
-          reciprocal_type = RECIPROCAL_ASSOCIATIONS[self[:type]]
-          if reciprocal_type == :many_to_many
-            left_key = self[:left_key]
-            right_key = self[:right_key]
-            join_table = self[:join_table]
-            associated_class.all_association_reflections.each do |assoc_reflect|
-              if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_key] == right_key \
-                 && assoc_reflect[:right_key] == left_key && assoc_reflect[:join_table] == join_table
-                return self[:reciprocal] = assoc_reflect[:name]
-              end
-            end
-          else
-            key = self[:key]
-            associated_class.all_association_reflections.each do |assoc_reflect|
-              if assoc_reflect[:type] == reciprocal_type && assoc_reflect[:key] == key
-                return self[:reciprocal] = assoc_reflect[:name]
-              end
-            end
-          end
-          self[:reciprocal] = nil
-        end
+    # Whether the reciprocal of this  association returns an array of objects instead of a single object,
+    # true by default.
+    def reciprocal_array?
+      true
+    end
 
-        # Name symbol for remove_all_ association method
-        def remove_all_method
-          :"remove_all_#{self[:name]}"
-        end
-      
-        # Name symbol for remove_ association method
-        def remove_method
-          :"remove_#{self[:name].to_s.singularize}"
-        end
-      
-        # The columns to select when loading the association
-        def select
-         return self[:select] if include?(:select)
-         self[:select] = self[:type] == :many_to_many ? associated_class.table_name.* : nil
-        end
+    # Name symbol for remove_all_ association method
+    def remove_all_method
+      :"remove_all_#{self[:name]}"
+    end
+  
+    # Name symbol for remove_ association method
+    def remove_method
+      :"remove_#{self[:name].to_s.singularize}"
+    end
+  
+    # Whether this association returns an array of objects instead of a single object,
+    # true by default.
+    def returns_array?
+      true
+    end
 
-        # Whether to set the reciprocal to the current object when loading
-        def set_reciprocal_to_self?
-          self[:type] == :one_to_many
-        end
+    # The columns to select when loading the association, nil by default.
+    def select
+      self[:select]
+    end
 
-        # Name symbol for setter association method
-        def setter_method
-          :"#{self[:name]}="
-        end
+    # By default, associations shouldn't set the reciprocal association to self.
+    def set_reciprocal_to_self?
+      false
+    end
+
+    # Name symbol for setter association method
+    def setter_method
+      :"#{self[:name]}="
+    end
+
+  end
+
+  class ManyToOneAssociationReflection < AssociationReflection
+    ASSOCIATION_TYPES[:many_to_one] = self
+
+    # Whether the dataset needs a primary key to function, false for many_to_one associations.
+    def dataset_need_primary_key?
+      false
+    end
+
+    # Default foreign key name symbol for foreign key in current model's table that points to
+    # the given association's table's primary key.
+    def default_key
+      :"#{self[:name]}_id"
+    end
+  
+    # Whether to eagerly graph a lazy dataset, true for many_to_one associations
+    # only if the key is nil.
+    def eager_graph_lazy_dataset?
+      self[:key].nil?
+    end
+
+    # The key to use for the key hash when eager loading
+    def eager_loader_key
+      self[:key]
+    end
+
+    # The column in the associated table that the key in the current table references.
+    def primary_key
+     self[:primary_key] ||= associated_class.primary_key
+    end
+  
+    # Whether this association returns an array of objects instead of a single object,
+    # false for a many_to_one association.
+    def returns_array?
+      false
+    end
+
+    private
+
+    # The reciprocal type of a many_to_one association is a one_to_many association.
+    def reciprocal_type
+      :one_to_many
+    end
+  end
+
+  class OneToManyAssociationReflection < AssociationReflection
+    ASSOCIATION_TYPES[:one_to_many] = self
+
+    # Default foreign key name symbol for key in associated table that points to
+    # current table's primary key.
+    def default_key
+      :"#{self[:model].name.to_s.demodulize.underscore}_id"
+    end
+
+    # The key to use for the key hash when eager loading
+    def eager_loader_key
+      primary_key
+    end
+
+    # The column in the current table that the key in the associated table references.
+    def primary_key
+     self[:primary_key] ||= self[:model].primary_key
+    end
+  
+    # One to many associations set the reciprocal to self.
+    def set_reciprocal_to_self?
+      true
+    end
+
+    # Whether the reciprocal of this  association returns an array of objects instead of a single object,
+    # false for a one_to_many association.
+    def reciprocal_array?
+      false
+    end
+
+    private
+
+    # The reciprocal type of a one_to_many association is a many_to_one association.
+    def reciprocal_type
+      :many_to_one
+    end
+  end
+
+  class ManyToManyAssociationReflection < AssociationReflection
+    ASSOCIATION_TYPES[:many_to_many] = self
+
+    # Default name symbol for the join table.
+    def default_join_table
+      ([self[:class_name].demodulize, self[:model].name.to_s.demodulize]. \
+        map{|i| i.pluralize.underscore}.sort.join('_')).to_sym
+    end
+  
+    # Default foreign key name symbol for key in join table that points to
+    # current table's primary key (or :left_primary_key column).
+    def default_left_key
+      :"#{self[:model].name.to_s.demodulize.underscore}_id"
+    end
+
+    # Default foreign key name symbol for foreign key in join table that points to
+    # the association's table's primary key (or :right_primary_key column).
+    def default_right_key
+      :"#{self[:name].to_s.singularize}_id"
+    end
+  
+    # The key to use for the key hash when eager loading
+    def eager_loader_key
+      self[:left_primary_key]
+    end
 
-        # Whether the association should return a single object or multiple objects.
-        def single_associated_object?
-          self[:type] == :many_to_one
+    # Whether the associated object needs a primary key to be added/removed,
+    # true for many_to_many associations.
+    def need_associated_primary_key?
+      true
+    end
+
+    # Returns/sets the reciprocal association variable, if one exists
+    def reciprocal
+      return self[:reciprocal] if include?(:reciprocal)
+      left_key = self[:left_key]
+      right_key = self[:right_key]
+      join_table = self[:join_table]
+      associated_class.all_association_reflections.each do |assoc_reflect|
+        if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_key] == right_key \
+           && assoc_reflect[:right_key] == left_key && assoc_reflect[:join_table] == join_table
+          return self[:reciprocal] = assoc_reflect[:name]
         end
       end
+      self[:reciprocal] = nil
+    end
+
+    # The primary key column to use in the associated table.
+    def right_primary_key
+      self[:right_primary_key] ||= associated_class.primary_key
+    end
+
+    # The columns to select when loading the association, associated_class.table_name.* by default.
+    def select
+     return self[:select] if include?(:select)
+     self[:select] ||= associated_class.table_name.*
     end
   end
 end