serrano-vk 0.1.0

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

@@ -0,0 +1,80 @@
+# frozen-string-literal: true
+#
+# The caller_logging extension includes caller information before
+# query logging, showing which code caused the query.  It skips
+# internal Sequel code, showing the first non-Sequel caller line.
+#
+#   DB.extension :caller_logging
+#   DB[:table].first
+#   # Logger:
+#   # (0.000041s) (source: /path/to/app/foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+#
+# You can further filter the caller lines by setting
+# <tt>Database#caller_logging_ignore</tt> to a regexp of additional
+# caller lines to ignore.  This is useful if you have specific
+# methods or internal extensions/plugins that you would also
+# like to ignore as they obscure the code actually making the
+# request.
+#
+#   DB.caller_logging_ignore = %r{/path/to/app/lib/plugins}
+#
+# You can also format the caller before it is placed in the logger,
+# using +caller_logging_formatter+:
+#
+#   DB.caller_logging_formatter = lambda do |caller|
+#     "(#{caller.sub(/\A\/path\/to\/app\//, '')})"
+#   end
+#   DB[:table].first
+#   # Logger:
+#   # (0.000041s) (foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+#
+# Related module: Sequel::CallerLogging
+
+require 'rbconfig'
+
+#
+module Sequel
+  module CallerLogging
+    SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
+    RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+    INTERNAL = '<internal'
+
+    # A regexp of caller lines to ignore, in addition to internal Sequel and Ruby code.
+    attr_accessor :caller_logging_ignore
+
+    # A callable to format the external caller
+    attr_accessor :caller_logging_formatter
+
+    # Include caller information when logging query.
+    def log_connection_yield(sql, conn, args=nil)
+      if !@loggers.empty? && (external_caller = external_caller_for_log)
+        sql = "#{external_caller} #{sql}"
+      end
+      super
+    end
+
+    private
+
+    # The caller to log, ignoring internal Sequel and Ruby code, and user specified
+    # lines to ignore.
+    def external_caller_for_log
+      ignore = caller_logging_ignore
+      c = caller.find do |line|
+        !(line.start_with?(SEQUEL_LIB_PATH, RUBY_STDLIB, INTERNAL) ||
+          (ignore && line =~ ignore))
+      end
+
+      if c
+        c = if formatter = caller_logging_formatter
+          formatter.call(c)
+        else
+          "(source: #{c})"
+        end
+      end
+
+      c
+    end
+  end
+
+  Database.register_extension(:caller_logging, CallerLogging)
+end

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

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+#
+# The columns_introspection extension attempts to introspect the
+# selected columns for a dataset before issuing a query.  If it
+# thinks it can guess correctly at the columns the query will use,
+# it will return the columns without issuing a database query.
+#
+# This method is not fool-proof, it's possible that some databases
+# will use column names that Sequel does not expect.  Also, it
+# may not correctly handle all cases. 
+#
+# To attempt to introspect columns for a single dataset:
+#
+#   ds = ds.extension(:columns_introspection)
+#
+# To attempt to introspect columns for all datasets on a single database:
+#
+#   DB.extension(:columns_introspection)
+#
+# Related module: Sequel::ColumnsIntrospection
+
+#
+module Sequel
+  module ColumnsIntrospection
+    # Attempt to guess the columns that will be returned
+    # if there are columns selected, in order to skip a database
+    # query to retrieve the columns.  This should work with
+    # Symbols, SQL::Identifiers, SQL::QualifiedIdentifiers, and
+    # SQL::AliasedExpressions.
+    def columns
+      if cols = _columns
+        return cols
+      end
+      if (pcs = probable_columns) && pcs.all?
+        self.columns = pcs
+      else
+        super
+      end
+    end
+
+    protected
+
+    # Return an array of probable column names for the dataset, or
+    # nil if it is not possible to determine that through
+    # introspection.
+    def probable_columns
+      if (cols = opts[:select]) && !cols.empty?
+        cols.map{|c| probable_column_name(c)}
+      elsif !opts[:join] && !opts[:with] && (from = opts[:from]) && from.length == 1 && (from = from.first)
+        if from.is_a?(SQL::AliasedExpression)
+          from = from.expression
+        end
+        
+        case from
+        when Dataset
+          from.probable_columns
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
+          schemas = db.instance_variable_get(:@schemas)
+          if schemas && (table = literal(from)) && (sch = Sequel.synchronize{schemas[table]})
+            sch.map{|c,_| c}
+          end
+        end
+      end
+    end
+
+    private
+
+    # Return the probable name of the column, or nil if one
+    # cannot be determined.
+    def probable_column_name(c)
+      case c
+      when Symbol
+        _, c, a = split_symbol(c)
+        (a || c).to_sym
+      when SQL::Identifier
+        c.value.to_sym
+      when SQL::QualifiedIdentifier
+        c.column.to_sym
+      when SQL::AliasedExpression
+        a = c.alias
+        a.is_a?(SQL::Identifier) ? a.value.to_sym : a.to_sym
+      end
+    end
+  end
+
+  Dataset.register_extension(:columns_introspection, Sequel::ColumnsIntrospection)
+end
+

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

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+#
+# The connection_checkout_event_callback extension modifies a database's
+# connection pool to allow for a checkout event callback. This callback is
+# called with the following arguments:
+#
+# :immediately_available :: Connection immediately available and returned
+# :not_immediately_available :: Connection not immediately available
+# :new_connection :: New connection created and returned
+# Float :: Number of seconds waiting to acquire a connection
+#
+# This is a low-level extension that allows for building telemetry
+# information. It doesn't implement any telemetry reporting itself. The
+# main reason for recording this information is to use it to determine the
+# appropriate size for the connection pool. Having too large a connection
+# pool can waste resources, while having too small a connection pool can
+# result in substantial time to check out a connection. In general, you
+# want to use as small a pool as possible while keeping the time to
+# checkout a connection low.
+#
+# To use the connection checkout event callback, you must first load the
+# extension:
+#
+#   DB.extension(:connection_checkout_event_callback)
+#
+# By default, an empty proc is used as the callback so that loading the
+# support doesn't break anything. If you are using the extension, you
+# should set the callback at some point during application startup:
+#
+#   DB.pool.on_checkout_event = proc do |event|
+#     # ...
+#   end
+#
+# When using the sharded connection pool, the callback is also
+# passed a second argument, the requested server shard (generally a
+# symbol), allowing for collection of per-shard telemetry:
+#
+#   DB.pool.on_checkout_event = proc do |event, server|
+#     # ...
+#   end
+#
+# Note that the callback may be called currently by multiple threads.
+# You should use some form of concurrency control inside the callback,
+# such as a mutex or queue.
+#
+# Below is a brief example of usage to determine the percentage of
+# connection requests where a connection was immediately available:
+#
+#   mutex = Mutex.new
+#   total = immediates = 0
+#
+#   DB.pool.on_checkout_event = proc do |event|
+#     case event
+#     when :immediately_available
+#       mutex.synchronize do
+#         total += 1
+#         immediates += 1
+#       end
+#     when :not_immediately_available
+#       mutex.synchronize do
+#         total += 1
+#       end
+#     end
+#   end
+#
+#   immediate_percentage = lambda do
+#     mutex.synchronize do
+#       100.0 * immediates / total
+#     end
+#   end
+#   
+# Note that this extension only works with the timed_queue
+# and sharded_timed_queue connection pools (the default
+# connection pools when using Ruby 3.2+).
+#
+# Related modules: Sequel::ConnectionCheckoutEventCallbacks::TimedQueue,
+# Sequel::ConnectionCheckoutEventCallbacks::ShardedTimedQueue
+
+#
+module Sequel
+  module ConnectionCheckoutEventCallbacks
+    module TimedQueue
+      # The callback that is called with connection checkout events.
+      attr_accessor :on_checkout_event
+
+      private
+
+      def available
+        conn = super
+        @on_checkout_event.call(conn ? :immediately_available : :not_immediately_available)
+        conn
+      end
+
+      def try_make_new
+        conn = super
+        @on_checkout_event.call(:new_connection) if conn
+        conn
+      end
+
+      def wait_until_available
+        timer = Sequel.start_timer
+        conn = super
+        @on_checkout_event.call(Sequel.elapsed_seconds_since(timer))
+        conn
+      end
+    end
+
+    module ShardedTimedQueue
+      # The callback that is called with connection checkout events.
+      attr_accessor :on_checkout_event
+
+      private
+
+      def available(queue, server)
+        conn = super
+        @on_checkout_event.call(conn ? :immediately_available : :not_immediately_available, server)
+        conn
+      end
+
+      def try_make_new(server)
+        conn = super
+        @on_checkout_event.call(:new_connection, server) if conn
+        conn
+      end
+
+      def wait_until_available(queue, server)
+        timer = Sequel.start_timer
+        conn = super
+        @on_checkout_event.call(Sequel.elapsed_seconds_since(timer), server)
+        conn
+      end
+    end
+  end
+
+  default_callback = proc{}
+
+  Database.register_extension(:connection_checkout_event_callback) do |db|
+    pool = db.pool
+
+    case pool.pool_type
+    when :timed_queue
+      db.pool.extend(ConnectionCheckoutEventCallbacks::TimedQueue)
+    when :sharded_timed_queue
+      db.pool.extend(ConnectionCheckoutEventCallbacks::ShardedTimedQueue)
+    else
+      raise Error, "the connection_checkout_event_callback extension is only supported when using a timed_queue connection pool"
+    end
+
+    pool.on_checkout_event ||= default_callback
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen-string-literal: true
+#
+# The connection_expiration extension modifies a database's
+# connection pool to validate that connections checked out
+# from the pool are not expired, before yielding them for
+# use.  If it detects an expired connection, it removes it
+# from the pool and tries the next available connection,
+# creating a new connection if no available connection is
+# unexpired.  Example of use:
+#
+#   DB.extension(:connection_expiration)
+#
+# The default connection timeout is 14400 seconds (4 hours).
+# To override it:
+#
+#   DB.pool.connection_expiration_timeout = 3600 # 1 hour
+#
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
+# pools is for speed, and this extension makes the connection
+# pool slower, there's not much point in modifying this
+# extension to work with the single threaded pools.  The
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
+#
+# Related module: Sequel::ConnectionExpiration
+
+#
+module Sequel
+  module ConnectionExpiration
+    class Retry < Error; end
+    Sequel::Deprecation.deprecate_constant(self, :Retry)
+
+    # The number of seconds that need to pass since
+    # connection creation before expiring a connection.
+    # Defaults to 14400 seconds (4 hours).
+    attr_accessor :connection_expiration_timeout
+
+    # The maximum number of seconds that will be added as a random delay to the expiration timeout
+    # Defaults to 0 seconds (no random delay).
+    attr_accessor :connection_expiration_random_delay
+
+    # Initialize the data structures used by this extension.
+    def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool"
+      end
+
+      pool.instance_exec do
+        sync do
+          @connection_expiration_timestamps ||= {}
+          @connection_expiration_timeout ||= 14400
+          @connection_expiration_random_delay ||= 0
+        end
+      end
+    end
+
+    private
+
+    # Clean up expiration timestamps during disconnect.
+    def disconnect_connection(conn)
+      sync{@connection_expiration_timestamps.delete(conn)}
+      super
+    end
+
+    # Record the time the connection was created.
+    def make_new(*)
+      conn = super
+      @connection_expiration_timestamps[conn] = [Sequel.start_timer, @connection_expiration_timeout + (rand * @connection_expiration_random_delay)].freeze
+      conn
+    end
+
+    # When acquiring a connection, check if the connection is expired.
+    # If it is expired, disconnect the connection, and retry with a new
+    # connection.
+    def acquire(*a)
+      conn = nil
+      1.times do
+        if (conn = super) &&
+           (cet = sync{@connection_expiration_timestamps[conn]}) &&
+           Sequel.elapsed_seconds_since(cet[0]) > cet[1]
+
+          case pool_type
+          when :sharded_threaded, :sharded_timed_queue
+            sync{@allocated[a.last].delete(Sequel.current)}
+          else
+            sync{@allocated.delete(Sequel.current)}
+          end
+
+          disconnect_acquired_connection(conn, *a)
+          redo
+        end
+      end
+
+      conn
+    end
+  end
+
+  Database.register_extension(:connection_expiration){|db| db.pool.extend(ConnectionExpiration)}
+end
+

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

