sequel 0.5.0.2 → 1.0

data/lib/sequel/dataset/sequelizer.rb

@@ -1,354 +0,0 @@
-class Sequel::Dataset
-  # The Sequelizer module includes methods for translating Ruby expressions
-  # into SQL expressions, making it possible to specify dataset filters using
-  # blocks, e.g.:
-  #
-  #   DB[:items].filter {:price < 100}
-  #   DB[:items].filter {:category == 'ruby' && :date < 3.days.ago}
-  #
-  # Block filters can refer to literals, variables, constants, arguments, 
-  # instance variables or anything else in order to create parameterized 
-  # queries. Block filters can also refer to other dataset objects as 
-  # sub-queries. Block filters are pretty much limitless!
-  #
-  # Block filters are based on ParseTree. If you do not have the ParseTree
-  # gem installed, block filters will raise an error.
-  #
-  # To enable full block filter support make sure you have both ParseTree and
-  # Ruby2Ruby installed:
-  #
-  #   sudo gem install parsetree
-  #   sudo gem install ruby2ruby
-  module Sequelizer
-    # Formats an comparison expression involving a left value and a right
-    # value. Comparison expressions differ according to the class of the right
-    # value. The stock implementation supports Range (inclusive and exclusive),
-    # Array (as a list of values to compare against), Dataset (as a subquery to
-    # compare against), or a regular value.
-    #
-    #   dataset.compare_expr('id', 1..20) #=>
-    #     "(id >= 1 AND id <= 20)"
-    #   dataset.compare_expr('id', [3,6,10]) #=>
-    #     "(id IN (3, 6, 10))"
-    #   dataset.compare_expr('id', DB[:items].select(:id)) #=>
-    #     "(id IN (SELECT id FROM items))"
-    #   dataset.compare_expr('id', nil) #=>
-    #     "(id IS NULL)"
-    #   dataset.compare_expr('id', 3) #=>
-    #     "(id = 3)"
-    def compare_expr(l, r)
-      case r
-      when Range
-        r.exclude_end? ? \
-          "(#{literal(l)} >= #{literal(r.begin)} AND #{literal(l)} < #{literal(r.end)})" : \
-          "(#{literal(l)} >= #{literal(r.begin)} AND #{literal(l)} <= #{literal(r.end)})"
-      when Array
-        "(#{literal(l)} IN (#{literal(r)}))"
-      when Sequel::Dataset
-        "(#{literal(l)} IN (#{r.sql}))"
-      when NilClass
-        "(#{literal(l)} IS NULL)"
-      when Regexp
-        match_expr(l, r)
-      else
-        "(#{literal(l)} = #{literal(r)})"
-      end
-    end
-    
-    # Formats a string matching expression. The stock implementation supports
-    # matching against strings only using the LIKE operator. Specific adapters
-    # can override this method to provide support for regular expressions.
-    def match_expr(l, r)
-      case r
-      when String
-        "(#{literal(l)} LIKE #{literal(r)})"
-      else
-        raise Sequel::Error, "Unsupported match pattern class (#{r.class})."
-      end
-    end
-
-    # Evaluates a method call. This method is used to evaluate Ruby expressions
-    # referring to indirect values, e.g.:
-    #
-    #   dataset.filter {:category => category.to_s}
-    #   dataset.filter {:x > y[0..3]}
-    #
-    # This method depends on the Ruby2Ruby gem. If you do not have Ruby2Ruby 
-    # installed, this method will raise an error.
-    def ext_expr(e, b, opts)
-      eval(RubyToRuby.new.process(e), b)
-    end
-
-    # Translates a method call parse-tree to SQL expression. The following 
-    # operators are recognized and translated to SQL expressions: >, <, >=, <=,
-    # ==, =~, +, -, *, /, %:
-    #
-    #   :x == 1 #=> "(x = 1)"
-    #   (:x + 100) < 200 #=> "((x + 100) < 200)"
-    #
-    # The in, in?, nil and nil? method calls are intercepted and passed to 
-    # #compare_expr.
-    #
-    #   :x.in [1, 2, 3] #=> "(x IN (1, 2, 3))"
-    #   :x.in?(DB[:y].select(:z)) #=> "(x IN (SELECT z FROM y))"
-    #   :x.nil? #=> "(x IS NULL)"
-    #
-    # The like and like? method calls are intercepted and passed to #match_expr.
-    #
-    #   :x.like? 'ABC%' #=> "(x LIKE 'ABC%')"
-    #
-    # The method also supports SQL functions by invoking Symbol#[]:
-    #
-    #   :avg[:x] #=> "avg(x)"
-    #   :substring[:x, 5] #=> "substring(x, 5)"
-    #
-    # All other method calls are evaulated as normal Ruby code.
-    def call_expr(e, b, opts)
-      case op = e[2]
-      when :>, :<, :>=, :<=
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        if l.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression) || \
-          r.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression)
-          "(#{literal(l)} #{op} #{literal(r)})"
-        else
-          ext_expr(e, b, opts)
-        end
-      when :==
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        compare_expr(l, r)
-      when :=~
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        match_expr(l, r)
-      when :+, :-, :*, :%, :/
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        if l.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression) || \
-          r.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression)
-          "(#{literal(l)} #{op} #{literal(r)})".lit
-        else
-          ext_expr(e, b, opts)
-        end
-      when :<<
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        "#{literal(l)} = #{literal(r)}".lit
-      when :|
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        if l.is_one_of?(Symbol, Sequel::SQL::Subscript)
-          l|r
-        else
-          ext_expr(e, b, opts)
-        end
-      when :in, :in?
-        # in/in? operators are supported using two forms:
-        #   :x.in([1, 2, 3])
-        #   :x.in(1, 2, 3) # variable arity
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr((e[3].size == 2) ? e[3][1] : e[3], b, opts)
-        compare_expr(l, r)
-      when :nil, :nil?
-        l = eval_expr(e[1], b, opts)
-        compare_expr(l, nil)
-      when :like, :like?
-        l = eval_expr(e[1], b, opts)
-        r = eval_expr(e[3][1], b, opts)
-        match_expr(l, r)
-      else
-        if (op == :[]) && (e[1][0] == :lit) && (Symbol === e[1][1])
-          # SQL Functions, e.g.: :sum[:x]
-          if e[3]
-            e[1][1][*eval_expr(e[3], b, opts)]
-          else
-            e[1][1][]
-          end
-        else
-          # external code
-          ext_expr(e, b, opts)
-        end
-      end
-    end
-    
-    def fcall_expr(e, b, opts) #:nodoc:
-      ext_expr(e, b, opts)
-    end
-    
-    def vcall_expr(e, b, opts) #:nodoc:
-      eval(e[1].to_s, b)
-    end
-    
-    def iter_expr(e, b, opts) #:nodoc:
-      if e[1][0] == :call && e[1][2] == :each
-        unfold_each_expr(e, b, opts)
-      elsif e[1] == [:fcall, :proc]
-        eval_expr(e[3], b, opts) # inline proc
-      else
-        ext_expr(e, b, opts) # method call with inline proc
-      end
-    end
-    
-    def replace_dvars(a, values)
-      a.map do |i|
-        if i.is_a?(Array) && (i[0] == :dvar)
-          if v = values[i[1]]
-            value_to_parse_tree(v)
-          else
-            i
-          end
-        elsif Array === i
-          replace_dvars(i, values)
-        else
-          i
-        end
-      end
-    end
-    
-    def value_to_parse_tree(value)
-      c = Class.new
-      c.class_eval("def m; #{value.inspect}; end")
-      ParseTree.translate(c, :m)[2][1][2]
-    end
-    
-    def unfold_each_expr(e, b, opts) #:nodoc:
-      source = eval_expr(e[1][1], b, opts)
-      block_dvars = []
-      if e[2][0] == :dasgn_curr
-        block_dvars << e[2][1]
-      elsif e[2][0] == :masgn
-        e[2][1].each do |i|
-          if i.is_a?(Array) && i[0] == :dasgn_curr
-            block_dvars << i[1]
-          end
-        end
-      end
-      new_block = [:block]
-      
-      source.each do |*dvars|
-        iter_values = (Array === dvars[0]) ? dvars[0] : dvars
-        values = block_dvars.inject({}) {|m, i| m[i] = iter_values.shift; m}
-        iter = replace_dvars(e[3], values)
-        new_block << iter
-      end
-      
-      pt_expr(new_block, b, opts)
-    end
-    
-    # Evaluates a parse-tree into an SQL expression.
-    def eval_expr(e, b, opts)
-      case e[0]
-      when :call # method call
-        call_expr(e, b, opts)
-      when :fcall
-        fcall_expr(e, b, opts)
-      when :vcall
-        vcall_expr(e, b, opts)
-      when :ivar, :cvar, :dvar, :const, :gvar # local ref
-        eval(e[1].to_s, b)
-      when :nth_ref
-        eval("$#{e[1]}", b)
-      when :lvar # local context
-        if e[1] == :block
-          pr = eval(e[1].to_s, b)
-          "#{proc_to_sql(pr)}"
-        else
-          eval(e[1].to_s, b)
-        end
-      when :lit, :str # literal
-         e[1]
-      when :dot2 # inclusive range
-        eval_expr(e[1], b, opts)..eval_expr(e[2], b, opts)
-      when :dot3 # exclusive range
-        eval_expr(e[1], b, opts)...eval_expr(e[2], b, opts)
-      when :colon2 # qualified constant ref
-        eval_expr(e[1], b, opts).const_get(e[2])
-      when :false
-        false
-      when :true
-        true
-      when :nil
-        nil
-      when :array
-        # array
-        e[1..-1].map {|i| eval_expr(i, b, opts)}
-      when :match3
-        # =~/!~ operator
-        l = eval_expr(e[2], b, opts)
-        r = eval_expr(e[1], b, opts)
-        compare_expr(l, r)
-      when :iter
-        iter_expr(e, b, opts)
-      when :dasgn, :dasgn_curr
-        # assignment
-        l = e[1]
-        r = eval_expr(e[2], b, opts)
-        raise Sequel::Error::InvalidExpression, "#{l} = #{r}. Did you mean :#{l} == #{r}?"
-      when :if, :dstr
-        ext_expr(e, b, opts)
-      else
-        raise Sequel::Error::InvalidExpression, "Invalid expression tree: #{e.inspect}"
-      end
-    end
-    
-    JOIN_AND = " AND ".freeze
-    JOIN_COMMA = ", ".freeze
-    
-    def pt_expr(e, b, opts = {}) #:nodoc:
-      case e[0]
-      when :not # negation: !x, (x != y), (x !~ y)
-        if (e[1][0] == :lit) && (Symbol === e[1][1])
-          # translate (!:x) into (x = 'f')
-          compare_expr(e[1][1], false)
-        else
-          "(NOT #{pt_expr(e[1], b, opts)})"
-        end
-      when :and # x && y
-        "(#{e[1..-1].map {|i| pt_expr(i, b, opts)}.join(JOIN_AND)})"
-      when :or # x || y
-        "(#{pt_expr(e[1], b, opts)} OR #{pt_expr(e[2], b, opts)})"
-      when :call, :vcall, :iter, :match3 # method calls, blocks
-        eval_expr(e, b, opts)
-      when :block # block of statements
-        if opts[:comma_separated]
-          "#{e[1..-1].map {|i| pt_expr(i, b, opts)}.join(JOIN_COMMA)}"
-        else
-          "(#{e[1..-1].map {|i| pt_expr(i, b, opts)}.join(JOIN_AND)})"
-        end
-      else # literals
-        if e == [:lvar, :block]
-          eval_expr(e, b, opts)
-        else
-          literal(eval_expr(e, b, opts))
-        end
-      end
-    end
-
-    # Translates a Ruby block into an SQL expression.
-    def proc_to_sql(proc, opts = {})
-      c = Class.new {define_method(:m, &proc)}
-      pt_expr(ParseTree.translate(c, :m)[2][2], proc.binding, opts)
-    end
-  end
-end
-
-begin
-  require 'parse_tree'
-rescue Exception
-  module Sequel::Dataset::Sequelizer
-    def proc_to_sql(proc)
-      raise Sequel::Error, "You must have the ParseTree gem installed in order to use block filters."
-    end
-  end
-end
-
-begin
-  require 'ruby2ruby'
-rescue Exception
-  module Sequel::Dataset::Sequelizer
-    def ext_expr(e)
-      raise Sequel::Error, "You must have the Ruby2Ruby gem installed in order to use this block filter."
-    end
-  end
-end

