sequel 3.28.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)
@@ -398,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
@@ -548,6 +548,15 @@ module Sequel
         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)
@@ -562,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),
@@ -692,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
@@ -722,12 +731,14 @@ module Sequel
       
       # Insert given values into the database.
       def insert(*values, &block)
-        if @opts[:sql] || @opts[:returning]
+        if @opts[:returning]
           super
-        elsif supports_insert_select?
+        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
-          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
+          super
         end
       end
 
@@ -868,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

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

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

@@ -11,14 +11,6 @@ module Sequel
       TEMP_STORE = [:default, :file, :memory].freeze
       VIEWS_FILTER = "type = 'view'".freeze
 
-      # Run all alter_table commands in a transaction.  This is technically only
-      # needed for drop column.
-      def alter_table(name, generator=nil, &block)
-        remove_cached_schema(name)
-        generator ||= Schema::AlterTableGenerator.new(self, &block)
-        transaction{generator.operations.each{|op| alter_table_sql_list(name, [op]).flatten.each{|sql| execute_ddl(sql)}}}
-      end
-
       # A symbol signifying the value of the auto_vacuum PRAGMA.
       def auto_vacuum
         AUTO_VACUUM[pragma_get(:auto_vacuum).to_i]
@@ -31,7 +23,20 @@ module Sequel
         value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
         pragma_set(:auto_vacuum, value)
       end
+
+      # Boolean signifying the value of the case_sensitive_likePRAGMA, or nil
+      # if not using SQLite 3.2.3+.
+      def case_sensitive_like
+        pragma_get(:case_sensitive_like).to_i == 1 if sqlite_version >= 30203
+      end
       
+      # Set the case_sensitive_like PRAGMA using the given boolean value, if using
+      # SQLite 3.2.3+.  If not using 3.2.3+, no error is raised. See pragma_set.
+      # Consider using the :case_sensitive_like Database option instead.
+      def case_sensitive_like=(value)
+        pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
+      end
+
       # SQLite uses the :sqlite database type.
       def database_type
         :sqlite
@@ -162,6 +167,22 @@ module Sequel
 
       private
 
+      # Run all alter_table commands in a transaction.  This is technically only
+      # needed for drop column.
+      def apply_alter_table(table, ops)
+        transaction do 
+          if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint}
+            # If you are just doing constraints, apply all of them at the same time,
+            # as otherwise all but the last one get lost.
+            alter_table_sql_list(table, [{:op=>:add_constraints, :ops=>ops}]).flatten.each{|sql| execute_ddl(sql)}
+          else
+            # Run each operation separately, as later operations may depend on the
+            # results of earlier operations.
+            ops.each{|op| alter_table_sql_list(table, [op]).flatten.each{|sql| execute_ddl(sql)}}
+          end
+        end
+      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
@@ -188,11 +209,26 @@ module Sequel
           duplicate_table(table){|columns| columns.each{|s| s[:null] = op[:null] if s[:name].to_s == op[:name].to_s}}
         when :set_column_type
           duplicate_table(table){|columns| columns.each{|s| s[:type] = op[:type] if s[:name].to_s == op[:name].to_s}}
+        when :drop_constraint
+          case op[:type]
+          when :primary_key
+            duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = nil}}
+          when :foreign_key
+            duplicate_table(table){|columns| columns.each{|s| s[:table] = nil}}
+          when :unique
+            duplicate_table(table)
+          else
+            raise Error, "Unsupported :type option for drop_constraint: #{op[:type].inspect}"
+          end
+        when :add_constraint
+          duplicate_table(table, :constraints=>[op])
+        when :add_constraints
+          duplicate_table(table, :constraints=>op[:ops])
         else
-          raise Error, "Unsupported ALTER TABLE operation"
+          raise Error, "Unsupported ALTER TABLE operation: #{op[:op].inspect}"
         end
       end
-      
+
       # The array of column symbols in the table, except for ones given in opts[:except]
       def backup_table_name(table, opts={})
         table = table.gsub('`', '')
@@ -202,17 +238,14 @@ module Sequel
         end
       end
 
-      # Allow use without a generator, needed for the alter table hackery that Sequel allows.
-      def column_list_sql(generator)
-        generator.is_a?(Schema::Generator) ? super : generator.map{|c| column_definition_sql(c)}.join(', ')
-      end
-
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.
       def connection_pragmas
         ps = []
         v = typecast_value_boolean(opts.fetch(:foreign_keys, 1))
         ps << "PRAGMA foreign_keys = #{v ? 1 : 0}"
+        v = typecast_value_boolean(opts.fetch(:case_sensitive_like, 1))
+        ps << "PRAGMA case_sensitive_like = #{v ? 1 : 0}"
         [[:auto_vacuum, AUTO_VACUUM], [:synchronous, SYNCHRONOUS], [:temp_store, TEMP_STORE]].each do |prag, con|
           if v = opts[prag]
             raise(Error, "Value for PRAGMA #{prag} not supported, should be one of #{con.join(', ')}") unless v = con.index(v.to_sym)