@@ -0,0 +1,133 @@
+# frozen-string-literal: true
+#
+# The connection_validator extension modifies a database's
+# connection pool to validate that connections checked out
+# from the pool are still valid, before yielding them for
+# use.  If it detects an invalid connection, it removes it
+# from the pool and tries the next available connection,
+# creating a new connection if no available connection is
+# valid.  Example of use:
+#
+#   DB.extension(:connection_validator)
+#
+# As checking connections for validity involves issuing a
+# query, which is potentially an expensive operation,
+# the validation checks are only run if the connection has
+# been idle for longer than a certain threshold. By default,
+# that threshold is 3600 seconds (1 hour), but it can be
+# modified by the user, set to -1 to always validate
+# connections on checkout:
+#
+#   DB.pool.connection_validation_timeout = -1
+#
+# Note that if you set the timeout to validate connections
+# on every checkout, you should probably manually control
+# connection checkouts on a coarse basis, using
+# Database#synchronize.  In a web application, the optimal
+# place for that would be a rack middleware.  Validating
+# connections on every checkout without setting up coarse
+# connection checkouts will hurt performance, in some cases
+# significantly.  Note that setting up coarse connection
+# checkouts reduces the concurrency level achievable.  For
+# example, in a web application, using Database#synchronize
+# in a rack middleware will limit the number of concurrent
+# web requests to the number to connections in the database
+# connection pool.
+#
+# Note that this extension does not work with the single
+# threaded and sharded single threaded connection pools.
+# As the only reason to use the single threaded
+# pools is for speed, and this extension makes the connection
+# pool slower, there's not much point in modifying this
+# extension to work with the single threaded pools.  The
+# non-single threaded pools work fine even in single threaded
+# code, so if you are currently using a single threaded pool
+# and want to use this extension, switch to using another
+# pool.
+#
+# Related module: Sequel::ConnectionValidator
+
+#
+module Sequel
+  module ConnectionValidator
+    class Retry < Error; end
+    Sequel::Deprecation.deprecate_constant(self, :Retry)
+
+    # The number of seconds that need to pass since
+    # connection checkin before attempting to validate
+    # the connection when checking it out from the pool.
+    # Defaults to 3600 seconds (1 hour).
+    attr_accessor :connection_validation_timeout
+
+    # Initialize the data structures used by this extension.
+    def self.extended(pool)
+      case pool.pool_type
+      when :single, :sharded_single
+        raise Error, "cannot load connection_validator extension if using single or sharded_single connection pool"
+      end
+
+      pool.instance_exec do
+        sync do
+          @connection_timestamps ||= {}
+          @connection_validation_timeout ||= 3600
+        end
+      end
+
+      # Make sure the valid connection SQL query is precached,
+      # otherwise it's possible it will happen at runtime. While
+      # it should work correctly at runtime, it's better to avoid
+      # the possibility of failure altogether.
+      pool.db.send(:valid_connection_sql)
+    end
+
+    private
+
+    # Record the time the connection was checked back into the pool.
+    def checkin_connection(*)
+      conn = super
+      @connection_timestamps[conn] = Sequel.start_timer
+      conn
+    end
+
+    # Clean up timestamps during disconnect.
+    def disconnect_connection(conn)
+      sync{@connection_timestamps.delete(conn)}
+      super
+    end
+
+    # When acquiring a connection, if it has been
+    # idle for longer than the connection validation timeout,
+    # test the connection for validity.  If it is not valid,
+    # disconnect the connection, and retry with a new connection.
+    def acquire(*a)
+      conn = nil
+
+      1.times do
+        if (conn = super) &&
+           (timer = sync{@connection_timestamps.delete(conn)}) &&
+           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout
+
+          begin
+            valid = db.valid_connection?(conn)
+          ensure
+            unless valid
+              case pool_type
+              when :sharded_threaded, :sharded_timed_queue
+                sync{@allocated[a.last].delete(Sequel.current)}
+              else
+                sync{@allocated.delete(Sequel.current)}
+              end
+
+              disconnect_acquired_connection(conn, *a)
+              redo if valid == false
+            end
+          end
+        end
+      end
+
+      conn
+    end
+  end
+
+  Database.register_extension(:connection_validator){|db| db.pool.extend(ConnectionValidator)}
+end

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

