sequel_core 1.5.1 → 2.0.0

data/lib/sequel_core/dataset.rb

@@ -1,13 +1,6 @@
-require 'time'
-require 'date'
-require 'yaml'
-require 'base64'
-
-require File.join(File.dirname(__FILE__), 'dataset/sql')
-require File.join(File.dirname(__FILE__), 'dataset/sequelizer')
-require File.join(File.dirname(__FILE__), 'dataset/convenience')
-require File.join(File.dirname(__FILE__), 'dataset/callback')
-require File.join(File.dirname(__FILE__), 'dataset/pagination')
+%w'callback convenience pagination query schema sequelizer sql'.each do |f|
+  require "sequel_core/dataset/#{f}"
+end
 
 module Sequel
   # A Dataset represents a view of a the data in a database, constrained by
@@ -16,6 +9,7 @@ module Sequel
   # 
   # Query results are always retrieved on demand, so a dataset can be kept
   # around and reused indefinitely:
+  #
   #   my_posts = DB[:posts].filter(:author => 'david') # no records are retrieved
   #   p my_posts.all # records are now retrieved
   #   ...
@@ -24,6 +18,7 @@ module Sequel
   # In order to provide this functionality, dataset methods such as where, 
   # select, order, etc. return modified copies of the dataset, so you can
   # use different datasets to access data:
+  #
   #   posts = DB[:posts]
   #   davids_posts = posts.filter(:author => 'david')
   #   old_posts = posts.filter('stamp < ?', Date.today - 7)
@@ -34,7 +29,7 @@ module Sequel
   # === The Dataset Adapter Interface
   #
   # Each adapter should define its own dataset class as a descendant of
-  # Sequel::Dataset. The following methods should be overriden by the adapter
+  # Sequel::Dataset. The following methods should be overridden by the adapter
   # Dataset class (each method with the stock implementation):
   #
   #   # Iterate over the results of the SQL query and call the supplied
@@ -66,113 +61,158 @@ module Sequel
   #       @db.execute(delete_sql(opts)).affected_rows
   #     end
   #   end
+  #
+  # === Methods added via metaprogramming
+  #
+  # Some methods are added via metaprogramming:
+  #
+  # * ! methods - These methods are the same as their non-! counterparts,
+  #   but they modify the receiver instead of returning a modified copy
+  #   of the dataset.
+  # * inner_join, full_outer_join, right_outer_join, left_outer_join - 
+  #   This methods are shortcuts to join_table with the join type
+  #   already specified.
   class Dataset
     include Enumerable
-    include Sequelizer
-    include SQL
-    include Convenience
-    include Callback
     
+    # The dataset options that require the removal of cached columns
+    # if changed.
+    COLUMN_CHANGE_OPTS = [:select, :sql, :from, :join].freeze
+
+    # Array of all subclasses of Dataset
+    DATASET_CLASSES = []
+
+    # All methods that should have a ! method added that modifies
+    # the receiver.
+    MUTATION_METHODS = %w'and distinct exclude exists filter from from_self full_outer_join graph
+    group group_and_count group_by having inner_join intersect invert join
+    left_outer_join limit naked or order order_by order_more paginate query reject
+    reverse reverse_order right_outer_join select select_all select_more
+    set_graph_aliases set_model sort sort_by unfiltered union unordered where'.collect{|x| x.to_sym}
+
+    NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
+    STOCK_TRANSFORMS = {
+      :marshal => [
+        # for backwards-compatibility we support also non-base64-encoded values.
+        proc {|v| Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)}, 
+        proc {|v| [Marshal.dump(v)].pack('m')}
+      ],
+      :yaml => [
+        proc {|v| YAML.load v if v}, 
+        proc {|v| v.to_yaml}
+      ]
+    }
+
     attr_accessor :db, :opts, :row_proc
+
+    # Whether to quote identifiers for this dataset
+    attr_writer :quote_identifiers
     
-    alias_method :size, :count
-    
-    # Returns an array with all records in the dataset. If a block is given,
-    # the array is iterated over.
-    def all(opts = nil, &block)
-      a = []
-      each(opts) {|r| a << r}
-      post_load(a)
-      a.each(&block) if block
-      a
-    end
-  
-    # Constructs a new instance of a dataset with a database instance, initial
-    # options and an optional record class. Datasets are usually constructed by
-    # invoking Database methods:
+    # Constructs a new instance of a dataset with an associated database and 
+    # options. Datasets are usually constructed by invoking Database methods:
+    #
     #   DB[:posts]
