serrano-vk 0.1.0

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

@@ -0,0 +1,179 @@
+# frozen-string-literal: true
+#
+# The server_block extension adds the Database#with_server method, which takes a shard
+# argument and a block, and makes it so that access inside the block will use the
+# specified shard by default.
+#
+# First, you need to enable it on the database object:
+#
+#   DB.extension :server_block
+# 
+# Then you can call with_server:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB[:a].server(:shard2).all # Uses shard2
+#   end
+#   DB[:a].all # Uses default
+#
+# You can nest calls to with_server:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB.with_server(:shard2) do
+#       DB[:a].all # Uses shard2
+#     end
+#     DB[:a].all # Uses shard1
+#   end
+#   DB[:a].all # Uses default
+# 
+# Note that if you pass the nil, :default, or :read_only server/shard
+# names to Dataset#server inside a with_server block, they will be
+# ignored and the server/shard given to with_server will be used:
+#
+#   DB.with_server(:shard1) do
+#     DB[:a].all # Uses shard1
+#     DB[:a].server(:shard2).all # Uses shard2
+#     DB[:a].server(nil).all # Uses shard1
+#     DB[:a].server(:default).all # Uses shard1
+#     DB[:a].server(:read_only).all # Uses shard1
+#   end
+#
+# If you pass two separate shards to with_server, the second shard will
+# be used instead of the :read_only shard, and the first shard will be
+# used instead of the :default shard:
+#
+#   DB.with_server(:shard1, :shard2) do
+#     DB[:a].all # Uses shard2
+#     DB[:a].delete # Uses shard1
+#     DB[:a].server(:shard3).all # Uses shard3
+#     DB[:a].server(:shard3).delete # Uses shard3
+#     DB[:a].server(:default).all # Uses shard1
+#     DB[:a].server(:read_only).delete # Uses shard2
+#   end
+#
+# If you use an invalid server when calling with_server, it will be
+# treated the same way as if you called Dataset#server with an invalid
+# server.  By default, the default server will be used in such cases.
+# If you would like a different server to be used, or an exception to
+# be raised, then use the :servers_hash Database option.
+#
+# Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
+# Sequel::ThreadedServerBlock
+
+#
+module Sequel
+  module ServerBlock
+    # Enable the server block on the connection pool, choosing the correct
+    # extension depending on whether the connection pool is threaded or not.
+    # Also defines the with_server method on the receiver for easy use.
+    def self.extended(db)
+      pool = db.pool
+      case pool.pool_type
+      when :sharded_threaded, :sharded_timed_queue
+        pool.extend(ThreadedServerBlock)
+        pool.instance_variable_set(:@default_servers, {})
+      else
+        pool.extend(UnthreadedServerBlock)
+        pool.instance_variable_set(:@default_servers, [])
+      end
+    end
+
+    # Delegate to the connection pool
+    def with_server(default_server, read_only_server=default_server, &block)
+      pool.with_server(default_server, read_only_server, &block)
+    end
+  end
+
+  # Adds with_server support for the sharded single connection pool.
+  module UnthreadedServerBlock
+    # Set a default server/shard to use inside the block.
+    def with_server(default_server, read_only_server=default_server)
+      set_default_server(default_server, read_only_server)
+      yield
+    ensure
+      clear_default_server
+    end
+
+    private
+
+    # Make the given server the new default server.
+    def set_default_server(default_server, read_only_server=default_server)
+      @default_servers << [default_server, read_only_server]
+    end
+
+    # Remove the current default server, restoring the
+    # previous default server.
+    def clear_default_server
+      @default_servers.pop
+    end
+
+    # Use the server given to with_server if appropriate.
+    def pick_server(server)
+      if @default_servers.empty?
+        super
+      else
+        case server
+        when :default, nil
+          @servers[@default_servers[-1][0]]
+        when :read_only
+          @servers[@default_servers[-1][1]]
+        else
+          super
+        end
+      end
+    end
+  end
+
+  # Adds with_server support for the sharded threaded connection pool.
+  module ThreadedServerBlock
+    # Set a default server/shard to use inside the block for the current
+    # thread.
+    def with_server(default_server, read_only_server=default_server)
+      set_default_server(default_server, read_only_server)
+      yield
+    ensure
+      clear_default_server
+    end
+
+    private
+
+    # Make the given server the new default server for the current thread.
+    def set_default_server(default_server, read_only_server=default_server)
+      sync{(@default_servers[Sequel.current] ||= [])} << [default_server, read_only_server]
+    end
+
+    # Remove the current default server for the current thread, restoring the
+    # previous default server.
+    def clear_default_server
+      t = Sequel.current
+      a = sync{@default_servers[t]}
+      a.pop
+      sync{@default_servers.delete(t)} if a.empty?
+    end
+
+    # Use the server given to with_server for the given thread, if appropriate.
+    def pick_server(server)
+      a = sync{@default_servers[Sequel.current]}
+      if !a || a.empty?
+        super
+      else
+        # Hash handling required to work when loaded after arbitrary servers plugin.
+        case server
+        when :default, nil
+          v = a[-1][0]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
+        when :read_only
+          v = a[-1][1]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
+        else
+          super
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:server_block, ServerBlock)
+end

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

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+#
+# The server_logging extension makes the logger include the server/shard
+# the query was issued on.  This makes it easier to use the logs when
+# using sharding.
+#
+# Example:
+#
+#   DB.opts[:server]
+#   # {:read_only=>{}, :b=>{}}
+#   DB.extension :server_logging
+#   DB[:a].all
+#   # (0.000005s) (conn: 1014942550, server: read_only) SELECT * FROM a
+#   DB[:a].server(:b).all
+#   # (0.000004s) (conn: 997304100, server: b) SELECT * FROM a
+#   DB[:a].insert
+#   # (0.000004s) (conn: 1014374750, server: default) INSERT INTO a DEFAULT VALUES
+#
+# In order for the server/shard to be correct for all connections, you need to
+# use this before connections to the database are made, or you need to call
+# <tt>Database#disconnect</tt> after loading this extension.
+#
+# Related module: Sequel::ServerLogging
+
+#
+module Sequel
+  module ServerLogging
+    # Initialize the hash mapping connections to shards, and turn on logging
+    # of connection info unless it has specifically been turned off.
+    def self.extended(db)
+      db.instance_exec do
+        @server_connection_map ||= {}
+        self.log_connection_info = true if log_connection_info.nil?
+      end
+    end
+
+    # When setting up a new connection, associate the connection with the
+    # shard.
+    def connect(server)
+      conn = super
+      Sequel.synchronize{@server_connection_map[conn] = server}
+      conn
+    end
+
+    # When disconnecting a connection, remove the related connection from the mapping.
+    def disconnect_connection(conn)
+      super
+    ensure
+      Sequel.synchronize{@server_connection_map.delete(conn)}
+    end
+
+    private
+
+    # Include the server with the connection's id.
+    def connection_info(conn)
+      "(conn: #{conn.__id__}, server: #{Sequel.synchronize{@server_connection_map[conn]}}) "
+    end
+  end
+
+  Database.register_extension(:server_logging, ServerLogging)
+end

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

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+#
+# The set_literalizer extension should no longer be used, as Sequel
+# now supports Set values by default. For backwards compatibility
+# the set_literalizer extension will treat a set that contains only
+# 2 element arrays as a condition specifier (matching the behavior
+# for arrays where all elements are 2 element arrays). This is not
+# compatible with Sequel's current default behavior. If you are
+# relying on this behavior, it is recommended you convert the set
+# to an array.
+#
+# Related module: Sequel::Dataset::SetLiteralizer
+
+module Sequel
+  # SEQUEL6: Remove
+  Sequel::Deprecation.deprecate("The set_literalizer extension", "Sequel now supports set literalization by default")
+
+  class Dataset
+    module SetLiteralizer
+      private
+
+      # Allow using sets as condition specifiers.
+      def filter_expr(expr = nil, &block)
+        if expr.is_a?(Set)
+          expr
+        else
+          super
+        end
+      end
+
+      # Literalize Set instances by converting the set to array.
+      def literal_set_append(sql, v)
+        literal_append(sql, v.to_a) 
+      end
+    end
+
+    register_extension(:set_literalizer, SetLiteralizer)
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen-string-literal: true
+#
+# The split_array_nil extension overrides Sequel's default handling of
+# IN/NOT IN with arrays of values to do specific nil checking.  For example,
+#
+#   ds = DB[:table].where(column: [1, nil])
+# 
+# By default, that produces the following SQL:
+#
+#   SELECT * FROM table WHERE (column IN (1, NULL))
+#
+# However, because NULL = NULL is not true in SQL (it is NULL), this
+# will not return rows in the table where the column is NULL.  This
+# extension allows for an alternative behavior more similar to ruby,
+# which will return rows in the table where the column is NULL, using
+# a query like:
+#
+#   SELECT * FROM table WHERE ((column IN (1)) OR (column IS NULL)))
+#
+# Similarly, for NOT IN queries:
+#
+#   ds = DB[:table].exclude(column: [1, nil])
+#   # Default:
+#   #   SELECT * FROM table WHERE (column NOT IN (1, NULL))
+#   # with split_array_nils extension:
+#   #   SELECT * FROM table WHERE ((column NOT IN (1)) AND (column IS NOT NULL)))
+#
+# In addition to arrays, this splitting is also done for sets:
+#
+#   ds = DB[:table].where(column: Set[1, nil])
+#   # SELECT * FROM table WHERE ((column IN (1)) OR (column IS NULL)))
+#
+# To use this extension with a single dataset:
+#
+#   ds = ds.extension(:split_array_nil)
+#
+# To use this extension for all of a database's datasets:
+#
+#   DB.extension(:split_array_nil)
+#
+# Related module: Sequel::Dataset::SplitArrayNil
+
+#
+module Sequel
+  class Dataset
+    module SplitArrayNil
+      # Over the IN/NOT IN handling with an array of values where one of the
+      # values in the array is nil, by removing nils from the array of values,
+      # and using a separate OR IS NULL clause for IN or AND IS NOT NULL clause
+      # for NOT IN.
+      def complex_expression_sql_append(sql, op, args)
+      case op
+      when :IN, :"NOT IN"
+        vals = args[1]
+        if (vals.is_a?(Array) || vals.is_a?(Set)) && vals.any?(&:nil?)
+          cols = args[0]
+          if vals.is_a?(Set)
+            vals = vals.dup
+            vals.delete(nil)
+          else
+            vals = vals.compact
+          end
+          c = Sequel::SQL::BooleanExpression
+          if op == :IN
+            literal_append(sql, c.new(:OR, c.new(:IN, cols, vals), c.new(:IS, cols, nil)))
+          else
+            literal_append(sql, c.new(:AND, c.new(:"NOT IN", cols, vals), c.new(:"IS NOT", cols, nil)))
+          end
+        else
+          super
+        end
+      else
+        super
+      end
+      end
+    end
+  end
+
+  Dataset.register_extension(:split_array_nil, Dataset::SplitArrayNil)
+end

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

