sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/pg_array_ops.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_array_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL array functions and operators.
 #
@@ -17,7 +19,7 @@
 # Also, on most Sequel expression objects, you can call the pg_array
 # method:
 #
-#   ia = Sequel.expr(:int_array_column).pg_array
+#   ia = Sequel[:int_array_column].pg_array
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
@@ -49,8 +51,8 @@
 #   ia.length(2)       # array_length(int_array_column, 2)
 #   ia.lower           # array_lower(int_array_column, 1)
 #   ia.lower(2)        # array_lower(int_array_column, 2)
-#   ia.join            # array_to_string(int_array_column, '', NULL)
-#   ia.join(':')       # array_to_string(int_array_column, ':', NULL)
+#   ia.join            # array_to_string(int_array_column, '')
+#   ia.join(':')       # array_to_string(int_array_column, ':')
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
 #   ia.unnest(:b)      # unnest(int_array_column, b)
@@ -64,6 +66,8 @@
 #
 # In order for #hstore to automatically wrap the returned value correctly in
 # an HStoreOp, you need to load the pg_hstore_ops extension.
+#
+# Related module: Sequel::Postgres::ArrayOp
 
 #
 module Sequel
@@ -153,7 +157,9 @@ module Sequel
         else
           Sequel.function(:hstore, self, wrap_array(arg))
         end
+        # :nocov:
         if Sequel.respond_to?(:hstore_op)
+        # :nocov:
           v = Sequel.hstore_op(v)
         end
         v
@@ -213,12 +219,16 @@ module Sequel
 
       # Call the array_to_string method:
       #
-      #   array_op.join           # array_to_string(array, '', NULL)
-      #   array_op.to_string      # array_to_string(array, '', NULL)
-      #   array_op.join(":")      # array_to_string(array, ':', NULL)
+      #   array_op.join           # array_to_string(array, '')
+      #   array_op.to_string      # array_to_string(array, '')
+      #   array_op.join(":")      # array_to_string(array, ':')
       #   array_op.join(":", "*") # array_to_string(array, ':', '*')
       def to_string(joiner="", null=nil)
-        function(:array_to_string, joiner, null)
+        if null.nil?
+          function(:array_to_string, joiner)
+        else
+          function(:array_to_string, joiner, null)
+        end
       end
       alias join to_string
       
@@ -275,7 +285,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGArray)
+    # :nocov:
       class PGArray
         # Wrap the PGArray instance in an ArrayOp, allowing you to easily use
         # the PostgreSQL array functions and operators with literal arrays.

data/lib/sequel/extensions/pg_enum.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The pg_enum extension adds support for Sequel to handle PostgreSQL's enum
 # types.  To use this extension, first load it into your Database instance:
 #
@@ -5,15 +7,25 @@
 #
 # It allows creation of enum types using create_enum:
 #
-#   DB.create_enum(:type_name, %w'value1 value2 value3')
+#   DB.create_enum(:enum_type_name, %w'value1 value2 value3')
 #
 # You can also add values to existing enums via add_enum_value:
 #
 #   DB.add_enum_value(:enum_type_name, 'value4')
 #
+# If you want to rename an enum type, you can use rename_enum:
+#
+#   DB.rename_enum(:enum_type_name, :enum_type_another_name)
+#
+# If you want to rename an enum value, you can use rename_enum_value:
+#
+#   DB.rename_enum_value(
+#     :enum_type_name, :enum_value_name, :enum_value_another_name
+#   )
+#
 # If you want to drop an enum type, you can use drop_enum:
 #
-#   DB.drop_enum(:type_name)
+#   DB.drop_enum(:enum_type_name)
 #
 # Just like any user-created type, after creating the type, you
 # can create tables that have a column of that type:
@@ -28,8 +40,11 @@
 #   DB.schema(:table_name)
 #   [[:column_name, {:type=>:enum, :enum_values=>['value1', 'value2']}]]
 #