+    #
     # Or:
+    #
     #   DB.dataset # the returned dataset is blank
     #
     # Sequel::Dataset is an abstract class that is not useful by itself. Each
     # database adaptor should provide a descendant class of Sequel::Dataset.
     def initialize(db, opts = nil)
       @db = db
+      @quote_identifiers = db.quote_identifiers? if db.respond_to?(:quote_identifiers?)
       @opts = opts || {}
       @row_proc = nil
       @transform = nil
     end
     
-    # Returns a new clone of the dataset with with the given options merged.
-    def clone(opts = {})
-      c = super()
-      c.opts = @opts.merge(opts)
-      c.instance_variable_set(:@columns, nil)
-      c
+    ### Class Methods ###
+
+    # The array of dataset subclasses.
+    def self.dataset_classes
+      DATASET_CLASSES
+    end
+
+    # Setup mutation (e.g. filter!) methods.  These operate the same as the
+    # non-! methods, but replace the options of the current dataset with the
+    # options of the resulting dataset.
+    def self.def_mutation_method(*meths)
+      meths.each do |meth|
+        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+      end
+    end
+
+    # Add the subclass to the array of subclasses.
+    def self.inherited(c)
+      DATASET_CLASSES << c
     end
     
-    NOTIMPL_MSG = "This method must be overriden in Sequel adapters".freeze
-    
-    # Executes a select query and fetches records, passing each record to the
-    # supplied block. Adapters should override this method.
-    def fetch_rows(sql, &block)
-      # @db.synchronize do
-      #   r = @db.execute(sql)
-      #   r.each(&block)
-      # end
-      raise NotImplementedError, NOTIMPL_MSG
+    ### Instance Methods ###
+
+    # Alias for insert, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def <<(*args)
+      insert(*args)
     end
-  
-    # Inserts values into the associated table. Adapters should override this
-    # method.
-    def insert(*values)
-      # @db.synchronize do
-      #   @db.execute(insert_sql(*values)).last_insert_id
-      # end
-      raise NotImplementedError, NOTIMPL_MSG
+
+    # Return the dataset as a column with the given alias, so it can be used in the
+    # SELECT clause. This dataset should result in a single row and a single column.
+    def as(a)
+      ::Sequel::SQL::ColumnExpr.new(self, 'AS', a)
     end
-  
-    # Updates values for the dataset. Adapters should override this method.
-    def update(values, opts = nil)
-      # @db.synchronize do
-      #   @db.execute(update_sql(values, opts)).affected_rows
-      # end
-      raise NotImplementedError, NOTIMPL_MSG
+
+    # Returns an array with all records in the dataset. If a block is given,
+    # the array is iterated over after all items have been loaded.
+    def all(opts = nil, &block)
+      a = []
+      each(opts) {|r| a << r}
+      post_load(a)
+      a.each(&block) if block
+      a
     end
   
-    # Deletes the records in the dataset. Adapters should override this method.
-    def delete(opts = nil)
-      # @db.synchronize do
-      #   @db.execute(delete_sql(opts)).affected_rows
-      # end
-      raise NotImplementedError, NOTIMPL_MSG
+    # Returns a new clone of the dataset with with the given options merged.
+    # If the options changed include options in COLUMN_CHANGE_OPTS, the cached
+    # columns are deleted.
+    def clone(opts = {})
+      c = super()
+      c.opts = @opts.merge(opts)
+      c.instance_variable_set(:@columns, nil) unless (opts.keys & COLUMN_CHANGE_OPTS).empty?
+      c
     end
     
-    # Returns the columns in the result set in their true order. The stock 
-    # implementation returns the content of @columns. If @columns is nil,
-    # a query is performed. Adapters are expected to fill @columns with the
-    # column information when a query is performed.
+    # Returns the columns in the result set in their true order.
+    # If the columns are currently cached, returns the cached value. Otherwise,
+    # a SELECT query is performed to get a single row. Adapters are expected
+    # to fill the columns cache with the column information when a query is performed.
+    # If the dataset does not have any rows, this will be an empty array.
+    # If you are looking for all columns for a single table, see Schema::SQL#schema.
     def columns
