sequel 3.47.0 → 3.48.0

data/lib/sequel/extensions/graph_each.rb

@@ -0,0 +1,63 @@
+# The graph_each extension adds Dataset#graph_each and
+# makes Dataset#each call #graph_each if the dataset has been graphed.
+# Dataset#graph_each splits result hashes into subhashes per table:
+#
+#   DB[:a].graph(:b, :id=>:b_id).all
+#   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds.extension(:graph_each)
+#
+# 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(:graph_each)
+
+module Sequel
+  module GraphEach
+    # Fetch the rows, split them into component table parts,
+    # tranform and run the row_proc on each part (if applicable),
+    # and yield a hash of the parts.
+    def graph_each
+      # Reject tables with nil datasets, as they are excluded from
+      # the result set
+      datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
+      # Get just the list of table aliases into a local variable, for speed
+      table_aliases = datasets.collect{|ta,ds| ta}
+      # Get an array of arrays, one for each dataset, with
+      # the necessary information about each dataset, for speed
+      datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
+      # Use the manually set graph aliases, if any, otherwise
+      # use the ones automatically created by .graph
+      column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
+      fetch_rows(select_sql) do |r|
+        graph = {}
+        # Create the sub hashes, one per table
+        table_aliases.each{|ta| graph[ta]={}}
+        # Split the result set based on the column aliases
+        # If there are columns in the result set that are
+        # not in column_aliases, they are ignored
+        column_aliases.each do |col_alias, tc|
+          ta, column = tc
+          graph[ta][column] = r[col_alias]
+        end
+        # For each dataset run the row_proc if applicable
+        datasets.each do |ta,ds,rp|
+          g = graph[ta]
+          graph[ta] = if g.values.any?{|x| !x.nil?}
+            rp ? rp.call(g) : g
+          else
+            nil
+          end
+        end
+
+        yield graph
+      end
+      self
+    end
+  end
+
+  Dataset.register_extension(:graph_each, GraphEach)
+end

data/lib/sequel/extensions/hash_aliases.rb

@@ -0,0 +1,44 @@
+# The hash_aliases extension allows Dataset#select and Dataset#from
+# to treat a hash argument as an alias specification, with keys
+# being the expressions and values being the aliases, 
+# which was the historical behavior before Sequel 4.
+# It is only recommended to use this for backwards compatibility.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds.extension(:hash_aliases)
+#
+# 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(:hash_aliases)
+
+module Sequel
+  module HashAliases
+    def from(*source)
+      super(*convert_hash_aliases(source))
+    end
+
+    def select(*columns, &block)
+      virtual_row_columns(columns, block)
+      super(*convert_hash_aliases(columns), &nil)
+    end
+
+    private
+
+    def convert_hash_aliases(columns)
+      m = []
+      columns.each do |i|
+        if i.is_a?(Hash)
+          m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)})
+        else
+          m << i
+        end
+      end
+      m
+    end
+  end
+
+  Dataset.register_extension(:hash_aliases, HashAliases)
+end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -1,6 +1,12 @@
-# The LooserTypecasting extension changes the float and integer typecasting to
-# use the looser .to_f and .to_i instead of the more strict Kernel.Float and
-# Kernel.Integer.  To load the extension into the database:
+# The LooserTypecasting extension loosens the default database typecasting
+# for the following types:
+#
+# :float :: use to_f instead of Float()
+# :integer :: use to_i instead of Integer()
+# :decimal :: don't check string conversion with Float()
+# :string :: silently allow hash and array conversion to string
+#
+# To load the extension into the database:
 #
 #   DB.extension :looser_typecasting
 
@@ -16,6 +22,11 @@ module Sequel
       value.to_i
     end
 
+    # Typecast the value to an Integer using to_i instead of Kernel.Integer
+    def typecast_value_string(value)
+      value.to_s
+    end
+
     # Typecast the value to a BigDecimal, without checking if strings
     # have a valid format.
     def typecast_value_decimal(value)

data/lib/sequel/extensions/migration.rb

@@ -583,9 +583,8 @@ module Sequel
     def schema_dataset
       c = column
       ds = db.from(table)