@@ -0,0 +1,203 @@
+# frozen-string-literal: true
+#
+# The sql_comments extension adds Dataset#comment to the datasets,
+# allowing you to set SQL comments in the resulting query.  These
+# comments are appended to the end of the SQL query:
+#
+#   ds = DB[:table].comment("Some Comment").all
+#   # SELECT * FROM table -- Some Comment
+#   #
+#
+# As you can see, this uses single line SQL comments (--) suffixed
+# by a newline.  This plugin transforms all consecutive whitespace
+# in the comment to a single string:
+#
+#   ds = DB[:table].comment("Some\r\nComment     Here").all
+#   # SELECT * FROM table -- Some Comment Here
+#   #
+#
+# The reason for the prefixing and suffixing by newlines is to
+# work correctly when used in subqueries:
+#
+#   ds = DB[:table].comment("Some\r\nComment     Here")
+#   ds.where(id: ds).all
+#   # SELECT * FROM table WHERE (id IN (SELECT * FROM table -- Some Comment Here
+#   # )) -- Some Comment Here
+#   #
+#
+# In addition to working on SELECT queries, it also works when
+# inserting, updating, and deleting.
+#
+# Due to the use of single line SQL comments and converting all
+# whitespace to spaces, this should correctly handle even
+# malicious input.  However, it would be unwise to rely on that,
+# you should ensure that the argument given
+# to Dataset#comment is not derived from user input.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:sql_comments)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:sql_comments)
+#
+# Loading the sql_comments extension into the database also adds 
+# support for block-level comment support via Database#with_comments.
+# You call #with_comments with a hash.  Queries inside the hash will
+# include a comment based on the hash (assuming they are inside the
+# same thread):
+#
+#   DB.with_comments(model: Album, action: :all) do
+#     DB[:albums].all
+#     # SELECT * FROM albums -- model:Album,action:all
+#   end
+#
+# You can nest calls to #with_comments, which will combine the
+# entries from both calls:
+#
+#   DB.with_comments(application: App, path: :scrubbed_path) do
+#     DB.with_comments(model: Album, action: :all) do
+#       ds = DB[:albums].all
+#       # SELECT * FROM albums
+#       # -- application:App,path:scrubbed_path,model:Album,action:all
+#     end
+#   end
+#
+# You can override comment entries specified in earlier blocks, or
+# remove entries specified earlier using a nil value:
+#
+#   DB.with_comments(application: App, path: :scrubbed_path) do
+#     DB.with_comments(application: Foo, path: nil) do
+#       ds = DB[:albums].all
+#       # SELECT * FROM albums # -- application:Foo
+#     end
+#   end
+#
+# You can combine block-level comments with dataset-specific
+# comments:
+#
+#   DB.with_comments(model: Album, action: :all) do
+#     DB[:table].comment("Some Comment").all
+#     # SELECT * FROM albums -- model:Album,action:all -- Some Comment
+#   end
+#
+# Note that Microsoft Access does not support inline comments,
+# and attempting to use comments on it will result in SQL syntax
+# errors.
+#
+# Related modules: Sequel::SQLComments, Sequel::Database::SQLComments
+
+#
+module Sequel
+  module SQLComments
+    # Return a modified copy of the dataset that will use the given comment.
+    # To uncomment a commented dataset, pass nil as the argument.
+    def comment(comment)
+      clone(:comment=>(format_sql_comment(comment) if comment))
+    end
+
+    %w'select insert update delete'.each do |type|
+      define_method(:"#{type}_sql") do |*a|
+        sql = super(*a)
+        if comment = _sql_comment
+          # This assumes that the comment stored in the dataset has
+          # already been formatted. If not, this could result in SQL
+          # injection.
+          #
+          # Additionally, due to the use of an SQL comment, if any
+          # SQL is appened to the query after the comment is added,
+          # it will become part of the comment unless it is preceded
+          # by a newline.
+          if sql.frozen?
+            sql += comment
+            sql.freeze
+          elsif @opts[:append_sql] || @opts[:placeholder_literalizer]
+            sql << comment
+          else
+            sql += comment
+          end
+        end
+        sql
+      end
+    end
+
+    private
+
+    # The comment to include in the SQL query, if any.
+    def _sql_comment
+      @opts[:comment]
+    end
+
+    # Format the comment.  For maximum compatibility, this uses a
+    # single line SQL comment, and converts all consecutive whitespace
+    # in the comment to a single space.
+    def format_sql_comment(comment)
+      " -- #{comment.to_s.gsub(/\s+/, ' ')}\n"
+    end
+  end
+
+  module Database::SQLComments
+    def self.extended(db)
+      db.instance_variable_set(:@comment_hashes, {})
+      db.extend_datasets DatasetSQLComments
+    end
+
+    # A map of threads to comment hashes, used for correctly setting
+    # comments for all queries inside #with_comments blocks.
+    attr_reader :comment_hashes
+
+    # Store the comment hash and use it to create comments inside the block
+    def with_comments(comment_hash)
+      hashes = @comment_hashes
+      t = Sequel.current
+      new_hash = if hash = Sequel.synchronize{hashes[t]}
+        hash.merge(comment_hash)
+      else
+        comment_hash.dup
+      end
+      yield Sequel.synchronize{hashes[t] = new_hash}
+    ensure
+      if hash
+        Sequel.synchronize{hashes[t] = hash}
+      else
+        t && Sequel.synchronize{hashes.delete(t)}
+      end
+    end
+
+    module DatasetSQLComments
+      include Sequel::SQLComments
+
+      private
+
+      # Include comments added via Database#with_comments in the output SQL.
+      def _sql_comment
+        specific_comment = super
+        return specific_comment if @opts[:append_sql]
+
+        t = Sequel.current
+        hashes = db.comment_hashes
+        block_comment = if comment_hash = Sequel.synchronize{hashes[t]}
+          comment_array = comment_hash.map{|k,v| "#{k}:#{v}" unless v.nil?}
+          comment_array.compact!
+          comment_array.join(",")
+        end
+
+        if block_comment
+          if specific_comment
+            format_sql_comment(block_comment + specific_comment)
+          else
+            format_sql_comment(block_comment)
+          end
+        else
+          specific_comment
+        end
+      end
+    end
+  end
+
+  Dataset.register_extension(:sql_comments, SQLComments)
+  Database.register_extension(:sql_comments, Database::SQLComments)
+end

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

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+#
+# The sql_expr extension adds the sql_expr method to every object, which
+# returns an wrapped object that works nicely with Sequel's DSL by calling
+# Sequel.expr:
+#
+#   1.sql_expr < :a     # 1 < a
+#   false.sql_expr & :a # FALSE AND a
+#   true.sql_expr | :a  # TRUE OR a
+#   ~nil.sql_expr       # NOT NULL
+#   "a".sql_expr + "b"  # 'a' || 'b'
+#
+# To load the extension:
+#
+#   Sequel.extension :sql_expr
+
+#
+class Object
+  # Return the object wrapper in an appropriate Sequel expression object.
+  def sql_expr
+    Sequel[self]
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+#
+# The sql_log_normalizer extension normalizes the SQL that is logged,
+# removing the literal strings and numbers in the SQL, and removing the
+# logging of any bound variables:
+#
+#   ds = DB[:table].first(a: 1, b: 'something')
+#   # Without sql_log_normalizer extension
+#   # SELECT * FROM "table" WHERE (("a" = 1) AND ("b" = 'something')) LIMIT 1
+#
+#   # With sql_log_normalizer_extension
+#   # SELECT * FROM "table" WHERE (("a" = ?) AND ("b" = ?)) LIMIT ?
+#
+# The normalization is done by scanning the SQL string being executed
+# for literal strings and numbers, and replacing them with question
+# marks.  While this should work for all or almost all production queries,
+# there are pathlogical queries that will not be handled correctly, such as
+# the use of apostrophes in identifiers:
+#
+#   DB[:"asf'bar"].where(a: 1, b: 'something').first
+#   # Logged as:
+#   # SELECT * FROM "asf?something')) LIMIT ?
+#
+# The expected use case for this extension is when you want to normalize
+# logs to group similar queries, or when you want to protect sensitive
+# data from being stored in the logs.
+#
+# Related module: Sequel::SQLLogNormalizer
+
+#
+module Sequel
+  module SQLLogNormalizer
+    def self.extended(db)
+      type = case db.literal("'")
+      when "''''"
+        :standard
+      when "'\\''"
+        :backslash
+      when "N''''"
+        :n_standard
+      else
+        raise Error, "SQL log normalization is not supported on this database (' literalized as #{db.literal("'").inspect})"
+      end
+      db.instance_variable_set(:@sql_string_escape_type, type)
+    end
+
+    # Normalize the SQL before calling super.
+    def log_connection_yield(sql, conn, args=nil)
+      unless skip_logging?
+        sql = normalize_logged_sql(sql)
+        args = nil
+      end
+      super
+    end
+
+    # Replace literal strings and numbers in SQL with question mark placeholders.
+    def normalize_logged_sql(sql)
+      sql = sql.dup
+      sql.force_encoding('BINARY')
+      start_index = 0
+      check_n = @sql_string_escape_type == :n_standard
+      outside_string = true
+
+      if @sql_string_escape_type == :backslash
+        search_char = /[\\']/
+        escape_char_offset = 0
+        escape_char_value = 92 # backslash
+      else
+        search_char = "'"
+        escape_char_offset = 1
+        escape_char_value = 39 # apostrophe
+      end
+
+      # The approach used here goes against Sequel's philosophy of never attempting
+      # to parse SQL.  However, parsing the SQL is basically the only way to implement
+      # this support with Sequel's design, and it's better to be pragmatic and accept
+      # this than not be able to support this.
+
+      # Replace literal strings
+      while outside_string && (index = start_index = sql.index("'", start_index))
+        if check_n && index != 0 && sql.getbyte(index-1) == 78 # N' start
+          start_index -= 1
+        end
+        index += 1
+        outside_string = false
+
+        while (index = sql.index(search_char, index)) && (sql.getbyte(index + escape_char_offset) == escape_char_value)
+          # skip escaped characters inside string literal
+          index += 2
+        end
+
+        if index
+          # Found end of string
+          sql[start_index..index] = '?'
+          start_index += 1
+          outside_string = true
+        end
+      end
+
+      # Replace integer and decimal floating point numbers
+      sql.gsub!(/\b-?\d+(?:\.\d+)?\b/, '?')
+
+      sql
+    end
+  end
+
+  Database.register_extension(:sql_log_normalizer, SQLLogNormalizer)
+end