-      first unless @columns
+      single_record unless @columns
       @columns || []
     end
     
+    # Remove the cached list of columns and do a SELECT query to find
+    # the columns.
     def columns!
-      first
-      @columns || []
+      @columns = nil
+      columns
     end
     
-    # Inserts the supplied values into the associated table.
-    def <<(*args)
-      insert(*args)
+    # Add a mutation method to this dataset instance.
+    def def_mutation_method(*meths)
+      meths.each do |meth|
+        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+      end
     end
-  
-    # Updates the dataset with the given values.
-    def set(*args, &block)
-      update(*args, &block)
+
+    # Deletes the records in the dataset. Adapters should override this method.
+    def delete(opts = nil)
+      raise NotImplementedError, NOTIMPL_MSG
     end
     
-    # Iterates over the records in the dataset
+    # Iterates over the records in the dataset.
     def each(opts = nil, &block)
       if graph = @opts[:graph]
         graph_each(opts, &block)
@@ -188,25 +228,56 @@ module Sequel
       self
     end
 
+    # Executes a select query and fetches records, passing each record to the
+    # supplied block. Adapters should override this method.
+    def fetch_rows(sql, &block)
+      raise NotImplementedError, NOTIMPL_MSG
+    end
+  
+    # Inserts values into the associated table. Adapters should override this
+    # method.
+    def insert(*values)
+      raise NotImplementedError, NOTIMPL_MSG
+    end
+  
+    # Returns a string representation of the dataset including the class name 
+    # and the corresponding SQL select statement.
+    def inspect
+      "#<#{self.class}: #{sql.inspect}>"
+    end
+
     # Returns the the model classes associated with the dataset as a hash.
+    # If the dataset is associated with a single model class, a key of nil
+    # is used.  For datasets with polymorphic models, the keys are
+    # values of the polymorphic column and the values are the corresponding
+    # model classes to which they map.
     def model_classes
       @opts[:models]
     end
     
+    # Returns a naked dataset clone - i.e. a dataset that returns records as
+    # hashes rather than model objects.
+    def naked
+      clone.set_model(nil)
+    end
+    
     # Returns the column name for the polymorphic key.
     def polymorphic_key
       @opts[:polymorphic_key]
     end
     
-    # Returns a naked dataset clone - i.e. a dataset that returns records as
-    # hashes rather than model objects.
-    def naked
-      d = clone(:naked => true, :models => nil, :polymorphic_key => nil)
-      d.set_model(nil)
-      d
+    # Whether this dataset quotes identifiers.
+    def quote_identifiers?
+      @quote_identifiers
     end
-    
-    # Associates or disassociates the dataset with a model. If no argument or
+
+    # Alias for set, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def set(*args, &block)
+      update(*args, &block)
+    end
+
+    # Associates or disassociates the dataset with a model(s). If
     # nil is specified, the dataset is turned into a naked dataset and returns
     # records as hashes. If a model class specified, the dataset is modified
     # to return records as instances of the model class, e.g:
@@ -241,20 +312,18 @@ module Sequel
     # class corresponding to nil:
     #
     #   dataset.set_model(:kind, {nil => DefaultClass, 1 => Person, 2 => Business})
-    # 
-    # To disassociate a model from the dataset, you can call the #set_model 
-    # and specify nil as the class:
-    # 
-    #   dataset.set_model(nil)
     #
+    # To make sure that there is always a default model class, the hash provided
+    # should have a default value.  To make the dataset map string values to
+    # model classes, and keep a good default, try:
+    #
+    #   dataset.set_model(:kind, Hash.new{|h,k| h[k] = (k.constantize rescue DefaultClass)})
     def set_model(key, *args)
-      # pattern matching
+      # This code is more verbose then necessary for performance reasons
       case key
-      when nil # set_model(nil) => no
-        # no argument provided, so the dataset is denuded
+      when nil # set_model(nil) => no argument provided, so the dataset is denuded
         @opts.merge!(:naked => true, :models => nil, :polymorphic_key => nil)
         self.row_proc = nil
-        # extend_with_stock_each
       when Class
         # isomorphic model
         @opts.merge!(:naked => nil, :models => {nil => key}, :polymorphic_key => nil)