data/lib/sequel/dataset/sql.rb

@@ -1,586 +0,0 @@
-module Sequel
-  class Dataset
-    # The Dataset SQL module implements all the dataset methods concerned with
-    # generating SQL statements for retrieving and manipulating records.
-    module SQL
-      # Adds quoting to column references. This method is just a stub and can
-      # be overriden in adapters in order to provide correct column quoting
-      # behavior.
-      def quote_column_ref(name); name.to_s; end
-      
-      ALIASED_REGEXP = /^(.*)\s(.*)$/.freeze
-      QUALIFIED_REGEXP = /^(.*)\.(.*)$/.freeze
-
-      # Returns a qualified column name (including a table name) if the column
-      # name isn't already qualified.
-      def qualified_column_name(column, table)
-        s = literal(column)
-        if s =~ QUALIFIED_REGEXP
-          return column
-        else
-          if (table =~ ALIASED_REGEXP)
-            table = $2
-          end
-          Sequel::SQL::QualifiedColumnRef.new(table, column)
-          # "#{table}.#{column}"
-        end
-      end
-
-      WILDCARD = '*'.freeze
-      COMMA_SEPARATOR = ", ".freeze
-
-      # Converts an array of column names into a comma seperated string of 
-      # column names. If the array is empty, a wildcard (*) is returned.
-      def column_list(columns)
-        if columns.empty?
-          WILDCARD
-        else
-          m = columns.map do |i|
-            i.is_a?(Hash) ? i.map {|kv| "#{literal(kv[0])} AS #{kv[1]}"} : literal(i)
-          end
-          m.join(COMMA_SEPARATOR)
-        end
-      end
-
-      # Converts an array of sources names into into a comma separated list.
-      def source_list(source)
-        if source.nil? || source.empty?
-          raise Error, 'No source specified for query'
-        end
-        auto_alias_count = 0
-        m = source.map do |i|
-          case i
-          when Dataset
-            auto_alias_count += 1
-            i.to_table_reference(auto_alias_count)
-          when Hash
-            i.map {|k, v| "#{k.is_a?(Dataset) ? k.to_table_reference : k} #{v}"}.
-              join(COMMA_SEPARATOR)
-          else
-            i
-          end
-        end
-        m.join(COMMA_SEPARATOR)
-      end
-
-      NULL = "NULL".freeze
-      TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
-      DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
-      TRUE = "'t'".freeze
-      FALSE = "'f'".freeze
-
-      # Returns a literal representation of a value to be used as part
-      # of an SQL expression. The stock implementation supports literalization 
-      # of String (with proper escaping to prevent SQL injections), numbers,
-      # Symbol (as column references), Array (as a list of literalized values),
-      # Time (as an SQL TIMESTAMP), Date (as an SQL DATE), Dataset (as a 
-      # subquery) and nil (AS NULL).
-      # 
-      #   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)"
-      #
-      # If an unsupported object is given, an exception is raised.
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when String
-          "'#{v.gsub(/'/, "''")}'"
-        when Integer, Float
-          v.to_s
-        when BigDecimal
-          v.to_s("F")
-        when NilClass
-          NULL
-        when TrueClass
-          TRUE
-        when FalseClass
-          FALSE
-        when Symbol
-          v.to_column_ref(self)
-        when Sequel::SQL::Expression
-          v.to_s(self)
-        when Array
-          v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
-        when Time
-          v.strftime(TIMESTAMP_FORMAT)
-        when Date
-          v.strftime(DATE_FORMAT)
-        when Dataset
-          "(#{v.sql})"
-        else
-          raise Error, "can't express #{v.inspect} as a SQL literal"
-        end
-      end
-
-      AND_SEPARATOR = " AND ".freeze
-      QUESTION_MARK = '?'.freeze
-
-      # Formats a where clause. If parenthesize is true, then the whole 
-      # generated clause will be enclosed in a set of parentheses.
-      def expression_list(expr, parenthesize = false)
-        case expr
-        when Hash
-          parenthesize = false if expr.size == 1
-          fmt = expr.map {|i| compare_expr(i[0], i[1])}.join(AND_SEPARATOR)
-        when Array
-          fmt = expr.shift.gsub(QUESTION_MARK) {literal(expr.shift)}
-        when Proc
-          fmt = proc_to_sql(expr)
-        else
-          # if the expression is compound, it should be parenthesized in order for 
-          # things to be predictable (when using #or and #and.)
-          parenthesize |= expr =~ /\).+\(/
-          fmt = expr
-        end
-        parenthesize ? "(#{fmt})" : fmt
-      end
-
-      # Returns a copy of the dataset with the source changed.
-      def from(*source)
-        clone_merge(:from => source)
-      end
-
-      # Returns a copy of the dataset with the selected columns changed.
-      def select(*columns)
-        clone_merge(:select => columns)
-      end
-
-      # Returns a copy of the dataset with the distinct option.
-      def uniq(*args)
-        clone_merge(:distinct => args)
-      end
-      alias_method :distinct, :uniq
-
-      # Returns a copy of the dataset with the order changed.
-      def order(*order)
-        clone_merge(:order => order)
-      end
-      
-      alias_method :order_by, :order
-
-      # Returns a copy of the dataset with the order reversed. If no order is
-      # given, the existing order is inverted.
-      def reverse_order(*order)
-        order(*invert_order(order.empty? ? @opts[:order] : order))
-      end
-
-      # Inverts the given order by breaking it into a list of column references
-      # and inverting them.
-      #
-      #   dataset.invert_order([:id.desc]]) #=> [:id]
-      #   dataset.invert_order(:category, :price.desc]) #=>
-      #     [:category.desc, :price]
-      def invert_order(order)
-        new_order = []
-        order.map do |f|
-          if f.is_a?(Sequel::SQL::ColumnExpr) && (f.op == Sequel::SQL::ColumnMethods::DESC)
-            f.l
-          else
-            f.desc
-          end
-        end
-      end
-
-      # Returns a copy of the dataset with the results grouped by the value of 
-      # the given columns
-      def group(*columns)
-        clone_merge(:group => columns)
-      end
-      
-      alias_method :group_by, :group
-
-      # Returns a copy of the dataset with the given conditions imposed upon it.  
-      # If the query has been grouped, then the conditions are imposed in the 
-      # HAVING clause. If not, then they are imposed in the WHERE clause. Filter
-      # accepts a Hash (formated into a list of equality expressions), an Array
-      # (formatted ala ActiveRecord conditions), a String (taken literally), or
-      # a block that is converted into expressions.
-      #
-      #   dataset.filter(:id => 3).sql #=>
-      #     "SELECT * FROM items WHERE (id = 3)"
-      #   dataset.filter('price < ?', 100).sql #=>
-      #     "SELECT * FROM items WHERE price < 100"
-      #   dataset.filter('price < 100').sql #=>
-      #     "SELECT * FROM items WHERE price < 100"
-      #   dataset.filter {price < 100}.sql #=>
-      #     "SELECT * FROM items WHERE (price < 100)"
-      # 
-      # Multiple filter calls can be chained for scoping:
-      #
-      #   software = dataset.filter(:category => 'software')
-      #   software.filter {price < 100}.sql #=>
-      #     "SELECT * FROM items WHERE (category = 'software') AND (price < 100)"
-      def filter(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
-        cond = cond.first if cond.size == 1
-        if cond === true || cond === false
-          raise Error::InvalidFilter, "Invalid filter specified. Did you mean to supply a block?"
-        end
-        parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
-        filter = cond.is_a?(Hash) && cond
-        if @opts[clause]
-          l = expression_list(@opts[clause])
-          r = expression_list(block || cond, parenthesize)
-          clone_merge(clause => "#{l} AND #{r}")
-        else
-          clone_merge(:filter => cond, clause => expression_list(block || cond))
-        end
-      end
-
-      # Adds an alternate filter to an existing filter using OR. If no filter 
-      # exists an error is raised.
-      def or(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
-        cond = cond.first if cond.size == 1
-        parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
-        if @opts[clause]
-          l = expression_list(@opts[clause])
-          r = expression_list(block || cond, parenthesize)
-          clone_merge(clause => "#{l} OR #{r}")
-        else
-          raise Error::NoExistingFilter, "No existing filter found."
-        end
-      end
-
-      # Adds an further filter to an existing filter using AND. If no filter 
-      # exists an error is raised. This method is identical to #filter except
-      # it expects an existing filter.
-      def and(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
-        unless @opts[clause]
-          raise Error::NoExistingFilter, "No existing filter found."
-        end
-        filter(*cond, &block)
-      end
-
-      # Performs the inverse of Dataset#filter.
-      #
-      #   dataset.exclude(:category => 'software').sql #=>
-      #     "SELECT * FROM items WHERE NOT (category = 'software')"
-      def exclude(*cond, &block)
-        clause = (@opts[:group] ? :having : :where)
-        cond = cond.first if cond.size == 1
-        parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
-        if @opts[clause]
-          l = expression_list(@opts[clause])
-          r = expression_list(block || cond, parenthesize)
-          cond = "#{l} AND (NOT #{r})"
-        else
-          cond = "(NOT #{expression_list(block || cond, true)})"
-        end
-        clone_merge(clause => cond)
-      end
-
-      # Returns a copy of the dataset with the where conditions changed. Raises 
-      # if the dataset has been grouped. See also #filter.
-      def where(*cond, &block)
-        if @opts[:group]
-          raise Error, "Can't specify a WHERE clause once the dataset has been grouped"
-        else
-          filter(*cond, &block)
-        end
-      end
-
-      # Returns a copy of the dataset with the having conditions changed. Raises 
-      # if the dataset has not been grouped. See also #filter
-      def having(*cond, &block)
-        unless @opts[:group]
-          raise Error, "Can only specify a HAVING clause on a grouped dataset"
-        else
-          filter(*cond, &block)
-        end
-      end
-
-      # Adds a UNION clause using a second dataset object. If all is true the
-      # clause used is UNION ALL, which may return duplicate rows.
-      def union(dataset, all = false)
-        clone_merge(:union => dataset, :union_all => all)
-      end
-
-      # Adds an INTERSECT clause using a second dataset object. If all is true 
-      # the clause used is INTERSECT ALL, which may return duplicate rows.
-      def intersect(dataset, all = false)
-        clone_merge(:intersect => dataset, :intersect_all => all)
-      end
-
-      # Adds an EXCEPT clause using a second dataset object. If all is true the
-      # clause used is EXCEPT ALL, which may return duplicate rows.
-      def except(dataset, all = false)
-        clone_merge(:except => dataset, :except_all => all)
-      end
-
-      JOIN_TYPES = {
-        :left_outer => 'LEFT OUTER JOIN'.freeze,
-        :right_outer => 'RIGHT OUTER JOIN'.freeze,
-        :full_outer => 'FULL OUTER JOIN'.freeze,
-        :inner => 'INNER JOIN'.freeze
-      }
-
-      # Returns a join clause based on the specified join type and condition.
-      def join_expr(type, table, expr)
-        join_type = JOIN_TYPES[type || :inner]
-        unless join_type
-          raise Error::InvalidJoinType, "Invalid join type: #{type}"
-        end
-
-        join_conditions = {}
-        expr.each do |k, v|
-          k = qualified_column_name(k, table) if k.is_a?(Symbol)
-          v = qualified_column_name(v, @opts[:last_joined_table] || @opts[:from].first) if v.is_a?(Symbol)
-          join_conditions[k] = v
-        end
-        " #{join_type} #{table} ON #{expression_list(join_conditions)}"
-      end
-
-      # Returns a joined dataset with the specified join type and condition.
-      def join_table(type, table, expr)
-        unless expr.is_a?(Hash)
-          expr = {expr => :id}
-        end
-        clause = join_expr(type, table, expr)
-        join = @opts[:join] ? @opts[:join] + clause : clause
-        clone_merge(:join => join, :last_joined_table => table)
-      end
-
-      # Returns a LEFT OUTER joined dataset.
-      def left_outer_join(table, expr); join_table(:left_outer, table, expr); end
-      
-      # Returns a RIGHT OUTER joined dataset.
-      def right_outer_join(table, expr); join_table(:right_outer, table, expr); end
-      
-      # Returns an OUTER joined dataset.
-      def full_outer_join(table, expr); join_table(:full_outer, table, expr); end
-      
-      # Returns an INNER joined dataset.
-      def inner_join(table, expr); join_table(:inner, table, expr); end
-      alias join inner_join
-
-      # Inserts multiple values. If a block is given it is invoked for each
-      # item in the given array before inserting it.
-      def insert_multiple(array, &block)
-        if block
-          array.each {|i| insert(block[i])}
-        else
-          array.each {|i| insert(i)}
-        end
-      end
-
-      # Formats a SELECT statement using the given options and the dataset
-      # options.
-      def select_sql(opts = nil)
-        opts = opts ? @opts.merge(opts) : @opts
-        
-        if sql = opts[:sql]
-          return sql
-        end
-
-        columns = opts[:select]
-        select_columns = columns ? column_list(columns) : WILDCARD
-
-        if distinct = opts[:distinct]
-          distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{column_list(distinct)})"
-          sql = "SELECT #{distinct_clause} #{select_columns}"
-        else
-          sql = "SELECT #{select_columns}"
-        end
-        
-        if opts[:from]
-          sql << " FROM #{source_list(opts[:from])}"
-        end
-        
-        if join = opts[:join]
-          sql << join
-        end
-
-        if where = opts[:where]
-          sql << " WHERE #{where}"
-        end
-
-        if group = opts[:group]
-          sql << " GROUP BY #{column_list(group)}"
-        end
-
-        if order = opts[:order]
-          sql << " ORDER BY #{column_list(order)}"
-        end
-
-        if having = opts[:having]
-          sql << " HAVING #{having}"
-        end
-
-        if limit = opts[:limit]
-          sql << " LIMIT #{limit}"
-          if offset = opts[:offset]
-            sql << " OFFSET #{offset}"
-          end
-        end
-
-        if union = opts[:union]
-          sql << (opts[:union_all] ? \
-            " UNION ALL #{union.sql}" : " UNION #{union.sql}")
-        elsif intersect = opts[:intersect]
-          sql << (opts[:intersect_all] ? \
-            " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
-        elsif except = opts[:except]
-          sql << (opts[:except_all] ? \
-            " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
-        end
-
-        sql
-      end
-      alias_method :sql, :select_sql
-
-      # Formats an INSERT statement using the given values. If a hash is given,
-      # the resulting statement includes column names. If no values are given, 
-      # the resulting statement includes a DEFAULT VALUES clause.
-      #
-      #   dataset.insert_sql() #=> 'INSERT INTO items DEFAULT VALUES'
-      #   dataset.insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
-      #   dataset.insert_sql(:a => 1, :b => 2) #=>
-      #     'INSERT INTO items (a, b) VALUES (1, 2)'
-      def insert_sql(*values)
-        if values.empty?
-          "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
-        else
-          values = values[0] if values.size == 1
-          case values
-          when Sequel::Model
-            insert_sql(values.values)
-          when Array
-            if values.empty?
-              "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
-            elsif values.keys
-              fl = values.keys.map {|f| literal(f.to_sym)}
-              vl = @transform ? transform_save(values.values) : values.values
-              vl.map! {|v| literal(v)}
-              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
-            else
-              "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
-            end
-          when Hash
-            values = transform_save(values) if @transform
-            if values.empty?
-              "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
-            else
-              fl, vl = [], []
-              values.each {|k, v| fl << literal(k.to_sym); vl << literal(v)}
-              "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
-            end
-          when Dataset
-            "INSERT INTO #{@opts[:from]} #{literal(values)}"
-          else
-            "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
-          end
-        end
-      end
-
-      # Formats an UPDATE statement using the given values.
-      #
-      #   dataset.update_sql(:price => 100, :category => 'software') #=>
-      #     "UPDATE items SET price = 100, category = 'software'"
-      def update_sql(values = {}, opts = nil, &block)
-        opts = opts ? @opts.merge(opts) : @opts
-
-        if opts[:group]
-          raise Error::InvalidOperation, "A grouped dataset cannot be updated"
-        elsif (opts[:from].size > 1) or opts[:join]
-          raise Error::InvalidOperation, "A joined dataset cannot be updated"
-        end
-        
-        sql = "UPDATE #{@opts[:from]} SET "
-        if block
-          sql << proc_to_sql(block, :comma_separated => true)
-        else
-          # check if array with keys
-          values = values.to_hash if values.is_a?(Array) && values.keys
-          if values.is_a?(Hash)
-            # get values from hash
-            values = transform_save(values) if @transform
-            set = values.map do |k, v|
-              # convert string key into symbol
-              k = k.to_sym if String === k
-              "#{literal(k)} = #{literal(v)}"
-            end.join(COMMA_SEPARATOR)
-          else
-            # copy values verbatim
-            set = values
-          end
-          sql << set
-        end
-        if where = opts[:where]
-          sql << " WHERE #{where}"
-        end
-
-        sql
-      end
-
-      # Formats a DELETE statement using the given options and dataset options.
-      # 
-      #   dataset.filter {price >= 100}.delete_sql #=>
-      #     "DELETE FROM items WHERE (price >= 100)"
-      def delete_sql(opts = nil)
-        opts = opts ? @opts.merge(opts) : @opts
-
-        if opts[:group]
-          raise Error::InvalidOperation, "Grouped datasets cannot be deleted from"
-        elsif opts[:from].is_a?(Array) && opts[:from].size > 1
-          raise Error::InvalidOperation, "Joined datasets cannot be deleted from"
-        end
-
-        sql = "DELETE FROM #{opts[:from]}"
-
-        if where = opts[:where]
-          sql << " WHERE #{where}"
-        end
-
-        sql
-      end
-
-      # Returns a table reference for use in the FROM clause. If the dataset has
-      # only a :from option refering to a single table, only the table name is 
-      # returned. Otherwise a subquery is returned.
-      def to_table_reference(idx = nil)
-        if opts.keys == [:from] && opts[:from].size == 1
-          opts[:from].first.to_s
-        else
-          idx ? "(#{sql}) t#{idx}" : "(#{sql})"
-        end
-      end
-
-      # Returns an EXISTS clause for the dataset.
-      #
-      #   dataset.exists #=> "EXISTS (SELECT 1 FROM items)"
-      def exists(opts = nil)
-        "EXISTS (#{sql({:select => [1]}.merge(opts || {}))})"
-      end
-
-      # If given an integer, the dataset will contain only the first l results.
-      # If given a range, it will contain only those at offsets within that
-      # range. If a second argument is given, it is used as an offset.
-      def limit(l, o = nil)
-        if l.is_a? Range
-          lim = (l.exclude_end? ? l.last - l.first : l.last + 1 - l.first)
-          clone_merge(:limit => lim, :offset=>l.first)
-        elsif o
-          clone_merge(:limit => l, :offset => o)
-        else
-          clone_merge(:limit => l)
-        end
-      end
-      
-      STOCK_COUNT_OPTS = {:select => ["COUNT(*)".lit], :order => nil}.freeze
-
-      # Returns the number of records in the dataset.
-      def count
-        opts = @opts[:sql] ? \
-          {:sql => "SELECT COUNT(*) FROM (#{@opts[:sql]}) AS c", :order => nil} : \
-          STOCK_COUNT_OPTS
-
-        single_value(opts).to_i
-      end
-    end
-  end
-end