sequel 3.36.1 → 3.37.0

data/lib/sequel/core.rb

@@ -228,6 +228,19 @@ module Sequel
   def self.quote_identifiers=(value)
     Database.quote_identifiers = value
   end
+
+  # Convert each item in the array to the correct type, handling multi-dimensional
+  # arrays.  For each element in the array or subarrays, call the converter,
+  # unless the value is nil.
+  def self.recursive_map(array, converter)
+    array.map do |i|
+      if i.is_a?(Array)
+        recursive_map(i, converter)
+      elsif i
+        converter.call(i)
+      end
+    end
+  end
   
   # Require all given +files+ which should be in the same or a subdirectory of
   # this file.  If a +subdir+ is given, assume all +files+ are in that subdir.

data/lib/sequel/database/misc.rb

@@ -4,6 +4,28 @@ module Sequel
     # :section: 7 - Miscellaneous methods
     # These methods don't fit neatly into another category.
     # ---------------------
+    
+    # Hash of extension name symbols to callable objects to load the extension
+    # into the Database object (usually by extending it with a module defined
+    # in the extension).
+    EXTENSIONS = {}
+
+    # Register an extension callback for Database objects.  ext should be the
+    # extension name symbol, and mod should either be a Module that the
+    # database is extended with, or a callable object called with the database
+    # object.  If mod is not provided, a block can be provided and is treated
+    # as the mod object.
+    def self.register_extension(ext, mod=nil, &block)
+      if mod
+        raise(Error, "cannot provide both mod and block to Database.register_extension") if block
+        if mod.is_a?(Module)
+          block = proc{|db| db.extend(mod)}
+        else
+          block = mod
+        end
+      end
+      Sequel.synchronize{EXTENSIONS[ext] = block}
+    end
 
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
@@ -107,6 +129,23 @@ module Sequel
       type_literal(:type=>type)
     end
 
+    # Load an extension into the receiver.  In addition to requiring the extension file, this
+    # also modifies the database to work with the extension (usually extending it with a
+    # module defined in the extension file).  If no related extension file exists or the
+    # extension does not have specific support for Database objects, an Error will be raised.
+    # Returns self.
+    def extension(*exts)
+      Sequel.extension(*exts)
+      exts.each do |ext|
+        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          pr.call(self)
+        else
+          raise(Error, "Extension #{ext} does not have specific support handling individual databases")
+        end
+      end
+      self
+    end
+
     # Convert the given timestamp from the application's timezone,
     # to the databases's timezone or the default database timezone if
     # the database does not have a timezone.
@@ -362,7 +401,8 @@ module Sequel
         if value.is_a?(SQLTime)
           value
         else
-          SQLTime.create(value.hour, value.min, value.sec, value.respond_to?(:nsec) ? value.nsec/1000.0 : value.usec)
+          # specifically check for nsec == 0 value to work around JRuby 1.6 ruby 1.9 mode bug
+          SQLTime.create(value.hour, value.min, value.sec, (value.respond_to?(:nsec) && value.nsec != 0) ? value.nsec/1000.0 : value.usec)
         end
       when String
         Sequel.string_to_time(value)

data/lib/sequel/database/schema_generator.rb

@@ -1,20 +1,20 @@
 module Sequel
   # The Schema module holds the schema generators.
   module Schema
-    # Schema::Generator is an internal class that the user is not expected
+    # Schema::CreateTableGenerator 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
     # gives the Database a table description, which the database uses to
     # create a table.
     #
-    # Schema::Generator has some methods but also includes method_missing,
+    # Schema::CreateTableGenerator 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.
     #
     # For more information on Sequel's support for schema modification, see
     # the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
-    class Generator
+    class CreateTableGenerator
       # Classes specifying generic types that Sequel will convert to database-specific types.
       GENERIC_TYPES=[String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal,
       Date, DateTime, Time, File, TrueClass, FalseClass]
@@ -255,6 +255,9 @@ module Sequel
       
       add_type_method(*GENERIC_TYPES)
     end
+
+    # Alias of CreateTableGenerator for backwards compatibility.
+    Generator = CreateTableGenerator
   
     # Schema::AlterTableGenerator is an internal class that the user is not expected
     # to instantiate directly.  Instances are created by Database#alter_table.
@@ -278,7 +281,7 @@ module Sequel
       end
       
       # Add a column with the given name, type, and opts to the DDL for the table.
