sequel 3.10.0 → 3.11.0

data/lib/sequel/dataset/sql.rb

@@ -1,29 +1,197 @@
 module Sequel
   class Dataset
+    # ---------------------
+    # :section: User Methods relating to SQL Creation
+    # These are methods you can call to see what SQL will be generated by the dataset.
+    # ---------------------
+    
+    # Formats a DELETE statement using the given options and dataset options.
+    # 
+    #   dataset.filter{|o| o.price >= 100}.delete_sql #=>
+    #     "DELETE FROM items WHERE (price >= 100)"
+    def delete_sql
+      return static_sql(opts[:sql]) if opts[:sql]
+      check_modification_allowed!
+      clause_sql(:delete)
+    end
+    
+    # Returns an EXISTS clause for the dataset as a LiteralString.
+    #
+    #   DB.select(1).where(DB[:items].exists).sql
+    #   #=> "SELECT 1 WHERE (EXISTS (SELECT * FROM items))"
+    def exists
+      LiteralString.new("EXISTS (#{select_sql})")
+    end
+    
+    # Formats an INSERT statement using the given values. The API is a little
+    # complex, and best explained by example:
+    #
+    #   # Default values
+    #   DB[:items].insert_sql #=> 'INSERT INTO items DEFAULT VALUES'
+    #   DB[:items].insert_sql({}) #=> 'INSERT INTO items DEFAULT VALUES'
+    #   # Values without columns
+    #   DB[:items].insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
+    #   DB[:items].insert_sql([1,2,3]) #=> 'INSERT INTO items VALUES (1, 2, 3)'
+    #   # Values with columns
+    #   DB[:items].insert_sql([:a, :b], [1,2]) #=> 'INSERT INTO items (a, b) VALUES (1, 2)'
+    #   DB[:items].insert_sql(:a => 1, :b => 2) #=> 'INSERT INTO items (a, b) VALUES (1, 2)'
+    #   # Using a subselect
+    #   DB[:items].insert_sql(DB[:old_items]) #=> 'INSERT INTO items SELECT * FROM old_items
+    #   # Using a subselect with columns
+    #   DB[:items].insert_sql([:a, :b], DB[:old_items]) #=> 'INSERT INTO items (a, b) SELECT * FROM old_items
+    def insert_sql(*values)
+      return static_sql(@opts[:sql]) if @opts[:sql]
+
+      check_modification_allowed!
+
+      columns = []
+
+      case values.size
+      when 0
+        return insert_sql({})
+      when 1
+        case vals = values.at(0)
+        when Hash
+          vals = @opts[:defaults].merge(vals) if @opts[:defaults]
+          vals = vals.merge(@opts[:overrides]) if @opts[:overrides]
+          values = []
+          vals.each do |k,v| 
+            columns << k
+            values << v
+          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))
+          columns, values = v0, v1
+          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
+        end
+      end
+
+      columns = columns.map{|k| literal(String === k ? k.to_sym : k)}
+      clone(:columns=>columns, :values=>values)._insert_sql
+    end
+    
+    # Returns a literal representation of a value to be used as part
+    # of an SQL expression. 
+    # 
+    #   dataset.literal("abc'def\\") #=> "'abc''def\\\\'"
+    #   dataset.literal(:items__id) #=> "items.id"
+    #   dataset.literal([1, 2, 3]) => "(1, 2, 3)"
+    #   dataset.literal(DB[:items]) => "(SELECT * FROM items)"
+    #   dataset.literal(:x + 1 > :y) => "((x + 1) > y)"
+    #
+    # If an unsupported object is given, an exception is raised.
+    def literal(v)
+      case v
+      when String
+        return v if v.is_a?(LiteralString)
+        v.is_a?(SQL::Blob) ? literal_blob(v) : literal_string(v)
+      when Symbol
+        literal_symbol(v)
+      when Integer
+        literal_integer(v)
+      when Hash
+        literal_hash(v)
+      when SQL::Expression
+        literal_expression(v)
+      when Float
+        literal_float(v)
+      when BigDecimal
+        literal_big_decimal(v)
+      when NilClass
+        literal_nil
+      when TrueClass
+        literal_true
+      when FalseClass
+        literal_false
+      when Array
+        literal_array(v)
+      when Time
+        literal_time(v)
+      when DateTime
+        literal_datetime(v)
+      when Date
+        literal_date(v)
+      when Dataset
+        literal_dataset(v)
+      else
+        literal_other(v)
+      end
+    end
+    
+    # Returns an array of insert statements for inserting multiple records.
+    # This method is used by #multi_insert to format insert statements and
+    # expects a keys array and and an array of value arrays.
+    #
+    # This method should be overridden by descendants if the support
+    # inserting multiple records in a single SQL statement.
+    def multi_insert_sql(columns, values)
+      values.map{|r| insert_sql(columns, r)}
+    end
+    
+    # Formats a SELECT statement
+    #
+    #   dataset.select_sql # => "SELECT * FROM items"
+    def select_sql
+      return static_sql(@opts[:sql]) if @opts[:sql]
+      clause_sql(:select)
+    end
+
+    # Same as select_sql, not aliased directly to make subclassing simpler.
+    def sql
+      select_sql
+    end
+    
+    # SQL query to truncate the table
+    def truncate_sql
+      if opts[:sql]
+        static_sql(opts[:sql])
+      else
+        check_modification_allowed!
+        raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where]
+        _truncate_sql(source_list(opts[:from]))
+      end
+    end
+
+    # Formats an UPDATE statement using the given values.
+    #
+    #   dataset.update_sql(:price => 100, :category => 'software') #=>
+    #     "UPDATE items SET price = 100, category = 'software'"
+    #
+    # Raises an error if the dataset is grouped or includes more
+    # than one table.
+    def update_sql(values = {})
+      return static_sql(opts[:sql]) if opts[:sql]
+      check_modification_allowed!
+      clone(:values=>values)._update_sql
+    end
+    
+    # ---------------------
+    # :section: Internal Methods relating to SQL Creation
+    # These methods, while public, are not designed to be used directly by the end user.
+    # ---------------------
+    
     # Given a type (e.g. select) and an array of clauses,
     # return an array of methods to call to build the SQL string.
     def self.clause_methods(type, clauses)
       clauses.map{|clause| :"#{type}_#{clause}_sql"}.freeze
     end
 
