sequel 2.7.1 → 2.8.0

data/lib/sequel_core/adapters/shared/oracle.rb

@@ -13,69 +13,48 @@ module Sequel
     end
     
     module DatasetMethods
+      include Dataset::UnsupportedIntersectExceptAll
+
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having union intersect except order limit'.freeze
+
       def empty?
         db[:dual].where(exists).get(1) == nil
       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) : '*'
-        sql = opts[:distinct] ? \
-        "SELECT DISTINCT #{select_columns}" : \
-        "SELECT #{select_columns}"
-        
-        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
+      private
 
-        if group = opts[:group]
-          sql << " GROUP BY #{expression_list(group)}"
-        end
+      # Oracle doesn't support the use of AS when aliasing a dataset.  It doesn't require
+      # the use of AS anywhere, so this disables it in all cases.
+      def as_sql(expression, aliaz)
+        "#{expression} #{quote_identifier(aliaz)}"
+      end
 
-        if having = opts[:having]
-          sql << " HAVING #{literal(having)}"
-        end
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      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}")
+      # Oracle doesn't support DISTINCT ON
+      def select_distinct_sql(sql, opts)
+        if opts[:distinct]
+          raise(Error, "DISTINCT ON not supported by Oracle") unless opts[:distinct].empty?
+          sql << " DISTINCT"
         end
+      end
 
-        if order = opts[:order]
-          sql << " ORDER BY #{expression_list(order)}"
-        end
+      # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
+      def select_except_sql(sql, opts)
+        sql << " MINUS #{opts[:except].sql}" if opts[:except]
+      end
 
+      # Oracle requires a subselect to do limit and offset
+      def select_limit_sql(sql, opts)
         if limit = opts[:limit]
           if (offset = opts[:offset]) && (offset > 0)
-            sql = "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}"
+            sql.replace("SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}")
           else
-            sql = "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
+            sql.replace("SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}")
           end
         end
-
-        sql
       end
     end
   end

data/lib/sequel_core/adapters/shared/postgres.rb

@@ -4,6 +4,15 @@ module Sequel
     # uses NativeExceptions, the native adapter uses PGError.
     CONVERTED_EXCEPTIONS = []
     
+    @force_standard_strings = true
+
+    # By default, Sequel forces the use of standard strings, so that
+    # '\\' is interpreted as '\\' and not '\\'.  While PostgreSQL defaults
+    # to interpreting plain strings as extended strings, this will change
+    # in a future version of PostgreSQL.  Sequel assumes that SQL standard
+    # strings will be used.
+    metaattr_accessor :force_standard_strings
+
     # Methods shared by adapter/connection instances.
     module AdapterMethods
       attr_writer :db
@@ -57,6 +66,20 @@ module Sequel
       # to implement multi-level transactions with savepoints.
       attr_accessor :transaction_depth
       
+      # Apply connection settings for this connection. Currently, turns
+      # standard_conforming_strings ON if Postgres.force_standard_strings
+      # is true.
+      def apply_connection_settings
+        if Postgres.force_standard_strings
+          sql = "SET standard_conforming_strings = ON"
+          @db.log_info(sql)
+          # This setting will only work on PostgreSQL 8.2 or greater
+          # and we don't know the server version at this point, so
+          # try it unconditionally and rescue any errors.
+          execute(sql) rescue nil
+        end
+      end
+
       # Get the last inserted value for the given sequence.
       def last_insert_id(sequence)
         sql = SELECT_CURRVAL % sequence
@@ -67,6 +90,15 @@ module Sequel
         end
       end
       
+      # Get the primary key for the given table.
+      def primary_key(schema, table)
+        sql = SELECT_PK % [schema, table]
+        @db.log_info(sql)
+        execute(sql) do |r|
+          return single_value(r)
+        end
+      end
+      
       # Get the primary key and sequence for the given table.
       def sequence(schema, table)
         sql = SELECT_SERIAL_SEQUENCE % [schema, table]
@@ -82,15 +114,6 @@ module Sequel
           return single_value(r)
         end
       end
-      
-      # Get the primary key for the given table.
-      def primary_key(schema, table)
-        sql = SELECT_PK % [schema, table]
-        @db.log_info(sql)
-        execute(sql) do |r|
-          return single_value(r)
-        end
-      end
     end
     
     # Methods shared by Database instances that connect to PostgreSQL.
@@ -110,11 +133,6 @@ module Sequel
         @default_schema ||= :public
       end
       