-      # See Generator#column for the available options.
+      # See CreateTableGenerator#column for the available options.
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       def add_column(name, type, opts = {})
@@ -286,7 +289,7 @@ module Sequel
       end
       
       # Add a constraint with the given name and args to the DDL for the table.
-      # See Generator#constraint.
+      # See CreateTableGenerator#constraint.
       #
       #   add_constraint(:valid_name, :name.like('A%'))
       #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%')
@@ -303,7 +306,7 @@ module Sequel
       end
 
       # Add a foreign key with the given name and referencing the given table
-      # to the DDL for the table.  See Generator#column for the available options.
+      # to the DDL for the table.  See CreateTableGenerator#column for the available options.
       #
       # You can also pass an array of column names for creating composite foreign
       # keys. In this case, it will assume the columns exist and will only add
@@ -314,26 +317,36 @@ module Sequel
       #
       #   add_foreign_key(:artist_id, :table) # ADD COLUMN artist_id integer REFERENCES table
       #   add_foreign_key([:name], :table) # ADD FOREIGN KEY (name) REFERENCES table
+      #
+      # PostgreSQL specific options:
+      #
+      # :not_valid :: Set to true to add the constraint with the NOT VALID syntax.
+      #               This makes it so that future inserts must respect referential
+      #               integrity, but allows the constraint to be added even if existing
+      #               column values reference rows that do not exist.  After all the
+      #               existing data has been cleaned up, validate_constraint can be used
+      #               to mark the constraint as valid.  Note that this option only makes
+      #               sense when using an array of columns.
       def add_foreign_key(name, table, opts = {})
         return add_composite_foreign_key(name, table, opts) if name.is_a?(Array)
         add_column(name, Integer, {:table=>table}.merge(opts))
       end
       
       # Add a full text index on the given columns to the DDL for the table.
-      # See Generator#index for available options.
+      # See CreateTableGenerator#index for available options.
       def add_full_text_index(columns, opts = {})
         add_index(columns, {:type=>:full_text}.merge(opts))
       end
       
       # Add an index on the given columns to the DDL for the table.  See
-      # Generator#index for available options.
+      # CreateTableGenerator#index for available options.
       #
       #   add_index(:artist_id) # CREATE INDEX table_artist_id_index ON table (artist_id)
       def add_index(columns, opts = {})
         @operations << {:op => :add_index, :columns => Array(columns)}.merge(opts)
       end
       
-      # Add a primary key to the DDL for the table.  See Generator#column
+      # Add a primary key to the DDL for the table.  See CreateTableGenerator#column
       # for the available options.  Like +add_foreign_key+, if you specify
       # the column name as an array, it just creates a constraint:
       #
@@ -346,7 +359,7 @@ module Sequel
       end
       
       # Add a spatial index on the given columns to the DDL for the table.
-      # See Generator#index for available options.
+      # See CreateTableGenerator#index for available options.
       def add_spatial_index(columns, opts = {})
         add_index(columns, {:type=>:spatial}.merge(opts))
       end

data/lib/sequel/database/schema_methods.rb

@@ -68,12 +68,18 @@ module Sequel
     #
     # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
     def alter_table(name, generator=nil, &block)
-      generator ||= Schema::AlterTableGenerator.new(self, &block)
+      generator ||= alter_table_generator(&block)
       remove_cached_schema(name)
       apply_alter_table(name, generator.operations)
       nil
     end
 
+    # Return a new Schema::AlterTableGenerator instance with the receiver as
+    # the database and the given block.
+    def alter_table_generator(&block)
+      alter_table_generator_class.new(self, &block)
+    end
+
     # Create a join table using a hash of foreign keys to referenced
     # table names.  Example:
     #
@@ -146,12 +152,12 @@ module Sequel
     # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     def create_table(name, options={}, &block)
       remove_cached_schema(name)
-      options = {:generator=>options} if options.is_a?(Schema::Generator)
+      options = {:generator=>options} if options.is_a?(Schema::CreateTableGenerator)
       if sql = options[:as]
         raise(Error, "can't provide both :as option and block to create_table") if block
         create_table_as(name, sql, options)
       else
-        generator = options[:generator] || Schema::Generator.new(self, &block)
+        generator = options[:generator] || create_table_generator(&block)
         create_table_from_generator(name, generator, options)
         create_table_indexes_from_generator(name, generator, options)
         nil
@@ -181,6 +187,12 @@ module Sequel
         create_table(name, options, &block)
       end
     end
+
+    # Return a new Schema::CreateTableGenerator instance with the receiver as
+    # the database and the given block.
+    def create_table_generator(&block)
+      create_table_generator_class.new(self, &block)
+    end
     
     # Creates a view, replacing it if it already exists:
     #
