sequel 3.21.0 → 3.39.0

data/lib/sequel/extensions/pg_interval.rb

@@ -0,0 +1,191 @@
+# The pg_interval extension adds support for PostgreSQL's interval type.
+#
+# This extension integrates with Sequel's native postgres adapter, so
+# that when interval type values are retrieved, they are parsed and returned
+# as instances of ActiveSupport::Duration.
+#
+# In addition to the parser, this extension adds literalizers for
+# ActiveSupport::Duration that use the standard Sequel literalization
+# callbacks, so they work on all adapters.
+#
+# If you would like to use interval columns in your model objects, you
+# probably want to modify the typecasting so that it
+# recognizes and correctly handles the interval columns, which you can
+# do by:
+#
+#   DB.extension :pg_interval
+#
+# If you are not using the native postgres adapter, you probably
+# also want to use the typecast_on_load plugin in the model, and
+# set it to typecast the interval type column(s) on load.
+#
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of interval types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_interval
+#
+# The parser this extension uses requires that IntervalStyle for PostgreSQL
+# is set to postgres (the default setting).  If IntervalStyle is changed from
+# the default setting, the parser will probably not work.  The parser used is
+# very simple, and is only designed to parse PostgreSQL's default output
+# format, it is not designed to support all input formats that PostgreSQL
+# supports.
+
+require 'active_support/duration'
+Sequel.require 'adapters/utils/pg_types'
+
+module Sequel
+  module Postgres
+    module IntervalDatabaseMethods
+      EMPTY_INTERVAL = '0'.freeze
+      DURATION_UNITS = [:years, :months, :days, :minutes, :seconds].freeze
+
+      # Return an unquoted string version of the duration object suitable for
+      # use as a bound variable.
+      def self.literal_duration(duration)
+        h = Hash.new(0)
+        duration.parts.each{|unit, value| h[unit] += value}
+        s = ''
+
+        DURATION_UNITS.each do |unit|
+          if (v = h[unit]) != 0
+            s << "#{v.is_a?(Integer) ? v : sprintf('%0.6f', v)} #{unit} "
+          end
+        end
+
+        if s.empty?
+          EMPTY_INTERVAL
+        else
+          s
+        end
+      end
+
+      # Creates callable objects that convert strings into ActiveSupport::Duration instances.
+      class Parser
+        # Regexp that parses the full range of PostgreSQL interval type output.
+        PARSER = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d\d):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/o
+
+        # Parse the interval input string into an ActiveSupport::Duration instance.
+        def call(string)
+          raise(InvalidValue, "invalid or unhandled interval format: #{string.inspect}") unless matches = PARSER.match(string)
+
+          value = 0
+          parts = []
+
+          if v = matches[1]
+            v = v.to_i
+            value += 31557600 * v
+            parts << [:years, v]
+          end
+          if v = matches[2]
+            v = v.to_i
+            value += 2592000 * v
+            parts << [:months, v]
+          end
+          if v = matches[3]
+            v = v.to_i
+            value += 86400 * v
+            parts << [:days, v]
+          end
+          if matches[5]
+            seconds = matches[5].to_i * 3600 + matches[6].to_i * 60
+            seconds += matches[8] ? matches[7].to_f : matches[7].to_i
+            seconds *= -1 if matches[4] == '-'
+            value += seconds
+            parts << [:seconds, seconds]
+          elsif matches[9] || matches[10] || matches[11]
+            seconds = 0
+            if v = matches[9]
+              seconds += v.to_i * 3600
+            end
+            if v = matches[10]
+              seconds += v.to_i * 60
+            end
+            if v = matches[11]
+              seconds += matches[12] ? v.to_f : v.to_i
+            end
+            value += seconds
+            parts << [:seconds, seconds]
+          end
+
+          ActiveSupport::Duration.new(value, parts)
+        end
+      end
+
+      # Single instance of Parser used for parsing, to save on memory (since the parser has no state).
+      PARSER = Parser.new
+
+      # Reset the conversion procs if using the native postgres adapter,
+      # and extend the datasets to correctly literalize ActiveSupport::Duration values.
+      def self.extended(db)
+        db.extend_datasets(IntervalDatasetMethods)
+      end
+
+      # Handle ActiveSupport::Duration values in bound variables.
+      def bound_variable_arg(arg, conn)
+        case arg
+        when ActiveSupport::Duration
+          IntervalDatabaseMethods.literal_duration(arg)
+        else
+          super
+        end
+      end
+
+      private
+
+      # Handle arrays of interval types in bound variables.
+      def bound_variable_array(a)
+        case a
+        when ActiveSupport::Duration
+          "\"#{IntervalDatabaseMethods.literal_duration(a)}\""
+        else
+          super
+        end
+      end
+
+      # Typecast value correctly to an ActiveSupport::Duration instance.
+      # If already an ActiveSupport::Duration, return it. 
+      # If a numeric argument is given, assume it represents a number
+      # of seconds, and create a new ActiveSupport::Duration instance
+      # representing that number of seconds.
+      # If a String, assume it is in PostgreSQL interval output format
+      # and attempt to parse it.
+      def typecast_value_interval(value)
+        case value
+        when ActiveSupport::Duration
+          value
+        when Numeric
+          ActiveSupport::Duration.new(value, [[:seconds, value]])
+        when String
+          PARSER.call(value)
+        else
+          raise Sequel::InvalidValue, "invalid value for interval type: #{value.inspect}"
+        end
+      end
+    end
+
+    module IntervalDatasetMethods
+      CAST_INTERVAL = '::interval'.freeze
+
+      # Handle literalization of ActiveSupport::Duration objects, treating them as
+      # PostgreSQL intervals.
+      def literal_other_append(sql, v)
+        case v
+        when ActiveSupport::Duration
+          literal_append(sql, IntervalDatabaseMethods.literal_duration(v))
+          sql << CAST_INTERVAL
+        else
+          super
+        end
+      end
+    end
+
+    PG_TYPES[1186] = Postgres::IntervalDatabaseMethods::PARSER
+    if defined?(PGArray) && PGArray.respond_to?(:register)
+      PGArray.register('interval', :oid=>1187, :scalar_oid=>1186)
+    end
+  end
+
+  Database.register_extension(:pg_interval, Postgres::IntervalDatabaseMethods)
+end