-    # These symbols have _join methods created (e.g. inner_join) that
-    # call join_table with the symbol, passing along the arguments and
-    # block from the method call.
-    CONDITIONED_JOIN_TYPES = [:inner, :full_outer, :right_outer, :left_outer, :full, :right, :left]
-
-    # These symbols have _join methods created (e.g. natural_join) that
-    # call join_table with the symbol.  They only accept a single table
-    # argument which is passed to join_table, and they raise an error
-    # if called with a block.
-    UNCONDITIONED_JOIN_TYPES = [:natural, :natural_left, :natural_right, :natural_full, :cross]
-
     AND_SEPARATOR = " AND ".freeze
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
+    COMMA_SEPARATOR = ', '.freeze
     COLUMN_REF_RE1 = /\A([\w ]+)__([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
+    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
     DATASET_ALIAS_BASE_NAME = 't'.freeze
     FOR_UPDATE = ' FOR UPDATE'.freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
@@ -39,7 +207,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
-    WILDCARD = '*'.freeze
+    WILDCARD = LiteralString.new('*').freeze
     SQL_WITH = "WITH ".freeze
 
     # SQL fragment for the aliased expression
@@ -149,139 +317,12 @@ module Sequel
       constant.to_s
     end
 
-    # Returns the number of records in the dataset.
-    def count
-      aggregate_dataset.get{COUNT(:*){}.as(count)}.to_i
-    end
-
-    # Formats a DELETE statement using the given options and dataset options.
-    # 
-    #   dataset.filter{|o| o.price >= 100}.delete_sql #=>
-    #     "DELETE FROM items WHERE (price >= 100)"
-    def delete_sql
-      return static_sql(opts[:sql]) if opts[:sql]
-      check_modification_allowed!
-      clause_sql(:delete)
-    end
-
-    # Returns an EXISTS clause for the dataset as a LiteralString.
-    #
-    #   DB.select(1).where(DB[:items].exists).sql
-    #   #=> "SELECT 1 WHERE (EXISTS (SELECT * FROM items))"
-    def exists
-      LiteralString.new("EXISTS (#{select_sql})")
-    end
-
-    # The first source (primary table) for this dataset.  If the dataset doesn't
-    # have a table, raises an error.  If the table is aliased, returns the aliased name.
-    def first_source_alias
-      source = @opts[:from]
-      if source.nil? || source.empty?
-        raise Error, 'No source specified for query'
-      end
-      case s = source.first
-      when SQL::AliasedExpression
-        s.aliaz
-      when Symbol
-        sch, table, aliaz = split_symbol(s)
-        aliaz ? aliaz.to_sym : s
-      else
-        s
-      end
-    end
-    alias first_source first_source_alias
-    
-    # The first source (primary table) for this dataset.  If the dataset doesn't
-    # have a table, raises an error.  If the table is aliased, returns the original
-    # table, not the alias
-    def first_source_table
-      source = @opts[:from]
-      if source.nil? || source.empty?
-        raise Error, 'No source specified for query'
-      end
-      case s = source.first
-      when SQL::AliasedExpression
-        s.expression
-      when Symbol
-        sch, table, aliaz = split_symbol(s)
-        aliaz ? (sch ? SQL::QualifiedIdentifier.new(sch, table) : table.to_sym) : s
-      else
-        s
-      end
-    end
-
     # SQL fragment specifying an SQL function call
     def function_sql(f)
       args = f.args
       "#{f.f}#{args.empty? ? '()' : literal(args)}"
     end
 
-    # Inserts multiple values. If a block is given it is invoked for each
-    # item in the given array before inserting it.  See #multi_insert as
-    # a possible faster version that inserts multiple records in one
-    # SQL statement.
-    def insert_multiple(array, &block)
-      if block
-        array.each {|i| insert(block[i])}
-      else
-        array.each {|i| insert(i)}
-      end
-    end
-
-    # Formats an INSERT statement using the given values. The API is a little
-    # complex, and best explained by example:
-    #
-    #   # Default values
-    #   DB[:items].insert_sql #=> 'INSERT INTO items DEFAULT VALUES'
-    #   DB[:items].insert_sql({}) #=> 'INSERT INTO items DEFAULT VALUES'
-    #   # Values without columns
-    #   DB[:items].insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
-    #   DB[:items].insert_sql([1,2,3]) #=> 'INSERT INTO items VALUES (1, 2, 3)'
-    #   # Values with columns
-    #   DB[:items].insert_sql([:a, :b], [1,2]) #=> 'INSERT INTO items (a, b) VALUES (1, 2)'
-    #   DB[:items].insert_sql(:a => 1, :b => 2) #=> 'INSERT INTO items (a, b) VALUES (1, 2)'
-    #   # Using a subselect
-    #   DB[:items].insert_sql(DB[:old_items]) #=> 'INSERT INTO items SELECT * FROM old_items
-    #   # Using a subselect with columns
-    #   DB[:items].insert_sql([:a, :b], DB[:old_items]) #=> 'INSERT INTO items (a, b) SELECT * FROM old_items
-    def insert_sql(*values)
-      return static_sql(@opts[:sql]) if @opts[:sql]
-
-      check_modification_allowed!
-
-      columns = []
-
-      case values.size
-      when 0
-        return insert_sql({})
-      when 1
-        case vals = values.at(0)
-        when Hash
-          vals = @opts[:defaults].merge(vals) if @opts[:defaults]
-          vals = vals.merge(@opts[:overrides]) if @opts[:overrides]
-          values = []
-          vals.each do |k,v| 
-            columns << k
-            values << v
-          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))
-          columns, values = v0, v1
-          raise(Error, "Different number of values and columns given to insert_sql") if values.is_a?(Array) and columns.length != values.length
-        end
-      end
-
-      columns = columns.map{|k| literal(String === k ? k.to_sym : k)}
-      clone(:columns=>columns, :values=>values)._insert_sql
-    end
-
     # SQL fragment specifying a JOIN clause without ON or USING.
     def join_clause_sql(jc)
       table = jc.table
