sequel 3.47.0 → 3.48.0

data/lib/sequel/extensions/pg_range_ops.rb

@@ -79,8 +79,14 @@ module Sequel
       OPERATORS.keys.each do |f|
         class_eval("def #{f}(v); operator(:#{f}, v) end", __FILE__, __LINE__)
       end
-      alias starts_before ends_before
-      alias ends_after starts_after
+      def starts_before(v)
+        Sequel::Deprecation.deprecate('Postgres::PGRangeOp#starts_before', "Please switch to Postgres::PGRangeOp#ends_before")
+        ends_before(v)
+      end
+      def ends_after(v)
+        Sequel::Deprecation.deprecate('Postgres::PGRangeOp#ends_after', "Please switch to Postgres::PGRangeOp#starts_after")
+        starts_after(v)
+      end
 
       # These operators are already supported by the wrapper, but for ranges they
       # return ranges, so wrap the results in another RangeOp.

data/lib/sequel/extensions/pg_statement_cache.rb

@@ -228,6 +228,7 @@ module Sequel
         # Set the statement_cache for the connection, using the database's
         # :statement_cache_opts option.
         def self.extended(c)
+          Sequel::Deprecation.deprecate('The pg_statement_cache extension', 'Please stop loading it') unless defined?(SEQUEL_EXTENSIONS_NO_DEPRECATION_WARNING)
           c.instance_variable_set(:@statement_cache, StatementCache.new(c.sequel_db.opts[:statement_cache_opts] || {}){|name| c.deallocate(name)})
         end
 

data/lib/sequel/extensions/pretty_table.rb

@@ -9,22 +9,31 @@
 #   |2 |test   |
 #   +--+-------+
 #
-# To load the extension:
+# You can load this extension into specific datasets:
 #
-#   Sequel.extension :pretty_table
+#   ds = DB[:table]
+#   ds.extension(:pretty_table)
+#
+# 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.extension(:pretty_table)
 
 module Sequel
   extension :_pretty_table
 
+  module DatasetPrinter
+  end
+
   class Dataset
     # Pretty prints the records in the dataset as plain-text table.
     def print(*cols)
