sequel 3.38.0 → 3.39.0

data/lib/sequel/database/schema_methods.rb

@@ -21,6 +21,11 @@ module Sequel
     # The default options for join table columns.
     DEFAULT_JOIN_TABLE_COLUMN_OPTIONS = {:null=>false}
 
+    # The alter table operations that are combinable.
+    COMBINABLE_ALTER_TABLE_OPS = [:add_column, :drop_column, :rename_column,
+      :set_column_type, :set_column_default, :set_column_null,
+      :add_constraint, :drop_constraint]
+
     # Adds a column to the specified table. This method expects a column name,
     # a datatype and optionally a hash with additional constraints and options:
     #
@@ -70,7 +75,7 @@ module Sequel
     def alter_table(name, generator=nil, &block)
       generator ||= alter_table_generator(&block)
       remove_cached_schema(name)
-      apply_alter_table(name, generator.operations)
+      apply_alter_table_generator(name, generator)
       nil
     end
 
@@ -333,17 +338,21 @@ module Sequel
 
     # Apply the changes in the given alter table ops to the table given by name.
     def apply_alter_table(name, ops)
-      alter_table_sql_list(name, ops).flatten.each{|sql| execute_ddl(sql)}
+      alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
     end
     
+    # Apply the operations in the given generator to the table given by name.
+    def apply_alter_table_generator(name, generator)
+      apply_alter_table(name, generator.operations)
+    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)
+    # SQL fragment for given alter table operation.
+    def alter_table_op_sql(table, op)
       quoted_name = quote_identifier(op[:name]) if op[:name]
       alter_table_op = case op[:op]
       when :add_column
@@ -358,24 +367,56 @@ module Sequel
         "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
       when :set_column_null
         "ALTER COLUMN #{quoted_name} #{op[:null] ? 'DROP' : 'SET'} NOT NULL"
-      when :add_index
-        return index_definition_sql(table, op)
-      when :drop_index
-        return drop_index_sql(table, op)
       when :add_constraint
         "ADD #{constraint_definition_sql(op)}"
       when :drop_constraint
         "DROP CONSTRAINT #{quoted_name}#{' CASCADE' if op[:cascade]}"
       else
-        raise Error, "Unsupported ALTER TABLE operation"
+        raise Error, "Unsupported ALTER TABLE operation: #{op[:op]}"
+      end
+    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)
+      case op[:op]
+      when :add_index
+        index_definition_sql(table, op)
+      when :drop_index
+        drop_index_sql(table, op)
+      else
+        "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op_sql(table, op)}"
       end
-      "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op}"
     end
 
     # Array of SQL DDL modification statements for the given table,
     # corresponding to the DDL changes specified by the operations.
     def alter_table_sql_list(table, operations)
-      operations.map{|op| alter_table_sql(table, op)}
+      if supports_combining_alter_table_ops?
+        grouped_ops = []
+        last_combinable = false
+        operations.each do |op|
+          if combinable_alter_table_op?(op)
+            if sql = alter_table_op_sql(table, op)
+              grouped_ops << [] unless last_combinable
+              grouped_ops.last << sql
+              last_combinable = true
+            end
+          elsif sql = alter_table_sql(table, op)
+            grouped_ops << sql
+            last_combinable = false
+          end
+        end
+        grouped_ops.map do |gop|
+          if gop.is_a?(Array)
+            "ALTER TABLE #{quote_schema_table(table)} #{gop.join(', ')}"
+          else
+            gop
+          end
+        end
+      else
+        operations.map{|op| alter_table_sql(table, op)}.flatten.compact
+      end
     end
     
     # The SQL string specify the autoincrement property, generally used by
@@ -458,6 +499,12 @@ module Sequel
       "FOREIGN KEY #{literal(constraint[:columns])}#{column_references_sql(constraint)}"
     end
 
+    # Whether the given alter table operation is combinable.
+    def combinable_alter_table_op?(op)
+      # Use a dynamic lookup for easier overriding in adapters
+      COMBINABLE_ALTER_TABLE_OPS.include?(op[:op])
+    end
+
     # SQL DDL fragment specifying a constraint on a table.
     def constraint_definition_sql(constraint)
       sql = constraint[:name] ? "CONSTRAINT #{quote_identifier(constraint[:name])} " : ""