@@ -300,150 +341,6 @@ module Sequel
     def join_using_clause_sql(jc)
       "#{join_clause_sql(jc)} USING (#{column_list(jc.using)})"
     end
-
-    # Returns a joined dataset.  Uses the following arguments:
-    #
-    # * 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 with all two pairs - Assumes key (1st arg) is column of joined table (unless already
-    #     qualified), and value (2nd arg) is column of the last joined or primary table (or the
-    #     :implicit_qualifier option).
-    #     To specify multiple conditions on a single joined table column, you must use an array.
-    #     Uses a JOIN with an ON clause.
-    #   * Array - If all members of the array are symbols, considers them as columns and 
-    #     uses a JOIN with a USING clause.  Most databases will remove duplicate columns from
-    #     the result set if this is used.
-    #   * nil - If a block is not given, doesn't use ON or USING, so the JOIN should be a NATURAL
-    #     or CROSS join. If a block is given, uses a ON clause based on the block, see below.
-    #   * Everything else - pretty much the same as a using the argument in a call to filter,
-    #     so strings are considered literal, symbols specify boolean columns, and blockless
-    #     filter expressions can be used. Uses a JOIN with an ON clause.
-    # * options - a hash of options, with any of the following keys:
-    #   * :table_alias - the name of the table's alias when joining, necessary for joining
-    #     to the same table more than once.  No alias is used by default.
-    #   * :implicit_qualifier - The name to use for qualifying implicit conditions.  By default,
-    #     the last joined or primary table is used.
-    # * block - The block argument should only be given if a JOIN with an ON clause is used,
-    #   in which case it yields the table alias/name for the table currently being joined,
-    #   the table alias/name for the last joined (or first table), and an array of previous
-    #   SQL::JoinClause.
-    def join_table(type, table, expr=nil, options={}, &block)
-      using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
-      if using_join && !supports_join_using?
-        h = {}
-        expr.each{|s| h[s] = s}
-        return join_table(type, table, h, options)
-      end
-
-      case options
-      when Hash
-        table_alias = options[:table_alias]
-        last_alias = options[:implicit_qualifier]
-      when Symbol, String, SQL::Identifier
-        table_alias = options
-        last_alias = nil 
-      else
-        raise Error, "invalid options format for join_table: #{options.inspect}"
-      end
-
-      if Dataset === table
-        if table_alias.nil?
-          table_alias_num = (@opts[:num_dataset_sources] || 0) + 1
-          table_alias = dataset_alias(table_alias_num)
-        end
-        table_name = table_alias
-      else
-        table = table.table_name if table.respond_to?(:table_name)
-        table_name = table_alias || table
-      end
-
-      join = if expr.nil? and !block_given?
-        SQL::JoinClause.new(type, table, table_alias)
-      elsif using_join
-        raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block_given?
-        SQL::JoinUsingClause.new(expr, type, table, table_alias)
-      else
-        last_alias ||= @opts[:last_joined_table] || first_source_alias
-        if Sequel.condition_specifier?(expr)
-          expr = expr.collect do |k, v|
-            k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
-            v = qualified_column_name(v, last_alias) if v.is_a?(Symbol)
-            [k,v]
-          end
-        end
-        if block_given?
-          expr2 = yield(table_name, last_alias, @opts[:join] || [])
-          expr = expr ? SQL::BooleanExpression.new(:AND, expr, expr2) : expr2
-        end
-        SQL::JoinOnClause.new(expr, type, table, table_alias)
-      end
-
-      opts = {:join => (@opts[:join] || []) + [join], :last_joined_table => table_name}
-      opts[:num_dataset_sources] = table_alias_num if table_alias_num
-      clone(opts)
-    end
-
-    # Returns a literal representation of a value to be used as part
-    # of an SQL expression. 
-    # 
-    #   dataset.literal("abc'def\\") #=> "'abc''def\\\\'"
-    #   dataset.literal(:items__id) #=> "items.id"
-    #   dataset.literal([1, 2, 3]) => "(1, 2, 3)"
-    #   dataset.literal(DB[:items]) => "(SELECT * FROM items)"
-    #   dataset.literal(:x + 1 > :y) => "((x + 1) > y)"
-    #
-    # If an unsupported object is given, an exception is raised.
-    def literal(v)
-      case v
-      when String
-        return v if v.is_a?(LiteralString)
-        v.is_a?(SQL::Blob) ? literal_blob(v) : literal_string(v)
-      when Symbol
-        literal_symbol(v)
-      when Integer
-        literal_integer(v)
-      when Hash
-        literal_hash(v)
-      when SQL::Expression
-        literal_expression(v)
-      when Float
-        literal_float(v)
-      when BigDecimal
-        literal_big_decimal(v)
-      when NilClass
-        literal_nil
-      when TrueClass
-        literal_true
-      when FalseClass
-        literal_false
-      when Array
-        literal_array(v)
-      when Time
-        literal_time(v)
-      when DateTime
-        literal_datetime(v)
-      when Date
-        literal_date(v)
-      when Dataset
-        literal_dataset(v)
-      else
-        literal_other(v)
-      end
-    end
-
-    # Returns an array of insert statements for inserting multiple records.
-    # This method is used by #multi_insert to format insert statements and
-    # expects a keys array and and an array of value arrays.
-    #
-    # This method should be overridden by descendants if the support
-    # inserting multiple records in a single SQL statement.
-    def multi_insert_sql(columns, values)
-      values.map{|r| insert_sql(columns, r)}
-    end
     
     # SQL fragment for NegativeBooleanConstants
     def negative_boolean_constant_sql(constant)
