sequel 3.36.1 → 3.37.0

data/lib/sequel/extensions/pg_range_ops.rb

@@ -0,0 +1,122 @@
+# The pg_range_ops extension adds support to Sequel's DSL to make
+# it easier to call PostgreSQL range functions and operators.
+#
+# To load the extension:
+#
+#   Sequel.extension :pg_range_ops
+#
+# The most common usage is taking an object that represents an SQL
+# identifier (such as a :symbol), and calling #pg_range on it:
+#
+#   r = :range.pg_range
+#
+# This creates a Sequel::Postgres::RangeOp object that can be used
+# for easier querying:
+#
+#   r.contains(:other)      # range @> other
+#   r.contained_by(:other)  # range <@ other 
+#   r.overlaps(:other)      # range && other
+#   r.left_of(:other)       # range << other
+#   r.right_of(:other)      # range >> other
+#   r.starts_before(:other) # range &< other
+#   r.ends_after(:other)    # range &> other
+#   r.adjacent_to(:other)   # range -|- other
+#
+#   r.lower            # lower(range)
+#   r.upper            # upper(range)
+#   r.isempty          # isempty(range)
+#   r.lower_inc        # lower_inc(range)
+#   r.upper_inc        # upper_inc(range)
+#   r.lower_inf        # lower_inf(range)
+#   r.upper_inf        # upper_inf(range)
+#   
+# See the PostgreSQL range function and operator documentation for more
+# details on what these functions and operators do.
+#
+# If you are also using the pg_range extension, you should load it before
+# loading this extension.  Doing so will allow you to use PGArray#op to get
+# an RangeOp, allowing you to perform range operations on range literals.
+
+module Sequel
+  module Postgres
+    # The RangeOp class is a simple container for a single object that
+    # defines methods that yield Sequel expression objects representing
+    # PostgreSQL range operators and functions.
+    #
+    # Most methods in this class are defined via metaprogramming, see
+    # the pg_range_ops extension documentation for details on the API.
+    class RangeOp < Sequel::SQL::Wrapper
+      OPERATORS = {
+        :contains => ["(".freeze, " @> ".freeze, ")".freeze].freeze,
+        :contained_by => ["(".freeze, " <@ ".freeze, ")".freeze].freeze,
+        :left_of => ["(".freeze, " << ".freeze, ")".freeze].freeze,
+        :right_of => ["(".freeze, " >> ".freeze, ")".freeze].freeze,
+        :starts_before => ["(".freeze, " &< ".freeze, ")".freeze].freeze,
+        :ends_after => ["(".freeze, " &> ".freeze, ")".freeze].freeze,
+        :adjacent_to => ["(".freeze, " -|- ".freeze, ")".freeze].freeze,
+        :overlaps => ["(".freeze, " && ".freeze, ")".freeze].freeze,
+      }
+      FUNCTIONS = %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf'
+
+      FUNCTIONS.each do |f|
+        class_eval("def #{f}; function(:#{f}) end", __FILE__, __LINE__)
+      end
+      OPERATORS.keys.each do |f|
+        class_eval("def #{f}(v); operator(:#{f}, v) end", __FILE__, __LINE__)
+      end
+
+      # These operators are already supported by the wrapper, but for ranges they
+      # return ranges, so wrap the results in another RangeOp.
+      %w'+ * -'.each do |f|
+        class_eval("def #{f}(v); RangeOp.new(super) end", __FILE__, __LINE__)
+      end
+
+      # Return the receiver.
+      def pg_range
+        self
+      end
+
+      private
+
+      # Create a boolen expression for the given type and argument.
+      def operator(type, other)
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(OPERATORS[type], [value, other]))
+      end
+
+      # Return a function called with the receiver.
+      def function(name)
+        Sequel::SQL::Function.new(name, self)
+      end
+    end
+
+    module RangeOpMethods
+      # Wrap the receiver in an RangeOp so you can easily use the PostgreSQL
+      # range functions and operators with it.
+      def pg_range
+        RangeOp.new(self)
+      end
+    end
+
+    if defined?(PGRange)
+      class PGRange
+        # Wrap the PGRange instance in an RangeOp, allowing you to easily use
+        # the PostgreSQL range functions and operators with literal ranges.
+        def op
+          RangeOp.new(self)
+        end
+      end
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::Postgres::RangeOpMethods
+  end
+
+  class LiteralString
+    include Sequel::Postgres::RangeOpMethods
+  end
+end
+
+class Symbol
+  include Sequel::Postgres::RangeOpMethods
+end

