serrano-vk 0.1.0

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

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+#
+# The symbol_as extension adds Symbol#as, for creating
+# Sequel::SQL::AliasedExpression objects. It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:column].as(:alias)
+#
+# you can just write:
+#
+#   :column.as(:alias)
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_as
+#
+# If you are using Ruby 2+, and you would like to use refinements, there
+# is a refinement version of this in the symbol_as_refinement extension.
+
+# 
+class Symbol
+  include Sequel::SQL::AliasMethods
+end

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

@@ -0,0 +1,37 @@
+# frozen-string-literal: true
+#
+# The symbol_as_refinement extension adds a refinement that makes
+# Symbol#as return Sequel::SQL::AliasedExpression instances.  It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:column].as(:alias) # column AS alias
+#
+# you can just write:
+#   
+#   :column.as(:alias) # column AS alias
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_as_refinement
+#
+# To enable the refinement for the current file:
+#
+#   using Sequel::SymbolAs
+#
+# If you would like this extension to be enabled globally instead
+# of as a refinement, use the symbol_as extension.
+#
+# Related module: Sequel::SymbolAs
+
+# :nocov:
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
+
+module Sequel::SymbolAs
+  refine Symbol do
+    def as(aliaz, columns=nil)
+      Sequel::SQL::AliasedExpression.new(self, aliaz, columns)
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# The synchronize_sql extension checks out a connection from the pool while
+# generating an SQL string.  In cases where a connection is necessary
+# in order to properly escape input, and multiple inputs in the query need
+# escaping, this can result in fewer connection checkouts and better
+# overall performance. In other cases this results in a performance decrease
+# because a connection is checked out and either not used or kept checked out
+# longer than necessary.
+#
+# The adapters where this extension may improve performance include amalgalite,
+# mysql2, postgres, jdbc/postgresql, and tinytds. In these adapters, escaping
+# strings requires a connection object for as proper escaping requires calling
+# an escaping method on the connection object.
+#
+# This extension is most helpful when dealing with queries with lots of
+# strings that need escaping (e.g. IN queries with long lists).  By default,
+# a connection will be checked out and back in for each string to be escaped,
+# which under high contention can cause the query to spend longer generating
+# the SQL string than the actual pool timeout (since every individual checkout
+# will take less than the timeout, but the sum of all of them can be greater).
+#
+# This extension is unnecessary and will decrease performance if the single
+# threaded connection pool is used.
+
+#
+module Sequel
+  class Dataset
+    module SynchronizeSQL
+      %w'insert select update delete'.each do |type|
+        define_method(:"#{type}_sql") do |*args|
+          if @opts[:sql].is_a?(String)
+            return super(*args)
+          end
+
+          db.synchronize(@opts[:server]) do
+            super(*args)
+          end
+        end
+      end
+    end
+
+    register_extension(:synchronize_sql, SynchronizeSQL)
+  end
+end

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