@@ -476,35 +373,6 @@ module Sequel
       [qcr.table, qcr.column].map{|x| [SQL::QualifiedIdentifier, SQL::Identifier, Symbol].any?{|c| x.is_a?(c)} ? literal(x) : quote_identifier(x)}.join('.')
     end
 
-    # Qualify to the given table, or first source if not table is given.
-    def qualify(table=first_source)
-      qualify_to(table)
-    end
-
-    # Return a copy of the dataset with unqualified identifiers in the
-    # SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
-    # given table. If no columns are currently selected, select all
-    # columns of the given table.
-    def qualify_to(table)
-      o = @opts
-      return clone if o[:sql]
-      h = {}
-      (o.keys & QUALIFY_KEYS).each do |k|
-        h[k] = qualified_expression(o[k], table)
-      end
-      h[:select] = [SQL::ColumnAll.new(table)] if !o[:select] || o[:select].empty?
-      clone(h)
-    end
-    
-    # Qualify the dataset to its current first source.  This is useful
-    # if you have unqualified identifiers in the query that all refer to
-    # the first source, and you want to join to another table which
-    # has columns with the same name as columns in the current dataset.
-    # See qualify_to.
-    def qualify_to_first_source
-      qualify_to(first_source)
-    end
-
     # Adds quoting to identifiers (columns and tables). If identifiers are not
     # being quoted, returns name as a string.  If identifiers are being quoted
     # quote the name with quoted_identifier.
