sequel 2.7.1 → 2.8.0

data/lib/sequel_core/database.rb

@@ -14,7 +14,7 @@ module Sequel
     include Schema::SQL
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado db2 dbi informix jdbc mysql odbc odbc_mssql openbase oracle postgres sqlite'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado db2 dbi informix jdbc mysql odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym}
 
     SQL_BEGIN = 'BEGIN'.freeze
     SQL_COMMIT = 'COMMIT'.freeze
@@ -29,6 +29,12 @@ module Sequel
     # Whether to quote identifiers (columns and tables) by default
     @@quote_identifiers = true
 
+    # Whether to upcase identifiers (columns and tables) by default
+    @@upcase_identifiers = nil
+
+    # The default schema to use
+    attr_accessor :default_schema
+
     # Array of SQL loggers to use for this database
     attr_accessor :loggers
 
@@ -38,26 +44,41 @@ module Sequel
     # The connection pool for this database
     attr_reader :pool
 
-    # Whether to quote identifiers (columns and tables) for this database
-    attr_writer :quote_identifiers
-    
     # The prepared statement objects for this database, keyed by name
     attr_reader :prepared_statements
 
+    # Whether to quote identifiers (columns and tables) for this database
+    attr_writer :quote_identifiers
+    
+    # Whether to upcase identifiers (columns and tables) for this database
+    attr_writer :upcase_identifiers
+    
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Sequel::Database is an abstract class that is not useful by itself.
+    #
+    # Takes the following options:
+    # * :default_schema : The default schema to use, should generally be nil
+    # * :disconnection_proc: A proc used to disconnect the connection.
+    # * :loggers : An array of loggers to use.
+    # * :quote_identifiers : Whether to quote identifiers
+    # * :single_threaded : Whether to use a single-threaded connection pool
+    #
+    # All options given are also passed to the ConnectionPool.  If a block
+    # is given, it is used as the connection_proc for the ConnectionPool.
     def initialize(opts = {}, &block)
       @opts = opts
       
       @quote_identifiers = opts.include?(:quote_identifiers) ? opts[:quote_identifiers] : @@quote_identifiers
       @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
       @schemas = nil
+      @default_schema = opts[:default_schema]
       @prepared_statements = {}
       @transactions = []
       @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
       @pool.connection_proc = proc{|server| connect(server)} unless block
+      @pool.disconnection_proc = proc{|conn| disconnect_connection(conn)} unless opts[:disconnection_proc]
 
       @loggers = Array(opts[:logger]) + Array(opts[:loggers])
       ::Sequel::DATABASES.push(self)
@@ -142,6 +163,12 @@ module Sequel
       @@single_threaded = value
     end
 
+    # Sets the default quote_identifiers mode for new databases.
+    # See Sequel.quote_identifiers=.
+    def self.upcase_identifiers=(value)
+      @@upcase_identifiers = value
+    end
+
     ### Private Class Methods ###
 
     # Sets the adapter scheme for the Database class. Call this method in
@@ -212,10 +239,10 @@ module Sequel
       ds = Sequel::Dataset.new(self)
     end
     
-    # Disconnects from the database. This method should be overridden by 
-    # descendants.
+    # Disconnects all available connections from the connection pool.  If any
+    # connections are currently in use, they will not be disconnected.
     def disconnect
-      raise NotImplementedError, "#disconnect should be overridden by adapters"
+      pool.disconnect
     end
 
     # Executes the given SQL. This method should be overridden in descendants.
@@ -250,9 +277,8 @@ module Sequel
     #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).print
     def fetch(sql, *args, &block)
       ds = dataset
-      sql = sql.gsub('?') {|m|  ds.literal(args.shift)}
-      ds.opts[:sql] = sql
-      ds.fetch_rows(sql, &block) if block
+      ds.opts[:sql] = Sequel::SQL::PlaceholderLiteralString.new(sql, args)
+      ds.each(&block) if block
       ds
     end
     alias_method :>>, :fetch
@@ -335,17 +361,19 @@ module Sequel
       @pool.hold(server || :default, &block)
     end
 
-    # Returns true if a table with the given name exists.
+    # Returns true if a table with the given name exists.  This requires a query
+    # to the database unless this database object already has the schema for
+    # the given table name.
     def table_exists?(name)