-# If the pg_array extension is used, arrays of enums are returned as a
-# PGArray:
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of enum types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_enum
 #
 #   DB.create_table(:table_name) do
 #     column :column_name, 'enum_type_name[]'
@@ -42,7 +57,7 @@
 #
 #   Sequel.migration do
 #     change do
-#       create_enum(:type_name, %w'value1 value2 value3')
+#       create_enum(:enum_type_name, %w'value1 value2 value3')
 #     end
 #   end
 #
@@ -50,6 +65,8 @@
 # allows you to use symbols in your model code.  Similar, you can provide
 # the enum values as symbols when creating enums using create_enum or
 # add_enum_value.
+#
+# Related module: Sequel::Postgres::EnumDatabaseMethods
 
 #
 module Sequel
@@ -59,7 +76,10 @@ module Sequel
       # Parse the available enum values when loading this extension into
       # your database.
       def self.extended(db)
-        db.send(:parse_enum_labels)
+        db.instance_exec do
+          @enum_labels = {}
+          parse_enum_labels
+        end
       end
 
       # Run the SQL to add the given value to the existing enum type.
@@ -68,23 +88,31 @@ module Sequel
       # :before :: Add the new value before this existing value.
       # :if_not_exists :: Do not raise an error if the value already exists in the enum.
       def add_enum_value(enum, value, opts=OPTS)
-        sql = "ALTER TYPE #{quote_schema_table(enum)} ADD VALUE#{' IF NOT EXISTS' if opts[:if_not_exists]} #{literal(value.to_s)}"
+        sql = String.new
+        sql << "ALTER TYPE #{quote_schema_table(enum)} ADD VALUE#{' IF NOT EXISTS' if opts[:if_not_exists]} #{literal(value.to_s)}"
         if v = opts[:before]
           sql << " BEFORE #{literal(v.to_s)}"
         elsif v = opts[:after]
           sql << " AFTER #{literal(v.to_s)}"
         end
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql(sql)
       end
 
       # Run the SQL to create an enum type with the given name and values.
       def create_enum(enum, values)
-        sql = "CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})")
+      end
+
+      # Run the SQL to rename the enum type with the given name
+      # to the another given name.
+      def rename_enum(enum, new_name)
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}")
+      end
+
+      # Run the SQL to rename the enum value with the given name
+      # to the another given name.
+      def rename_enum_value(enum, old_name, new_name)
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME VALUE #{literal(old_name.to_s)} TO #{literal(new_name.to_s)}")
       end
 
       # Run the SQL to drop the enum type with the given name.
@@ -92,26 +120,34 @@ module Sequel
       # :if_exists :: Do not raise an error if the enum type does not exist
       # :cascade :: Also drop other objects that depend on the enum type
       def drop_enum(enum, opts=OPTS)
-        sql = "DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}")
       end
 
       private
 
+      # Run the SQL on the database, reparsing the enum labels after it is run.
+      def _process_enum_change_sql(sql)
+        run(sql)
+        parse_enum_labels
+        nil
+      end
+
       # Parse the pg_enum table to get enum values, and
       # the pg_type table to get names and array oids for
       # enums.
       def parse_enum_labels
-        @enum_labels = metadata_dataset.from(:pg_enum).
-          order(:enumtypid, :enumsortorder).
-          select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel)
+        order = [:enumtypid]
+        order << :enumsortorder if server_version >= 90100
+
+        enum_labels = metadata_dataset.from(:pg_enum).
+          order(*order).
+          select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
+        enum_labels.each_value(&:freeze)
 
         if respond_to?(:register_array_type)
           array_types = metadata_dataset.
             from(:pg_type).
-            where(:oid=>@enum_labels.keys).
+            where(:oid=>enum_labels.keys).
             exclude(:typarray=>0).
             select_map([:typname, Sequel.cast(:typarray, Integer).as(:v)])
 