@@ -548,55 +416,10 @@ module Sequel
       end
     end
 
-    # Formats a SELECT statement
-    #
-    #   dataset.select_sql # => "SELECT * FROM items"
-    def select_sql
-      return static_sql(@opts[:sql]) if @opts[:sql]
-      clause_sql(:select)
-    end
-
-    # Same as select_sql, not aliased directly to make subclassing simpler.
-    def sql
-      select_sql
-    end
-
     # SQL fragment for specifying subscripts (SQL arrays)
     def subscript_sql(s)
       "#{literal(s.f)}[#{expression_list(s.sub)}]"
     end
-    
-    # SQL query to truncate the table
-    def truncate_sql
-      if opts[:sql]
-        static_sql(opts[:sql])
-      else
-        check_modification_allowed!
-        raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where]
-        _truncate_sql(source_list(opts[:from]))
-      end
-    end
-
-    # Formats an UPDATE statement using the given values.
-    #
-    #   dataset.update_sql(:price => 100, :category => 'software') #=>
-    #     "UPDATE items SET price = 100, category = 'software'"
-    #
-    # Raises an error if the dataset is grouped or includes more
-    # than one table.
-    def update_sql(values = {})
-      return static_sql(opts[:sql]) if opts[:sql]
-      check_modification_allowed!
-      clone(:values=>values)._update_sql
-    end
-
-    # Add a condition to the WHERE clause.  See #filter for argument types.
-    #
-    #   dataset.group(:a).having(:a).filter(:b) # SELECT * FROM items GROUP BY a HAVING a AND b
-    #   dataset.group(:a).having(:a).where(:b) # SELECT * FROM items WHERE b GROUP BY a HAVING a
-    def where(*cond, &block)
-      _filter(:where, *cond, &block)
-    end
 
     # The SQL fragment for the given window's options.
     def window_sql(opts)