-      begin 
-        if respond_to?(:tables)
-          tables.include?(name.to_sym)
-        else
+      if @schemas && @schemas[name]
+        true
+      else
+        begin 
           from(name).first
           true
+        rescue
+          false
         end
-      rescue
-        false
       end
     end
     
@@ -458,6 +486,12 @@ module Sequel
       end
     end
 
+    # Returns true if the database upcases identifiers.
+    def upcase_identifiers?
+      return @upcase_identifiers unless @upcase_identifiers.nil?
+      @upcase_identifiers = @opts.include?(:upcase_identifiers) ? @opts[:upcase_identifiers] : (@@upcase_identifiers.nil? ? upcase_identifiers_default : @@upcase_identifiers)
+    end
+    
     # Returns the URI identifying the database.
     # This method can raise an error if the database used options
     # instead of a connection string.
@@ -496,11 +530,6 @@ module Sequel
       {}
     end
     
-    # Sequel doesn't use database schema's by default.
-    def default_schema
-      nil
-    end
-
     # SQL to ROLLBACK a transaction.
     def rollback_transaction_sql
       SQL_ROLLBACK
@@ -520,19 +549,7 @@ module Sequel
     
     # Split the schema information from the table
     def schema_and_table(table_name)
-      case table_name
-      when Symbol
-        s, t, a = dataset.send(:split_symbol, table_name)
-        [s||default_schema, t]
-      when SQL::QualifiedIdentifier
-        [table_name.table, table_name.column]
-      when SQL::Identifier
-        [default_schema, table_name.value]
-      when String
-        [default_schema, table_name]
-      else
-        raise Error, 'table_name should be a Symbol, SQL::QualifiedIdentifier, SQL::Identifier, or String'
-      end
+      schema_utility_dataset.schema_and_table(table_name)
     end
 
     # Return the options for the given server by merging the generic
@@ -559,6 +576,14 @@ module Sequel
     def transaction_error(e, *classes)
       raise_error(e, :classes=>classes) unless Error::Rollback === e
     end
+
+    # Sets whether to upcase identifiers by default.  Should be
+    # overridden in subclasses for databases that fold unquoted
+    # identifiers to lower case instead of uppercase, such as
+    # MySQL, PostgreSQL, and SQLite.
+    def upcase_identifiers_default
+      true
+    end
   end
 end
 

data/lib/sequel_core/database/schema.rb

@@ -40,7 +40,7 @@ module Sequel
     #
     # See Schema::AlterTableGenerator.
     def alter_table(name, generator=nil, &block)
-      @schemas.delete(name.to_sym) if @schemas
+      remove_cached_schema(name)
       generator ||= Schema::AlterTableGenerator.new(self, &block)
       alter_table_sql_list(name, generator.operations).flatten.each {|sql| execute_ddl(sql)}
     end
@@ -71,7 +71,7 @@ module Sequel
     #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
     #   DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     def create_or_replace_view(name, source)
-      @schemas.delete(name.to_sym) if @schemas
+      remove_cached_schema(name)
       source = source.sql if source.is_a?(Dataset)
       execute_ddl("CREATE OR REPLACE VIEW #{quote_identifier(name)} AS #{source}")
     end
@@ -109,7 +109,7 @@ module Sequel
     #   DB.drop_table(:posts, :comments)
     def drop_table(*names)
       names.each do |n|
-        @schemas.delete(n.is_a?(String) ? n.to_sym : n) if @schemas
+        remove_cached_schema(n)
         execute_ddl(drop_table_sql(n))
       end
     end
@@ -119,7 +119,7 @@ module Sequel
     #   DB.drop_view(:cheap_items)
     def drop_view(*names)
       names.each do |n|
-        @schemas.delete(n.to_sym) if @schemas
+        remove_cached_schema(n)
         execute_ddl("DROP VIEW #{quote_identifier(n)}")
       end
     end

data/lib/sequel_core/dataset.rb

@@ -1,4 +1,4 @@
-%w'callback convenience pagination prepared_statements query schema sql'.each do |f|
+%w'callback convenience pagination prepared_statements query schema sql unsupported'.each do |f|
   require "sequel_core/dataset/#{f}"
 end
 
@@ -75,13 +75,16 @@ module Sequel
     # The hash of options for this dataset, keys are symbols.
     attr_accessor :opts
 