data/lib/sequel/extensions/pg_statement_cache.rb

@@ -3,8 +3,7 @@
 # executed repeatedly.  When combined with the pg_auto_parameterize
 # extension, it can take Sequel code such as:
 #
-#   DB.extend Sequel::Postgres::AutoParameterize::DatabaseMethods
-#   DB.extend Sequel::Postgres::StatementCache::DatabaseMethods
+#   DB.extension :pg_auto_parameterize, :pg_statement_cache
 #   DB[:table].filter(:a=>1)
 #   DB[:table].filter(:a=>2)
 #   DB[:table].filter(:a=>3)
@@ -313,4 +312,6 @@ module Sequel
       end
     end
   end
+
+  Database.register_extension(:pg_statement_cache, Postgres::StatementCache::DatabaseMethods)
 end

data/lib/sequel/extensions/pretty_table.rb

@@ -1,6 +1,17 @@
 # The pretty_table extension adds Sequel::Dataset#print and the
 # Sequel::PrettyTable class for creating nice-looking plain-text
-# tables.
+# tables.  Example:
+#
+#   +--+-------+
+#   |id|name   |
+#   |--+-------|
+#   |1 |fasdfas|
+#   |2 |test   |
+#   +--+-------+
+#
+# To load the extension:
+#
+#   Sequel.extension :pretty_table
 
 module Sequel
   extension :_pretty_table

data/lib/sequel/extensions/query.rb

@@ -1,6 +1,10 @@
 # The query extension adds Sequel::Dataset#query which allows
 # a different way to construct queries instead of the usual
 # method chaining.
+#
+# To load the extension, do:
+#
+#   Sequel.extension :query
 
 module Sequel
   class Database

data/lib/sequel/extensions/query_literals.rb

@@ -21,17 +21,15 @@
 # desirable in this area, but for backwards compatibility, the
 # defaults won't be changed until the next major release.
 #
-# Loading this extension does nothing by default except make the
-# Sequel::QueryLiterals module available.  You can extend specific
-# datasets with this module:
+# You can load this extension into specific datasets:
 #
 #   ds = DB[:table]
-#   ds.extend(Sequel::QueryLiterals)
+#   ds.extension(:query_literals)
 #
-# Order you can extend all of a database's datasets with it, which
+# Or you can load it into all of a database's datasets, which
 # is probably the desired behavior if you are using this extension:
 #
-#   DB.extend_datasets(Sequel::QueryLiterals)
+#   DB.extension(:query_literals)
 
 module Sequel
   # The QueryLiterals module can be used to make select, group, and
@@ -76,4 +74,6 @@ module Sequel
       end
     end
   end
+
+  Dataset.register_extension(:query_literals, QueryLiterals)
 end

data/lib/sequel/extensions/schema_dumper.rb

@@ -3,6 +3,10 @@
 # database (which can be the same type or a different type than
 # the current database).  The main interface is through
 # Sequel::Database#dump_schema_migration.
+#
+# To load the extension:
+#
+#   Sequel.extension :schema_dumper
 
 module Sequel
   class Database
@@ -17,7 +21,7 @@ module Sequel
       ts = tables(options)
       <<END_MIG
 Sequel.migration do
-  up do
+  change do
 #{ts.sort_by{|t| t.to_s}.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
   end
 end
@@ -26,38 +30,35 @@ END_MIG
 
     # Dump indexes for all tables as a migration.  This complements
     # the :indexes=>false option to dump_schema_migration. Options:
-    # * :same_db - Create a dump for the same database type, so
-    #   don't ignore errors if the index statements fail.
-    # * :index_names - If set to false, don't record names of indexes. If
-    #   set to :namespace, prepend the table name to the index name if the
-    #   database does not use a global index namespace.
+    # :same_db :: Create a dump for the same database type, so
+    #             don't ignore errors if the index statements fail.
+    # :index_names :: If set to false, don't record names of indexes. If
+    #                 set to :namespace, prepend the table name to the index name if the
+    #                 database does not use a global index namespace.
     def dump_indexes_migration(options={})
       ts = tables(options)
       <<END_MIG
 Sequel.migration do