data/lib/sequel/extensions/pg_json.rb

@@ -0,0 +1,208 @@
+# The pg_json extension adds support for Sequel to handle
+# PostgreSQL's json type.  It is slightly more strict than the
+# PostgreSQL json type in that the object returned must be an
+# array or object (PostgreSQL's json type considers plain numbers
+# and strings as valid).  This is because Sequel relies completely
+# on the ruby JSON library for parsing, and ruby's JSON library
+# does not accept the values.
+#
+# This extension integrates with Sequel's native postgres adapter, so
+# that when json fields are retrieved, they are parsed and returned
+# as instances of Sequel::Postgres::JSONArray or
+# Sequel::Postgres::JSONHash.  JSONArray and JSONHash are
+# DelegateClasses of Array and Hash, so they mostly act the same, but
+# not completely (json_array.is_a?(Array) is false).  If you want
+# the actual array for a JSONArray, call JSONArray#to_a.  If you want
+# the actual hash for a JSONHash, call JSONHash#to_hash.
+# This is done so that Sequel does not treat JSONArray and JSONHash
+# like Array and Hash by default, which would cause issues.
+#
+# To turn an existing Array or Hash into a JSONArray or JSONHash,
+# use Sequel.pg_json:
+#
+#   Sequel.pg_json(array)
+#   Sequel.pg_json(hash)
+#
+# If you have loaded the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html]),
+# you can also use Array#pg_json and Hash#pg_json:
+#
+#   array.pg_json
+#   hash.pg_json
+#
+# So if you want to insert an array or hash into an json database column:
+#
+#   DB[:table].insert(:column=>Sequel.pg_json([1, 2, 3]))
+#   DB[:table].insert(:column=>Sequel.pg_json({'a'=>1, 'b'=>2}))
+#
+# If you would like to use PostgreSQL json columns in your model
+# objects, you probably want to modify the schema parsing/typecasting
+# so that it recognizes and correctly handles the json type, which
+# you can do by:
+#
+#   DB.extension :pg_json
+#
+# If you are not using the native postgres adapter, you probably
+# also want to use the typecast_on_load plugin in the model, and
+# set it to typecast the json column(s) on load.
+#
+# This extension integrates with the pg_array extension.  If you plan
+# to use the json[] type, load the pg_array extension before the
+# pg_json extension:
+#
+#   DB.extension :pg_array, :pg_json
+#
+# This extension requires both the json and delegate libraries.
+
+require 'delegate'
+require 'json'
+Sequel.require 'adapters/utils/pg_types'
+
+module Sequel
+  module Postgres
+    CAST_JSON = '::json'.freeze
+
+    # Class representating PostgreSQL JSON column array values.
+    class JSONArray < DelegateClass(Array)
+      # Convert the array to a string using to_json, 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)
+        sql << CAST_JSON
+      end
+    end
+
+    # Class representating PostgreSQL JSON column hash/object values.
+    class JSONHash < DelegateClass(Hash)
+      # Convert the array to a string using to_json, 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)
+        sql << CAST_JSON
+      end
+
+      # Return the object being delegated to.
+      alias to_hash __getobj__
+    end
+
+    # Methods enabling Database object integration with the json type.
+    module JSONDatabaseMethods
+      # 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.
+      def self.parse_json(s)
+        begin
+          value = JSON.parse(s)
+        rescue JSON::ParserError=>e
+          raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+        end
+
+        case value
+        when Array
+          JSONArray.new(value)
+        when Hash 
+          JSONHash.new(value)
+        else
+          raise Sequel::InvalidValue, "unhandled json value: #{value.inspect} (from #{s.inspect})"
+        end
+      end
+
+      # Handle JSONArray and JSONHash in bound variables
+      def bound_variable_arg(arg, conn)
+        case arg
+        when JSONArray, JSONHash
+          arg.to_json
+        else
+          super
+        end
+      end
+
+      # Make the column type detection recognize the json type.
+      def schema_column_type(db_type)
+        case db_type
+        when 'json'
+          :json
+        else
+          super
+        end
+      end
+
+      private
+
+      # Handle json[] types in bound variables.
+      def bound_variable_array(a)
+        case a
+        when JSONHash, JSONArray
+          "\"#{a.to_json.gsub('"', '\\"')}\""
+        else
+          super
+        end
+      end
+
+      # Given a value to typecast to the json column
+      # * If given a JSONArray or JSONHash, just return the value
+      # * If given an Array, return a JSONArray
+      # * If given a Hash, return a JSONHash
+      # * If given a String, parse it as would be done during
+      #   database retrieval.
+      def typecast_value_json(value)
+        case value
+        when JSONArray, JSONHash
+          value
+        when Array
+          JSONArray.new(value)
+        when Hash 
+          JSONHash.new(value)
+        when String
+          JSONDatabaseMethods.parse_json(value)
+        else
+          raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
+        end
+      end
+    end
+
+    PG_TYPES[114] = JSONDatabaseMethods.method(:parse_json)
+    if defined?(PGArray) && PGArray.respond_to?(:register)
+      PGArray.register('json', :oid=>199, :scalar_oid=>114)
+    end
+  end
+
+  module SQL::Builders
+    # Wrap the array or hash in a Postgres::JSONArray or Postgres::JSONHash.
+    def pg_json(v)
+      case v
+      when Postgres::JSONArray, Postgres::JSONHash
+        v
+      when Array
+        Postgres::JSONArray.new(v)
+      when Hash
+        Postgres::JSONHash.new(v)
+      else
+        raise Error, "Sequel.pg_json requires a hash or array argument"
+      end
+    end
+  end
+
+  Database.register_extension(:pg_json, Postgres::JSONDatabaseMethods)
+end
+
+if Sequel.core_extensions?
+  class Array
+    # Return a Sequel::Postgres::JSONArray proxy to the receiver.
+    # This is mostly useful as a short cut for creating JSONArray
+    # objects that didn't come from the database.
+    def pg_json
+      Sequel::Postgres::JSONArray.new(self)
+    end
+  end
+
+  class Hash
+    # Return a Sequel::Postgres::JSONHash proxy to the receiver.
+    # This is mostly useful as a short cut for creating JSONHash
+    # objects that didn't come from the database.
+    def pg_json
+      Sequel::Postgres::JSONHash.new(self)
+    end
+  end
+end