sequel 3.48.0 → 4.0.0

data/lib/sequel/extensions/pg_array.rb

@@ -164,7 +164,7 @@ module Sequel
       #                             to DatabaseMethods.
       #
       # If a block is given, it is treated as the :converter option.
-      def self.register(db_type, opts={}, &block)
+      def self.register(db_type, opts=OPTS, &block)
         db_type = db_type.to_s
         typecast_method = opts[:typecast_method]
         type = (typecast_method || opts[:type_symbol] || db_type).to_sym
@@ -248,7 +248,7 @@ module Sequel
         # different array types per Database.  Use of this method does not
         # affect global state, unlike PGArray.register.  See PGArray.register for
         # possible options.
-        def register_array_type(db_type, opts={}, &block)
+        def register_array_type(db_type, opts=OPTS, &block)
           opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_array_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge(opts)
           unless (opts.has_key?(:scalar_oid) || block) && opts.has_key?(:oid)
             array_oid, scalar_oid = from(:pg_type).where(:typname=>db_type.to_s).get([:typarray, :oid])
@@ -285,8 +285,10 @@ module Sequel
         # Automatically handle array types for the given named types. 
         def convert_named_procs_to_procs(named_procs)
           h = super
-          from(:pg_type).where(:oid=>h.keys).select_map([:typname, :oid, :typarray]).each do |name, scalar_oid, array_oid|
-            register_array_type(name, :type_procs=>h, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
+          unless h.empty?
+            from(:pg_type).where(:oid=>h.keys).select_map([:typname, :oid, :typarray]).each do |name, scalar_oid, array_oid|
+              register_array_type(name, :type_procs=>h, :oid=>array_oid.to_i, :scalar_oid=>scalar_oid.to_i)
+            end
           end
           h
         end

data/lib/sequel/extensions/pg_array_ops.rb

@@ -76,7 +76,9 @@ module Sequel
       #
       #   array_op[1] # array[1]
       def [](key)
-        Sequel::SQL::Subscript.new(self, [key])
+        s = Sequel::SQL::Subscript.new(self, [key])
+        s = ArrayOp.new(s) if key.is_a?(Range)
+        s
       end
 
       # Call the ALL function:
@@ -124,6 +126,23 @@ module Sequel
         function(:array_dims)
       end
 
+      # Convert the array into an hstore using the hstore function.
+      # If given an argument, use the two array form:
+      #
+      #   array_op.hstore          # hstore(array)
+      #   array_op.hstore(:array2) # hstore(array, array2)
+      def hstore(arg=(no_arg_given=true; nil))
+        v = if no_arg_given
+          Sequel.function(:hstore, self)
+        else
+          Sequel.function(:hstore, self, wrap_array(arg))
+        end
+        if Sequel.respond_to?(:hstore_op)
+          v = Sequel.hstore_op(v)
+        end
+        v
+      end
+
       # Call the array_length method:
       #
       #   array_op.length    # array_length(array, 1)
@@ -161,6 +180,21 @@ module Sequel
         self
       end
 
+      # Remove the given element from the array:
+      #
+      #   array_op.remove(1) # array_remove(array, 1)
+      def remove(element)
+        ArrayOp.new(function(:array_remove, element))
+      end
+
+      # Replace the given element in the array with another
+      # element:
+      #
+      #   array_op.replace(1, 2) # array_replace(array, 1, 2)
+      def replace(element, replacement)
+        ArrayOp.new(function(:array_replace, element, replacement))
+      end
+
       # Call the array_to_string method:
       #
       #   array_op.join           # array_to_string(array, '', NULL)

data/lib/sequel/extensions/pg_json.rb

@@ -100,6 +100,16 @@ module Sequel
         end
       end
 
+      # Parse JSON data coming from the database.  Since PostgreSQL allows
+      # non JSON data in JSON fields (such as plain numbers and strings),
+      # we don't want to raise an exception for that.
+      def self.db_parse_json(s)
+        parse_json(s)
+      rescue Sequel::InvalidValue
+        raise unless s.is_a?(String)
+        parse_json("[#{s}]").first
+      end
+
       # Parse the given string as json, returning either a JSONArray
       # or JSONHash instance, and raising an error if the JSON
       # parsing does not yield an array or hash.
@@ -174,7 +184,7 @@ module Sequel
       end
     end
 
-    PG_TYPES[114] = JSONDatabaseMethods.method(:parse_json)
+    PG_TYPES[114] = JSONDatabaseMethods.method(:db_parse_json)
     if defined?(PGArray) && PGArray.respond_to?(:register)
       PGArray.register('json', :oid=>199, :scalar_oid=>114)
     end
@@ -191,7 +201,7 @@ module Sequel
       when Hash
         Postgres::JSONHash.new(v)
       else
-        raise Error, "Sequel.pg_json requires a hash or array argument"
+        Sequel.pg_json_op(v)
       end
     end
   end

data/lib/sequel/extensions/pg_json_ops.rb

@@ -0,0 +1,266 @@
+# The pg_json_ops extension adds support to Sequel's DSL to make
+# it easier to call PostgreSQL JSON functions and operators (added
+# first in PostgreSQL 9.3).
+#
+# To load the extension:
+#
+#   Sequel.extension :pg_json_ops
+#
+# The most common usage is passing an expression to Sequel.pg_json_op:
+#
+#   j = Sequel.pg_json_op(:json_column)
+#
+# If you have also loaded the pg_json extension, you can use
+# Sequel.pg_json as well:
+#
+#  j = Sequel.pg_json(:json_column)
+#
+# Also, on most Sequel expression objects, you can call the pg_json
+# method:
+#
+#   j = Sequel.expr(:json_column).pg_json
+#
+# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
+# or you have loaded the {core_refinements extension}[link:files/doc/core_refinements_rdoc.html])
+# and have activated refinements for the file, you can also use Symbol#pg_json:
+#
+#   j = :json_column.pg_json
+#
+# This creates a Sequel::Postgres::JSONOp object that can be used
+# for easier querying:
+#
+#   j[1]                     # (json_column -> 1)
+#   j[%w'a b']               # (json_column #> ARRAY['a','b'])
+#   j.get_text(1)            # (json_column ->> 1)
+#   j.get_text(%w'a b')      # (json_column #>> ARRAY['a','b'])
+#   j.extract('a', 'b')      # json_extract_path(json_column, 'a', 'b')
+#   j.extract_text('a', 'b') # json_extract_path_text(json_column, 'a', 'b')
+#
+#   j.array_length           # json_array_length(json_column)
+#   j.array_elements         # json_array_elements(json_column)
+#   j.each                   # json_each(json_column)
+#   j.each_text              # json_each_text(json_column)
+#   j.keys                   # json_object_keys(json_column)
+#
+#   j.populate(:a)           # json_populate_record(:a, json_column)
+#   j.populate_set(:a)       # json_populate_recordset(:a, json_column)
+#
+# If you are also using the pg_json extension, you should load it before
+# loading this extension.  Doing so will allow you to use JSONHash#op and
+# JSONArray#op to get a JSONOp, allowing you to perform json operations
+# on json literals.
+module Sequel
+  module Postgres
+    # The JSONOp class is a simple container for a single object that
+    # defines methods that yield Sequel expression objects representing
+    # PostgreSQL json operators and functions.
+    #
+    # In the method documentation examples, assume that:
+    #
+    #   json_op = Sequel.pg_json(:json)
+    class JSONOp < Sequel::SQL::Wrapper
+      GET = ["(".freeze, " -> ".freeze, ")".freeze].freeze
+      GET_TEXT = ["(".freeze, " ->> ".freeze, ")".freeze].freeze
+      GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
+      GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
+
+      # Get JSON array element or object field as json.  If an array is given,
+      # gets the object at the specified path.
+      #
+      #   json_op[1] # (json -> 1)
+      #   json_op['a'] # (json -> 'a')
+      #   json_op[%w'a b'] # (json #> ARRAY['a', 'b'])
+      def [](key)
+        if is_array?(key)
+          json_op(GET_PATH, wrap_array(key))
+        else
+          json_op(GET, key)
+        end
+      end
+      alias get []
+
+      # Returns a set of json values for the elements in the json array.
+      #
+      #   json_op.array_elements # json_oarray_elements(json)
+      def array_elements
+        function(:json_array_elements)
+      end
+
+      # Get the length of the outermost json array.
+      #
+      #   json_op.array_length # json_array_length(json)
+      def array_length
+        Sequel::SQL::NumericExpression.new(:NOOP, function(:json_array_length))
+      end
+
+      # Returns a set of key and value pairs, where the keys
+      # are text and the values are JSON.
+      #
+      #   json_op.each # json_each(json)
+      def each
+        function(:json_each)
+      end
+
+      # Returns a set of key and value pairs, where the keys
+      # and values are both text.
+      #
+      #   json_op.each_text # json_each_text(json)
+      def each_text
+        function(:json_each_text)
+      end
+
+      # Returns a json value for the object at the given path.
+      #
+      #   json_op.extract('a') # json_extract_path(json, 'a')
+      #   json_op.extract('a', 'b') # json_extract_path(json, 'a', 'b')
+      def extract(*a)
+        JSONOp.new(function(:json_extract_path, *a))
+      end
+
+      # Returns a text value for the object at the given path.
+      #
+      #   json_op.extract_text('a') # json_extract_path_text(json, 'a')
+      #   json_op.extract_text('a', 'b') # json_extract_path_text(json, 'a', 'b')
+      def extract_text(*a)
+        Sequel::SQL::StringExpression.new(:NOOP, function(:json_extract_path_text, *a))
+      end
+
+      # Get JSON array element or object field as text.  If an array is given,
+      # gets the object at the specified path.
+      #
+      #   json_op.get_text(1) # (json ->> 1)
+      #   json_op.get_text('a') # (json ->> 'a')
+      #   json_op.get_text(%w'a b') # (json #>> ARRAY['a', 'b'])
+      def get_text(key)
+        if is_array?(key)
+          json_op(GET_PATH_TEXT, wrap_array(key))
+        else
+          json_op(GET_TEXT, key)
+        end
+      end
+
+      # Returns a set of keys AS text in the json object.
+      #
+      #   json_op.keys # json_object_keys(json)
+      def keys
+        function(:json_object_keys)
+      end
+
+      # Return the receiver, since it is already a JSONOp.
+      def pg_json
+        self
+      end
+
+      # Expands the given argument using the columns in the json.
+      #
+      #   json_op.populate(arg) # json_populate_record(arg, json)
+      def populate(arg)
+        SQL::Function.new(:json_populate_record, arg, self)
+      end
+
+      # Expands the given argument using the columns in the json.
+      #
+      #   json_op.populate_set(arg) # json_populate_recordset(arg, json)
+      def populate_set(arg)
+        SQL::Function.new(:json_populate_recordset, arg, self)
+      end
+
+      private
+
+      # Return a placeholder literal with the given str and args, wrapped
+      # in an JSONOp, used by operators that return json.
+      def json_op(str, args)
+        JSONOp.new(Sequel::SQL::PlaceholderLiteralString.new(str, [self, args]))
+      end
+
+      # Return a function with the given name, and the receiver as the first
+      # argument, with any additional arguments given.
+      def function(name, *args)
+        SQL::Function.new(name, self, *args)
+      end
+
+      # Whether the given object represents an array in PostgreSQL.
+      def is_array?(a)
+        a.is_a?(Array) || (defined?(PGArray) && a.is_a?(PGArray)) || (defined?(ArrayOp) && a.is_a?(ArrayOp))
+      end
+
+      # Return a placeholder literal with the given str and args, wrapped
+      # in an SQL::StringExpression, used by operators that return text.
+      def text_op(str, args)
+        Sequel::SQL::StringExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [self, args]))
+      end
+
+      # Automatically wrap argument in a PGArray if it is a plain Array.
+      # Requires that the pg_array extension has been loaded to work.
+      def wrap_array(arg)
+        if arg.instance_of?(Array) && Sequel.respond_to?(:pg_array)
+          Sequel.pg_array(arg)
+        else
+          arg
+        end
+      end
+    end
+
+    module JSONOpMethods
+      # Wrap the receiver in an JSONOp so you can easily use the PostgreSQL
+      # json functions and operators with it.
+      def pg_json
+        JSONOp.new(self)
+      end
+    end
+
+    if defined?(JSONArray)
+      class JSONArray
+        # Wrap the JSONHash instance in an JSONOp, allowing you to easily use
+        # the PostgreSQL json functions and operators with literal jsons.
+        def op
+          JSONOp.new(self)
+        end
+      end
+
+      class JSONHash
+        # Wrap the JSONHash instance in an JSONOp, allowing you to easily use
+        # the PostgreSQL json functions and operators with literal jsons.
+        def op
+          JSONOp.new(self)
+        end
+      end
+    end
+  end
+
+  module SQL::Builders
+    # Return the object wrapped in an Postgres::JSONOp.
+    def pg_json_op(v)
+      case v
+      when Postgres::JSONOp
+        v
+      else
+        Postgres::JSONOp.new(v)
+      end
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::Postgres::JSONOpMethods
+  end
+
+  class LiteralString
+    include Sequel::Postgres::JSONOpMethods
+  end
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::Postgres::JSONOpMethods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::JSONOpMethods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/pg_range.rb