-      # Set a new default schema to use.
-      def default_schema=(schema)
-        @default_schema = schema
-      end
-      
       # Remove the cached entries for primary keys and sequences when dropping a table.
       def drop_table(*names)
         names.each do |name|
@@ -161,12 +179,11 @@ module Sequel
         synchronize(server){|conn| primary_key_for_table(conn, table)}
       end
 
-      # Support :schema__table format for table
-      def schema(table_name=nil, opts={})
-        schema, table_name = schema_and_table(table_name) if table_name
-        opts[:schema] = schema if schema
-        super(table_name, opts)
-      end
+      # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
+      # a rename table operation, so speciying a new schema in new_name will not have an effect.
+      def rename_table_sql(name, new_name)
+        "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
+      end 
 
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
@@ -255,6 +272,11 @@ module Sequel
 
       private
       
+      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers by default.
+      def upcase_identifiers_default
+        false
+      end
+
       # The result of the insert for the given table and values.  If values
       # is an array, assume the first column is the primary key and return
       # that.  If values is a hash, lookup the primary key for the table.  If
@@ -322,7 +344,7 @@ module Sequel
       def schema_parse_tables(opts)
         schemas = {}
         schema_parser_dataset(nil, opts).each do |row|
-          (schemas[row.delete(:table).to_sym] ||= []) << row
+          (schemas[quote_schema_table(SQL::QualifiedIdentifier.new(row.delete(:schema), row.delete(:table)))] ||= []) << row
         end
         schemas.each do |table, rows|
           schemas[table] = schema_parse_rows(rows)
@@ -348,9 +370,9 @@ module Sequel
         if table_name
           ds.filter!(:pg_class__relname=>table_name.to_s)
         else
-          ds.select_more!(:pg_class__relname___table)
+          ds.select_more!(:pg_class__relname___table, :pg_namespace__nspname___schema)
+          ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>(opts[:schema] || default_schema).to_s)
         end
-        ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>(opts[:schema] || default_schema).to_s) if opts[:schema] || !opts.include?(:schema)
         ds
       end
     end
@@ -372,6 +394,7 @@ module Sequel
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having intersect union except order limit lock'.freeze
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
@@ -452,8 +475,10 @@ module Sequel
         case v
         when LiteralString
           v
+        when SQL::Blob
+          db.synchronize{|c| "E'#{c.escape_bytea(v)}'"}
         when String
-          db.synchronize{|c| "'#{SQL::Blob === v ? c.escape_bytea(v) : c.escape_string(v)}'"}
+          db.synchronize{|c| "'#{c.escape_string(v)}'"}
         when Time
           "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
         when DateTime
@@ -489,25 +514,6 @@ module Sequel
         ["INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
       end
       
-      # PostgreSQL assumes unquoted identifiers are lower case by default,
-      # so do not upcase the identifier when quoting it.
-      def quoted_identifier(c)
-        "\"#{c}\""
-      end
-      
-      # Support lock mode, allowing FOR SHARE and FOR UPDATE queries.
-      def select_sql(opts = nil)
-        row_lock_mode = opts ? opts[:lock] : @opts[:lock]
-        sql = super
-        case row_lock_mode
-        when :update
-          sql << FOR_UPDATE
-        when :share
-          sql << FOR_SHARE
-        end
-        sql
-      end
-      
       private
       
       # Call execute_insert on the database object with the given values.
@@ -521,6 +527,21 @@ module Sequel
         insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
       end
 
+      # The order of clauses in the SELECT SQL statement
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
+
+      # Support lock mode, allowing FOR SHARE and FOR UPDATE queries.
+      def select_lock_sql(sql, opts)
+        case opts[:lock]
+        when :update
+          sql << FOR_UPDATE
+        when :share
+          sql << FOR_SHARE
+        end
+      end
+      
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])

data/lib/sequel_core/adapters/shared/progress.rb

@@ -0,0 +1,31 @@
+module Sequel
+  module Progress
+    module DatabaseMethods
+
+      def dataset(opts = nil)
+        ds = super
+        ds.extend(DatasetMethods)
+        ds
+      end
+    end
+  
+    module DatasetMethods
+      include Dataset::UnsupportedIntersectExcept
+
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having union'.freeze
+
+      private
+
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
+
+      # Progress uses TOP for limit, but it is only supported in Progress 10.
+      # The Progress adapter targets Progress 9, so it silently ignores the option.
+      def select_limit_sql(sql, opts)
+        raise(Error, "OFFSET not supported") if opts[:offset]
+        #sql << " TOP #{opts[:limit]}" if opts[:limit]
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/shared/sqlite.rb