@@ -265,12 +334,11 @@ module Sequel
           # otherwise we just pass the hash to the constructor
           self.row_proc = proc{|h| key.new(h, *args)}
         end
-        extend_with_destroy
       when Symbol
         # polymorphic model
         hash = args.shift || raise(ArgumentError, "No class hash supplied for polymorphic model")
         @opts.merge!(:naked => true, :models => hash, :polymorphic_key => key)
-        if hash.values.first.respond_to?(:load)
+        if (hash.empty? ? (hash[nil] rescue nil) : hash.values.first).respond_to?(:load)
           # the class has a values setter method, so we use it
           self.row_proc = proc do |h|
             c = hash[h[key]] || hash[nil] || \
@@ -285,25 +353,12 @@ module Sequel
             c.new(h, *args)
           end
         end
-        extend_with_destroy
       else
         raise ArgumentError, "Invalid model specified"
       end
       self
     end
     
-    STOCK_TRANSFORMS = {
-      :marshal => [
-        # for backwards-compatibility we support also non-base64-encoded values.
-        proc {|v| Marshal.load(Base64.decode64(v)) rescue Marshal.load(v)}, 
-        proc {|v| Base64.encode64(Marshal.dump(v))}
-      ],
-      :yaml => [
-        proc {|v| YAML.load v if v}, 
-        proc {|v| v.to_yaml}
-      ]
-    }
-    
     # Sets a value transform which is used to convert values loaded and saved
     # to/from the database. The transform should be supplied as a hash. Each
     # value in the hash should be an array containing two proc objects - one
@@ -361,63 +416,23 @@ module Sequel
       end
     end
     
-    # Extends the dataset with a destroy method, that calls destroy for each
-    # record in the dataset.
-    def extend_with_destroy
-      unless respond_to?(:destroy)
-        meta_def(:destroy) do
-          unless @opts[:models]
-            raise Error, "No model associated with this dataset"
-          end
-          count = 0
-          @db.transaction {each {|r| count += 1; r.destroy}}
-          count
-        end
-      end
-    end
-
-    @@dataset_classes = []
-
-    def self.dataset_classes #:nodoc:
-      @@dataset_classes
-    end
-
-    def self.inherited(c) #:nodoc:
-      @@dataset_classes << c
-    end
-    
-    # Returns a string representation of the dataset including the class name 
-    # and the corresponding SQL select statement.
-    def inspect
-      '#<%s: %s>' % [self.class.to_s, sql.inspect]
-    end
-
-    # Setup mutation (e.g. filter!) methods
-    def self.def_mutation_method(*meths)
-      meths.each do |meth|
-        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
-      end
-    end
-    def def_mutation_method(*meths)
-      meths.each do |meth|
-        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
-      end
+    # Updates values for the dataset. Adapters should override this method.
+    def update(values, opts = nil)
+      raise NotImplementedError, NOTIMPL_MSG
     end
-
-    MUTATION_METHODS = %w'and distinct exclude exists filter from from_self full_outer_join graph
-    group group_and_count group_by having inner_join intersect invert_order join
-    left_outer_join limit naked or order order_by order_more paginate query reject
-    reverse reverse_order right_outer_join select select_all select_more
-    set_graph_aliases set_model sort sort_by union unordered where'.collect{|x| x.to_sym}
-
+  
+    # Add the mutation methods via metaprogramming
     def_mutation_method(*MUTATION_METHODS)
 
     private
-      def mutation_method(meth, *args, &block)
-        copy = send(meth, *args, &block)
-        @opts.merge!(copy.opts)
-        self
-      end
+
+    # Modify the receiver with the results of sending the meth, args, and block
+    # to the receiver and merging the options of the resulting dataset into
+    # the receiver's options.
+    def mutation_method(meth, *args, &block)
+      copy = send(meth, *args, &block)
+      @opts.merge!(copy.opts)
+      self
+    end
   end
 end
-

data/lib/sequel_core/deprecated.rb

@@ -1,6 +1,6 @@
 module Sequel
   # This module makes it easy to add deprecation functionality to other classes.
-  module Deprecation
+  module Deprecation # :nodoc:
     # This sets the output stream for the deprecation messages.  Set it to an IO
     # (or any object that responds to puts) and it will call puts on that
     # object with the deprecation message.  Set to nil to ignore deprecation messages.