-  up do
+  change do
 #{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
   end
-  
-  down do
-#{ts.sort_by{|t| t.to_s}.reverse.map{|t| dump_table_indexes(t, :drop_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
-  end
 end
 END_MIG
     end
 
     # Return a string that contains a Sequel::Migration subclass that when
     # run would recreate the database structure. Options:
-    # * :same_db - Don't attempt to translate database types to ruby types.
-    #   If this isn't set to true, all database types will be translated to
-    #   ruby types, but there is no guarantee that the migration generated
-    #   will yield the same type.  Without this set, types that aren't
-    #   recognized will be translated to a string-like type.
-    # * :foreign_keys - If set to false, don't dump foreign_keys
-    # * :indexes - If set to false, don't dump indexes (they can be added
-    #   later via dump_index_migration).
-    # * :index_names - If set to false, don't record names of indexes. If
-    #   set to :namespace, prepend the table name to the index name.
+    # :same_db :: Don't attempt to translate database types to ruby types.
+    #             If this isn't set to true, all database types will be translated to
+    #             ruby types, but there is no guarantee that the migration generated
+    #             will yield the same type.  Without this set, types that aren't
+    #             recognized will be translated to a string-like type.
+    # :foreign_keys :: If set to false, don't dump foreign_keys (they can be
+    #             added later via #dump_foreign_key_migration)
+    # :indexes :: If set to false, don't dump indexes (they can be added
+    #             later via #dump_index_migration).
+    # :index_names :: If set to false, don't record names of indexes. If
+    #                 set to :namespace, prepend the table name to the index name.
     def dump_schema_migration(options={})
       options = options.dup
       if options[:indexes] == false && !options.has_key?(:foreign_keys)
@@ -78,13 +79,9 @@ END_MIG
 
       <<END_MIG
 Sequel.migration do
-  up do
+  change do
 #{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}#{"\n    \n" if skipped_fks}#{skipped_fks}
   end
-  
-  down do
-    drop_table(#{ts.reverse.inspect[1...-1]})
-  end
 end
 END_MIG
     end
@@ -113,16 +110,15 @@ END_MIG
       end
     end
 
-    # Convert the given name and parsed database schema into an array with a method
-    # name and arguments to it to pass to a Schema::Generator to recreate the column.
-    def column_schema_to_generator_opts(name, schema, options)
+    # Recreate the column in the passed Schema::Generator from the given name and parsed database schema.
+    def recreate_column(name, schema, gen, options)
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
         type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
         if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
-          [:primary_key, name]
+          gen.primary_key(name)
         else
-          [:primary_key, name, type_hash]
+          gen.primary_key(name, type_hash)
         end
       else
         col_opts = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
@@ -137,9 +133,14 @@ END_MIG
         col_opts[:null] = false if schema[:allow_null] == false
         if table = schema[:table]
           [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}
-          [:foreign_key, name, table, col_opts]
+          col_opts[:type] = type unless type == Integer || type == 'integer'
+          gen.foreign_key(name, table, col_opts)
         else
-          [:column, name, type, col_opts]
+          gen.column(name, type, col_opts)
+          if (type == Integer || type == Bignum) && schema[:db_type] =~ / unsigned\z/io
+            Sequel.extension :eval_inspect
+            gen.check(Sequel::SQL::Identifier.new(name) >= 0)
+          end
         end
       end
     end
@@ -197,7 +198,7 @@ END_MIG
     # string that would add the foreign keys if run in a migration.
     def dump_add_fk_constraints(table, fks)
       sfks = "alter_table(#{table.inspect}) do\n"
-      sfks << Schema::Generator.new(self) do
+      sfks << create_table_generator do
         fks.sort_by{|fk| fk[:columns].map{|c| c.to_s}}.each do |fk|
           foreign_key fk[:columns], fk
         end
@@ -229,7 +230,7 @@ END_MIG
       s = schema(table).dup
       pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
       options = options.merge(:single_pk=>true) if pks.length == 1
-      m = method(:column_schema_to_generator_opts)
+      m = method(:recreate_column)
       im = method(:index_to_generator_opts)
 
       if options[:indexes] != false
@@ -269,8 +270,8 @@ END_MIG
         end
       end
 
-      Schema::Generator.new(self) do
-        s.each{|name, info| send(*m.call(name, info, options))}
+      create_table_generator do
+        s.each{|name, info| m.call(name, info, self, options)}
         primary_key(pks) if !@primary_key && pks.length > 0
         indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))} if indexes
         composite_fks.each{|fk| send(:foreign_key, fk[:columns], fk)} if composite_fks