@@ -6,6 +6,12 @@ module Sequel
       TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
       TEMP_STORE = {'0' => :default, '1' => :file, '2' => :memory}.freeze
       
+      # Run all alter_table commands in a transaction.  This is technically only
+      # needed for drop column.
+      def alter_table(name, generator=nil, &block)
+        transaction{super}
+      end
+
       # SQLite supports limited table modification.  You can add a column
       # or an index.  Dropping columns is supported by copying the table into
       # a temporary table, dropping the table, and creating a new table without
@@ -18,14 +24,12 @@ module Sequel
           index_definition_sql(table, op)
         when :drop_column
           columns_str = (schema_parse_table(table, {}).map{|c| c[0]} - Array(op[:name])).join(",")
-          ["BEGIN TRANSACTION",
-           "CREATE TEMPORARY TABLE #{table}_backup(#{columns_str})",
+           ["CREATE TEMPORARY TABLE #{table}_backup(#{columns_str})",
            "INSERT INTO #{table}_backup SELECT #{columns_str} FROM #{table}",
            "DROP TABLE #{table}",
            "CREATE TABLE #{table}(#{columns_str})",
            "INSERT INTO #{table} SELECT #{columns_str} FROM #{table}_backup",
-           "DROP TABLE #{table}_backup",
-           "COMMIT"]
+           "DROP TABLE #{table}_backup"]
         else
           raise Error, "Unsupported ALTER TABLE operation"
         end
@@ -82,6 +86,11 @@ module Sequel
       
       private
       
+      # SQLite folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers by default.
+      def upcase_identifiers_default
+        false
+      end
+
       # SQLite supports schema parsing using the table_info PRAGMA, so
       # parse the output of that into the format Sequel expects.
       def schema_parse_table(table_name, opts)
@@ -100,6 +109,8 @@ module Sequel
     
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
+      include Dataset::UnsupportedIntersectExceptAll
+
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
       # ILIKE.

data/lib/sequel_core/adapters/sqlite.rb

@@ -46,11 +46,6 @@ module Sequel
         SQLite::Dataset.new(self, opts)
       end
       
-      # Disconnect all connections from the database.
-      def disconnect
-        @pool.disconnect {|c| c.close}
-      end
-      
       # Run the given SQL with the given arguments and return the number of changed rows.
       def execute_dui(sql, opts={})
         _execute(sql, opts){|conn| conn.execute_batch(sql, opts[:arguments]); conn.changes}
@@ -110,6 +105,11 @@ module Sequel
         o[:max_connections] = 1 if @opts[:database] == ':memory:' || @opts[:database].blank?
         o
       end
+
+      # Disconnect given connections from the database.
+      def disconnect_connection(c)
+        c.close
+      end
     end
     
     # Dataset class for SQLite datasets that use the ruby-sqlite3 driver.
@@ -135,14 +135,6 @@ module Sequel
         
         private
         
-        # Work around for the default prepared statement and argument
-        # mapper code, which wants a hash that maps.  SQLite doesn't
-        # need to do this, but still requires a value for the argument
-        # in order for the substitution to work correctly.
-        def prepared_args_hash
-          true
-        end
-        
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
@@ -221,7 +213,7 @@ module Sequel
       # Prepare the given type of query with the given name and store
       # it in the database.  Note that a new native prepared statement is
       # created on each call to this prepared statement.
-      def prepare(type, name, values=nil)
+      def prepare(type, name=nil, values=nil)
         ps = to_prepared_statement(type, values)
         ps.extend(PreparedStatementMethods)
         db.prepared_statements[name] = ps if name

data/lib/sequel_core/connection_pool.rb

@@ -5,6 +5,9 @@ class Sequel::ConnectionPool
   # The proc used to create a new database connection.
   attr_accessor :connection_proc
 
+  # The proc used to disconnect a database connection.
+  attr_accessor :disconnection_proc
+
   # The maximum number of connections.
   attr_reader :max_size
   
@@ -40,6 +43,7 @@ class Sequel::ConnectionPool
     @max_size = opts[:max_connections] || 4
     @mutex = Mutex.new
     @connection_proc = block