@@ -651,6 +698,12 @@ module Sequel
       @schema_utility_dataset ||= dataset
     end
 
+    # Whether the database supports combining multiple alter table
+    # operations into a single query, false by default.
+    def supports_combining_alter_table_ops?
+      false
+    end
+
     # SQL DDL fragment for temporary table
     def temporary_table_sql
       self.class.const_get(:TEMPORARY)

data/lib/sequel/dataset/actions.rb

@@ -93,12 +93,30 @@ module Sequel
       columns
     end
     
-    # Returns the number of records in the dataset.
+    # Returns the number of records in the dataset. If an argument is provided,
+    # it is used as the argument to count.  If a block is provided, it is
+    # treated as a virtual row, and the result is used as the argument to
+    # count.
     #
     #   DB[:table].count # SELECT COUNT(*) AS count FROM table LIMIT 1
     #   # => 3
-    def count
-      aggregate_dataset.get{COUNT(:*){}.as(count)}.to_i
+    #   DB[:table].count(:column) # SELECT COUNT(column) AS count FROM table LIMIT 1
+    #   # => 2
+    #   DB[:table].count{foo(column)} # SELECT COUNT(foo(column)) AS count FROM table LIMIT 1
+    #   # => 1
+    def count(arg=(no_arg=true), &block)
+      if no_arg
+        if block
+          arg = Sequel.virtual_row(&block)
+          aggregate_dataset.get{COUNT(arg).as(count)}
+        else
+          aggregate_dataset.get{COUNT(:*){}.as(count)}.to_i
+        end
+      elsif block
+        raise Error, 'cannot provide both argument and block to Dataset#count'
+      else
+        aggregate_dataset.get{COUNT(arg).as(count)}
+      end
     end
     
     # Deletes the records in the dataset.  The returned value should be 
@@ -311,7 +329,7 @@ module Sequel
     #   # INSERT INTO table (x) VALUES (1)
     #   # INSERT INTO table (x) VALUES (2)
     #
-    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2}
+    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2; row }
     #   # => [6, 7]
     #   # INSERT INTO table (x, y) VALUES (1, 2)
     #   # INSERT INTO table (x, y) VALUES (2, 4)

data/lib/sequel/dataset/features.rb

@@ -114,6 +114,11 @@ module Sequel
       supports_distinct_on?
     end
     
+    # Whether the dataset supports pattern matching by regular expressions.
+    def supports_regexp?
+      false
+    end
+
     # Whether the RETURNING clause is supported for the given type of query.
     # +type+ can be :insert, :update, or :delete.
     def supports_returning?(type)

data/lib/sequel/dataset/graph.rb

@@ -73,9 +73,8 @@ module Sequel
     #                 alias the table.  You will get an error if the the alias (or table) name is
     #                 used more than once.
     def graph(dataset, join_conditions = nil, options = {}, &block)
-      # Allow the use of a model, dataset, or symbol as the first argument
+      # Allow the use of a dataset or symbol as the first argument
       # Find the table name/dataset based on the argument
-      dataset = dataset.dataset if dataset.respond_to?(:dataset)
       table_alias = options[:table_alias]
       case dataset
       when Symbol
@@ -91,7 +90,7 @@ module Sequel
           table_alias ||= dataset_alias((@opts[:num_dataset_sources] || 0)+1)
         end
       else
-        raise Error, "The dataset argument should be a symbol, dataset, or model"
+        raise Error, "The dataset argument should be a symbol or dataset"
       end
 
       # Raise Sequel::Error with explanation that the table alias has been used

data/lib/sequel/dataset/misc.rb

@@ -31,9 +31,9 @@ module Sequel
     end
 
     # Define a hash value such that datasets with the same DB, opts, and SQL
-    # will be consider equal.
+    # will be considered equal.
     def ==(o)
-      o.is_a?(self.class) && db == o.db  && opts == o.opts && sql == o.sql
+      o.is_a?(self.class) && db == o.db && opts == o.opts && sql == o.sql
     end
 
     # Alias for ==