@@ -286,7 +287,7 @@ END_MIG
         return ''
       end
       im = method(:index_to_generator_opts)
-      gen = Schema::Generator.new(self) do
+      gen = create_table_generator do
         indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))}
       end
       gen.dump_indexes(meth=>table, :ignore_errors=>!options[:same_db])

data/lib/sequel/extensions/select_remove.rb

@@ -1,6 +1,10 @@
 # The select_remove extension adds Sequel::Dataset#select_remove for removing existing selected
 # columns from a dataset.  It's not part of Sequel core as it is rarely needed and has
 # some corner cases where it can't work correctly.
+#
+# To load the extension:
+#
+#   Sequel.extension :select_remove
 
 module Sequel
   class Dataset

data/lib/sequel/extensions/server_block.rb

@@ -4,8 +4,7 @@
 #
 # First, you need to enable it on the database object:
 #
-#   Sequel.extension :server_block
-#   DB.extend Sequel::ServerBlock
+#   DB.extension :server_block
 # 
 # Then you can call with_server:
 #
@@ -136,4 +135,6 @@ module Sequel
       end
     end
   end
+
+  Database.register_extension(:server_block, ServerBlock)
 end

data/lib/sequel/extensions/split_array_nil.rb

@@ -0,0 +1,65 @@
+# The split_array_nil extension overrides Sequel's default handling of
+# IN/NOT IN with arrays of values to do specific nil checking.  For example,
+#
+#   ds = DB[:table].where(:column=>[1, nil])
+# 
+# By default, that produces the following SQL:
+#
+#   SELECT * FROM table WHERE (column IN (1, NULL))
+#
+# However, because NULL = NULL is not true in SQL (it is NULL), this
+# will not return rows in the table where the column is NULL.  This
+# extension allows for an alternative behavior more similar to ruby,
+# which will return rows in the table where the column is NULL, using
+# a query like:
+#
+#   SELECT * FROM table WHERE ((column IN (1)) OR (column IS NULL)))
+#
+# Similarly, for NOT IN queries:
+#
+#   ds = DB[:table].exclude(:column=>[1, nil])
+#   # Default:
+#   #   SELECT * FROM table WHERE (column NOT IN (1, NULL))
+#   # with split_array_nils extension:
+#   #   SELECT * FROM table WHERE ((column NOT IN (1)) AND (column IS NOT NULL)))
+#
+# To use this extension with a single dataset:
+#
+#   ds = ds.extension(:split_array_nil)
+#
+# To use this extension for all of a database's datasets:
+#
+#   DB.extension(:split_array_nil)
+
+module Sequel
+  class Dataset
+    module SplitArrayNil
+      # Over the IN/NOT IN handling with an array of values where one of the
+      # values in the array is nil, by removing nils from the array of values,
+      # and using a separate OR IS NULL clause for IN or AND IS NOT NULL clause
+      # for NOT IN.
+      def complex_expression_sql_append(sql, op, args)
+      case op
+      when :IN, :"NOT IN"
+        vals = args.at(1)
+        if vals.is_a?(Array) && vals.any?{|v| v.nil?}
+          cols = args.at(0)
+          vals = vals.compact
+          c = Sequel::SQL::BooleanExpression
+          if op == :IN
+            literal_append(sql, c.new(:OR, c.new(:IN, cols, vals), c.new(:IS, cols, nil)))
+          else
+            literal_append(sql, c.new(:AND, c.new(:"NOT IN", cols, vals), c.new(:"IS NOT", cols, nil)))
+          end
+        else
+          super
+        end
+      else
+        super
+      end
+      end
+    end
+  end
+
+  Dataset.register_extension(:split_array_nil, Dataset::SplitArrayNil)
+end