sequel 3.21.0 → 3.29.0

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

@@ -241,16 +241,6 @@ module Sequel
         self << drop_language_sql(name, opts)
       end
       
-      # Remove the cached entries for primary keys and sequences when dropping a table.
-      def drop_table(*names)
-        names.each do |name|
-          name = quote_schema_table(name)
-          @primary_keys.delete(name)
-          @primary_key_sequences.delete(name)
-        end
-        super
-      end
-
       # Drops a trigger from the database.  Arguments:
       # * table : table from which to drop the trigger
       # * name : name of the trigger to drop
@@ -294,6 +284,16 @@ module Sequel
         dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
       end
       
+      # Notifies the given channel.  See the PostgreSQL NOTIFY documentation. Options:
+      #
+      # :payload :: The payload string to use for the NOTIFY statement.  Only supported
+      #             in PostgreSQL 9.0+.
+      # :server :: The server to which to send the NOTIFY statement, if the sharding support
+      #            is being used.
+      def notify(channel, opts={})
+        execute_ddl("NOTIFY #{channel}#{", #{literal(opts[:payload].to_s)}" if opts[:payload]}", opts)
+      end
+
       # Return primary key for the given table.
       def primary_key(table, opts={})
         quoted_table = quote_schema_table(table)
@@ -358,6 +358,11 @@ module Sequel
         @supports_prepared_transactions = self['SHOW max_prepared_transactions'].get.to_i > 0
       end
 
+      # PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
+      def supports_create_table_if_not_exists?
+        server_version >= 90100
+      end
+
       # PostgreSQL supports savepoints
       def supports_savepoints?
         true
@@ -368,30 +373,24 @@ module Sequel
         true
       end
 
-      # Whether the given table exists in the database
+      # Array of symbols specifying table names in the current database.
+      # The dataset used is yielded to the block if one is provided,
+      # otherwise, an array of symbols of table names is returned.  
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def table_exists?(table, opts={})
-        im = input_identifier_meth
-        schema, table = schema_and_table(table)
-        opts[:schema] ||= schema
-        tables(opts){|ds| !ds.first(:relname=>im.call(table)).nil?}
+      def tables(opts={}, &block)
+        pg_class_relname('r', opts, &block)
       end
-      
-      # Array of symbols specifying table names in the current database.
-      # The dataset used is yielded to the block if one is provided,
-      # otherwise, an array of symbols of table names is returned.  
+
+      # Array of symbols specifying view names in the current database.
       #
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def tables(opts={})
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
-        ds = filter_schema(ds, opts)
-        m = output_identifier_meth
-        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      def views(opts={})
+        pg_class_relname('v', opts)
       end
 
       private
@@ -399,8 +398,8 @@ module Sequel
       # If the :prepare option is given and we aren't in a savepoint,
       # prepare the transaction for a two-phase commit.
       def commit_transaction(conn, opts={})
-        if opts[:prepare] && Thread.current[:sequel_transaction_depth] <= 1
-          log_connection_execute(conn, "PREPARE TRANSACTION #{literal(opts[:prepare])}")
+        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
+          log_connection_execute(conn, "PREPARE TRANSACTION #{literal(s)}")
         else
           super
         end
@@ -454,11 +453,6 @@ module Sequel
         "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
       end
 
-      # Always CASCADE the table drop
-      def drop_table_sql(name)
-        "DROP TABLE #{quote_schema_table(name)} CASCADE"
-      end
-      
       # SQL for dropping a trigger from the database.
       def drop_trigger_sql(table, name, opts={})
         "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"
@@ -540,12 +534,29 @@ module Sequel
         conn.execute(sql)
       end
       
+      # Backbone of the tables and views support.
+      def pg_class_relname(type, opts)
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
+        ds = filter_schema(ds, opts)
+        m = output_identifier_meth
+        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      end
+
       # Use a dollar sign instead of question mark for the argument
       # placeholder.
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER
       end
       
+      # Remove the cached entries for primary keys and sequences when a table is
+      # changed.
+      def remove_cached_schema(table)
+        tab = quote_schema_table(table)
+        @primary_keys.delete(tab)
+        @primary_key_sequences.delete(tab)
+        super
+      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)
@@ -560,8 +571,8 @@ module Sequel
 
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        m2 = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        m2 = input_identifier_meth(opts[:dataset])
         ds = metadata_dataset.select(:pg_attribute__attname___name,
             SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
             SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
@@ -628,10 +639,14 @@ module Sequel
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from using where')
+      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values')
+      INSERT_CLAUSE_METHODS_82 = Dataset.clause_methods(:insert, %w'into columns values returning')
+      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with into columns values returning')
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
@@ -645,17 +660,23 @@ module Sequel
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set from where')
+      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with table set from where returning')
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
+        def run(&block)
+          if @prepared_type == :insert && supports_insert_select?
+            fetch_rows(prepared_sql){|r| return r.values.first}
+          else
+            super
+          end
+        end
+
         def prepared_sql
           return @prepared_sql if @prepared_sql
+          @opts[:returning] = insert_pk if @prepared_type == :insert && supports_insert_select?
           super
-          if @prepared_type == :insert and !@opts[:disable_insert_returning] and server_version >= 80200
-            @prepared_sql = insert_returning_pk_sql(*@prepared_modify_values)
-            meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
-          end
           @prepared_sql
         end
       end
@@ -680,7 +701,7 @@ module Sequel
       def complex_expression_sql(op, args)
         case op
         when :^
-          "(#{literal(args.at(0))} # #{literal(args.at(1))})"
+          "(#{args.collect{|a| literal(a)}.join(" # ")})"
         else
           super
         end
@@ -709,25 +730,22 @@ module Sequel
       end
       
       # Insert given values into the database.
-      def insert(*values)
-        if @opts[:sql]
-          execute_insert(insert_sql(*values))
-        elsif @opts[:disable_insert_returning] || server_version < 80200
-          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
+      def insert(*values, &block)
+        if @opts[:returning]
+          super
+        elsif !@opts[:sql] && supports_insert_select?
+          returning(insert_pk).insert(*values){|r| return r.values.first}
+        elsif (f = opts[:from]) && !f.empty?
+          execute_insert(insert_sql(*values), :table=>f.first, :values=>values.size == 1 ? values.first : values)
         else
-          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
+          super
         end
       end
 
-      # Use the RETURNING clause to return the columns listed in returning.
-      def insert_returning_sql(returning, *values)
-        "#{insert_sql(*values)} RETURNING #{column_list(Array(returning))}"
-      end
-
       # Insert a record returning the record inserted
       def insert_select(*values)
-        return if opts[:disable_insert_returning] || server_version < 80200
-        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
+        return unless supports_insert_select?
+        returning.insert(*values){|r| return r}
       end
 
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with
@@ -752,6 +770,12 @@ module Sequel
         [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
+      # PostgreSQL supports using the WITH clause in subqueries if it
+      # supports using WITH at all (i.e. on PostgreSQL 8.4+).
+      def supports_cte_in_subqueries?
+        supports_cte?
+      end
+
       # DISTINCT ON is a PostgreSQL extension
       def supports_distinct_on?
         true
@@ -762,6 +786,14 @@ module Sequel
         true
       end
 
+      def supports_returning?(type)
+        if type == :insert
+          server_version >= 80200 && !opts[:disable_insert_returning]
+        else
+          server_version >= 90100
+        end
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true
@@ -781,7 +813,7 @@ module Sequel
       
       # PostgreSQL allows deleting from joined datasets
       def delete_clause_methods
-        DELETE_CLAUSE_METHODS
+        server_version >= 90100 ? DELETE_CLAUSE_METHODS_91 : DELETE_CLAUSE_METHODS
       end 
 
       # Only include the primary table in the main delete clause
@@ -794,12 +826,23 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
-      # Use the RETURNING clause to return the primary key of the inserted record, if it exists
-      def insert_returning_pk_sql(*values)
+      # PostgreSQL allows a RETURNING clause.
+      def insert_clause_methods
+        if server_version >= 90100
+          INSERT_CLAUSE_METHODS_91
+        elsif server_version >= 80200
+          INSERT_CLAUSE_METHODS_82
+        else
+          INSERT_CLAUSE_METHODS
+        end
+      end
+
+      # Return the primary key to use for RETURNING in an INSERT statement
+      def insert_pk
         pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
+        pk ? Sequel::SQL::Identifier.new(pk) : NULL
       end
-      
+
       # For multiple table support, PostgreSQL requires at least
       # two from tables, with joins allowed.
       def join_from_sql(type, sql)
@@ -836,6 +879,12 @@ module Sequel
         server_version >= 80400 ? SELECT_CLAUSE_METHODS_84 : SELECT_CLAUSE_METHODS
       end
       
+      # PostgreSQL requires parentheses around compound datasets if they use
+      # CTEs, and using them in other places doesn't hurt.
+      def compound_dataset_sql(ds)
+        "(#{super})"
+      end
+
       # Support FOR SHARE locking when using the :share lock style.
       def select_lock_sql(sql)
         @opts[:lock] == :share ? (sql << FOR_SHARE) : super
@@ -866,7 +915,7 @@ module Sequel
 
       # PostgreSQL splits the main table from the joined tables
       def update_clause_methods
-        UPDATE_CLAUSE_METHODS
+        server_version >= 90100 ? UPDATE_CLAUSE_METHODS_91 : UPDATE_CLAUSE_METHODS
       end
 
       # Use FROM to specify additional tables in an update query

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

@@ -6,12 +6,6 @@ module Sequel
       def database_type
         :progress
       end
-
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
     end
   
     module DatasetMethods