data/lib/sequel/dataset/query.rb

@@ -459,7 +459,6 @@ module Sequel
     # * type - The type of join to do (e.g. :inner)
     # * table - Depends on type:
     #   * Dataset - a subselect is performed with an alias of tN for some value of N
-    #   * Model (or anything responding to :table_name) - table.table_name
     #   * String, Symbol: table
     # * expr - specifies conditions, depends on type:
     #   * Hash, Array of two element arrays - Assumes key (1st arg) is column of joined table (unless already
@@ -536,7 +535,6 @@ module Sequel
         end
         table_name = table_alias
       else
-        table = table.table_name if table.respond_to?(:table_name)
         table, implicit_table_alias = split_alias(table)
         table_alias ||= implicit_table_alias
         table_name = table_alias || table

data/lib/sequel/dataset/sql.rb

@@ -49,10 +49,6 @@ module Sequel
           end
         when Dataset, Array, LiteralString
           values = vals
-        else
-          if vals.respond_to?(:values) && (v = vals.values).is_a?(Hash)
-            return insert_sql(v) 
-          end
         end
       when 2
         if (v0 = values.at(0)).is_a?(Array) && ((v1 = values.at(1)).is_a?(Array) || v1.is_a?(Dataset) || v1.is_a?(LiteralString))
@@ -182,6 +178,9 @@ module Sequel
       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
     end
 
+    # Map of emulated function names to native function names.
+    EMULATED_FUNCTION_MAP = {}
+
     WILDCARD = LiteralString.new('*').freeze
     ALL = ' ALL'.freeze
     AND_SEPARATOR = " AND ".freeze
@@ -272,6 +271,7 @@ module Sequel
     TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S%N%z'".freeze
     STANDARD_TIMESTAMP_FORMAT = "TIMESTAMP #{TIMESTAMP_FORMAT}".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
+    REGEXP_OPERATORS = ::Sequel::SQL::ComplexExpression::REGEXP_OPERATORS
     UNDERSCORE = '_'.freeze
     UPDATE = 'UPDATE'.freeze
     UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'update table set where')
@@ -456,6 +456,9 @@ module Sequel
           sql << PAREN_CLOSE
         end
       when *TWO_ARITY_OPERATORS
+        if REGEXP_OPERATORS.include?(op) && !supports_regexp?
+          raise InvalidOperation, "Pattern matching via regular expressions is not supported on #{db.database_type}"
+        end
         sql << PAREN_OPEN
         literal_append(sql, args.at(0))
         sql << SPACE << op.to_s << SPACE
@@ -493,15 +496,18 @@ module Sequel
       sql << constant.to_s
     end
 
-    # SQL fragment specifying an SQL function call
+    # SQL fragment specifying an emulated SQL function call.
+    # By default, assumes just the function name may need to
+    # be emulated, adapters should set an EMULATED_FUNCTION_MAP
+    # hash mapping emulated functions to native functions in
+    # their dataset class to setup the emulation.
+    def emulated_function_sql_append(sql, f)
+      _function_sql_append(sql, native_function_name(f.f), f.args)
+    end
+
+    # SQL fragment specifying an SQL function call without emulation.
     def function_sql_append(sql, f)
-      sql << f.f.to_s
-      args = f.args
-      if args.empty?
-        sql << FUNCTION_EMPTY
-      else
-        literal_append(sql, args)
-      end
+      _function_sql_append(sql, f.f, f.args)
     end
 
     # SQL fragment specifying a JOIN clause without ON or USING.
@@ -718,6 +724,16 @@ module Sequel
     
     private
 
+    # Backbone of function_sql_append and emulated_function_sql_append.
+    def _function_sql_append(sql, name, args)
+      sql << name.to_s
+      if args.empty?
+        sql << FUNCTION_EMPTY
+      else
+        literal_append(sql, args)
+      end
+    end
+
     # Formats the truncate statement.  Assumes the table given has already been
     # literalized.
     def _truncate_sql(table)
@@ -1127,6 +1143,11 @@ module Sequel
       BOOL_TRUE
     end
 
