sequel 2.11.0 → 2.12.0

data/lib/{sequel_core → sequel}/core_sql.rb

@@ -1,12 +1,34 @@
+# Sequel extends the Array class to add methods to implement the SQL DSL.
+# Most of these methods require that the array not be empty and that it
+# must consist solely of other arrays that have exactly two elements.
 class Array
-  # Return a Sequel::SQL::BooleanExpression created from this array, not matching any of the
+  # Return a Sequel::SQL::BooleanExpression created from this array, not matching all of the
   # conditions.
+  #
+  #   ~[[:a, true]] # SQL: a IS NOT TRUE
+  #   ~[[:a, 1], [:b, [2, 3]]] # SQL: a != 1 OR b NOT IN (2, 3)
   def ~
     sql_expr_if_all_two_pairs(:OR, true)
   end
 
+  # True if the array is not empty and all of its elements are
+  # arrays of size 2, false otherwise.  This is used to determine if the array
+  # could be a specifier of conditions, used similarly to a hash
+  # but allowing for duplicate keys and a specific order.
+  #
+  #    [].to_a.all_two_pairs? # => false
+  #    [:a].to_a.all_two_pairs? # => false
+  #    [[:b]].to_a.all_two_pairs? # => false
+  #    [[:a, 1]].to_a.all_two_pairs? # => true
+  def all_two_pairs?
+    !empty? && all?{|i| (Array === i) && (i.length == 2)}
+  end
+
   # Return a Sequel::SQL::CaseExpression with this array as the conditions and the given
-  # default value.
+  # default value and expression.
+  #
+  #   [[{:a=>[2,3]}, 1]].case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+  #   [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
   def case(default, expression = nil)
     ::Sequel::SQL::CaseExpression.new(self, default, expression)
   end
@@ -14,24 +36,37 @@ class Array
   # Return a Sequel::SQL::Array created from this array.  Used if this array contains
   # all two pairs and you want it treated as an SQL array instead of a ordered hash-like
   # conditions.
+  #
+  #   [[1, 2], [3, 4]] # SQL: 1 = 2 AND 3 = 4
+  #   [[1, 2], [3, 4]].sql_array # SQL: ((1, 2), (3, 4))
   def sql_array
     ::Sequel::SQL::SQLArray.new(self)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this array, matching all of the
-  # conditions.
+  # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+  # assumes that arrays of all two pairs specify this type of condition.
+  #
+  #   [[:a, true]].sql_expr # SQL: a IS TRUE
+  #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
   def sql_expr
     sql_expr_if_all_two_pairs
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this array, matching none
   # of the conditions.
+  #
+  #   [[:a, true]].sql_negate # SQL: a IS NOT TRUE
+  #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
   def sql_negate
     sql_expr_if_all_two_pairs(:AND, true)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this array, matching any of the
   # conditions.
+  #
+  #   [[:a, true]].sql_or # SQL: a IS TRUE
+  #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: a = 1 OR b IN (2, 3)
   def sql_or
     sql_expr_if_all_two_pairs(:OR)
   end
@@ -39,28 +74,23 @@ class Array
   # Return a Sequel::SQL::BooleanExpression representing an SQL string made up of the
   # concatenation of this array's elements.  If an argument is passed
   # it is used in between each element of the array in the SQL
-  # concatenation.
+  # concatenation.  This does not require that the array be made up of all two pairs.
+  #
+  #   [:a].sql_string_join # SQL: a
+  #   [:a, :b].sql_string_join # SQL: a || b
+  #   [:a, 'b'].sql_string_join # SQL: a || 'b'
+  #   ['a', :b].sql_string_join(' ') # SQL: 'a' || ' ' || b
   def sql_string_join(joiner=nil)
     if joiner
-      args = self.inject([]) do |m, a|
-        m << a
-        m << joiner
-      end
+      args = zip([joiner]*length).flatten
       args.pop
     else
       args = self
     end
-    args = args.collect{|a| a.is_one_of?(Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass) ? a : a.to_s}
+    args = args.collect{|a| [Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass].any?{|c| a.is_a?(c)} ? a : a.to_s}
     ::Sequel::SQL::StringExpression.new(:'||', *args)
   end
 