@@ -621,43 +444,6 @@ module Sequel
     def window_function_sql(function, window)
       "#{literal(function)} OVER #{literal(window)}"
     end
-    
-    # Add a simple common table expression (CTE) with the given name and a dataset that defines the CTE.
-    # A common table expression acts as an inline view for the query.
-    # Options:
-    # * :args - Specify the arguments/columns for the CTE, should be an array of symbols.
-    # * :recursive - Specify that this is a recursive CTE
-    def with(name, dataset, opts={})
-      raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
-      clone(:with=>(@opts[:with]||[]) + [opts.merge(:name=>name, :dataset=>dataset)])
-    end
-
-    # Add a recursive common table expression (CTE) with the given name, a dataset that
-    # defines the nonrecursive part of the CTE, and a dataset that defines the recursive part
-    # of the CTE.  Options:
-    # * :args - Specify the arguments/columns for the CTE, should be an array of symbols.
-    # * :union_all - Set to false to use UNION instead of UNION ALL combining the nonrecursive and recursive parts.
-    def with_recursive(name, nonrecursive, recursive, opts={})
-      raise(Error, 'This datatset does not support common table expressions') unless supports_cte?
-      clone(:with=>(@opts[:with]||[]) + [opts.merge(:recursive=>true, :name=>name, :dataset=>nonrecursive.union(recursive, {:all=>opts[:union_all] != false, :from_self=>false}))])
-    end
-
-    # Returns a copy of the dataset with the static SQL used.  This is useful if you want
-    # to keep the same row_proc/graph, but change the SQL used to custom SQL.
-    #
-    #   dataset.with_sql('SELECT * FROM foo') # SELECT * FROM foo
-    def with_sql(sql, *args)
-      sql = SQL::PlaceholderLiteralString.new(sql, args) unless args.empty?
-      clone(:sql=>sql)
-    end
-
-    CONDITIONED_JOIN_TYPES.each do |jtype|
-      class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end", __FILE__, __LINE__)
-    end
-    UNCONDITIONED_JOIN_TYPES.each do |jtype|
-      class_eval("def #{jtype}_join(table); raise(Sequel::Error, '#{jtype}_join does not accept join table blocks') if block_given?; join_table(:#{jtype}, table) end", __FILE__, __LINE__)
-    end
-    alias join inner_join
 
     protected
 
@@ -816,6 +602,12 @@ module Sequel
     def identifier_list(columns)
       columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
     end
+    
+    # Modify the identifier returned from the database based on the
+    # identifier_output_method.
+    def input_identifier(v)
+      (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
+    end
 
     # SQL fragment specifying the table to insert INTO
     def insert_into_sql(sql)