+    # Whether to quote identifiers for this dataset
+    attr_writer :quote_identifiers
+    
     # The row_proc for this database, should be a Proc that takes
     # a single hash argument and returns the object you want to
     # fetch_rows to return.
     attr_accessor :row_proc
 
-    # Whether to quote identifiers for this dataset
-    attr_writer :quote_identifiers
+    # Whether to upcase identifiers for this dataset
+    attr_writer :upcase_identifiers
     
     # Constructs a new instance of a dataset with an associated database and 
     # options. Datasets are usually constructed by invoking Database methods:
@@ -97,6 +100,7 @@ module Sequel
     def initialize(db, opts = nil)
       @db = db
       @quote_identifiers = db.quote_identifiers? if db.respond_to?(:quote_identifiers?)
+      @upcase_identifiers = db.upcase_identifiers? if db.respond_to?(:upcase_identifiers?)
       @opts = opts || {}
       @row_proc = nil
       @transform = nil
@@ -415,6 +419,11 @@ module Sequel
       end
     end
     
+    # Whether this dataset upcases identifiers.
+    def upcase_identifiers?
+      @upcase_identifiers
+    end
+    
     # Updates values for the dataset.  The returned value is generally the
     # number of rows updated, but that is adapter dependent.
     def update(*args)

data/lib/sequel_core/dataset/convenience.rb

@@ -198,20 +198,11 @@ module Sequel
     # if the dataset has fixed SQL or selects from another dataset
     # or more than one table.
     def table_exists?
-      if @opts[:sql]
-        raise Sequel::Error, "this dataset has fixed SQL"
-      end
-      
-      if @opts[:from].size != 1
-        raise Sequel::Error, "this dataset selects from multiple sources"
-      end
-      
+      raise(Sequel::Error, "this dataset has fixed SQL") if @opts[:sql]
+      raise(Sequel::Error, "this dataset selects from multiple sources") if @opts[:from].size != 1
       t = @opts[:from].first
-      if t.is_a?(Dataset)
-        raise Sequel::Error, "this dataset selects from a sub query"
-      end
-      
-      @db.table_exists?(t.to_sym)
+      raise(Sequel::Error, "this dataset selects from a sub query") if t.is_a?(Dataset)
+      @db.table_exists?(t)
     end
 
     # Returns a string in CSV format containing the dataset records. By 

data/lib/sequel_core/dataset/prepared_statements.rb

@@ -25,11 +25,10 @@ module Sequel
       end
         
       # Override the given *_sql method based on the type, and
-      # cache the result of the sql.  This requires that the object
-      # that includes this module implement prepared_args_hash.
+      # cache the result of the sql.
       def prepared_sql
         return @prepared_sql if @prepared_sql
-        @prepared_args = prepared_args_hash
+        @prepared_args ||= []
         @prepared_sql = super
         meta_def("#{sql_query_type}_sql"){|*args| prepared_sql}
         @prepared_sql
@@ -37,6 +36,7 @@ module Sequel
       
       private
       
+      # The type of query (:select, :insert, :delete, :update).
       def sql_query_type
         SQL_QUERY_TYPE[@prepared_type]
       end
@@ -51,7 +51,7 @@ module Sequel
     module PreparedStatementMethods
       PLACEHOLDER_RE = /\A\$(.*)\z/
       
-      # The type of prepared statement, should be one of :select,
+      # The type of prepared statement, should be one of :select, :first,
       # :insert, :update, or :delete
       attr_accessor :prepared_type
       
@@ -136,6 +136,15 @@ module Sequel
       def prepared_arg(k)
         @prepared_args[k]
       end
+
+      # Use a clone of the dataset extended with prepared statement
+      # support and using the same argument hash so that you can use
+      # bind variables/prepared arguments in subselects.
+      def subselect_sql(ds)
+        ps = ds.prepare(:select)
+        ps.prepared_args = prepared_args
+        ps.prepared_sql
+      end
     end
     
     # Default implementation for an argument mapper that uses
@@ -151,26 +160,15 @@ module Sequel
       # Keys in the input hash that are used more than once in the query
       # have multiple entries in the output array.
       def map_to_prepared_args(hash)
-        array = []
-        @prepared_args.each{|k,vs| vs.each{|v| array[v] = hash[k]}}
-        array
+        @prepared_args.map{|v| hash[v]}
       end
       
       private
       