@@ -0,0 +1,65 @@
+# frozen-string-literal: true
+#
+# The constant_sql_override extension allows you to change the SQL
+# generated for Sequel constants.
+#
+# One possible use-case for this is to have Sequel::CURRENT_TIMESTAMP use UTC time when
+# you have Sequel.database_timezone = :utc, but the database uses localtime when
+# generating CURRENT_TIMESTAMP.
+#
+# You can set SQL overrides with Database#set_constant_sql:
+#
+#   DB.set_constant_sql(Sequel::CURRENT_TIMESTAMP, "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'")
+#
+# Now, using Sequel::CURRENT_TIMESTAMP will use your override instead:
+#
+#   Album.where(released_at: Sequel::CURRENT_TIMESTAMP).sql
+#   # => SELECT "albums.*" FROM "albums" WHERE ("released_at" = CURRENT_TIMESTAMP AT TIME ZONE 'UTC')
+#
+# To use this extension, first load it into your Sequel::Database instance:
+#
+#   DB.extension :constant_sql_override
+#
+# Related module: Sequel::ConstantSqlOverride
+
+#
+module Sequel
+  module ConstantSqlOverride
+    module DatabaseMethods
+      # Create the initial empty hash of constant sql overrides.
+      def self.extended(db)
+        db.instance_exec do
+          @constant_sqls ||= {}
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      # Hash mapping constant symbols to SQL.  For internal use only.
+      attr_reader :constant_sqls # :nodoc:
+
+      # Set the SQL to use for the given Sequel::SQL::Constant
+      def set_constant_sql(constant, override)
+        @constant_sqls[constant.constant] = override
+      end
+
+      # Freeze the constant_sqls hash to prevent adding new overrides.
+      def freeze
+        @constant_sqls.freeze
+        super
+      end
+    end
+
+    module DatasetMethods
+      # Use overridden constant SQL
+      def constant_sql_append(sql, constant)
+        if constant_sql = db.constant_sqls[constant]
+          sql << constant_sql
+        else
+          super
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:constant_sql_override, ConstantSqlOverride::DatabaseMethods)
+end