-  # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
-  # comments are removed, as well as excessive white-space.
-  def to_sql
-    map {|l| ((m = /^(.*)--/.match(l)) ? m[1] : l).chomp}.join(' '). \
-      gsub(/\/\*.*\*\//, '').gsub(/\s+/, ' ').strip
-  end
-
   private
 
   # Raise an error if this array is not made up of all two pairs, otherwise create a Sequel::SQL::BooleanExpression from this array.
@@ -70,10 +100,14 @@ class Array
   end
 end
 
+# Sequel extends the Hash class to add methods to implement the SQL DSL.
 class Hash
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching
   # all of the conditions in this hash and the condition specified by
   # the given argument.
+  #
+  #   {:a=>1} & :b # SQL: a = 1 AND b
+  #   {:a=>true} & ~:b # SQL: a IS TRUE AND NOT b
   def &(ce)
     ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
   end
@@ -81,12 +115,18 @@ class Hash
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching
   # all of the conditions in this hash or the condition specified by
   # the given argument.
+  #
+  #   {:a=>1} | :b # SQL: a = 1 OR b
+  #   {:a=>true} | ~:b # SQL: a IS TRUE OR NOT b
   def |(ce)
     ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
   end
 
-  # Return a Sequel::SQL::BooleanExpression created from this hash, not matching any of the
+  # Return a Sequel::SQL::BooleanExpression created from this hash, not matching all of the
   # conditions.
+  #
+  #   ~{:a=>true} # SQL: a IS NOT TRUE
+  #   ~{:a=>1, :b=>[2, 3]} # SQL: a != 1 OR b NOT IN (2, 3)
   def ~
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
   end
@@ -94,29 +134,44 @@ class Hash
   # Return a Sequel::SQL::CaseExpression with this hash as the conditions and the given
   # default value.  Note that the order of the conditions will be arbitrary, so all
   # conditions should be orthogonal.
+  #
+  #   {{:a=>[2,3]}=>1}.case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+  #   {:a=>1, {:b=>2}].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+  #                                 #  or: CASE c WHEN b THEN 2 WHEN a THEN 1 ELSE d END
   def case(default, expression = nil)
     ::Sequel::SQL::CaseExpression.new(to_a, default, expression)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the
-  # conditions.
+  # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+  # assumes that hashes specify this type of condition.
+  #
+  #   {:a=>true}.sql_expr # SQL: a IS TRUE
+  #   {:a=>1, :b=>[2, 3]}.sql_expr # SQL: a = 1 AND b IN (2, 3)
   def sql_expr
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching none
   # of the conditions.
+  #
+  #   {:a=>true}.sql_negate # SQL: a IS NOT TRUE
+  #   {:a=>1, :b=>[2, 3]}.sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
   def sql_negate
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching any of the
   # conditions.
+  #
+  #   {:a=>true}.sql_or # SQL: a IS TRUE
+  #   {:a=>1, :b=>[2, 3]}.sql_or # SQL: a = 1 OR b IN (2, 3)
   def sql_or
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
   end
 end
 
+# Sequel extends the String class to add methods to implement the SQL DSL.
 class String
   include Sequel::SQL::AliasMethods
   include Sequel::SQL::CastMethods
@@ -137,28 +192,15 @@ class String
   def lit(*args)
     args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
   end
-  alias_method :expr, :lit
   
-  # Splits a string into separate SQL statements, removing comments
-  # and excessive white-space.
-  def split_sql
-    to_sql.split(';').map {|s| s.strip}
-  end
-
-  # Converts a string into an SQL string by removing comments.
-  # See also Array#to_sql.
-  def to_sql
-    split("\n").to_sql
-  end
-
-  # Returns a Blob that holds the same data as this string. Blobs provide proper
+  # Returns a Sequel::SQL::Blob that holds the same data as this string. Blobs provide proper
   # escaping of binary data.
   def to_sequel_blob
-    ::Sequel::SQL::Blob.new self
+    ::Sequel::SQL::Blob.new(self)
   end
-  alias to_blob to_sequel_blob
 end
 
+# Sequel extends the Symbol class to add methods to implement the SQL DSL.
 class Symbol
   include Sequel::SQL::QualifyingMethods
   include Sequel::SQL::IdentifierMethods
@@ -175,32 +217,32 @@ class Symbol
   # columns for this table.
   # If an argument is given, returns a Sequel::SQL::NumericExpression using the *
   # (multiplication) operator with this and the given argument.
+  # 
+  #   :table.* # SQL: table.*
+  #   :column * 2 # SQL: column * 2
   def *(ce=(arg=false;nil))
     return super(ce) unless arg == false
     Sequel::SQL::ColumnAll.new(self);
   end
 
   # Returns a Sequel::SQL::Function  with this as the function name,
-  # and the given arguments. This is aliased as Symbol#[] if ruby 1.9
-  # is not being used.  ruby 1.9 includes Symbol#[], and Sequel
+  # and the given arguments. This is aliased as Symbol#[] if the RUBY_VERSION
+  # is less than 1.9.0. Ruby 1.9 defines Symbol#[], and Sequel
   # doesn't override methods defined by ruby itself.
+  #
+  #   :now.sql_function # SQL: now()
+  #   :sum.sql_function(:a) # SQL: sum(a)
+  #   :concat.sql_function(:a, :b) # SQL: concat(a, b)
   def sql_function(*args)
     Sequel::SQL::Function.new(self, *args)
   end
   alias_method(:[], :sql_function) if RUBY_VERSION < '1.9.0'
 
-  # If the given argument is an Integer or an array containing an Integer, returns
-  # a Sequel::SQL::Subscript with this column and the given arg.
-  # Otherwise returns a Sequel::SQL::BooleanExpression where this column (which should be boolean)
-  # or the given argument is true.
-  def |(sub)
-    return super unless (Integer === sub) || ((Array === sub) && sub.any?{|x| Integer === x})
-    Sequel::SQL::Subscript.new(self, Array(sub))
-  end
-  
-  # Delegate the creation of the resulting SQL to the given dataset,
-  # since it may be database dependent.
-  def to_column_ref(ds)
-    ds.symbol_to_column_ref(self)
+  # Return an SQL array subscript with the given arguments.
+  #
+  #   :array.sql_subscript(1) # SQL: array[1]
+  #   :array.sql_subscript(1, 2) # SQL: array[1, 2]
+  def sql_subscript(*sub)
+    Sequel::SQL::Subscript.new(self, sub.flatten)
   end
 end

data/lib/{sequel_core → sequel}/database.rb

@@ -1,6 +1,8 @@
-require 'sequel_core/database/schema'
-
 module Sequel
+  # Hash of adapters that have been used. The key is the adapter scheme
+  # symbol, and the value is the Database subclass.
+  ADAPTER_MAP = {}
+    
   # Array of all databases to which Sequel has connected.  If you are
   # developing an application that can connect to an arbitrary number of 
   # databases, delete the database objects from this or they will not get
@@ -11,7 +13,8 @@ module Sequel
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
   class Database
-    include Schema::SQL
+    extend Metaprogramming
+    include Metaprogramming
 
     # Array of supported database adapters
     ADAPTERS = %w'ado db2 dbi do firebird informix jdbc mysql odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym}
@@ -20,9 +23,6 @@ module Sequel
     SQL_COMMIT = 'COMMIT'.freeze
     SQL_ROLLBACK = 'ROLLBACK'.freeze
 
-    # Hash of adapters that have been used
-    @@adapters = Hash.new
-    
     # The identifier input method to use by default
     @@identifier_input_method = nil
 
@@ -35,7 +35,7 @@ module Sequel
     # Whether to quote identifiers (columns and tables) by default
     @@quote_identifiers = nil
 
-    # The default schema to use
+    # The default schema to use, generally should be nil.
     attr_accessor :default_schema
 
     # Array of SQL loggers to use for this database
@@ -63,7 +63,6 @@ module Sequel
     # * :loggers : An array of loggers to use.
     # * :quote_identifiers : Whether to quote identifiers
     # * :single_threaded : Whether to use a single-threaded connection pool
-    # * :upcase_identifiers : Whether to upcase identifiers going into the database
     #
     # All options given are also passed to the ConnectionPool.  If a block
     # is given, it is used as the connection_proc for the ConnectionPool.
@@ -79,6 +78,7 @@ module Sequel
       @identifier_output_method = nil
       @quote_identifiers = nil
       if opts.include?(:upcase_identifiers)
+        Deprecation.deprecate('The :upcase_identifiers Database option', 'Use the :identifier_input_method => :upcase option instead')
         @identifier_input_method = opts[:upcase_identifiers] ? :upcase : ""
       end
       @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
@@ -92,25 +92,25 @@ module Sequel
     ### Class Methods ###
 
     # The Database subclass for the given adapter scheme.
-    # Raises Sequel::Error::AdapterNotFound if the adapter
+    # Raises Sequel::AdapterNotFound if the adapter
     # could not be loaded.
     def self.adapter_class(scheme)
       scheme = scheme.to_s.gsub('-', '_').to_sym
       
-      if (klass = @@adapters[scheme]).nil?
+      unless klass = ADAPTER_MAP[scheme]
         # attempt to load the adapter file
         begin
-          require "sequel_core/adapters/#{scheme}"
+          Sequel.require "adapters/#{scheme}"
         rescue LoadError => e
-          raise Error::AdapterNotFound, "Could not load #{scheme} adapter:\n  #{e.message}"
+          raise AdapterNotFound, "Could not load #{scheme} adapter:\n  #{e.message}"
         end
         
         # make sure we actually loaded the adapter
-        if (klass = @@adapters[scheme]).nil?
-          raise Error::AdapterNotFound, "Could not load #{scheme} adapter"
+        unless klass = ADAPTER_MAP[scheme]
+          raise AdapterNotFound, "Could not load #{scheme} adapter"
         end
       end
-      return klass
+      klass
     end
         
     # Returns the scheme for the Database class.
@@ -121,11 +121,8 @@ module Sequel
     # Connects to a database.  See Sequel.connect.
     def self.connect(conn_string, opts = {}, &block)
       if conn_string.is_a?(String)
-        if conn_string =~ /\Ajdbc:/
-          c = adapter_class(:jdbc)
-          opts = {:uri=>conn_string}.merge(opts)
-        elsif conn_string =~ /\Ado:/
-          c = adapter_class(:do)
+        if match = /\A(jdbc|do):/o.match(conn_string)
+          c = adapter_class(match[1].to_sym)
           opts = {:uri=>conn_string}.merge(opts)
         else
           uri = URI.parse(conn_string)
@@ -133,7 +130,7 @@ module Sequel
           scheme = :dbi if scheme =~ /\Adbi-/
           c = adapter_class(scheme)
           uri_options = {}
-          uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.blank?
+          uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.to_s.strip.empty?
           opts = c.send(:uri_to_options, uri).merge(uri_options).merge(opts)
         end
       else
@@ -165,6 +162,7 @@ module Sequel
     end
     
     # Set the method to call on identifiers going into the database
+    # See Sequel.identifier_input_method=.
     def self.identifier_input_method=(v)
       @@identifier_input_method = v || ""
     end
@@ -175,6 +173,7 @@ module Sequel
     end
     
     # Set the method to call on identifiers coming from the database
+    # See Sequel.identifier_output_method=.
     def self.identifier_output_method=(v)
       @@identifier_output_method = v || ""
     end
@@ -191,16 +190,10 @@ module Sequel
       @@single_threaded = value
     end
 
-    # Sets the default quote_identifiers mode for new databases.
-    # See Sequel.quote_identifiers=.
-    def self.upcase_identifiers=(value)
-      self.identifier_input_method = value ? :upcase : nil
-    end
-
     ### Private Class Methods ###
 
     # Sets the adapter scheme for the Database class. Call this method in
-    # descendnants of Database to allow connection using a URL. For example the
+    # descendants of Database to allow connection using a URL. For example the
     # following:
     #
     #   class Sequel::MyDB::Database < Sequel::Database
@@ -213,7 +206,7 @@ module Sequel
     #   Sequel.connect('mydb://user:password@dbserver/mydb')
     def self.set_adapter_scheme(scheme) # :nodoc:
       @scheme = scheme
-      @@adapters[scheme.to_sym] = self
+      ADAPTER_MAP[scheme.to_sym] = self
     end
     
     # Converts a uri to an options hash. These options are then passed
@@ -230,10 +223,9 @@ module Sequel
     
     ### Instance Methods ###
 
-    # Executes the supplied SQL statement. The SQL can be supplied as a string
-    # or as an array of strings. If an array is given, comments and excessive 
-    # white space are removed. See also Array#to_sql.
+    # Executes the supplied SQL statement string.
     def <<(sql)
+      Deprecation.deprecate('Passing an array argument to Database#<<', 'Use array.each{|x| database << x}') if Array === sql
       execute_ddl((Array === sql) ? sql.to_sql : sql)
     end
     
@@ -241,14 +233,14 @@ module Sequel
     # the method acts as an alias for Database#fetch, returning a dataset for
     # arbitrary SQL:
     #
-    #   DB['SELECT * FROM items WHERE name = ?', my_name].print
+    #   DB['SELECT * FROM items WHERE name = ?', my_name].all
     #
     # Otherwise, acts as an alias for Database#from, setting the primary
     # table for the dataset:
     #
     #   DB[:items].sql #=> "SELECT * FROM items"
-    def [](*args, &block)
-      (String === args.first) ? fetch(*args, &block) : from(*args, &block)
+    def [](*args)
+      (String === args.first) ? fetch(*args) : from(*args)
     end
     
     # Call the prepared statement with the given name with the given hash
@@ -262,36 +254,40 @@ module Sequel
       raise NotImplementedError, "#connect should be overridden by adapters"
     end
     
-    # Returns a blank dataset
+    # Returns a blank dataset for this database
     def dataset
       ds = Sequel::Dataset.new(self)
     end
     
-    # Disconnects all available connections from the connection pool.  If any
-    # connections are currently in use, they will not be disconnected.
+    # Disconnects all available connections from the connection pool.  Any
+    # connections currently in use will not be disconnected.
     def disconnect
       pool.disconnect
     end
 
-    # Executes the given SQL. This method should be overridden in descendants.
+    # Executes the given SQL on the database. This method should be overridden in descendants.
+    # This method should not be called directly by user code.
     def execute(sql, opts={})
       raise NotImplementedError, "#execute should be overridden by adapters"
     end
     
     # Method that should be used when submitting any DDL (Data Definition
     # Language) SQL.  By default, calls execute_dui.
+    # This method should not be called directly by user code.
     def execute_ddl(sql, opts={}, &block)
       execute_dui(sql, opts, &block)
     end
 
     # Method that should be used when issuing a DELETE, UPDATE, or INSERT
     # statement.  By default, calls execute.
+    # This method should not be called directly by user code.
     def execute_dui(sql, opts={}, &block)
       execute(sql, opts, &block)
     end
 
     # Method that should be used when issuing a INSERT
     # statement.  By default, calls execute_dui.
+    # This method should not be called directly by user code.
     def execute_insert(sql, opts={}, &block)
       execute_dui(sql, opts, &block)
     end
@@ -303,19 +299,17 @@ module Sequel
     #
     # The method returns a dataset instance:
     #
-    #   DB.fetch('SELECT * FROM items').print
+    #   DB.fetch('SELECT * FROM items').all
     #
     # Fetch can also perform parameterized queries for protection against SQL
     # injection:
     #
-    #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).print
+    #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).all
     def fetch(sql, *args, &block)
-      ds = dataset
-      ds.opts[:sql] = Sequel::SQL::PlaceholderLiteralString.new(sql, args)
+      ds = dataset.with_sql(sql, *args)
       ds.each(&block) if block
       ds
     end
-    alias_method :>>, :fetch
     
     # Returns a new dataset with the from method invoked. If a block is given,
     # it is used as a filter on the dataset.
@@ -331,8 +325,8 @@ module Sequel
     #
     #   # SELECT version()
     #   DB.get(:version.sql_function) #=> ...
-    def get(expr)
-      dataset.get(expr)
+    def get(*args, &block)
+      dataset.get(*args, &block)
     end
     
     # The method to call on identifiers going into the database
@@ -380,6 +374,11 @@ module Sequel
       "#<#{self.class}: #{(uri rescue opts).inspect}>" 
     end
 
+    # Proxy the literal call to the dataset, used for default values.
+    def literal(v)
+      schema_utility_dataset.literal(v)
+    end
+
     # Log a message at level info to all loggers.  All SQL logging
     # goes through this method.
     def log_info(message, args=nil)
@@ -387,27 +386,11 @@ module Sequel
       @loggers.each{|logger| logger.info(message)}
     end
 
-    # Return the first logger or nil if no loggers are being used.
-    # Should only be used for backwards compatibility.
-    def logger
-      @loggers.first
-    end
-
-    # Replace the array of loggers with the given logger(s).
+    # Remove any existing loggers and just use the given logger.
     def logger=(logger)
       @loggers = Array(logger)
     end
 
-    # Returns true unless the database is using a single-threaded connection pool.
-    def multi_threaded?
-      !@single_threaded
-    end
-    
-    # Returns a dataset modified by the given query block.  See Dataset#query.
-    def query(&block)
-      dataset.query(&block)
-    end
-    
     # Whether to quote identifiers (columns and tables) for this database
     def quote_identifiers=(v)
       reset_schema_utility_dataset
@@ -421,15 +404,64 @@ module Sequel
     end
     
     # Returns a new dataset with the select method invoked.
-    def select(*args)
-      dataset.select(*args)
+    def select(*args, &block)
+      dataset.select(*args, &block)
     end
     
-    # Default serial primary key options.
-    def serial_primary_key_options
-      {:primary_key => true, :type => Integer, :auto_increment => true}
+    # 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:
+    #
+    # * :reload - Get fresh information from the database, instead of using
+    #   cached information.  If table_name is blank, :reload should be used
+    #   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.
+    # * :schema - An explicit schema to use.  It may also be implicitly provided
+    #   via the table name.
+    def schema(table = nil, opts={})
+      Deprecation.deprecate('Calling Database#schema without a table argument', 'Use database.tables.inject({}){|h, m| h[m] = database.schema(m); h}') unless table
+      raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
+
+      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(quoted_name)
+        else
+          @schemas = nil
+        end
+      end
+
+      if @schemas
+        if table_name
+          return @schemas[quoted_name] if @schemas[quoted_name]
+        else
+          return @schemas
+        end
+      end
+
+      raise(Error, '#tables does not exist, you must provide a specific table to #schema') if table.nil? && !respond_to?(:tables, true)
+
+      @schemas ||= Hash.new do |h,k|
+        quote_name = quote_schema_table(k)
+        h[quote_name] if h.include?(quote_name)
+      end
+
+      if table_name
+        cols = schema_parse_table(table_name, opts)
+        raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+        @schemas[quoted_name] = cols
+      else
+        tables.each{|t| @schemas[quote_schema_table(t)] = schema_parse_table(t.to_s, opts)}
+        @schemas
+      end
     end
-    
+
     # Returns true if the database is using a single-threaded connection pool.
     def single_threaded?
       @single_threaded
@@ -467,8 +499,12 @@ module Sequel
     # supported - calling #transaction within a transaction will reuse the 
     # current transaction. Should be overridden for databases that support nested 
     # transactions.
-    def transaction(server=nil)
-      synchronize(server) do |conn|
+    def transaction(opts={})
+      unless opts.is_a?(Hash)
+        Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+        opts = {:server=>opts}
+      end
+      synchronize(opts[:server]) do |conn|
         return yield(conn) if @transactions.include?(Thread.current)
         log_info(begin_transaction_sql)
         conn.execute(begin_transaction_sql)
@@ -489,90 +525,23 @@ module Sequel
       end
     end
     
-    # Typecast the value to the given column_type. Can be overridden in
-    # adapters to support database specific column types.
-    # This method should raise Sequel::Error::InvalidValue if assigned value
+    # Typecast the value to the given column_type. Calls
+    # typecast_value_#{column_type} if the method exists,
+    # otherwise returns the value.
+    # This method should raise Sequel::InvalidValue if assigned value
     # is invalid.
     def typecast_value(column_type, value)
       return nil if value.nil?
+      meth = "typecast_value_#{column_type}"
       begin
-        case column_type
-        when :integer
-          Integer(value)
-        when :string
-          value.to_s
-        when :float
-          Float(value)
-        when :decimal
-          case value
-          when BigDecimal
-            value
-          when String, Float
-            value.to_d
-          when Integer
-            value.to_s.to_d
-          else
-            raise Sequel::Error::InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
-          end
-        when :boolean
-          case value
-          when false, 0, "0", /\Af(alse)?\z/i
-            false
-          else
-            value.blank? ? nil : true
-          end
-        when :date
-          case value
-          when Date
-            value
-          when DateTime, Time
-            Date.new(value.year, value.month, value.day)
-          when String
-            value.to_date
-          else
-            raise Sequel::Error::InvalidValue, "invalid value for Date: #{value.inspect}"
-          end
-        when :time
-          case value
-          when Time
-            value
-          when String
-            value.to_time
-          else
-            raise Sequel::Error::InvalidValue, "invalid value for Time: #{value.inspect}"
-          end
-        when :datetime
-          raise(Sequel::Error::InvalidValue, "invalid value for Datetime: #{value.inspect}") unless value.is_one_of?(DateTime, Date, Time, String)
-          if Sequel.datetime_class === value
-            # Already the correct class, no need to convert
-            value
-          else
-            # First convert it to standard ISO 8601 time, then
-            # parse that string using the time class.
-            (Time === value ? value.iso8601 : value.to_s).to_sequel_time
-          end
-        when :blob
-          ::Sequel::SQL::Blob.new(value)
-        else
-          value
-        end
-      rescue ArgumentError => exp
-        e = Sequel::Error::InvalidValue.new("#{exp.class} #{exp.message}")
+        respond_to?(meth, true) ? send(meth, value) : value
+      rescue ArgumentError, TypeError => exp
+        e = Sequel::InvalidValue.new("#{exp.class} #{exp.message}")
         e.set_backtrace(exp.backtrace)
         raise e
       end
     end
     
-    # Set whether to upcase identifiers going into the database.
-    def upcase_identifiers=(v)
-      self.identifier_input_method = v ? :upcase : nil
-    end
-
-    # Returns true if the database upcases identifiers.
-    def upcase_identifiers?
-      identifier_input_method == :upcase
-    end
-    
     # Returns the URI identifying the database.
     # This method can raise an error if the database used options
     # instead of a connection string.
@@ -605,6 +574,23 @@ module Sequel
       SQL_BEGIN
     end
 
+    # Returns true when the object is considered blank.
+    # The only objects that are blank are nil, false,
+    # strings with all whitespace, and ones that respond
+    # true to empty?
+    def blank_object?(obj)
+      case obj
+      when NilClass, FalseClass
+        true
+      when Numeric, TrueClass
+        false
+      when String
+        obj.strip.empty?
+      else
+        obj.respond_to?(:empty?) ? obj.empty? : false
+      end
+    end
+
     # SQL to COMMIT a transaction.
     def commit_transaction_sql
       SQL_COMMIT
@@ -636,6 +622,8 @@ module Sequel
       :downcase
     end
     
+    # Whether to quote identifiers by default for this database, true
+    # by default.
     def quote_identifiers_default
       true
     end
@@ -648,7 +636,7 @@ module Sequel
     # Convert the given exception to a DatabaseError, keeping message
     # and traceback.
     def raise_error(exception, opts={})
-      if !opts[:classes] || exception.is_one_of?(*opts[:classes])
+      if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
         e = DatabaseError.new("#{exception.class} #{exception.message}")
         e.set_backtrace(exception.backtrace)
         raise e
@@ -657,11 +645,57 @@ module Sequel
       end
     end
     
+    # Remove the cached schema for the given schema name
+    def remove_cached_schema(table)
+      @schemas.delete(quote_schema_table(table)) if @schemas
+    end
+
+    # Remove the cached schema_utility_dataset, because the identifier
+    # quoting has changed.
+    def reset_schema_utility_dataset
+      @schema_utility_dataset = nil
+    end
+
     # Split the schema information from the table
     def schema_and_table(table_name)
       schema_utility_dataset.schema_and_table(table_name)
     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/io
+        Sequel.convert_tinyint_to_bool ? :boolean : :integer
+      when /\Ainterval\z/io
+        :interval
+      when /\A(character( varying)?|varchar|text)/io
+        :string
+      when /\A(int(eger)?|bigint|smallint)/io
+        :integer
+      when /\Adate\z/io
+        :date
+      when /\A(datetime|timestamp( with(out)? time zone)?)\z/io
+        :datetime
+      when /\Atime( with(out)? time zone)?\z/io
+        :time
+      when /\Aboolean\z/io
+        :boolean
+      when /\A(real|float|double( precision)?)\z/io
+        :float
+      when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/io
+        :decimal
+      when /bytea|blob/io
+        :blob
+      end
+    end
+
+    # The dataset to use for proxying certain schema methods.
+    def schema_utility_dataset
+      @schema_utility_dataset ||= dataset
+    end
+
     # Return the options for the given server by merging the generic
     # options for all server with the specific options for the given
     # server specified in the :servers option.
@@ -682,9 +716,90 @@ module Sequel
       opts
     end
 
-    # Raise a database error unless the exception is an Error::Rollback.
+    # Raise a database error unless the exception is an Rollback.
     def transaction_error(e, *classes)
-      raise_error(e, :classes=>classes) unless Error::Rollback === e
+      raise_error(e, :classes=>classes) unless Rollback === e
+    end
+
+    # Typecast the value to an SQL::Blob
+    def typecast_value_blob(value)
+      value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)
+    end
+
+    # Typecast the value to true, false, or nil
+    def typecast_value_boolean(value)
+      case value
+      when false, 0, "0", /\Af(alse)?\z/i
+        false
+      else
+        blank_object?(value) ? nil : true
+      end
+    end
+
+    # Typecast the value to a Date
+    def typecast_value_date(value)
+      case value
+      when Date
+        value
+      when DateTime, Time
+        Date.new(value.year, value.month, value.day)
+      when String
+        Sequel.string_to_date(value)
+      else
+        raise InvalidValue, "invalid value for Date: #{value.inspect}"
+      end
+    end
+
+    # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
+    def typecast_value_datetime(value)
+      raise(Sequel::InvalidValue, "invalid value for Datetime: #{value.inspect}") unless [DateTime, Date, Time, String].any?{|c| value.is_a?(c)}
+      if Sequel.datetime_class === value
+        # Already the correct class, no need to convert
+       value
+      else
+        # First convert it to standard ISO 8601 time, then
+        # parse that string using the time class.
+        Sequel.string_to_datetime(Time === value ? value.iso8601 : value.to_s)
+      end
+    end
+
+    # Typecast the value to a BigDecimal
+    def typecast_value_decimal(value)
+      case value
+      when BigDecimal
+        value
+      when String, Numeric
+        BigDecimal.new(value.to_s)
+      else
+        raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
+      end
+    end
+
+    # Typecast the value to a Float
+    def typecast_value_float(value)
+      Float(value)
+    end
+
+    # Typecast the value to an Integer
+    def typecast_value_integer(value)
+      Integer(value)
+    end
+
+    # Typecast the value to a String
+    def typecast_value_string(value)
+      value.to_s
+    end
+
+    # Typecast the value to a Time
+    def typecast_value_time(value)
+      case value
+      when Time
+        value
+      when String
+        Sequel.string_to_time(value)
+      else
+        raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
+      end
     end
   end
 end