-      # Uses a separate array of each key, holding the positions
-      # in the output array (necessary to support arguments
-      # that are used more than once).
-      def prepared_args_hash
-        Hash.new{|h,k| h[k] = Array.new}
-      end
-      
       # Associates the argument with name k with the next position in
       # the output array.
       def prepared_arg(k)
-        @max_prepared_arg ||= 0
-        @prepared_args[k] << @max_prepared_arg
-        @max_prepared_arg += 1
+        @prepared_args << k
         prepared_arg_placeholder
       end
     end
@@ -181,7 +179,7 @@ module Sequel
     # insert or update (if one of those types is used),
     # which may contain placeholders.
     def call(type, bind_variables={}, values=nil)
-      to_prepared_statement(type, values).call(bind_variables)
+      prepare(type, nil, values).call(bind_variables)
     end
     
     # Prepare an SQL statement for later execution. This returns
@@ -193,17 +191,13 @@ module Sequel
     #   ps = prepare(:select, :select_by_name)
     #   ps.call(:name=>'Blah')
     #   db.call(:select_by_name, :name=>'Blah')
-    def prepare(type, name, values=nil)
-      db.prepared_statements[name] = to_prepared_statement(type, values)
+    def prepare(type, name=nil, values=nil)
+      ps = to_prepared_statement(type, values)
+      db.prepared_statements[name] = ps if name
+      ps
     end
     
-    private
-    
-    # The argument placeholder.  Most databases used unnumbered
-    # arguments with question marks, so that is the default.
-    def prepared_arg_placeholder
-      PREPARED_ARG_PLACEHOLDER
-    end
+    protected
     
     # Return a cloned copy of the current dataset extended with
     # PreparedStatementMethods, setting the type and modify values.
@@ -214,5 +208,13 @@ module Sequel
       ps.prepared_modify_values = values
       ps
     end
+
+    private
+    
+    # The argument placeholder.  Most databases used unnumbered
+    # arguments with question marks, so that is the default.
+    def prepared_arg_placeholder
+      PREPARED_ARG_PLACEHOLDER
+    end
   end
-end
+end

data/lib/sequel_core/dataset/sql.rb

@@ -12,6 +12,7 @@ module Sequel
     NULL = "NULL".freeze
     QUESTION_MARK = '?'.freeze
     STOCK_COUNT_OPTS = {:select => ["COUNT(*)".lit], :order => nil}.freeze
+    SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having intersect union except order limit'.freeze
     TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
     WILDCARD = '*'.freeze
@@ -46,7 +47,7 @@ module Sequel
 
     # SQL fragment for specifying all columns in a given table.
     def column_all_sql(ca)
-      "#{quote_identifier(ca.table)}.*"
+      "#{quote_schema_table(ca.table)}.*"
     end
 
     # SQL fragment for complex expressions
