serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/pg_auto_parameterize_in_array.rb

@@ -0,0 +1,194 @@
+# frozen-string-literal: true
+#
+# The pg_auto_parameterize_in_array extension builds on the pg_auto_parameterize
+# extension, adding support for handling additional types when converting from
+# IN to = ANY and NOT IN to != ALL:
+#
+#   DB[:table].where(column: [1.0, 2.0, ...])
+#   # Without extension: column IN ($1::numeric, $2:numeric, ...) # bound variables: 1.0, 2.0, ...
+#   # With extension:    column = ANY($1::numeric[]) # bound variables: [1.0, 2.0, ...]
+#
+# This prevents the use of an unbounded number of bound variables based on the
+# size of the array, as well as using different SQL for different array sizes.
+#
+# The following types are supported when doing the conversions, with the database
+# type used:
+#
+# Float :: if any are infinite or NaN, double precision, otherwise numeric
+# BigDecimal :: numeric
+# Date :: date
+# Time :: timestamp (or timestamptz if pg_timestamptz extension is used)
+# DateTime :: timestamp (or timestamptz if pg_timestamptz extension is used)
+# Sequel::SQLTime :: time
+# Sequel::SQL::Blob :: bytea
+#
+# Arrays of string values are not automatically converted by default, because the Ruby
+# String class can represent a number of different database types.  To convert
+# arrays of Ruby strings to an untyped array (a query parameter with no explicit
+# type cast), set the +:treat_string_list_as_untyped_array+ Database option
+# before loading the extension.
+# 
+# If you will only be using arrays of Ruby strings that represent the +text+ type,
+# you can use the +:treat_string_list_as_text_array+ Database option is used. This
+# can break programs, since the type for literal strings in PostgreSQL is +unknown+,
+# not +text+.
+#
+# The conversion is only done for single dimensional arrays that have two or
+# more elements, where all elements are of the same class (other than
+# +nil+ values).  You can also do the conversion for arrays of 1 element by setting
+# <tt>pg_auto_parameterize_min_array_size: 1</tt> Database option.  This makes
+# finding cases that need special handling easier, but it doesn't match
+# how PostgreSQL internally converts the expression (PostgreSQL converts
+# <tt>IN (single_value)</tt> to <tt>= single_value</tt>, not
+# <tt>= ANY(ARRAY[single_value])</tt>).
+#
+# Related module: Sequel::Postgres::AutoParameterizeInArray
+
+module Sequel
+  module Postgres
+    # Enable automatically parameterizing queries.
+    module AutoParameterizeInArray
+      module TreatStringListAsUntypedArray
+        # Sentinal value to use as an auto param type to use auto parameterization
+        # of a string array without an explicit type cast.
+        NO_EXPLICIT_CAST = Object.new.freeze
+
+        # Wrapper for untyped PGArray values that will be parameterized directly
+        # into the query.  This should only be used in cases where you know the
+        # value should be added as a query parameter.
+        class ParameterizedUntypedPGArray < SQL::Wrapper
+          def to_s_append(ds, sql)
+            sql.add_arg(@value)
+          end
+        end
+
+        private
+
+        # Recognize NO_EXPLICIT_CAST sentinal value and use wrapped
+        # PGArray that will be parameterized into the query.
+        def _convert_array_to_pg_array_with_type(r, type)
+          if NO_EXPLICIT_CAST.equal?(type)
+            ParameterizedUntypedPGArray.new(Sequel.pg_array(r))
+          else
+            super
+          end
+        end
+
+        # Use a query parameter with no type cast for string arrays.
+        def _bound_variable_type_for_string_array(r)
+          NO_EXPLICIT_CAST
+        end
+      end
+
+      module TreatStringListAsTextArray
+        private
+
+        # Assume all string arrays used on RHS of IN/NOT IN are for type text[]
+        def _bound_variable_type_for_string_array(r)
+          "text"
+        end
+      end
+
+      # Transform column IN (...) expressions into column = ANY($)
+      # and column NOT IN (...) expressions into column != ALL($)
+      # using an array bound variable for the ANY/ALL argument,
+      # if all values inside the predicate are of the same type and
+      # the type is handled by the extension.
+      # This is the same optimization PostgreSQL performs internally,
+      # but this reduces the number of bound variables.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :IN, :"NOT IN"
+          l, r = args
+          if auto_param?(sql) && (type = _bound_variable_type_for_array(r))
+            if op == :IN 
+              op = :"="
+              func = :ANY
+            else
+              op = :!=
+              func = :ALL
+            end
+            args = [l, Sequel.function(func, _convert_array_to_pg_array_with_type(r, type))]
+          end
+        end
+
+        super
+      end
+
+      private
+
+      # The bound variable type string to use for the bound variable array.
+      # Returns nil if a bound variable should not be used for the array.
+      def _bound_variable_type_for_array(r)
+        return unless (Array === r || Set === r) && r.size >= pg_auto_parameterize_min_array_size
+        classes = r.map(&:class)
+        classes.uniq!
+        classes.delete(NilClass)
+        return unless classes.size == 1
+
+        klass = classes[0]
+        if klass == Integer
+          # This branch is not taken on Ruby <2.4, because of the Fixnum/Bignum split.
+          # However, that causes no problems as pg_auto_parameterize handles integer
+          # arrays natively (though the SQL used is different)
+          "int8"
+        elsif klass == String
+          _bound_variable_type_for_string_array(r)
+        elsif klass == BigDecimal
+          "numeric"
+        elsif klass == Date
+          "date"
+        elsif klass == Time
+          @db.cast_type_literal(Time)
+        elsif klass == Float
+          # PostgreSQL treats literal floats as numeric, not double precision
+          # But older versions of PostgreSQL don't handle Infinity/NaN in numeric
+          r.all?{|v| v.nil? || v.finite?} ? "numeric" : "double precision"
+        elsif klass == Sequel::SQLTime
+          "time"
+        elsif klass == DateTime
+          @db.cast_type_literal(DateTime)
+        elsif klass == Sequel::SQL::Blob
+          "bytea"
+        end
+      end
+
+      # Do not auto parameterize string arrays by default.
+      def _bound_variable_type_for_string_array(r)
+        nil
+      end
+
+      # The minimium size of array to auto parameterize.
+      def pg_auto_parameterize_min_array_size
+        2
+      end
+
+      # Convert RHS of IN/NOT IN operator to PGArray with given type.
+      def _convert_array_to_pg_array_with_type(r, type)
+        r = r.to_a if Set === r
+        Sequel.pg_array(r, type)
+      end
+    end
+  end
+
+  Database.register_extension(:pg_auto_parameterize_in_array) do |db|
+    db.extension(:pg_array, :pg_auto_parameterize)
+    db.extend_datasets(Postgres::AutoParameterizeInArray)
+
+    if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+      db.extend_datasets(Postgres::AutoParameterizeInArray::TreatStringListAsTextArray)
+    elsif db.typecast_value(:boolean, db.opts[:treat_string_list_as_untyped_array])
+      db.extend_datasets(Postgres::AutoParameterizeInArray::TreatStringListAsUntypedArray)
+    end
+
+    if min_array_size = db.opts[:pg_auto_parameterize_min_array_size]
+      min_array_size = db.typecast_value(:integer, min_array_size)
+      mod = Module.new do
+        define_method(:pg_auto_parameterize_min_array_size){min_array_size}
+        private :pg_auto_parameterize_min_array_size
+      end
+      Sequel.set_temp_name(mod){"Sequel::Postgres::AutoParameterizeInArray::_MinArraySize#{min_array_size}"}
+      db.extend_datasets(mod)
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/pg_enum.rb