@@ -92,7 +92,7 @@ module Sequel
       #                proc.
       #
       # If a block is given, it is treated as the :converter option.
-      def self.register(db_type, opts={}, &block)
+      def self.register(db_type, opts=OPTS, &block)
         db_type = db_type.to_s.dup.freeze
 
         if converter = opts[:converter]
@@ -328,7 +328,7 @@ module Sequel
       # :empty :: Whether the range is empty (has no points)
       # :exclude_begin :: Whether the beginning element is excluded from the range.
       # :exclude_end :: Whether the ending element is excluded from the range.
-      def initialize(beg, en, opts={})
+      def initialize(beg, en, opts=OPTS)
         @begin = beg
         @end = en
         @empty = !!opts[:empty]

data/lib/sequel/extensions/pg_range_ops.rb

@@ -79,14 +79,6 @@ module Sequel
       OPERATORS.keys.each do |f|
         class_eval("def #{f}(v); operator(:#{f}, v) end", __FILE__, __LINE__)
       end
-      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_row.rb

@@ -290,7 +290,7 @@ module Sequel
 
         # Sets each of the parser's attributes, using options with
         # the same name (e.g. :columns sets the columns attribute).
-        def initialize(h={})
+        def initialize(h=OPTS)
           @columns = h[:columns]
           @column_converters = h[:column_converters]
           @column_oids = h[:column_oids]
@@ -417,7 +417,7 @@ module Sequel
         #
         # :converter :: Use a custom converter for the parser.
         # :typecaster :: Use a custom typecaster for the parser.
-        def register_row_type(db_type, opts={})
+        def register_row_type(db_type, opts=OPTS)
           procs = @conversion_procs
           rel_oid = nil
           array_oid = nil

data/lib/sequel/extensions/pretty_table.rb

@@ -23,12 +23,8 @@ 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)