+    @disconnection_proc = opts[:disconnection_proc]
     @servers = [:default]
     @servers += opts[:servers].keys - @servers if opts[:servers] 
     @available_connections = Hash.new{|h,k| h[:default]}
@@ -103,8 +107,11 @@ class Sequel::ConnectionPool
       end
       begin
         yield conn
+      rescue Sequel::DatabaseDisconnectError => dde
+        remove(t, conn, server)
+        raise
       ensure
-        release(t, conn, server)
+        release(t, conn, server) unless dde
       end
     rescue Exception => e
       raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
@@ -116,24 +123,19 @@ class Sequel::ConnectionPool
   # disconnecting from the database, assuming that no connections are currently
   # being used. Once a connection is requested using #hold, the connection pool
   # creates new connections to the database.
-  def disconnect
+  def disconnect(&block)
+    block ||= @disconnection_proc
     @mutex.synchronize do
       @available_connections.each do |server, conns|
-        conns.each{|c| yield(c)} if block_given?
+        conns.each{|c| block.call(c)} if block
         conns.clear
-        @created_count[server] = allocated(server).length
+        set_created_count(server, allocated(server).length)
       end
     end
   end
   
   private
 
-  # Returns the connection owned by the supplied thread for the given server,
-  # if any.
-  def owned_connection(thread, server)
-    @mutex.synchronize{@allocated[server][thread]}
-  end
-  
   # Assigns a connection to the supplied thread for the given server, if one
   # is available.
   def acquire(thread, server)
@@ -154,12 +156,18 @@ class Sequel::ConnectionPool
   # the server is less than the maximum size of the pool.
   def make_new(server)
     if @created_count[server] < @max_size
-      @created_count[server] += 1
+      set_created_count(server, @created_count[server] + 1)
       @connection_proc ? @connection_proc.call(server) : \
         (raise Error, "No connection proc specified")
     end
   end
   
+  # Returns the connection owned by the supplied thread for the given server,
+  # if any.
+  def owned_connection(thread, server)
+    @mutex.synchronize{@allocated[server][thread]}
+  end
+  
   # Releases the connection assigned to the supplied thread and server.
   def release(thread, conn, server)
     @mutex.synchronize do
@@ -167,6 +175,21 @@ class Sequel::ConnectionPool
       available_connections(server) << conn
     end
   end
+
+  # Removes the currently allocated connection from the connection pool.
+  def remove(thread, conn, server)
+    @mutex.synchronize do
+      allocated(server).delete(thread)
+      set_created_count(server, @created_count[server] - 1)
+      @disconnection_proc.call(conn) if @disconnection_proc
+    end
+  end
+
+  # Set the created count for the given server type
+  def set_created_count(server, value)
+    server = :default unless @created_count.include?(server)
+    @created_count[server] = value
+  end
 end
 
 # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
@@ -179,6 +202,9 @@ class Sequel::SingleThreadedPool
   # The proc used to create a new database connection
   attr_writer :connection_proc
   
+  # The proc used to disconnect a database connection.
+  attr_accessor :disconnection_proc
+
   # Initializes the instance with the supplied block as the connection_proc.
   #
   # The single threaded pool takes the following options:
@@ -187,6 +213,7 @@ class Sequel::SingleThreadedPool
   #   to RuntimeError exceptions (default true)
   def initialize(opts={}, &block)
     @connection_proc = block
+    @disconnection_proc = opts[:disconnection_proc]
     @conns = {}
     @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
   end
@@ -200,7 +227,13 @@ class Sequel::SingleThreadedPool
   # This method simulates the ConnectionPool#hold API.
   def hold(server=:default)
     begin
-      yield(@conns[server] ||= @connection_proc.call(server))
+      begin
+        yield(c = (@conns[server] ||= @connection_proc.call(server)))
+      rescue Sequel::DatabaseDisconnectError => dde
+        @conns.delete(server)
+        @disconnection_proc.call(c) if @disconnection_proc
+        raise
+      end
     rescue Exception => e
       # if the error is not a StandardError it is converted into RuntimeError.
       raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
@@ -210,7 +243,8 @@ class Sequel::SingleThreadedPool
   # Disconnects from the database. Once a connection is requested using
   # #hold, the connection is reestablished.
   def disconnect(&block)
-    @conns.values.each{|conn| yield(conn) if block_given?}
+    block ||= @disconnection_proc
+    @conns.values.each{|conn| block.call(conn) if block}
     @conns = {}
   end
 end