+    # Get the native function name given the emulated function name.
+    def native_function_name(emulated_function)
+      self.class.const_get(:EMULATED_FUNCTION_MAP).fetch(emulated_function, emulated_function)
+    end
+
     # Returns a qualified column name (including a table name) if the column
     # name isn't already qualified.
     def qualified_column_name(column, table)

data/lib/sequel/extensions/constraint_validations.rb

@@ -0,0 +1,451 @@
+# The constraint_validations extension is designed to easily create database
+# constraints inside create_table and alter_table blocks.  It also adds
+# relevant metadata about the constraints to a separate table, which the
+# constraint_validations model plugin uses to setup automatic validations.
+#
+# To use this extension, you first need to load it into the database:
+#
+#   DB.extension(:constraint_validations)
+#
+# Note that you should only need to do this when modifying the constraint
+# validations (i.e. when migrating).  You should probably not load this
+# extension in general application code. 
+#
+# You also need to make sure to add the metadata table for the automatic
+# validations.  By default, this table is called sequel_constraint_validations.
+#
+#   DB.create_constraint_validations_table
+#
+# This table should only be created once.  For new applications, you
+# generally want to create it first, before creating any other application
+# tables.
+#
+# Because migrations instance_eval the up and down blocks on a database,
+# using this extension in a migration can be done via:
+#
+#   Sequel.migration do
+#     up do
+#       extension(:constraint_validations)
+#       # ...
+#     end
+#     down do
+#       extension(:constraint_validations)
+#       # ...
+#     end
+#   end
+#
+# However, note that you cannot use change migrations with this extension,
+# you need to use separate up/down migrations.
+#
+# The API for creating the constraints with automatic validations is
+# similar to the validation_helpers model plugin API.  However,
+# instead of having separate validates_* methods, it just adds a validate
+# method that accepts a block to the schema generators.  Like the
+# create_table and alter_table blocks, this block is instance_evaled and
+# offers its own DSL. Example:
+#
+#   DB.create_table(:table) do
+#     Integer :id
+#     String :name
+#
+#     validate do
+#       presence :id
+#       min_length 5, :name
+#     end
+#   end
+#
+# instance_eval is used in this case because create_table and alter_table
+# already use instance_eval, so losing access to the surrounding receiver
+# is not an issue.
+#
+# Here's a breakdown of the constraints created for each constraint validation
+# method:
+#
+# All constraints except unique unless :allow_nil is true :: CHECK column IS NOT NULL
+# presence (String column) :: CHECK trim(column) != ''
+# exact_length 5 :: CHECK char_length(column) = 5
+# min_length 5 :: CHECK char_length(column) >= 5
+# max_length 5 :: CHECK char_length(column) <= 5
+# length_range 3..5 :: CHECK char_length(column) >= 3 AND char_length(column) <= 5
+# length_range 3...5 :: CHECK char_length(column) >= 3 AND char_length(column) < 5
+# format /foo\\d+/ :: CHECK column ~ 'foo\\d+'
+# format /foo\\d+/i :: CHECK column ~* 'foo\\d+'
+# like 'foo%' :: CHECK column LIKE 'foo%'
+# ilike 'foo%' :: CHECK column ILIKE 'foo%'
+# includes ['a', 'b'] :: CHECK column IN ('a', 'b')
+# includes [1, 2] :: CHECK column IN (1, 2)
+# includes 3..5 :: CHECK column >= 3 AND column <= 5
+# includes 3...5 :: CHECK column >= 3 AND column < 5
+# unique :: UNIQUE (column)
+#
+# There are some additional API differences:
+#
+# * Only the :message and :allow_nil options are respected.  The :allow_blank
+#   and :allow_missing options are not respected.
+# * A new option, :name, is respected, for providing the name of the constraint.  It is highly
+#   recommended that you provide a name for all constraint validations, as
+#   otherwise, it is difficult to drop the constraints later.
+# * The includes validation only supports an array of strings, and array of
+#   integers, and a range of integers.
+# * There are like and ilike validations, which are similar to the format
+#   validation but use a case sensitive or case insensitive LIKE pattern. LIKE
+#   patters are very simple, so many regexp patterns cannot be expressed by
+#   them, but only a couple databases (PostgreSQL and MySQL) support regexp
+#   patterns.
+# * When using the unique validation, column names cannot have embedded commas.
+#   For similar reasons, when using an includes validation with an array of
+#   strings, none of the strings in the array can have embedded commas.
+# * The unique validation does not support an arbitrary number of columns.
+#   For a single column, just the symbol should be used, and for an array
+#   of columns, an array of symbols should be used.  There is no support
+#   for creating two separate unique validations for separate columns in
+#   a single call.
+# * A drop method can be called with a constraint name in a alter_table
+#   validate block to drop an existing constraint and the related
+#   validation metadata.
+# * While it is allowed to create a presence constraint with :allow_nil
+#   set to true, doing so does not create a constraint unless the column
+#   has String type.
+#
+# Note that this extension has the following issues on certain databases:
+#
+# * MySQL does not support check constraints (they are parsed but ignored),
+#   so using this extension does not actually set up constraints on MySQL,
+#   except for the unique constraint.  It can still be used on MySQL to
+#   add the validation metadata so that the plugin can setup automatic
+#   validations.
+# * On SQLite, adding constraints to a table is not supported, so it must
+#   be emulated by dropping the table and recreating it with the constraints.
+#   If you want to use this plugin on SQLite with an alter_table block,
+#   you should drop all constraint validation metadata using
+#   <tt>drop_constraint_validations_for(:table=>'table')</tt>, and then
+#   readd all constraints you want to use inside the alter table block,
+#   making no other changes inside the alter_table block.
+
+module Sequel
+  module ConstraintValidations
+    # The default table name used for the validation metadata.
+    DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
+
+    # Set the default validation metadata table name if it has not already
+    # been set.
+    def self.extended(db)
+      db.constraint_validations_table ||= DEFAULT_CONSTRAINT_VALIDATIONS_TABLE
+    end
+
+    # This is the DSL class used for the validate block inside create_table and
+    # alter_table.
+    class Generator
+      # Store the schema generator that encloses this validates block.
+      def initialize(generator)
+        @generator = generator
+      end
+
+      # Create constraint validation methods that don't take an argument 
+      %w'presence unique'.each do |v|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{v}(columns, opts={})
+            @generator.validation({:type=>:#{v}, :columns=>Array(columns)}.merge(opts))
+          end
+        END
+      end
+
+      # Create constraint validation methods that take an argument 
+      %w'exact_length min_length max_length length_range format like ilike includes'.each do |v|
+        class_eval(<<-END, __FILE__, __LINE__+1)
+          def #{v}(arg, columns, opts={})
+            @generator.validation({:type=>:#{v}, :columns=>Array(columns), :arg=>arg}.merge(opts))
+          end
+        END
+      end
+
+      # Given the name of a constraint, drop that constraint from the database,
+      # and remove the related validation metadata.
+      def drop(constraint)
+        @generator.validation({:type=>:drop, :name=>constraint})
+      end
+
+      # Alias of instance_eval for a nicer API.
+      def process(&block)
+        instance_eval(&block)
+      end
+    end
+
+    # Additional methods for the create_table generator to support constraint validations.
+    module CreateTableGeneratorMethods
+      # An array of stored validation metadata, used later by the database to create
+      # constraints.
+      attr_reader :validations
+
+      # Add a validation metadata hash to the stored array.
+      def validation(opts)
+        @validations << opts
+      end
+
+      # Call into the validate DSL for creating constraint validations.
+      def validate(&block)
+        Generator.new(self).process(&block)
+      end
+    end
+
+    # Additional methods for the alter_table generator to support constraint validations,
+    # used to give it a more similar API to the create_table generator.
+    module AlterTableGeneratorMethods
+      include CreateTableGeneratorMethods
+
+      # Alias of add_constraint for similarity to create_table generator.
+      def constraint(*args)
+        add_constraint(*args)
+      end
+
+      # Alias of add_unique_constraint for similarity to create_table generator.
+      def unique(*args)
+        add_unique_constraint(*args)
+      end
+    end
+
+    # The name of the table storing the validation metadata.  If modifying this
+    # from the default, this should be changed directly after loading the
+    # extension into the database
+    attr_accessor :constraint_validations_table
+
+    # Create the table storing the validation metadata for all of the
+    # constraints created by this extension.
+    def create_constraint_validations_table
+      create_table(constraint_validations_table) do
+        String :table, :null=>false
+        String :constraint_name
+        String :validation_type, :null=>false
+        String :column, :null=>false
+        String :argument
+        String :message
+        TrueClass :allow_nil
+      end
+    end
+
+    # Drop the constraint validations table.
+    def drop_constraint_validations_table
+      drop_table(constraint_validations_table)
+    end
+
+    # Delete validation metadata for specific constraints.  At least
+    # one of the following options should be specified:
+    #
+    # :table :: The table containing the constraint
+    # :column :: The column affected by the constraint
+    # :constraint :: The name of the related constraint
+    #
+    # The main reason for this method is when dropping tables
+    # or columns.  If you have previously defined a constraint
+    # validation on the table or column, you should delete the
+    # related metadata when dropping the table or column.
+    # For a table, this isn't a big issue, as it will just result
+    # in some wasted space, but for columns, if you don't drop
+    # the related metadata, it could make it impossible to save
+    # rows, since a validation for a nonexistent column will be
+    # created.
+    def drop_constraint_validations_for(opts={})
+      ds = from(constraint_validations_table)
+      if table = opts[:table]
+        ds = ds.where(:table=>constraint_validations_literal_table(table))
+      end
+      if column = opts[:column]
+        ds = ds.where(:column=>column.to_s)
+      end
+      if constraint = opts[:constraint]
+        ds = ds.where(:constraint_name=>constraint.to_s)
+      end
+      unless table || column || constraint
+        raise Error, "must specify :table, :column, or :constraint when dropping constraint validations"
+      end
+      ds.delete
+    end
+
+    private
+
+    # Modify the default create_table generator to include
+    # the constraint validation methods.
+    def alter_table_generator(&block)
+      super do
+        extend AlterTableGeneratorMethods
+        @validations = []
+        instance_eval(&block) if block
+      end
+    end
+
+    # After running all of the table alteration statements,
+    # if there were any constraint validations, run table alteration
+    # statements to create related constraints.  This is purposely
+    # run after the other statements, as the presence validation
+    # in alter table requires introspecting the modified model
+    # schema.
+    def apply_alter_table_generator(name, generator)
+      super
+      unless generator.validations.empty?
+        gen = alter_table_generator
+        process_generator_validations(name, gen, generator.validations)
+        apply_alter_table(name, gen.operations)
+      end
+    end
+
+    # The value of a blank string.  An empty string by default, but nil
+    # on Oracle as Oracle treats the empty string as NULL.
+    def blank_string_value
+      if database_type == :oracle
+        nil
+      else
+        ''
+      end
+    end
+
+    # Return an unquoted literal form of the table name.
+    # This allows the code to handle schema qualified tables,
+    # without quoting all table names.
+    def constraint_validations_literal_table(table)
+      ds = dataset
+      ds.quote_identifiers = false
+      ds.literal(table)
+    end
+
+    # Before creating the table, add constraints for all of the
+    # generators validations to the generator.
+    def create_table_from_generator(name, generator, options)
+      unless generator.validations.empty?
+        process_generator_validations(name, generator, generator.validations)
+      end
+      super
+    end
+
+    # Modify the default create_table generator to include
+    # the constraint validation methods.
+    def create_table_generator(&block)
+      super do
+        extend CreateTableGeneratorMethods
+        @validations = []
+        instance_eval(&block) if block
+      end
+    end
+
+    # For the given table, generator, and validations, add constraints
+    # to the generator for each of the validations, as well as adding
+    # validation metadata to the constraint validations table.
+    def process_generator_validations(table, generator, validations)
+      drop_rows = []
+      rows = validations.map do |val|
+        columns, arg, constraint, validation_type, message, allow_nil = val.values_at(:columns, :arg, :name, :type, :message, :allow_nil)
+
+        case validation_type
+        when :presence
+          string_check = columns.select{|c| generator_string_column?(generator, table, c)}.map{|c| [Sequel.trim(c), blank_string_value]}
+          generator_add_constraint_from_validation(generator, val, (Sequel.negate(string_check) unless string_check.empty?))
+        when :exact_length
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {Sequel.char_length(c) => arg}}))
+        when :min_length
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) >= arg}))
+        when :max_length
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) <= arg}))
+        when :length_range
+          op = arg.exclude_end? ? :< : :<=
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).send(op, arg.end)}))
+          arg = "#{arg.begin}..#{'.' if arg.exclude_end?}#{arg.end}"
+        when :format
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          if arg.casefold?
+            validation_type = :iformat
+          end
+          arg = arg.source
+        when :includes
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          if arg.is_a?(Range)
+            if (b = arg.begin).is_a?(Integer) && (e = arg.end).is_a?(Integer)
+              validation_type = :includes_int_range
+              arg = "#{arg.begin}..#{'.' if arg.exclude_end?}#{arg.end}"
+            else
+              raise Error, "validates includes with a range only supports integers currently, cannot handle: #{arg.inspect}"
+            end
+          elsif arg.is_a?(Array)
+            if arg.all?{|x| x.is_a?(Integer)}
+              validation_type = :includes_int_array
+            elsif arg.all?{|x| x.is_a?(String)}
+              validation_type = :includes_str_array
+            else
+              raise Error, "validates includes with an array only supports strings and integers currently, cannot handle: #{arg.inspect}"
+            end
+            arg = arg.join(',')
+          else
+            raise Error, "validates includes only supports arrays and ranges currently, cannot handle: #{arg.inspect}"
+          end
+        when :like, :ilike
+          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.send(validation_type, c, arg)}))
+        when :unique
+          generator.unique(columns, :name=>constraint)
+          columns = [columns.join(',')]
+        when :drop
+          if generator.is_a?(Sequel::Schema::AlterTableGenerator)
+            unless constraint
+              raise Error, 'cannot drop a constraint validation without a constraint name'
+            end
+            generator.drop_constraint(constraint)
+            drop_rows << [constraint_validations_literal_table(table), constraint.to_s]
+            columns = []
+          else
+            raise Error, 'cannot drop a constraint validation in a create_table generator'
+          end
+        else
+          raise Error, "invalid or missing validation type: #{val.inspect}"
+        end
+
+        columns.map do  |column|
+          {:table=>constraint_validations_literal_table(table), :constraint_name=>(constraint.to_s if constraint), :validation_type=>validation_type.to_s, :column=>column.to_s, :argument=>(arg.to_s if arg), :message=>(message.to_s if message), :allow_nil=>allow_nil}
+        end
+      end
+
+      ds = from(:sequel_constraint_validations)
+      ds.multi_insert(rows.flatten)
+      unless drop_rows.empty?
+        ds.where([:table, :constraint_name]=>drop_rows).delete
+      end
+    end
+
+    # Add the constraint to the generator, including a NOT NULL constraint
+    # for all columns unless the :allow_nil option is given.
+    def generator_add_constraint_from_validation(generator, val, cons)
+      unless val[:allow_nil]
+        nil_cons = Sequel.negate(val[:columns].map{|c| [c, nil]})
+        cons = cons ? Sequel.&(nil_cons, cons) : nil_cons
+      end
+
+      if cons
+        generator.constraint(val[:name], cons)
+      end
+    end
+
+
+    # Introspect the generator to determine if column
+    # created is a string or not.
+    def generator_string_column?(generator, table, c)
+      if generator.is_a?(Sequel::Schema::AlterTableGenerator)
+        # This is the alter table case, which runs after the
+        # table has been altered, so just check the database
+        # schema for the column.
+        schema(table).each do |col, sch|
+          if col == c
+            return sch[:type] == :string
+          end
+        end
+        false
+      else
+        # This is the create table case, check the metadata
+        # for the column to be created to see if it is a string.
+        generator.columns.each do |col|
+          if col[:name] == c
+            return [String, :text, :varchar].include?(col[:type])
+          end
+        end
+        false
+      end
+    end
+  end
+
+  Database.register_extension(:constraint_validations, ConstraintValidations)
+end