@@ -0,0 +1,178 @@
+# frozen-string-literal: true
+#
+# The temporarily_release_connection extension adds support for temporarily
+# releasing a checked out connection back to the connection pool.  It is
+# designed for use in multithreaded transactional integration tests, allowing
+# a connection to start a transaction in one thread, but be temporarily
+# released back to the connection pool, so it can be operated on safely
+# by multiple threads inside a block. For example, the main thread could be
+# running tests that send web requests, and a separate thread running a web
+# server that is responding to those requests, and the same connection and
+# transaction would be used for both.
+#
+# To load the extension into the database:
+#
+#   DB.extension :temporarily_release_connection
+#
+# After the extension is loaded, call the +temporarily_release_connection+
+# method with the connection object to temporarily release the connection
+# back to the pool. Example:
+#
+#   DB.transaction(rollback: :always, auto_savepoint: true) do |conn|
+#     DB.temporarily_release_connection(conn) do
+#       # Other threads can operate on connection safely inside the transaction
+#       yield
+#     end
+#   end
+#
+# For sharded connection pools, the second argument to +temporarily_release_connection+
+# is respected, and specifies the server on which to temporarily release the connection.
+#
+# The temporarily_release_connection extension is only supported with the
+# threaded and timed_queue connection pools that ship with Sequel (and the sharded
+# versions of each).  To make sure that same connection object can be reacquired, it
+# is only supported if the maximum connection pool size is 1, so set the Database
+# :max_connections option to 1 if you plan to use this extension.
+#
+# If the +temporarily_release_connection+ method cannot reacquire the same connection
+# it released to the pool, it will raise a Sequel::UnableToReacquireConnectionError
+# exception.  This should only happen if the connection has been disconnected
+# while it was temporarily released.  If this error is raised, Database#transaction
+# will not rollback the transaction, since the connection object is likely no longer
+# valid, and on poorly written database drivers, that could cause the process to crash.
+#
+# Related modules: Sequel::TemporarilyReleaseConnection,
+# Sequel::UnableToReacquireConnectionError
+
+#
+module Sequel
+  # Error class raised if the connection pool does not provide the same connection
+  # object when checking a temporarily released connection out.
+  class UnableToReacquireConnectionError < Error
+  end
+
+  module TemporarilyReleaseConnection
+    module DatabaseMethods
+      # Temporarily release the connection back to the connection pool for the
+      # duration of the block.
+      def temporarily_release_connection(conn, server=:default, &block)
+        pool.temporarily_release_connection(conn, server, &block)
+      end
+
+      private
+
+      # Do nothing if UnableToReacquireConnectionError is raised, as it is
+      # likely the connection is not in a usable state.
+      def rollback_transaction(conn, opts)
+        return if UnableToReacquireConnectionError === $!
+        super
+      end
+    end
+
+    module PoolMethods
+      # Temporarily release a currently checked out connection, then yield to the block. Reacquire the same
+      # connection upon the exit of the block.
+      def temporarily_release_connection(conn, server)
+        t = Sequel.current
+        raise Error, "connection not currently checked out" unless conn.equal?(trc_owned_connection(t, server))
+
+        begin
+          trc_release(t, conn, server)
+          yield
+        ensure
+          c = trc_acquire(t, server)
+          unless conn.equal?(c)
+            raise UnableToReacquireConnectionError, "reacquired connection not the same as initial connection"
+          end
+        end
+      end
+    end
+
+    module TimedQueue
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t)
+      end
+
+      def trc_release(t, conn, server)
+        release(t)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t)
+      end
+    end
+
+    module ShardedTimedQueue
+      # Normalize the server name for sharded connection pools
+      def temporarily_release_connection(conn, server)
+        server = pick_server(server)
+        super
+      end
+
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t, server)
+      end
+
+      def trc_release(t, conn, server)
+        release(t, conn, server)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t, server)
+      end
+    end
+
+    module ThreadedBase
+      private
+
+      def trc_release(t, conn, server)
+        sync{super}
+      end
+    end
+
+    module Threaded
+      include TimedQueue
+      include ThreadedBase
+    end
+
+    module ShardedThreaded
+      include ShardedTimedQueue
+      include ThreadedBase
+    end
+  end
+
+  trc = TemporarilyReleaseConnection
+  trc_map = {
+    :threaded => trc::Threaded,
+    :sharded_threaded => trc::ShardedThreaded,
+    :timed_queue => trc::TimedQueue,
+    :sharded_timed_queue => trc::ShardedTimedQueue,
+  }.freeze
+
+  Database.register_extension(:temporarily_release_connection) do |db|
+    unless pool_mod = trc_map[db.pool.pool_type]
+      raise(Error, "temporarily_release_connection extension not supported for connection pool type #{db.pool.pool_type}")
+    end
+
+    case db.pool.pool_type
+    when :threaded, :sharded_threaded
+      if db.opts[:connection_handling] == :disconnect
+        raise Error, "temporarily_release_connection extension not supported with connection_handling: :disconnect option"
+      end
+    end
+
+    unless db.pool.max_size == 1
+      raise Error, "temporarily_release_connection extension not supported unless :max_connections option is 1"
+    end
+
+    db.extend(trc::DatabaseMethods)
+    db.pool.extend(trc::PoolMethods)
+    db.pool.extend(pool_mod)
+  end
+
+  private_constant :TemporarilyReleaseConnection
+end

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