@@ -234,15 +267,20 @@ module Sequel
           cols.reject!{|c| nono.include? c[:name] }
         end
 
-        if foreign_keys
-          metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
-            c = cols.find {|co| co[:name] == row[:from] } or next
-            c[:table] = row[:table]
-            c[:key] = row[:to]
-            c[:on_update] = on_delete_sql_to_sym(row[:on_update])
-            c[:on_delete] = on_delete_sql_to_sym(row[:on_delete])
-            # is there any way to get deferrable status?
+        begin
+          if foreign_keys
+            metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
+              c = cols.find {|co| co[:name] == row[:from] } or next
+              c[:table] = row[:table]
+              c[:key] = row[:to]
+              c[:on_update] = on_delete_sql_to_sym(row[:on_update])
+              c[:on_delete] = on_delete_sql_to_sym(row[:on_delete])
+              # is there any way to get deferrable status?
+            end
           end
+        rescue Sequel::DatabaseError
+          # Doesn't work correctly on some versions of JDBC SQLite,
+          # giving a "query does not return ResultSet" error.
         end
         cols
       end
@@ -257,17 +295,26 @@ module Sequel
         opts[:old_columns_proc].call(old_columns) if opts[:old_columns_proc]
 
         yield def_columns if block_given?
-        def_columns_str = column_list_sql(def_columns)
+
+        constraints = (opts[:constraints] || []).dup
+        pks = []
+        def_columns.each{|c| pks << c[:name] if c[:primary_key]}
+        if pks.length > 1
+          constraints << {:type=>:primary_key, :columns=>pks}
+          def_columns.each{|c| c[:primary_key] = false if c[:primary_key]}
+        end
+
+        def_columns_str = (def_columns.map{|c| column_definition_sql(c)} + constraints.map{|c| constraint_definition_sql(c)}).join(', ')
         new_columns = old_columns.dup
         opts[:new_columns_proc].call(new_columns) if opts[:new_columns_proc]
 
         qt = quote_schema_table(table)
         bt = quote_identifier(backup_table_name(qt))
         a = [
-           "CREATE TABLE #{bt}(#{def_columns_str})",
-           "INSERT INTO #{bt}(#{dataset.send(:identifier_list, new_columns)}) SELECT #{dataset.send(:identifier_list, old_columns)} FROM #{qt}",
-           "DROP TABLE #{qt}",
-           "ALTER TABLE #{bt} RENAME TO #{qt}"
+           "ALTER TABLE #{qt} RENAME TO #{bt}",
+           "CREATE TABLE #{qt}(#{def_columns_str})",
+           "INSERT INTO #{qt}(#{dataset.send(:identifier_list, new_columns)}) SELECT #{dataset.send(:identifier_list, old_columns)} FROM #{bt}",
+           "DROP TABLE #{bt}"
         ]
         indexes(table).each do |name, h|
           if (h[:columns].map{|x| x.to_s} - new_columns).empty?
@@ -306,7 +353,7 @@ module Sequel
 
       # Parse the output of the table_info pragma
       def parse_pragma(table_name, opts)
-        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth.call(table_name)).map do |row|
+        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name)).map do |row|
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
@@ -326,7 +373,7 @@ module Sequel
       # 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)
-        m = output_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
         parse_pragma(table_name, opts).map do |row|
           [m.call(row.delete(:name)), row]
         end
@@ -361,13 +408,16 @@ module Sequel
         case op
         when :~, :'!~', :'~*', :'!~*'
           raise Error, "SQLite does not support pattern matching via regular expressions"
-        when :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
-          # SQLite is case insensitive for ASCII, and non case sensitive for other character sets
-          "#{'NOT ' if [:'NOT LIKE', :'NOT ILIKE'].include?(op)}(#{literal(args.at(0))} LIKE #{literal(args.at(1))})"
+        when :ILIKE
+          super(:LIKE, args.map{|a| SQL::Function.new(:upper, a)})
+        when :"NOT LIKE", :"NOT ILIKE"
+          "NOT #{complex_expression_sql((op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)}"
         when :^
-          a = literal(args.at(0))
-          b = literal(args.at(1))
-          "((~(#{a} & #{b})) & (#{a} | #{b}))"
+          complex_expression_arg_pairs(args) do |a, b|
+            a = literal(a)
+            b = literal(b)
+            "((~(#{a} & #{b})) & (#{a} | #{b}))"
+          end
         when :extract
           part = args.at(0)
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
@@ -408,6 +458,18 @@ module Sequel
         "`#{c}`"
       end
       
+      # When a qualified column is selected on SQLite and the qualifier
+      # is a subselect, the column name used is the full qualified name
+      # (including the qualifier) instead of just the column name.  To
+      # get correct column names, you must use an alias.
+      def select(*cols)
+        if ((f = @opts[:from]) && f.any?{|t| t.is_a?(Dataset) || (t.is_a?(SQL::AliasedExpression) && t.expression.is_a?(Dataset))}) || ((j = @opts[:join]) && j.any?{|t| t.table.is_a?(Dataset)})
+          super(*cols.map{|c| alias_qualified_column(c)})
+        else
+          super
+        end
+      end
+      
       # SQLite does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