-      if !db.table_exists?(table)
-        db.create_table(table){Integer c, :default=>0, :null=>false}
-      elsif !ds.columns.include?(c)
+      db.create_table?(table){Integer c, :default=>0, :null=>false}
+      unless ds.columns.include?(c)
         db.alter_table(table){add_column c, Integer, :default=>0, :null=>false}
       end
       ds.insert(c=>0) if ds.empty?

data/lib/sequel/extensions/named_timezones.rb

@@ -26,6 +26,12 @@
 # York time.  When data is retrieved from the database, it is
 # converted to Los Angeles time.
 #
+# If you are using database specific timezones, you may want to load
+# this extension into the database in order to support similar API:
+#
+#   DB.extension :named_timezones
+#   DB.timezone = 'America/New_York'
+#
 # Note that typecasting from the database timezone to the application
 # timezone when fetching rows is dependent on the database adapter,
 # and only works on adapters where Sequel itself does the conversion.
@@ -37,6 +43,12 @@ module Sequel
   self.datetime_class = DateTime
   
   module NamedTimezones
+    module DatabaseMethods
+      def timezone=(tz)
+        super(Sequel.send(:convert_timezone_setter_arg, tz))
+      end
+    end
+
     # Handles TZInfo::AmbiguousTime exceptions automatically by providing a
     # proc called with both the datetime value being converted as well as
     # the array of TZInfo::TimezonePeriod results. Example:
@@ -47,7 +59,7 @@ module Sequel
     private 
     
     # Assume the given DateTime has a correct time but a wrong timezone.  It is
-    # currently in UTC timezone, but it should be converted to the input_timzone.
+    # currently in UTC timezone, but it should be converted to the input_timezone.
     # Keep the time the same but convert the timezone to the input_timezone.
     # Expects the input_timezone to be a TZInfo::Timezone instance.
     def convert_input_datetime_other(v, input_timezone)
@@ -82,4 +94,5 @@ module Sequel
   end
   
   extend NamedTimezones
+  Database.register_extension(:named_timezones, NamedTimezones::DatabaseMethods)
 end

data/lib/sequel/extensions/null_dataset.rb

@@ -29,11 +29,14 @@
 
 module Sequel
   class Dataset
+    module Nullifiable
+    end
+
     module NullDataset
       # Create a new dataset from the dataset (which won't
       # be nulled) to get the columns if they aren't already cached.
       def columns
-        @columns ||= db.dataset(@opts).columns
+        @columns ||= db.dataset.clone(@opts).columns
       end
 
       # Return 0 without sending a database query.
@@ -90,7 +93,10 @@ module Sequel
 
     # Nullify the current dataset
     def nullify!