@@ -0,0 +1,59 @@
+# frozen-string-literal: true
+#
+# The thread_local_timezones extension allows you to set a per-thread timezone that
+# will override the default global timezone while the thread is executing.  The
+# main use case is for web applications that execute each request in its own thread,
+# and want to set the timezones based on the request.
+#
+# To load the extension:
+#
+#   Sequel.extension :thread_local_timezones
+#
+# The most common example is having the database always store time in
+# UTC, but have the application deal with the timezone of the current
+# user.  That can be done with:
+#
+#   Sequel.database_timezone = :utc
+#   # In each thread:
+#   Sequel.thread_application_timezone = current_user.timezone
+#
+# This extension is designed to work with the named_timezones extension.
+#
+# This extension adds the thread_application_timezone=, thread_database_timezone=,
+# and thread_typecast_timezone= methods to the Sequel module.  It overrides
+# the application_timezone, database_timezone, and typecast_timezone
+# methods to check the related thread local timezone first, and use it if present.
+# If the related thread local timezone is not present, it falls back to the
+# default global timezone.
+#
+# There is one special case of note.  If you have a default global timezone
+# and you want to have a nil thread local timezone, you have to set the thread
+# local value to :nil instead of nil:
+#
+#   Sequel.application_timezone = :utc
+#   Sequel.thread_application_timezone = nil
+#   Sequel.application_timezone # => :utc
+#   Sequel.thread_application_timezone = :nil
+#   Sequel.application_timezone # => nil
+#
+# Related module: Sequel::ThreadLocalTimezones
+
+#
+module Sequel
+  module ThreadLocalTimezones
+    %w'application database typecast'.each do |t|
+      class_eval("def thread_#{t}_timezone=(tz); Thread.current[:#{t}_timezone] = convert_timezone_setter_arg(tz); end", __FILE__, __LINE__)
+      class_eval(<<END, __FILE__, __LINE__ + 1)
+        def #{t}_timezone
+          if tz = Thread.current[:#{t}_timezone]
+            tz unless tz == :nil
+          else
+            super
+          end
+        end
+END
+    end
+  end
+  
+  extend ThreadLocalTimezones
+end

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

@@ -0,0 +1,169 @@
+# frozen-string-literal: true
+#
+# This adds a <tt>Sequel::Dataset#to_dot</tt> method.  The +to_dot+ method
+# returns a string that can be processed by graphviz's +dot+ program in
+# order to get a visualization of the dataset.  Basically, it shows a version
+# of the dataset's abstract syntax tree.
+#
+# To load the extension:
+#
+#   Sequel.extension :to_dot
+#
+# Related module: Sequel::ToDot
+
+#
+module Sequel
+  class ToDot
+    module DatasetMethods
+      # Return a string that can be processed by the +dot+ program (included
+      # with graphviz) in order to see a visualization of the dataset's
+      # abstract syntax tree.
+      def to_dot
+        ToDot.output(self)
+      end
+    end
+
+    # The option keys that should be included in the dot output.
+    TO_DOT_OPTIONS = [:with, :distinct, :select, :from, :join, :where, :group, :having, :compounds, :order, :limit, :offset, :lock].freeze
+
+    # Given a +Dataset+, return a string in +dot+ format that will
+    # generate a visualization of the dataset.
+    def self.output(ds)
+      new(ds).output
+    end
+
+    # Given a +Dataset+, parse the internal structure to generate
+    # a dataset visualization.
+    def initialize(ds)
+      @i = 0
+      @stack = [@i]
+      @dot = ["digraph G {", "0 [label=\"self\"];"]
+      v(ds, "")
+      @dot << "}"
+    end
+
+    # Output the dataset visualization as a string in +dot+ format.
+    def output
+      @dot.join("\n")
+    end
+
+    private
+
+    # Add an entry to the +dot+ output with the given label.  If +j+
+    # is given, it is used directly as the node or transition.  Otherwise
+    # a node is created for the current object.
+    def dot(label, j=nil)
+      label = case label
+      when nil
+        "<nil>"
+      else
+        label.to_s
+      end
+      @dot << "#{j||@i} [label=#{label.inspect}];"
+    end
+
+    # Recursive method that parses all of Sequel's internal datastructures,
+    # adding the appropriate nodes and transitions to the internal +dot+
+    # structure.
+    def v(e, l)
+      @i += 1
+      dot(l, "#{@stack.last} -> #{@i}")
+      @stack.push(@i)
+      case e
+      when LiteralString
+        dot "Sequel.lit(#{e.to_s.inspect})"
+      when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
+        dot e.inspect
+      when Array
+        dot "Array"
+        e.each_with_index do |val, j|
+          v(val, j)
+        end
+      when Set
+        dot "Set"
+        e.each_with_index do |val, j|
+          v(val, j)
+        end
+      when Hash
+        dot "Hash"
+        e.each do |k, val|
+          v(val, k)
+        end
+      when SQL::ComplexExpression 
+        dot "ComplexExpression: #{e.op}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
+        end
+      when SQL::Identifier
+        dot "Identifier"
+        v(e.value, :value)
+      when SQL::QualifiedIdentifier
+        dot "QualifiedIdentifier"
+        v(e.table, :table)
+        v(e.column, :column)
+      when SQL::OrderedExpression
+        dot "OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}"
+        v(e.expression, :expression)
+      when SQL::AliasedExpression
+        dot "AliasedExpression"
+        v(e.expression, :expression)
+        v(e.alias, :alias)
+        v(e.columns, :columns) if e.columns
+      when SQL::CaseExpression
+        dot "CaseExpression"
+        v(e.expression, :expression) if e.expression
+        v(e.conditions, :conditions)
+        v(e.default, :default)
+      when SQL::Cast
+        dot "Cast"
+        v(e.expr, :expr)
+        v(e.type, :type)
+      when SQL::Function
+        dot "Function: #{e.name}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
+        end
+        v(e.args, :args)
+        v(e.opts, :opts)
+      when SQL::Subscript 
+        dot "Subscript"
+        v(e.f, :f)
+        v(e.sub, :sub)
+      when SQL::Window
+        dot "Window"
+        v(e.opts, :opts)
+      when SQL::PlaceholderLiteralString
+        str = e.str
+        str = "(#{str})" if e.parens
+        dot "PlaceholderLiteralString: #{str.inspect}"
+        v(e.args, :args)
+      when SQL::JoinClause
+        str = "#{e.join_type.to_s.upcase} JOIN".dup
+        if e.is_a?(SQL::JoinOnClause)
+          str << " ON"
+        elsif e.is_a?(SQL::JoinUsingClause)
+          str << " USING"
+        end
+        dot str
+        v(e.table_expr, :table)
+        if e.is_a?(SQL::JoinOnClause)
+          v(e.on, :on) 
+        elsif e.is_a?(SQL::JoinUsingClause)
+          v(e.using, :using) 
+        end
+      when Dataset
+        dot "Dataset"
+        TO_DOT_OPTIONS.each do |k|
+          if val = e.opts[k]
+            v(val, k) 
+          end
+        end
+      else
+        dot "Unhandled: #{e.inspect}"
+      end
+      @stack.pop
+    end
+  end
+
+  Dataset.register_extension(:to_dot, ToDot::DatasetMethods)
+end

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

@@ -0,0 +1,78 @@
+# frozen-string-literal: true
+#
+# The transaction_connection_validator extension automatically
+# retries a transaction on a connection if an disconnect error
+# is raised when sending the statement to begin a new
+# transaction, as long as the user has not already checked out
+# a connection.  This is safe to do because no other queries
+# have been issued on the connection, and no user-level code
+# is run before retrying.
+#
+# This approach to connection validation can be significantly
+# lower overhead than the connection_validator extension,
+# though it does not handle all cases handled by the
+# connection_validator extension.  However, it performs the
+# validation checks on every new transaction, so it will
+# automatically handle disconnected connections in some cases
+# where the connection_validator extension will not by default
+# (as the connection_validator extension only checks
+# connections if they have not been used in the last hour by
+# default).
+#
+# Related module: Sequel::TransactionConnectionValidator
+
+#
+module Sequel
+  module TransactionConnectionValidator
+    class DisconnectRetry < DatabaseDisconnectError
+      # The connection that raised the disconnect error
+      attr_accessor :connection
+
+      # The underlying disconnect error, in case it needs to be reraised.
+      attr_accessor :database_error
+    end
+
+    # Rescue disconnect errors raised when beginning a new transaction.  If there
+    # is a disconnnect error, it should be safe to retry the transaction using a
+    # new connection, as we haven't yielded control to the user yet.
+    def transaction(opts=OPTS)
+      super
+    rescue DisconnectRetry => e
+      if synchronize(opts[:server]){|conn| conn.equal?(e.connection)}
+        # If retrying would use the same connection, that means the
+        # connection was not removed from the pool, which means the caller has
+        # already checked out the connection, and retrying will not be successful.
+        # In this case, we can only reraise the exception.
+        raise e.database_error
+      end
+
+      num_retries ||= 0 
+      num_retries += 1
+      retry if num_retries < 5
+
+      raise e.database_error
+    end
+
+    private
+
+    # Reraise disconnect errors as DisconnectRetry so they can be retried.
+    def begin_new_transaction(conn, opts)
+      super
+    rescue Sequel::DatabaseDisconnectError, *database_error_classes => e
+      if e.is_a?(Sequel::DatabaseDisconnectError) || disconnect_error?(e, OPTS)
+        exception = DisconnectRetry.new(e.message)
+        exception.set_backtrace([])
+        exception.connection = conn
+        unless e.is_a?(Sequel::DatabaseError)
+          e = Sequel.convert_exception_class(e, database_error_class(e, OPTS))
+        end
+        exception.database_error = e
+        raise exception
+      end
+
+      raise
+    end
+  end
+
+  Database.register_extension(:transaction_connection_validator, TransactionConnectionValidator)
+end

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

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# These modifies virtual row blocks so that you can pass a block
+# when calling a method to change the behavior.  It only exists
+# for backwards compatibility with previous Sequel versions, and
+# is not recommended for new applications.
+# 
+# To load the extension:
+#
+#   Sequel.extension :virtual_row_method_block
+
+#
+module Sequel
+  module SQL
+    class VirtualRow < BasicObject
+      include(Module.new do
+        Sequel.set_temp_name(self){"Sequel::SQL:VirtualRow::_MethodBlockMethodMissing"}
+        # Handle blocks passed to methods and change the behavior.
+        def method_missing(m, *args, &block)
+          if block
+            if args.empty?
+              Function.new(m)
+            else
+              case args.shift
+              when :*
+                Function.new(m, *args).*
+              when :distinct
+                Function.new(m, *args).distinct
+              when :over
+                opts = args.shift || OPTS
+                f = Function.new(m, *::Kernel.Array(opts[:args]))
+                f = f.* if opts[:*]
+                f.over(opts)
+              else
+                Kernel.raise(Error, 'unsupported VirtualRow method argument used with block')
+              end
+            end
+          else
+            super
+          end
+        end
+      end)
+    end
+  end
+end