@@ -121,13 +157,16 @@ module Sequel
             register_array_type(name, :oid=>oid)
           end
         end
+
+        Sequel.synchronize{@enum_labels.replace(enum_labels)}
       end
 
       # For schema entries that are enums, set the type to
       # :enum and add a :enum_values entry with the enum values.
-      def schema_parse_table(*)
+      def schema_post_process(_)
         super.each do |_, s|
-          if values = @enum_labels[s[:oid]]
+          oid = s[:oid]
+          if values = Sequel.synchronize{@enum_labels[oid]}
             s[:type] = :enum
             s[:enum_values] = values
           end
@@ -142,12 +181,18 @@ module Sequel
   end
 
   # support reversible create_enum statements if the migration extension is loaded
+  # :nocov:
   if defined?(MigrationReverser)
+  # :nocov:
     class MigrationReverser
       private
       def create_enum(name, _)
         @actions << [:drop_enum, name]
       end
+
+      def rename_enum(old_name, new_name)
+        @actions << [:rename_enum, new_name, old_name]
+      end
     end
   end
 

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -0,0 +1,250 @@
+# frozen-string-literal: true
+#
+# The pg_extended_date_support extension allows support
+# for BC dates/timestamps by default, and infinite
+# dates/timestamps if configured.  Without this extension,
+# BC and infinite dates/timestamps will be handled incorrectly
+# or raise an error.  This behavior isn't the default because
+# it can hurt performance, and few users need support for BC
+# and infinite dates/timestamps.
+#
+# To load the extension into the database:
+#
+#   DB.extension :pg_extended_date_support
+#
+# To enable support for infinite dates/timestamps:
+#
+#   DB.convert_infinite_timestamps = 'string' # or 'nil' or 'float'
+#
+# Related module: Sequel::Postgres::ExtendedDateSupport
+
+#
+module Sequel
+  module Postgres
+    module ExtendedDateSupport
+      DATE_YEAR_1 = Date.new(1)
+      DATETIME_YEAR_1 = DateTime.new(1)
+      TIME_YEAR_1 = Time.at(-62135596800).utc
+      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
+      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
+      PLUS_DATE_INFINITY = Date::Infinity.new
+      MINUS_DATE_INFINITY = -PLUS_DATE_INFINITY
+
+      # Add dataset methods and update the conversion proces for dates and timestamps.
+      def self.extended(db)
+        db.extend_datasets(DatasetMethods)
+        procs = db.conversion_procs
+        procs[1082] = ::Sequel.method(:string_to_date)
+        procs[1184] = procs[1114] = db.method(:to_application_timestamp)
+      end
+
+      # Whether infinite timestamps/dates should be converted on retrieval.  By default, no
+      # conversion is done, so an error is raised if you attempt to retrieve an infinite
+      # timestamp/date.  You can set this to :nil to convert to nil, :string to leave
+      # as a string, or :float to convert to an infinite float.
+      attr_reader :convert_infinite_timestamps
+
+      # Set whether to allow infinite timestamps/dates.  Make sure the
+      # conversion proc for date reflects that setting.
+      def convert_infinite_timestamps=(v)
+        @convert_infinite_timestamps = case v
+        when Symbol
+          v
+        when 'nil'
+          :nil
+        when 'string'
+          :string
+        when 'date'
+          :date
+        when 'float'
+          :float
+        when String, true
+          typecast_value_boolean(v)
+        else
+          false
+        end
+
+        pr = old_pr = Sequel.method(:string_to_date)
+        if @convert_infinite_timestamps
+          pr = lambda do |val|
+            case val
+            when *INFINITE_TIMESTAMP_STRINGS
+              infinite_timestamp_value(val)
+            else
+              old_pr.call(val)
+            end
+          end
+        end
+        add_conversion_proc(1082, pr)
+      end
+
+      # Handle BC dates in timestamps by moving the BC from after the time to
+      # after the date, to appease ruby's date parser.
+      # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
+      # value based on the convert_infinite_timestamps setting.
+      def to_application_timestamp(value)
+        if value.is_a?(String) && (m = value.match(/((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[2] || m[3])
+          if m[3]
+            value = value.sub(' BC', '').sub(' ', ' BC ')
+            conv = defined?(JRUBY_VERSION) && JRUBY_VERSION == '9.2.0.0'
+          end
+          if m[2] || conv
+            dt = DateTime.parse(value)
+            if conv
+              # :nocov:
+              if Sequel.datetime_class == DateTime
+                dt >>= 12
+              else
+                dt >>= 24
+              end
+              # :nocov:
+            end
+            unless Sequel.datetime_class == DateTime
+              dt = dt.to_time
+              if conv && (timezone == nil || timezone == :local) && !m[1]
+                # :nocov:
+                dt = Sequel.send(:convert_input_timestamp, dt.strftime("%F %T.%6N"), :local)
+                # :nocov:
+              end
+            end
+            Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
+          else
+            super(value)
+          end
+        elsif convert_infinite_timestamps
+          case value
+          when *INFINITE_TIMESTAMP_STRINGS
+            infinite_timestamp_value(value)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      private
+      
+      # Return an appropriate value for the given infinite timestamp string.
+      def infinite_timestamp_value(value)
+        case convert_infinite_timestamps
+        when :nil
+          nil
+        when :string
+          value
+        when :date
+          value == 'infinity' ? PLUS_DATE_INFINITY : MINUS_DATE_INFINITY
+        else
+          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
+        end
+      end
+      
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite date), return it without converting it if
+      # convert_infinite_timestamps is set.
+      def typecast_value_date(value)
+        if convert_infinite_timestamps
+          case value
+          when *INFINITE_DATETIME_VALUES
+            value
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite timestamp), return it without converting it if
+      # convert_infinite_timestamps is set.
+      def typecast_value_datetime(value)
+        if convert_infinite_timestamps
+          case value
+          when *INFINITE_DATETIME_VALUES
+            value
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+        
+      module DatasetMethods
+        private
+
+        # Handle BC Date objects.
+        def literal_date(date)
+          if date < DATE_YEAR_1
+            date <<= ((date.year) * 24 - 12)
+            date.strftime("'%Y-%m-%d BC'")
+          else
+            super
+          end
+        end
+
+        # Handle BC DateTime objects.
+        def literal_datetime(date)
+          if date < DATETIME_YEAR_1
+            date <<= ((date.year) * 24 - 12)
+            date = db.from_application_timestamp(date)
+            minutes = (date.offset * 1440).to_i
+            date.strftime("'%Y-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*minutes.divmod(60))} BC'")
+          else
+            super
+          end
+        end
+
+        # Handle Date::Infinity values
+        def literal_other_append(sql, v)
+          if v.is_a?(Date::Infinity)
+            sql << (v > 0 ? "'infinity'" : "'-infinity'")
+          else
+            super
+          end
+        end
+
+        if RUBY_ENGINE == 'jruby'
+          # :nocov:
+
+          ExtendedDateSupport::CONVERT_TYPES = [Java::JavaSQL::Types::DATE, Java::JavaSQL::Types::TIMESTAMP]
+
+          # Use non-JDBC parsing as JDBC parsing doesn't work for BC dates/timestamps.
+          def type_convertor(map, meta, type, i)
+            case type
+            when *CONVERT_TYPES
+              db.oid_convertor_proc(meta.getField(i).getOID)
+            else
+              super
+            end
+          end
+
+          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              dt = DateTime.parse(super)
+              # Work around JRuby bug #5191
+              dt >>= 12 if JRUBY_VERSION == '9.2.0.0'
+              literal_datetime(dt)
+            else
+              super
+            end
+          end
+          # :nocov:
+        else
+          # Handle BC Time objects.
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              literal_datetime(time.to_datetime)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_extended_date_support, Postgres::ExtendedDateSupport)
+end