@@ -324,6 +336,11 @@ module Sequel
       alter_table_sql_list(name, ops).flatten.each{|sql| execute_ddl(sql)}
     end
     
+    # The class used for alter_table generators.
+    def alter_table_generator_class
+      Schema::AlterTableGenerator
+    end
+    
     # 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)
@@ -465,6 +482,11 @@ module Sequel
       execute_ddl(create_table_sql(name, generator, options))
     end
 
+    # The class used for create_table generators.
+    def create_table_generator_class
+      Schema::CreateTableGenerator
+    end
+    
     # Execute the create index statements using the generator.
     def create_table_indexes_from_generator(name, generator, options)
       e = options[:ignore_index_errors] || options[:if_not_exists]
@@ -621,7 +643,7 @@ module Sequel
 
     # Return true if the given column schema represents an autoincrementing primary key.
     def schema_autoincrementing_primary_key?(schema)
-      !!schema[:primary_key]
+      !!(schema[:primary_key] && schema[:db_type] =~ /int/io)
     end
 
     # The dataset to use for proxying certain schema methods.

data/lib/sequel/dataset/graph.rb

@@ -63,6 +63,7 @@ module Sequel
     #                     determines the alias to use.
     # :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.
+    # :qualify:: The type of qualification to do, see #join_table.
     # :select :: An array of columns to select.  When not used, selects
     #            all columns in the given dataset.  When set to false, selects no
     #            columns and is like simply joining the tables, though graph keeps
@@ -106,7 +107,7 @@ module Sequel
       ds = (!@opts[:graph] && (@opts[:from].length > 1 || @opts[:join])) ? from_self(:alias=>options[:from_self_alias] || first_source) : self
       
       # Join the table early in order to avoid cloning the dataset twice
-      ds = ds.join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
+      ds = ds.join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], :qualify=>options[:qualify], &block)
       opts = ds.opts
 
       # Whether to include the table in the result set

data/lib/sequel/dataset/query.rb

@@ -5,6 +5,11 @@ module Sequel
     # These methods all return modified copies of the receiver.
     # ---------------------
 
+    # Hash of extension name symbols to callable objects to load the extension
+    # into the Dataset object (usually by extending it with a module defined
+    # in the extension).
+    EXTENSIONS = {}
+
     # The dataset options that require the removal of cached columns
     # if changed.
     COLUMN_CHANGE_OPTS = [:select, :sql, :from, :join].freeze
@@ -37,6 +42,27 @@ module Sequel
       unlimited unordered where with with_recursive with_sql
     METHS
 
+    # Register an extension callback for Dataset objects.  ext should be the
+    # extension name symbol, and mod should either be a Module that the
+    # dataset is extended with, or a callable object called with the database
+    # object.  If mod is not provided, a block can be provided and is treated
+    # as the mod object.
+    #
+    # If mod is a module, this also registers a Database extension that will
+    # extend all of the database's datasets.
+    def self.register_extension(ext, mod=nil, &block)
+      if mod
+        raise(Error, "cannot provide both mod and block to Dataset.register_extension") if block
+        if mod.is_a?(Module)
+          block = proc{|ds| ds.extend(mod)}
+          Sequel::Database.register_extension(ext){|db| db.extend_datasets(mod)}
+        else
+          block = mod
+        end
+      end
+      Sequel.synchronize{EXTENSIONS[ext] = block}
+    end
+
     # Adds an further filter to an existing filter using AND. If no filter 
     # exists an error is raised. This method is identical to #filter except
     # it expects an existing filter.
@@ -130,6 +156,28 @@ module Sequel
       _filter_or_exclude(true, :where, *cond, &block)
     end
 
+    # Return a clone of the dataset loaded with the extensions, see #extension!.
+    def extension(*exts)
+      clone.extension!(*exts)
+    end
+
+    # Load an extension into the receiver.  In addition to requiring the extension file, this
+    # also modifies the dataset to work with the extension (usually extending it with a
+    # module defined in the extension file).  If no related extension file exists or the
+    # extension does not have specific support for Database objects, an Error will be raised.
+    # Returns self.
+    def extension!(*exts)
+      Sequel.extension(*exts)
+      exts.each do |ext|
+        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          pr.call(self)
+        else
+          raise(Error, "Extension #{ext} does not have specific support handling individual datasets")
+        end
+      end
+      self
+    end
+
     # Returns a copy of the dataset with the given conditions imposed upon it.  
     # If the query already has a HAVING clause, then the conditions are imposed in the 
     # HAVING clause. If not, then they are imposed in the WHERE clause.