+      Sequel::Deprecation.deprecate('Loading the null_dataset extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(Nullifiable)
       extend NullDataset
     end
   end
+
+  Dataset.register_extension(:null_dataset, Dataset::Nullifiable)
 end

data/lib/sequel/extensions/pagination.rb

@@ -2,19 +2,29 @@
 # which return paginated (limited and offset) datasets with some helpful methods
 # that make creating a paginated display easier.
 #
-# To load the extension:
+# This extension uses Object#extend at runtime, which can hurt performance.
 #
-#   Sequel.extension :pagination
+# You can load this extension into specific datasets:
 #
-# This extension uses Object#extend at runtime, which can hurt performance.
+#   ds = DB[:table]
+#   ds.extension(:pagination)
+#
+# 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(:pagination)
 
 module Sequel
+  module DatasetPagination
+  end
+
   class Dataset
     # Returns a paginated dataset. The returned dataset is limited to
     # the page size at the correct offset, and extended with the Pagination
     # module.  If a record count is not provided, does a count of total
     # number of records for this dataset.
     def paginate(page_no, page_size, record_count=nil)
+      Sequel::Deprecation.deprecate('Loading the pagination extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(DatasetPagination)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
       paginated = limit(page_size, (page_no - 1) * page_size)
       paginated.extend(Pagination)
@@ -24,6 +34,7 @@ module Sequel
     # Yields a paginated dataset for each page and returns the receiver. Does
     # a count to find the total number of records for this dataset.
     def each_page(page_size)
+      Sequel::Deprecation.deprecate('Loading the pagination extension globally', "Please use Database/Dataset#extension to load the extension into this dataset") unless is_a?(DatasetPagination)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
       record_count = count
       total_pages = (record_count / page_size.to_f).ceil
@@ -104,6 +115,5 @@ module Sequel
     end
   end
 
-  Database.register_extension(:pagination){}
-  Dataset.register_extension(:pagination){}
+  Dataset.register_extension(:pagination, DatasetPagination)
 end

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -91,6 +91,7 @@ module Sequel
       module DatabaseMethods
         # Extend the database's datasets with the necessary code.
         def self.extended(db)
+          Sequel::Deprecation.deprecate('The pg_auto_parameterize extension', 'Please stop loading it') unless defined?(SEQUEL_EXTENSIONS_NO_DEPRECATION_WARNING)
           db.extend_datasets(DatasetMethods)
         end
 

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -82,8 +82,10 @@ module Sequel
       #
       #   hstore_op - 'a' # (hstore - 'a')
       def -(other)
-        if other.is_a?(String) && !other.is_a?(Sequel::LiteralString)
-          other = Sequel.cast_string(other)
+        other = if other.is_a?(String) && !other.is_a?(Sequel::LiteralString)
+          Sequel.cast_string(other)
+        else
+          wrap_input_array(wrap_input_hash(other))
         end
         HStoreOp.new(super)
       end
@@ -92,35 +94,40 @@ module Sequel
       #
       #   hstore_op['a'] # (hstore -> 'a')
       def [](key)
-        Sequel::SQL::StringExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, key]))
+        v = Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)])
+        if key.is_a?(Array) || (defined?(Sequel::Postgres::PGArray) && key.is_a?(Sequel::Postgres::PGArray)) || (defined?(Sequel::Postgres::ArrayOp) && key.is_a?(Sequel::Postgres::ArrayOp))
+          wrap_output_array(v)
+        else
+          Sequel::SQL::StringExpression.new(:NOOP, v)
+        end
       end
 
       # Check if the receiver contains all of the keys in the given array:
       #
       #   hstore_op.contain_all(:a) # (hstore ?& a)
       def contain_all(other)
-        bool_op(CONTAIN_ALL, other)
+        bool_op(CONTAIN_ALL, wrap_input_array(other))
       end
 
       # Check if the receiver contains any of the keys in the given array:
       #
       #   hstore_op.contain_any(:a) # (hstore ?| a)
       def contain_any(other)
-        bool_op(CONTAIN_ANY, other)
+        bool_op(CONTAIN_ANY, wrap_input_array(other))
       end
 
       # Check if the receiver contains all entries in the other hstore:
       #
       #   hstore_op.contains(:h) # (hstore @> h)
       def contains(other)
-        bool_op(CONTAINS, other)
+        bool_op(CONTAINS, wrap_input_hash(other))
       end
 
       # Check if the other hstore contains all entries in the receiver:
       #
       #   hstore_op.contained_by(:h) # (hstore <@ h)
       def contained_by(other)
-        bool_op(CONTAINED_BY, other)
+        bool_op(CONTAINED_BY, wrap_input_hash(other))
       end
 
       # Check if the receiver contains a non-NULL value for the given key:
@@ -134,7 +141,7 @@ module Sequel
       #
       #   hstore_op.delete('a') # delete(hstore, 'a')
       def delete(key)
-        HStoreOp.new(function(:delete, key))
+        HStoreOp.new(function(:delete, wrap_input_array(wrap_input_hash(key))))
       end
 
       # Transform the receiver into a set of keys and values:
@@ -164,7 +171,7 @@ module Sequel
       #
       #   hstore_op.keys # akeys(hstore)
       def keys
-        function(:akeys)
+        wrap_output_array(function(:akeys))
       end
       alias akeys keys
 
@@ -172,7 +179,7 @@ module Sequel
       #
       #   hstore_op.merge(:a) # (hstore || a)
       def merge(other)