@@ -0,0 +1,199 @@
+# 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:
+#
+#   DB.extension :pg_enum
+#
+# It allows creation of enum types using create_enum:
+#
+#   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(:enum_type_name)
+#
+# Just like any user-created type, after creating the type, you
+# can create tables that have a column of that type:
+#
+#   DB.create_table(:table_name) do
+#     enum_type_name :column_name
+#   end
+#
+# When parsing the schema, enum types are recognized, and available
+# values returned in the schema hash:
+#
+#   DB.schema(:table_name)
+#   [[:column_name, {:type=>:enum, :enum_values=>['value1', 'value2']}]]
+#
+# 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_enum extension:
+#
+#   DB.extension :pg_array, :pg_enum
+#
+#   DB.create_table(:table_name) do
+#     column :column_name, 'enum_type_name[]'
+#   end
+#   DB[:table_name].get(:column_name)
+#   # ['value1', 'value2']
+#
+# If the migration extension is loaded before this one (the order is important),
+# you can use create_enum in a reversible migration:
+#
+#   Sequel.migration do
+#     change do
+#       create_enum(:enum_type_name, %w'value1 value2 value3')
+#     end
+#   end
+#
+# Finally, typecasting for enums is setup to cast to strings, which
+# 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
+  module Postgres
+    # Methods enabling Database object integration with enum types.
+    module EnumDatabaseMethods
+      # Parse the available enum values when loading this extension into
+      # your database.
+      def self.extended(db)
+        db.instance_exec do
+          @enum_labels = {}
+          parse_enum_labels
+        end
+      end
+
+      # Run the SQL to add the given value to the existing enum type.
+      # Options:
+      # :after :: Add the new value after this existing value.
+      # :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 = 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
+        _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)
+        _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.
+      # Options:
+      # :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)
+        _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
+        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).
+            exclude(:typarray=>0).
+            select_map([:typname, Sequel.cast(:typarray, Integer).as(:v), Sequel.cast(:oid, Integer).as(:sv)])
+
+          existing_oids = conversion_procs.keys
+          array_types.each do |name, oid, scalar_oid|
+            next if existing_oids.include?(oid)
+            register_array_type(name, :oid=>oid, :scalar_oid=>scalar_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_post_process(_)
+        super.each do |_, s|
+          oid = s[:oid]
+          if s[:type] == :enum && (values = Sequel.synchronize{@enum_labels[oid]})
+            s[:enum_values] = values
+          end
+        end
+      end
+
+      # Typecast the given value to a string.
+      def typecast_value_enum(value)
+        value.to_s
+      end
+    end
+  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
+
+  Database.register_extension(:pg_enum, Postgres::EnumDatabaseMethods)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/pg_extended_date_support.rb

@@ -0,0 +1,261 @@
+# 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
+      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
+      RATIONAL_60 = Rational(60)
+      TIME_CAN_PARSE_BC = RUBY_VERSION >= '2.5'
+
+      # 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)
+        if ocps = db.instance_variable_get(:@oid_convertor_map)
+          # Clear the oid convertor map entries for timestamps if they
+          # exist, so it will regenerate new ones that use this extension.
+          # This is only taken when using the jdbc adapter.
+          Sequel.synchronize do
+            ocps.delete(1184)
+            ocps.delete(1114)
+          end
+        end
+      end
+
+      # Handle BC dates and times in bound variables. This is necessary for Date values
+      # when using both the postgres and jdbc adapters, but also necessary for Time values
+      # on jdbc.
+      def bound_variable_arg(arg, conn)
+        case arg
+        when Time, Date
+          @default_dataset.literal_date_or_time(arg)
+        else
+          super
+        end
+      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 = /((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/.match(value)) && (m[2] || m[3])
+          if m[3]
+            value = value.sub(' BC', '').sub(' ', ' BC ')
+          end
+          if m[2]
+            dt = if Sequel.datetime_class == DateTime
+              DateTime.parse(value)
+            elsif TIME_CAN_PARSE_BC
+              Time.parse(value)
+            # :nocov:
+            else
+              DateTime.parse(value).to_time
+            # :nocov:
+            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.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.%6N#{sprintf("%+03i%02i", *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
+              literal_datetime(DateTime.parse(super))
+            else
+              super
+            end
+          end
+          # :nocov:
+        else
+          # Handle BC Time objects.
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              time = db.from_application_timestamp(time)
+              time.strftime("'#{sprintf('%04i', time.year.abs+1)}-%m-%d %H:%M:%S.%6N#{sprintf("%+03i%02i", *(time.utc_offset/RATIONAL_60).divmod(60))} BC'")
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_extended_date_support, Postgres::ExtendedDateSupport)
+end