@@ -432,6 +480,9 @@ module Sequel
     #     to the same table more than once.  No alias is used by default.
     #   * :implicit_qualifier - The name to use for qualifying implicit conditions.  By default,
     #     the last joined or primary table is used.
+    #   * :qualify - Can be set to false to not do any implicit qualification.  Can be set
+    #     to :deep to use the Qualifier AST Transformer, which will attempt to qualify
+    #     subexpressions of the expression tree.
     # * block - The block argument should only be given if a JOIN with an ON clause is used,
     #   in which case it yields the table alias/name for the table currently being joined,
     #   the table alias/name for the last joined (or first table), and an array of previous
@@ -470,6 +521,7 @@ module Sequel
       when Hash
         table_alias = options[:table_alias]
         last_alias = options[:implicit_qualifier]
+        qualify_type = options[:qualify]
       when Symbol, String, SQL::Identifier
         table_alias = options
         last_alias = nil 
@@ -499,8 +551,16 @@ module Sequel
         last_alias ||= @opts[:last_joined_table] || first_source_alias
         if Sequel.condition_specifier?(expr)
           expr = expr.collect do |k, v|
-            k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
-            v = qualified_column_name(v, last_alias) if v.is_a?(Symbol)
+            case qualify_type
+            when false
+              nil # Do no qualification
+            when :deep
+              k = Sequel::Qualifier.new(self, table_name).transform(k)
+              v = Sequel::Qualifier.new(self, last_alias).transform(v)
+            else
+              k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
+              v = qualified_column_name(v, last_alias) if v.is_a?(Symbol)
+            end
             [k,v]
           end
           expr = SQL::BooleanExpression.from_value_pairs(expr)

data/lib/sequel/extensions/_pretty_table.rb

@@ -1,6 +1,10 @@
-# The pretty_table extension adds Sequel::Dataset#print and the
-# Sequel::PrettyTable class for creating nice-looking plain-text
-# tables.
+# This _pretty_table extension is only for internal use.
+# It adds the Sequel::PrettyTable class without modifying 
+# Sequel::Dataset.
+#
+# To load the extension:
+#
+#   Sequel.extension :_pretty_table
 
 module Sequel
   module PrettyTable

data/lib/sequel/extensions/arbitrary_servers.rb

@@ -1,10 +1,8 @@
 # The arbitrary_servers extension allows you to connect to arbitrary
 # servers/shards that were not defined when you created the database.
-# To use it, you first extend the Database's connection pool with the
-# Sequel::ArbitraryServers module:
+# To use it, you first load the extension into the Database object:
 #
-#   Sequel.extension :arbitrary_servers
-#   DB.pool.extend Sequel::ArbitraryServers
+#   DB.extension :arbitrary_servers
 #
 # Then you can pass arbitrary connection options for the server/shard
 # to use as a hash:
@@ -105,4 +103,7 @@ module Sequel
       end
     end
   end
+
+  Database.register_extension(:arbitrary_servers){|db| db.pool.extend(ArbitraryServers)}
 end
+

data/lib/sequel/extensions/blank.rb

@@ -1,4 +1,8 @@
 # The blank extension adds the blank? method to all objects (e.g. Object#blank?).
+#
+# To load the extension:
+#
+#   Sequel.extension :blank
 
 class FalseClass
   # false is always blank

data/lib/sequel/extensions/columns_introspection.rb

@@ -5,9 +5,17 @@
 # This method is not fool-proof, it's possible that some databases
 # will use column names that Sequel does not expect.
 #
-# To enable this for a single dataset, extend the dataset with
-# Sequel::ColumnIntrospection.  To enable this for all datasets, run:
+# To attempt to introspect columns for a single dataset:
 #
+#   ds.extension(:columns_introspection)
+#
+# To attempt to introspect columns for all datasets on a single database:
+#
+#   DB.extension(:columns_introspection)
+#
+# To attempt to introspect columns for all datasets on all databases:
+#
+#   Sequel.extension :columns_introspection
 #   Sequel::Dataset.introspect_all_columns
 
 module Sequel
@@ -58,4 +66,7 @@ module Sequel
       remove_method(:columns) if instance_methods(false).map{|x| x.to_s}.include?('columns')
     end
   end
+
+  Dataset.register_extension(:columns_introspection, Sequel::ColumnsIntrospection)
 end
+