-        HStoreOp.new(Sequel::SQL::PlaceholderLiteralString.new(CONCAT, [self, other]))
+        HStoreOp.new(Sequel::SQL::PlaceholderLiteralString.new(CONCAT, [self, wrap_input_hash(other)]))
       end
       alias concat merge
 
@@ -201,7 +208,7 @@ module Sequel
       #
       #   hstore_op.slice(:a) # slice(hstore, a)
       def slice(keys)
-        HStoreOp.new(function(:slice, keys))
+        HStoreOp.new(function(:slice, wrap_input_array(keys)))
       end
 
       # Return the values as a PostgreSQL set:
@@ -216,7 +223,7 @@ module Sequel
       #
       #   hstore_op.to_array # hstore_to_array(hstore)
       def to_array
-        function(:hstore_to_array)
+        wrap_output_array(function(:hstore_to_array))
       end
 
       # Return a nested array of the receiver, with arrays of
@@ -224,14 +231,14 @@ module Sequel
       #
       #   hstore_op.to_matrix # hstore_to_matrix(hstore)
       def to_matrix
-        function(:hstore_to_matrix)
+        wrap_output_array(function(:hstore_to_matrix))
       end
 
       # Return the values as a PostgreSQL array:
       #
       #   hstore_op.values # avals(hstore)
       def values
-        function(:avals)
+        wrap_output_array(function(:avals))
       end
       alias avals values
 
@@ -248,6 +255,33 @@ module Sequel
       def function(name, *args)
         SQL::Function.new(name, self, *args)
       end
+
+      # Wrap argument in a PGArray if it is an array
+      def wrap_input_array(obj)
+        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
+          Sequel.pg_array(obj)
+        else
+          obj
+        end
+      end
+
+      # Wrap argument in an Hstore if it is a hash
+      def wrap_input_hash(obj)
+        if obj.is_a?(Hash) && Sequel.respond_to?(:hstore) 
+          Sequel.hstore(obj)
+        else
+          obj
+        end
+      end
+
+      # Wrap argument in a PGArrayOp if supported
+      def wrap_output_array(obj)
+        if Sequel.respond_to?(:pg_array_op) 
+          Sequel.pg_array_op(obj)
+        else
+          obj
+        end
+      end
     end
 
     module HStoreOpMethods

data/lib/sequel/extensions/pg_json.rb

@@ -66,11 +66,11 @@ module Sequel
     class JSONArray < DelegateClass(Array)
       include Sequel::SQL::AliasMethods
 
-      # Convert the array to a string using to_json, append a
+      # Convert the array to a json string, append a
       # literalized version of the string to the sql, and explicitly
       # cast the string to json.
       def sql_literal_append(ds, sql)
-        ds.literal_append(sql, to_json)
+        ds.literal_append(sql, Sequel.object_to_json(self))
         sql << CAST_JSON
       end
     end
@@ -79,11 +79,11 @@ module Sequel
     class JSONHash < DelegateClass(Hash)
       include Sequel::SQL::AliasMethods
 
-      # Convert the array to a string using to_json, append a
+      # Convert the hash to a json string, append a
       # literalized version of the string to the sql, and explicitly
       # cast the string to json.
       def sql_literal_append(ds, sql)
-        ds.literal_append(sql, to_json)
+        ds.literal_append(sql, Sequel.object_to_json(self))
         sql << CAST_JSON
       end
 
@@ -106,7 +106,7 @@ module Sequel
       def self.parse_json(s)
         begin
           value = Sequel.parse_json(s)
-        rescue JSON::ParserError=>e
+        rescue Sequel.json_parser_error_class => e
           raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
         end
 
@@ -124,7 +124,7 @@ module Sequel
       def bound_variable_arg(arg, conn)
         case arg
         when JSONArray, JSONHash
-          arg.to_json
+          Sequel.object_to_json(arg)
         else
           super
         end
@@ -136,7 +136,7 @@ module Sequel
       def bound_variable_array(a)
         case a
         when JSONHash, JSONArray
-          "\"#{a.to_json.gsub('"', '\\"')}\""
+          "\"#{Sequel.object_to_json(a).gsub('"', '\\"')}\""
         else
           super
         end