@@ -80,9 +81,7 @@ module Sequel
     def delete_sql(opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
-      if sql = opts[:sql]
-        return sql
-      end
+      return static_sql(opts[:sql]) if opts[:sql]
 
       if opts[:group]
         raise Error::InvalidOperation, "Grouped datasets cannot be deleted from"
@@ -122,12 +121,12 @@ module Sequel
       clone(clause => cond)
     end
 
-    # Returns an EXISTS clause for the dataset.
+    # 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(opts = nil)
-      "EXISTS (#{select_sql(opts)})"
+      "EXISTS (#{select_sql(opts)})".lit
     end
 
     # Returns a copy of the dataset with the given conditions imposed upon it.  
@@ -270,9 +269,7 @@ module Sequel
     #   dataset.insert_sql(:a => 1, :b => 2) #=>
     #     'INSERT INTO items (a, b) VALUES (1, 2)'
     def insert_sql(*values)
-      if sql = @opts[:sql]
-        return sql
-      end
+      return static_sql(@opts[:sql]) if @opts[:sql]
 
       from = source_list(@opts[:from])
       case values.size
@@ -494,7 +491,7 @@ module Sequel
       when Date
         v.strftime(DATE_FORMAT)
       when Dataset
-        "(#{v.sql})"
+        "(#{subselect_sql(v)})"
       else
         raise Error, "can't express #{v.inspect} as a SQL literal"
       end
@@ -555,31 +552,43 @@ module Sequel
       "#{literal(oe.expression)} #{oe.descending ? 'DESC' : 'ASC'}"
     end
 
+    # SQL fragment for a literal string with placeholders
+    def placeholder_literal_string_sql(pls)
+      args = pls.args.dup
+      s = pls.str.gsub(QUESTION_MARK){literal(args.shift)}
+      s = "(#{s})" if pls.parens
+      s
+    end
+
     # SQL fragment for the qualifed identifier, specifying
     # a table and a column (or schema and table).
     def qualified_identifier_sql(qcr)
-      [qcr.table, qcr.column].map{|x| x.is_one_of?(SQL::QualifiedIdentifier, SQL::Identifier) ? literal(x) : quote_identifier(x)}.join('.')
+      [qcr.table, qcr.column].map{|x| x.is_one_of?(SQL::QualifiedIdentifier, SQL::Identifier, Symbol) ? literal(x) : quote_identifier(x)}.join('.')
     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.
     def quote_identifier(name)
-      quote_identifiers? ? quoted_identifier(name) : name.to_s
+      name = name.to_s
+      name = name.upcase if upcase_identifiers?
+      name = quoted_identifier(name) if quote_identifiers?
+      name
     end
     alias_method :quote_column_ref, :quote_identifier
 
+    # Separates the schema from the table and returns a string with them
+    # quoted (if quoting identifiers)
+    def quote_schema_table(table)
+      schema, table = schema_and_table(table)
+      "#{"#{quote_identifier(schema)}." if schema}#{quote_identifier(table)}"
+    end
+
     # This method quotes the given name with the SQL standard double quote. 
-    # It uppercases the name given to conform with the SQL standard. This
     # should be overridden by subclasses to provide quoting not matching the
-    # SQL standard, such as backtick (used by MySQL and SQLite), or where
-    # lowercase is the default for unquoted identifiers (PostgreSQL).
-    #
-    # If you are using a database such as Oracle that defaults to uppercase
-    # but you are using lower case identifiers, you should override this
-    # method to not upcase the name for those identifiers.
+    # SQL standard, such as backtick (used by MySQL and SQLite).
     def quoted_identifier(name)
-      "\"#{name.to_s.upcase}\""
+      "\"#{name}\""
     end
 
     # Returns a copy of the dataset with the order reversed. If no order is
@@ -589,6 +598,24 @@ module Sequel
     end
     alias_method :reverse, :reverse_order
 
+    # Split the schema information from the table
+    def schema_and_table(table_name)
+      sch = db.default_schema if db
+      case table_name
+      when Symbol
+        s, t, a = split_symbol(table_name)
+        [s||sch, t]
+      when SQL::QualifiedIdentifier
+        [table_name.table, table_name.column]
+      when SQL::Identifier
+        [sch, table_name.value]
+      when String
+        [sch, table_name]
+      else
+        raise Error, 'table_name should be a Symbol, SQL::QualifiedIdentifier, SQL::Identifier, or String'
+      end
+    end
+
     # Returns a copy of the dataset with the columns selected changed
     # to the given columns.
     def select(*columns)
@@ -610,63 +637,9 @@ module Sequel
     # 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 (#{expression_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]
-        join.each{|j| sql << literal(j)}
-      end
-
-      if where = opts[:where]
-        sql << " WHERE #{literal(where)}"
-      end
-
-      if group = opts[:group]
-        sql << " GROUP BY #{expression_list(group)}"
-      end
-
-      if having = opts[:having]
-        sql << " HAVING #{literal(having)}"
-      end
-
-      if order = opts[:order]
-        sql << " ORDER BY #{expression_list(order)}"
-      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
-
+      return static_sql(opts[:sql]) if opts[:sql]
+      sql = 'SELECT'
+      select_clause_order.each{|x| send("select_#{x}_sql", sql, opts)}
       sql
     end
 
@@ -733,9 +706,7 @@ module Sequel
     def update_sql(values = {}, opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
-      if sql = opts[:sql]
-        return sql
-      end
+      return static_sql(opts[:sql]) if opts[:sql]
 
       if opts[:group]
         raise Error::InvalidOperation, "A grouped dataset cannot be updated"
@@ -788,7 +759,7 @@ module Sequel
     # 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?
+      if columns.blank?
         WILDCARD
       else
         m = columns.map do |i|
@@ -817,7 +788,7 @@ module Sequel
         SQL::BooleanExpression.from_value_pairs(expr)
       when Array
         if String === expr[0]
-          filter_expr(expr.shift.gsub(QUESTION_MARK){literal(expr.shift)}.lit)
+          SQL::PlaceholderLiteralString.new(expr.shift, expr, true)
         else
           SQL::BooleanExpression.from_value_pairs(expr)
         end
@@ -876,14 +847,90 @@ module Sequel
     def qualified_column_name(column, table)
       if Symbol === column 
         c_table, column, c_alias = split_symbol(column)
-        schema, table, t_alias = split_symbol(table) if Symbol === table
-        c_table ||= t_alias || table
+        unless c_table
+          case table
+          when Symbol
+            schema, table, t_alias = split_symbol(table)
+            t_alias ||= Sequel::SQL::QualifiedIdentifier.new(schema, table) if schema
+          when Sequel::SQL::AliasedExpression
+            t_alias = table.aliaz
+          end
+          c_table = t_alias || table
+        end
         ::Sequel::SQL::QualifiedIdentifier.new(c_table, column)
       else
         column
       end
     end
 
+    # The order of methods to call to build the SELECT SQL statement
+    def select_clause_order
+      SELECT_CLAUSE_ORDER
+    end
+
+    # Modify the sql to add the columns selected
+    def select_columns_sql(sql, opts)
+      sql << " #{column_list(opts[:select])}"
+    end
+
+    # Modify the sql to add the DISTINCT modifier
+    def select_distinct_sql(sql, opts)
+      if distinct = opts[:distinct]
+        sql << " DISTINCT#{" ON (#{expression_list(distinct)})" unless distinct.empty?}"
+      end
+    end
+
+    # Modify the sql to add a dataset to the EXCEPT clause
+    def select_except_sql(sql, opts)
+      sql << " EXCEPT#{' ALL' if opts[:except_all]} #{opts[:except].sql}" if opts[:except]
+    end
+
+    # Modify the sql to add the list of tables to select FROM
+    def select_from_sql(sql, opts)
+      sql << " FROM #{source_list(opts[:from])}" if opts[:from]
+    end
+
+    # Modify the sql to add the expressions to GROUP BY
+    def select_group_sql(sql, opts)
+      sql << " GROUP BY #{expression_list(opts[:group])}" if opts[:group]
+    end
+
+    # Modify the sql to add the filter criteria in the HAVING clause
+    def select_having_sql(sql, opts)
+      sql << " HAVING #{literal(opts[:having])}" if opts[:having]
+    end
+
+    # Modify the sql to add a dataset to the INTERSECT clause
+    def select_intersect_sql(sql, opts)
+      sql << " INTERSECT#{' ALL' if opts[:intersect_all]} #{opts[:intersect].sql}" if opts[:intersect]
+    end
+
+    # Modify the sql to add the list of tables to JOIN to
+    def select_join_sql(sql, opts)
+      opts[:join].each{|j| sql << literal(j)} if opts[:join]
+    end
+
+    # Modify the sql to limit the number of rows returned and offset
+    def select_limit_sql(sql, opts)
+      sql << " LIMIT #{opts[:limit]}" if opts[:limit]
+      sql << " OFFSET #{opts[:offset]}" if opts[:offset]
+    end
+
+    # Modify the sql to add the expressions to ORDER BY
+    def select_order_sql(sql, opts)
+      sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
+    end
+
+    # Modify the sql to add a dataset to the UNION clause
+    def select_union_sql(sql, opts)
+      sql << " UNION#{' ALL' if opts[:union_all]} #{opts[:union].sql}" if opts[:union]
+    end
+
+    # Modify the sql to add the filter criteria in the WHERE clause
+    def select_where_sql(sql, opts)
+      sql << " WHERE #{literal(opts[:where])}" if opts[:where]
+    end
+
     # Converts an array of source names into into a comma separated list.
     def source_list(source)
       if source.nil? || source.empty?
@@ -920,7 +967,19 @@ module Sequel
       end
     end
 
-    # SQL fragement specifying a table name.
+    # SQL to use if this dataset uses static SQL.  Since static SQL
+    # can be a PlaceholderLiteralString in addition to a String,
+    # we literalize nonstrings.
+    def static_sql(sql)
+      sql.is_a?(String) ? sql : literal(sql)
+    end
+
+    # SQL fragment for a subselect using the given database's SQL.
+    def subselect_sql(ds)
+      ds.sql
+    end
+
+    # SQL fragment specifying a table name.
     def table_ref(t)
       case t
       when Dataset