@@ -29,172 +29,4 @@ module Sequel
       ::Sequel::Deprecation.deprecate("#{meth} is deprecated, and will be removed in Sequel 2.0.#{"  #{message}." if message}")
     end
   end
-  
-  class << self
-    include Sequel::Deprecation
-    def method_missing(m, *args) #:nodoc:
-      deprecate("Sequel.method_missing", "You should define Sequel.#{m} for the adapter.")
-      c = Database.adapter_class(m)
-      begin
-        # three ways to invoke this:
-        # 0 arguments: Sequel.dbi
-        # 1 argument:  Sequel.dbi(db_name)
-        # more args:   Sequel.dbi(db_name, opts)
-        case args.size
-        when 0
-          opts = {}
-        when 1
-          opts = args[0].is_a?(Hash) ? args[0] : {:database => args[0]}
-        else
-          opts = args[1].merge(:database => args[0])
-        end
-      rescue
-        raise Error::AdapterNotFound, "Unknown adapter (#{m})"
-      end
-      c.new(opts)
-    end
-  end
-
-  class Dataset
-    include Deprecation
-
-    MUTATION_RE = /^(.+)!$/.freeze
-
-    def clone_merge(opts = {}) #:nodoc:
-      deprecate("Sequel::Dataset#clone", "Use clone")
-      clone(opts)
-    end
-
-    def set_options(opts) #:nodoc:
-      deprecate("Sequel::Dataset#set_options")
-      @opts = opts
-      @columns = nil
-    end
-
-    def set_row_proc(&filter) #:nodoc:
-      deprecate("Sequel::Dataset#set_row_proc", "Use row_proc=")
-      @row_proc = filter
-    end
-
-    def remove_row_proc #:nodoc:
-      deprecate("Sequel::Dataset#remove_row_proc", "Use row_proc=nil")
-      @row_proc = nil
-    end
-
-    # Provides support for mutation methods (filter!, order!, etc.) and magic
-    # methods.
-    def method_missing(m, *args, &block) #:nodoc:
-      if m.to_s =~ MUTATION_RE
-        meth = $1.to_sym
-        super unless respond_to?(meth)
-        copy = send(meth, *args, &block)
-        super if copy.class != self.class
-        deprecate("Sequel::Dataset#method_missing", "Define Sequel::Dataset##{m}, or use Sequel::Dataset.def_mutation_method(:#{meth})")
-        @opts.merge!(copy.opts)
-        self
-      elsif magic_method_missing(m)
-        send(m, *args)
-      else
-         super
-      end
-    end
-
-    MAGIC_METHODS = {
-      /^order_by_(.+)$/   => proc {|c| proc {deprecate("Sequel::Dataset#method_missing", "Use order(#{c.inspect}) or define order_by_#{c}"); order(c)}},
-      /^first_by_(.+)$/   => proc {|c| proc {deprecate("Sequel::Dataset#method_missing", "Use order(#{c.inspect}).first or define first_by_#{c}"); order(c).first}},
-      /^last_by_(.+)$/    => proc {|c| proc {deprecate("Sequel::Dataset#method_missing", "Use order(#{c.inspect}).last or define last_by_#{c}"); order(c).last}},
-      /^filter_by_(.+)$/  => proc {|c| proc {|v| deprecate("Sequel::Dataset#method_missing", "Use filter(#{c.inspect}=>#{v.inspect}) or define filter_by_#{c}"); filter(c => v)}},
-      /^all_by_(.+)$/     => proc {|c| proc {|v| deprecate("Sequel::Dataset#method_missing", "Use filter(#{c.inspect}=>#{v.inspect}).all or define all_by_#{c}"); filter(c => v).all}},
-      /^find_by_(.+)$/    => proc {|c| proc {|v| deprecate("Sequel::Dataset#method_missing", "Use filter(#{c.inspect}=>#{v.inspect}).first or define find_by_#{c}"); filter(c => v).first}},
-      /^group_by_(.+)$/   => proc {|c| proc {deprecate("Sequel::Dataset#method_missing", "Use group(#{c.inspect}) or define group_by_#{c}"); group(c)}},
-      /^count_by_(.+)$/   => proc {|c| proc {deprecate("Sequel::Dataset#method_missing", "Use group_and_count(#{c.inspect}) or define count_by_#{c})"); group_and_count(c)}}
-    }
-
-    # Checks if the given method name represents a magic method and
-    # defines it. Otherwise, nil is returned.
-    def magic_method_missing(m) #:nodoc:
-      method_name = m.to_s
-      MAGIC_METHODS.each_pair do |r, p|
-        if method_name =~ r
-          impl = p[$1.to_sym]
-          return Dataset.class_def(m, &impl)
-        end
-      end
-      nil
-    end
-  end
-  
-  module SQL 
-    module DeprecatedColumnMethods #:nodoc:
-      AS = 'AS'.freeze
-      DESC = 'DESC'.freeze
-      ASC = 'ASC'.freeze
-
-      def as(a) #:nodoc:
-        Sequel::Deprecation.deprecate("Object#as is deprecated and will be removed in Sequel 2.0.  Use Symbol#as or String#as.")
-        ColumnExpr.new(self, AS, a)
-      end
-      def AS(a) #:nodoc:
-        Sequel::Deprecation.deprecate("Object#AS is deprecated and will be removed in Sequel 2.0.  Use Symbol#as or String#as.")
-        ColumnExpr.new(self, AS, a)
-      end
-      def desc #:nodoc:
-        Sequel::Deprecation.deprecate("Object#desc is deprecated and will be removed in Sequel 2.0.  Use Symbol#desc or String#desc.")
-        ColumnExpr.new(self, DESC)
-      end
-      def DESC #:nodoc:
-        Sequel::Deprecation.deprecate("Object#DESC is deprecated and will be removed in Sequel 2.0.  Use Symbol#desc or String#desc.")
-        ColumnExpr.new(self, DESC)
-      end
-      def asc #:nodoc:
-        Sequel::Deprecation.deprecate("Object#asc is deprecated and will be removed in Sequel 2.0.  Use Symbol#asc or String#asc.")
-        ColumnExpr.new(self, ASC)
-      end
-      def ASC #:nodoc:
-        Sequel::Deprecation.deprecate("Object#ASC is deprecated and will be removed in Sequel 2.0.  Use Symbol#asc or String#asc.")
-        ColumnExpr.new(self, ASC)
-      end
-      def all #:nodoc:
-        Sequel::Deprecation.deprecate("Object#all is deprecated and will be removed in Sequel 2.0.  Use :#{self}.* or '#{self}.*'.lit.")
-        Sequel::SQL::ColumnAll.new(self)
-      end
-      def ALL #:nodoc:
-        Sequel::Deprecation.deprecate("Object#ALL is deprecated and will be removed in Sequel 2.0.  Use :#{self}.* or '#{self}.*'.lit.")
-        Sequel::SQL::ColumnAll.new(self)
-      end
-
-      def cast_as(t) #:nodoc:
-        Sequel::Deprecation.deprecate("Object#cast_as is deprecated and will be removed in Sequel 2.0.  Use Symbol#cast_as or String#cast_as.")
-        if t.is_a?(Symbol)
-          t = t.to_s.lit
-        end
-        Sequel::SQL::Function.new(:cast, self.as(t))
-      end
-    end
-  end
-end
-
-class Object
-  include Sequel::SQL::DeprecatedColumnMethods
-  def Sequel(*args) #:nodoc:
-    Sequel::Deprecation.deprecate("Object#Sequel is deprecated and will be removed in Sequel 2.0.  Use Sequel.connect.")
-    Sequel.connect(*args)
-  end
-  def rollback! #:nodoc:
-    Sequel::Deprecation.deprecate("Object#rollback! is deprecated and will be removed in Sequel 2.0.  Use raise Sequel::Error::Rollback.")
-    raise Sequel::Error::Rollback
-  end
-end
-
-class Symbol
-  # Converts missing method calls into functions on columns, if the
-  # method name is made of all upper case letters.
-  def method_missing(sym, *args) #:nodoc:
-    if ((s = sym.to_s) =~ /^([A-Z]+)$/)
-      Sequel::Deprecation.deprecate("Symbol#method_missing is deprecated and will be removed in Sequel 2.0.  Use :#{sym}[:#{self}].")
-      Sequel::SQL::Function.new(s.downcase, self)
-    else
-      super
-    end
-  end
 end