+      Sequel::Deprecation.deprecate('Loading the pretty_table extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(DatasetPrinter)
       ds = naked
       rows = ds.all
       Sequel::PrettyTable.print(rows, cols.empty? ? ds.columns : cols)
     end
   end
 
-  Database.register_extension(:pretty_table){}
-  Dataset.register_extension(:pretty_table){}
+  Dataset.register_extension(:pretty_table, DatasetPrinter)
 end

data/lib/sequel/extensions/query.rb

@@ -2,18 +2,34 @@
 # a different way to construct queries instead of the usual
 # method chaining.  See Sequel::Dataset#query for details.
 #
-# To load the extension, do:
+# You can load this extension into specific datasets:
 #
-#   Sequel.extension :query
+#   ds = DB[:table]
+#   ds.extension(:query)
+#
+# 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.extension(:query)
 
 module Sequel
+  module DatabaseQuery
+    def self.extended(db)
+      db.extend_datasets(DatasetQuery)
+    end
+  end
+
   class Database
     # Return a dataset modified by the query block
     def query(&block)
+      Sequel::Deprecation.deprecate('Loading the query extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(DatabaseQuery)
       dataset.query(&block)
     end
   end
 
+  module DatasetQuery
+  end
+
   class Dataset
     # Translates a query block into a dataset. Query blocks are an
     # alternative to Sequel's usual method chaining, by using
@@ -29,6 +45,7 @@ module Sequel
     #
     #  dataset = DB[:items].select(:x, :y, :z).filter{(x > 1) & (y > 2)}.reverse(:z)
     def query(&block)
+      Sequel::Deprecation.deprecate('Loading the query extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(DatasetQuery)
       query = Query.new(self)
       query.instance_eval(&block)
       query.dataset
@@ -52,6 +69,6 @@ module Sequel
     end
   end
 
-  Dataset.register_extension(:query){}
-  Database.register_extension(:query){}
+  Dataset.register_extension(:query, DatasetQuery)
+  Database.register_extension(:query, DatabaseQuery)
 end

data/lib/sequel/extensions/ruby18_symbol_extensions.rb

@@ -0,0 +1,22 @@
+# The ruby18_symbol_extensions adds the <, <=, >, >= to Symbol
+# to reflect the mathmatical operators.  It also adds the [] method
+# to Symbol for creating SQL functions.
+#
+# Usage of this extension is not recommended. This extension will
+# only load on ruby 1.8, so you will not be able to upgrade to
+# newer ruby versions if you use it. If you still want to use it,
+# you can load it via:
+#
+#   Sequel.extension :ruby18_symbol_extensions
+
+raise(Sequel::Error, "The ruby18_symbol_extensions is only available on ruby 1.8.") unless RUBY_VERSION < '1.9.0'
+
+class Symbol
+  include Sequel::SQL::InequalityMethods
+
+  # Create an SQL Function with the receiver as the function name
+  # and the given arguments.
+  def [](*args)
+    Sequel::SQL::Function.new(self, *args)
+  end
+end

data/lib/sequel/extensions/schema_caching.rb

@@ -6,10 +6,8 @@
 #
 # Basic usage in application code:
 #
-#   Sequel.extension :schema_caching
-#
 #   DB = Sequel.connect('...')
-#
+#   DB.extension :schema_caching
 #   DB.load_schema_cache('/path/to/schema.dump')
 #
 #   # load model files
@@ -23,10 +21,8 @@
 # all tables, and you don't worry about race conditions, you can
 # choose to use the following in your application code:
 #
-#   Sequel.extension :schema_caching
-#
 #   DB = Sequel.connect('...')
-#
+#   DB.extension :schema_caching
 #   DB.load_schema_cache?('/path/to/schema.dump')
 #
 #   # load model files
@@ -47,9 +43,13 @@
 # you should not attempt to load the schema from a untrusted file.
 
 module Sequel
+  module SchemaCaching
+  end
+
   class Database
     # Dump the cached schema to the filename given in Marshal format.
     def dump_schema_cache(file)
+      Sequel::Deprecation.deprecate('Loading the schema_caching extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaCaching)
       File.open(file, 'wb'){|f| f.write(Marshal.dump(@schemas))}
       nil
     end
@@ -57,12 +57,14 @@ module Sequel
     # Dump the cached schema to the filename given unless the file
     # already exists.
     def dump_schema_cache?(file)
+      Sequel::Deprecation.deprecate('Loading the schema_caching extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaCaching)
       dump_schema_cache(file) unless File.exist?(file)
     end
 
     # Replace the schema cache with the data from the given file, which
     # should be in Marshal format.
     def load_schema_cache(file)
+      Sequel::Deprecation.deprecate('Loading the schema_caching extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaCaching)
       @schemas = Marshal.load(File.read(file))
       nil
     end
@@ -70,9 +72,10 @@ module Sequel
     # Replace the schema cache with the data from the given file if the
     # file exists.
     def load_schema_cache?(file)
+      Sequel::Deprecation.deprecate('Loading the schema_caching extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaCaching)
       load_schema_cache(file) if File.exist?(file)
     end
   end
 
-  Database.register_extension(:schema_caching){}
+  Database.register_extension(:schema_caching, SchemaCaching)
 end

data/lib/sequel/extensions/schema_dumper.rb

@@ -6,11 +6,14 @@
 #
 # To load the extension:
 #
-#   Sequel.extension :schema_dumper
+#   DB.extension :schema_dumper
 
 Sequel.extension :eval_inspect
 
 module Sequel
+  module SchemaDumper
+  end
+
   class Database
     # Dump foreign key constraints for all tables as a migration. This complements
     # the :foreign_keys=>false option to dump_schema_migration. This only dumps
@@ -20,6 +23,7 @@ module Sequel
     # Note that the migration this produces does not have a down
     # block, so you cannot reverse it.
     def dump_foreign_key_migration(options={})
+      Sequel::Deprecation.deprecate('Loading the schema_dumper extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaDumper)
       ts = tables(options)
       <<END_MIG
 Sequel.migration do
@@ -38,6 +42,7 @@ END_MIG
     #                 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={})
+      Sequel::Deprecation.deprecate('Loading the schema_dumper extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaDumper)
       ts = tables(options)
       <<END_MIG
 Sequel.migration do
@@ -62,6 +67,7 @@ END_MIG
     # :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={})
+      Sequel::Deprecation.deprecate('Loading the schema_dumper extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaDumper)
       options = options.dup
       if options[:indexes] == false && !options.has_key?(:foreign_keys)
         # Unless foreign_keys option is specifically set, disable if indexes
@@ -91,6 +97,7 @@ END_MIG
     # Return a string with a create table block that will recreate the given
     # table's schema.  Takes the same options as dump_schema_migration.
     def dump_table_schema(table, options={})
+      Sequel::Deprecation.deprecate('Loading the schema_dumper extension globally', "Please use Database#extension to load the extension into this database") unless is_a?(SchemaDumper)
       table = table.value.to_s if table.is_a?(SQL::Identifier)
       gen = dump_table_generator(table, options)
       commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
@@ -209,13 +216,11 @@ END_MIG
     # For the table given, get the list of foreign keys and return an alter_table
     # string that would add the foreign keys if run in a migration.
     def dump_table_foreign_keys(table, options={})
-      begin
+      if supports_foreign_key_parsing?
         fks = foreign_key_list(table, options).sort_by{|fk| fk[:columns].map{|c| c.to_s}}
-      rescue Sequel::NotImplemented
-        return ''
       end
 
-      if fks.empty?
+      if fks.nil? || fks.empty?
         ''
       else
         dump_add_fk_constraints(table, fks)
@@ -233,40 +238,32 @@ END_MIG
       m = method(:recreate_column)
       im = method(:index_to_generator_opts)
 
-      if options[:indexes] != false
-        begin
-          indexes = indexes(table).sort_by{|k,v| k.to_s}
-        rescue Sequel::NotImplemented
-          nil
-        end
+      if options[:indexes] != false && supports_index_parsing?
+        indexes = indexes(table).sort_by{|k,v| k.to_s}
       end
 
-      if options[:foreign_keys] != false
-        begin
-          fk_list = foreign_key_list(table)
-          
-          if (sfk = options[:skipped_foreign_keys]) && (sfkt = sfk[table])
-            fk_list.delete_if{|fk| sfkt.has_key?(fk[:columns])}
-          end
+      if options[:foreign_keys] != false && supports_foreign_key_parsing?
+        fk_list = foreign_key_list(table)
+        
+        if (sfk = options[:skipped_foreign_keys]) && (sfkt = sfk[table])
+          fk_list.delete_if{|fk| sfkt.has_key?(fk[:columns])}
+        end
 
-          composite_fks, single_fks = fk_list.partition{|h| h[:columns].length > 1}
-          fk_hash = {}
+        composite_fks, single_fks = fk_list.partition{|h| h[:columns].length > 1}
+        fk_hash = {}
 
-          single_fks.each do |fk|
-            column = fk.delete(:columns).first
-            fk.delete(:name)
-            fk_hash[column] = fk
-          end
+        single_fks.each do |fk|
+          column = fk.delete(:columns).first
+          fk.delete(:name)
+          fk_hash[column] = fk
+        end
 
-          s = s.map do |name, info|
-            if fk_info = fk_hash[name]
-              [name, fk_info.merge(info)]
-            else
-              [name, info]
-            end
+        s = s.map do |name, info|
+          if fk_info = fk_hash[name]
+            [name, fk_info.merge(info)]
+          else
+            [name, info]
           end
-        rescue Sequel::NotImplemented
-          nil
         end
       end
 
@@ -281,11 +278,12 @@ END_MIG
     # Return a string that containing add_index/drop_index method calls for
     # creating the index migration.
     def dump_table_indexes(table, meth, options={})
-      begin
+      if supports_index_parsing?
         indexes = indexes(table).sort_by{|k,v| k.to_s}
-      rescue Sequel::NotImplemented
+      else
         return ''
       end
+
       im = method(:index_to_generator_opts)
       gen = create_table_generator do
         indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))}
@@ -311,18 +309,7 @@ END_MIG
     # Sort the tables so that referenced tables are created before tables that
     # reference them, and then by name.  If foreign keys are disabled, just sort by name.
     def sort_dumped_tables(tables, options={})
-      sort_topologically = if options[:foreign_keys] != false
-        begin
-          foreign_key_list(:some_table_that_does_not_exist)
-          true
-        rescue Sequel::NotImplemented
-          false
-        rescue
-          true
-        end
-      end
-
-      if sort_topologically
+      if options[:foreign_keys] != false && supports_foreign_key_parsing?
         table_fks = {}
         tables.each{|t| table_fks[t] = foreign_key_list(t)}
         # Remove self referential foreign keys, not important when sorting.
@@ -484,5 +471,5 @@ END_MIG
     end
   end
 
-  Database.register_extension(:schema_dumper){}
+  Database.register_extension(:schema_dumper, SchemaDumper)
 end

data/lib/sequel/extensions/select_remove.rb

@@ -2,11 +2,20 @@
 # 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:
+# You can load this extension into specific datasets:
 #
-#   Sequel.extension :select_remove
+#   ds = DB[:table]
+#   ds.extension(:select_remove)
+#
+# 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.extension(:select_remove)
 
 module Sequel
+  module SelectRemove
+  end
+
   class Dataset
     # Remove columns from the list of selected columns.  If any of the currently selected
     # columns use expressions/aliases, this will remove selected columns with the given
@@ -29,6 +38,7 @@ module Sequel
     #
     # There may be other cases where this method does not work correctly, use it with caution.
     def select_remove(*cols)
+      Sequel::Deprecation.deprecate('Loading the select_remove extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(SelectRemove)
       if (sel = @opts[:select]) && !sel.empty?
         select(*(columns.zip(sel).reject{|c, s| cols.include?(c)}.map{|c, s| s} - cols))
       else
@@ -37,6 +47,5 @@ module Sequel
     end
   end
 
-  Database.register_extension(:select_remove){}
-  Dataset.register_extension(:select_remove){}
+  Dataset.register_extension(:select_remove, SelectRemove)
 end

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -0,0 +1,117 @@
+# This adds the following dataset methods:
+#
+# []= :: filter with the first argument, update with the second
+# insert_multiple :: insert multiple rows at once
+# set :: alias for update
+# to_csv :: return string in csv format for the dataset
+# db= :: change the dataset's database
+# opts= :: change the dataset's opts
+#
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds.extension(:sequel_3_dataset_methods)
+#
+# 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.extension(:sequel_3_dataset_methods)
+
+module Sequel
+  module Sequel3DatasetMethods
+    COMMA = Dataset::COMMA
+    # The database related to this dataset.  This is the Database instance that
+    # will execute all of this dataset's queries.
+    attr_writer :db
+
+    # The hash of options for this dataset, keys are symbols.
+    attr_writer :opts
+
+    # Update all records matching the conditions with the values specified.
+    # Returns the number of rows affected.
+    #
+    #   DB[:table][:id=>1] = {:id=>2} # UPDATE table SET id = 2 WHERE id = 1
+    #   # => 1 # number of rows affected
+    def []=(conditions, values)
+      filter(conditions).update(values)
+    end
+
+    # Inserts multiple values. If a block is given it is invoked for each
+    # item in the given array before inserting it.  See +multi_insert+ as
+    # a possibly faster version that may be able to insert multiple
+    # records in one SQL statement (if supported by the database).
+    # Returns an array of primary keys of inserted rows.
+    #
+    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}])
+    #   # => [4, 5]
+    #   # INSERT INTO table (x) VALUES (1)
+    #   # INSERT INTO table (x) VALUES (2)
+    #
+    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2; row }
+    #   # => [6, 7]
+    #   # INSERT INTO table (x, y) VALUES (1, 2)
+    #   # INSERT INTO table (x, y) VALUES (2, 4)
+    def insert_multiple(array, &block)
+      if block
+        array.map{|i| insert(block.call(i))}
+      else
+        array.map{|i| insert(i)}
+      end
+    end
+    
+    # Return a copy of the dataset with unqualified identifiers in the
+    # SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
+    # given table. If no columns are currently selected, select all
+    # columns of the given table.
+    #
+    #   DB[:items].filter(:id=>1).qualify_to(:i)
+    #   # SELECT i.* FROM items WHERE (i.id = 1)
+    def qualify_to(table)
+      qualify(table)
+    end
+    
+    # Qualify the dataset to its current first source.  This is useful
+    # if you have unqualified identifiers in the query that all refer to
+    # the first source, and you want to join to another table which
+    # has columns with the same name as columns in the current dataset.
+    # See +qualify_to+.
+    #
+    #   DB[:items].filter(:id=>1).qualify_to_first_source
+    #   # SELECT items.* FROM items WHERE (items.id = 1)
+    def qualify_to_first_source
+      qualify
+    end
+    
+    # Alias for update, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def set(*args)
+      update(*args)
+    end
+    
+    # Returns a string in CSV format containing the dataset records. By 
+    # default the CSV representation includes the column titles in the
+    # first line. You can turn that off by passing false as the 
+    # include_column_titles argument.
+    #
+    # This does not use a CSV library or handle quoting of values in
+    # any way.  If any values in any of the rows could include commas or line
+    # endings, you shouldn't use this.
+    #
+    #   puts DB[:table].to_csv # SELECT * FROM table
+    #   # id,name
+    #   # 1,Jim
+    #   # 2,Bob
+    def to_csv(include_column_titles = true)
+      n = naked
+      cols = n.columns
+      csv = ''
+      csv << "#{cols.join(COMMA)}\r\n" if include_column_titles
+      n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(COMMA)}\r\n"}
+      csv
+    end
+  end
+
+  Dataset.register_extension(:sequel_3_dataset_methods, Sequel3DatasetMethods)
+end