@@ -442,6 +504,23 @@ module Sequel
         aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
         "#{expression} AS #{literal(aliaz.to_s)}"
       end
+
+      # If col is a qualified column, alias it to the same as the column name
+      def alias_qualified_column(col)
+        case col
+        when Symbol
+          t, c, a = split_symbol(col)
+          if t && !a
+            alias_qualified_column(SQL::QualifiedIdentifier.new(t, c))
+          else
+            col
+          end
+        when SQL::QualifiedIdentifier
+          SQL::AliasedExpression.new(col, col.column)
+        else
+          col
+        end
+      end
       
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
@@ -464,7 +543,7 @@ module Sequel
       def select_lock_sql(sql)
         super unless @opts[:lock] == :update
       end
-      
+
       # SQLite treats a DELETE with no WHERE clause as a TRUNCATE
       def _truncate_sql(table)
         "DELETE FROM #{table}"

data/lib/sequel/adapters/sqlite.rb

@@ -21,7 +21,6 @@ module Sequel
     # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
     {
-      %w'timestamp datetime' => ::Sequel.method(:database_to_application_timestamp),
       %w'date' => ::Sequel.method(:string_to_date),
       %w'time' => ::Sequel.method(:string_to_time),
       %w'bit bool boolean' => tt.method(:boolean),
@@ -47,6 +46,16 @@ module Sequel
       end
       
       private_class_method :uri_to_options
+
+      # The conversion procs to use for this database
+      attr_reader :conversion_procs
+
+      def initialize(opts={})
+        super
+        @conversion_procs = SQLITE_TYPES.dup
+        @conversion_procs['timestamp'] = method(:to_application_timestamp)
+        @conversion_procs['datetime'] = method(:to_application_timestamp)
+      end
       
       # Connect to the database.  Since SQLite is a file based database,
       # the only options available are :database (to specify the database
@@ -68,11 +77,6 @@ module Sequel
         db
       end
       
-      # Return instance of Sequel::SQLite::Dataset with the given options.
-      def dataset(opts = nil)
-        SQLite::Dataset.new(self, opts)
-      end
-      
       # Run the given SQL with the given arguments and yield each row.
       def execute(sql, opts={}, &block)
         _execute(:select, sql, opts, &block)
@@ -113,7 +117,8 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
             log_args = opts[:arguments]
-            args = opts.fetch(:arguments, [])
+            args = {}
+            opts.fetch(:arguments, {}).each{|k, v| args[k] = prepared_statement_argument(v)}
             case type
             when :select
               log_yield(sql, log_args){conn.query(sql, args, &block)}
@@ -200,6 +205,8 @@ module Sequel
     # Dataset class for SQLite datasets that use the ruby-sqlite3 driver.
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
+
+      Database::DatasetClass = self
       
       PREPARED_ARG_PLACEHOLDER = ':'.freeze
       
@@ -288,7 +295,8 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |result|
           i = -1
-          type_procs = result.types.map{|t| SQLITE_TYPES[base_type_name(t)]}
+          cps = db.conversion_procs
+          type_procs = result.types.map{|t| cps[base_type_name(t)]}
           cols = result.columns.map{|c| i+=1; [output_identifier(c), i, type_procs[i]]}
           @columns = cols.map{|c| c.first}
           result.each do |values|

data/lib/sequel/adapters/swift.rb

@@ -15,16 +15,19 @@ module Sequel
     DATABASE_SETUP = {:postgres=>proc do |db|
         Sequel.ts_require 'adapters/swift/postgres'
         db.extend(Sequel::Swift::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::Postgres::Dataset
         db.swift_class = ::Swift::DB::Postgres
       end,
       :mysql=>proc do |db|
         Sequel.ts_require 'adapters/swift/mysql'
         db.extend(Sequel::Swift::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::MySQL::Dataset
         db.swift_class = ::Swift::DB::Mysql
       end,
       :sqlite=>proc do |db|
         Sequel.ts_require 'adapters/swift/sqlite'
         db.extend(Sequel::Swift::SQLite::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::SQLite::Dataset
         db.swift_class = ::Swift::DB::Sqlite3
       end,
     }
@@ -59,11 +62,6 @@ module Sequel
         setup_connection(swift_class.new(server_opts(server)))
       end
       
-      # Return a Sequel::Swift::Dataset object for this database.
-      def dataset(opts = nil)
-        Swift::Dataset.new(self, opts)
-      end
-    
       # Execute the given SQL, yielding a Swift::Result if a block is given.
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
@@ -134,6 +132,8 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       # Set the columns and yield the hashes to the block.
       def fetch_rows(sql, &block)
         execute(sql) do |res|