serrano-vk 0.1.0

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

@@ -0,0 +1,313 @@
+# frozen-string-literal: true
+#
+# The sqlite_json_ops extension adds support to Sequel's DSL to make
+# it easier to call SQLite JSON functions and operators (added
+# first in SQLite 3.38.0).  It also supports the SQLite JSONB functions
+# added in SQLite 3.45.0.
+#
+# To load the extension:
+#
+#   Sequel.extension :sqlite_json_ops
+#
+# This extension works by calling methods on Sequel::SQLite::JSONOp and
+# Sequel::SQLite::JSONBOp objects, which you can create using
+# Sequel.sqlite_json_op and Sequel.sqlite_jsonb_op:
+#
+#   j = Sequel.sqlite_json_op(:json_column)
+#   jb = Sequel.sqlite_jsonb_op(:jsonb_column)
+#
+# Also, on most Sequel expression objects, you can call the sqlite_json_op or
+# sqlite_jsonb_op method to create a Sequel::SQLite::JSONOp or 
+# Sequel::SQLite::JSONBOp object:
+#
+#   j = Sequel[:json_column].sqlite_json_op
+#   jb = Sequel[:jsonb_column].sqlite_jsonb_op
+#
+# If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
+# or you have loaded the core_refinements extension
+# and have activated refinements for the file, you can also use Symbol#sqlite_json_op:
+# or Symbol#sqlite_jsonb_op:
+#
+#   j = :json_column.sqlite_json_op
+#   jb = :json_column.sqlite_jsonb_op
+#
+# The following methods are available for Sequel::SQLite::JSONOp instances:
+#
+#   j[1]                     # (json_column ->> 1)
+#   j.get(1)                 # (json_column ->> 1)
+#   j.get_json(1)            # (json_column -> 1)
+#   j.extract('$.a')         # json_extract(json_column, '$.a')
+#   jb.extract('$.a')        # jsonb_extract(jsonb_column, '$.a')
+#
+#   j.array_length           # json_array_length(json_column)
+#   j.type                   # json_type(json_column)
+#   j.valid                  # json_valid(json_column)
+#   jb.json                  # json(jsonb_column)
+#   j.jsonb                  # jsonb(json_column)
+#
+#   j.insert('$.a', 1)       # json_insert(json_column, '$.a', 1)
+#   j.set('$.a', 1)          # json_set(json_column, '$.a', 1)
+#   j.replace('$.a', 1)      # json_replace(json_column, '$.a', 1)
+#   j.remove('$.a')          # json_remove(json_column, '$.a')
+#   j.patch('{"a":2}')       # json_patch(json_column, '{"a":2}')
+#
+#   jb.insert('$.a', 1)      # jsonb_insert(jsonb_column, '$.a', 1)
+#   jb.set('$.a', 1)         # jsonb_set(jsonb_column, '$.a', 1)
+#   jb.replace('$.a', 1)     # jsonb_replace(jsonb_column, '$.a', 1)
+#   jb.remove('$.a')         # jsonb_remove(jsonb_column, '$.a')
+#   jb.patch('{"a":2}')      # jsonb_patch(jsonb_column, '{"a":2}')
+#
+#   j.each                   # json_each(json_column)
+#   j.tree                   # json_tree(json_column)
+#
+# Related modules: Sequel::SQLite::JSONBaseOp, Sequel::SQLite::JSONOp,
+# Sequel::SQLite::JSONBOp
+
+#
+module Sequel
+  module SQLite
+    # JSONBaseOp is an abstract base wrapper class for a object that
+    # defines methods that return Sequel expression objects representing
+    # SQLite json operators and functions. It is subclassed by both
+    # JSONOp and JSONBOp for json and jsonb specific behavior.
+    #
+    # In the method documentation examples, assume that:
+    #
+    #   json_op = Sequel.sqlite_json_op(:json)
+    class JSONBaseOp < Sequel::SQL::Wrapper
+      GET = ["(".freeze, " ->> ".freeze, ")".freeze].freeze
+      private_constant :GET
+
+      GET_JSON = ["(".freeze, " -> ".freeze, ")".freeze].freeze
+      private_constant :GET_JSON
+
+      # Returns an expression for getting the JSON array element or object field
+      # at the specified path as a SQLite value.
+      #
+      #   json_op[1]         # (json ->> 1)
+      #   json_op['a']       # (json ->> 'a')
+      #   json_op['$.a.b']   # (json ->> '$.a.b')
+      #   json_op['$[1][2]'] # (json ->> '$[1][2]')
+      def [](key)
+        json_op(GET, key)
+      end
+      alias get []
+
+      # Returns an expression for the length of the JSON array, or the JSON array at
+      # the given path.
+      #
+      #   json_op.array_length         # json_array_length(json)
+      #   json_op.array_length('$[1]') # json_array_length(json, '$[1]')
+      def array_length(*args)
+        Sequel::SQL::NumericExpression.new(:NOOP, SQL::Function.new(:json_array_length, self, *args))
+      end
+
+      # Returns an expression for a set of information extracted from the top-level
+      # members of the JSON array or object, or the top-level members of the JSON array
+      # or object at the given path.
+      #
+      #   json_op.each        # json_each(json)
+      #   json_op.each('$.a') # json_each(json, '$.a')
+      def each(*args)
+        SQL::Function.new(:json_each, self, *args)
+      end
+
+      # Returns an expression for the JSON array element or object field at the specified
+      # path as a SQLite value, but only accept paths as arguments, and allow the use of
+      # multiple paths.
+      #
+      #   json_op.extract('$.a')        # json_extract(json, '$.a')
+      #   json_op.extract('$.a', '$.b') # json_extract(json, '$.a', '$.b')
+      def extract(*a)
+        function(:extract, *a)
+      end
+
+      # Returns an expression for getting the JSON array element or object field at the
+      # specified path as a JSON value.
+      #
+      #   json_op.get_json(1)         # (json -> 1)
+      #   json_op.get_json('a')       # (json -> 'a')
+      #   json_op.get_json('$.a.b')   # (json -> '$.a.b')
+      #   json_op.get_json('$[1][2]') # (json -> '$[1][2]')
+      def get_json(key)
+        self.class.new(json_op(GET_JSON, key))
+      end
+
+      # Returns an expression for creating new entries at the given paths in the JSON array
+      # or object, but not overwriting existing entries.
+      #
+      #   json_op.insert('$.a', 1)           # json_insert(json, '$.a', 1)
+      #   json_op.insert('$.a', 1, '$.b', 2) # json_insert(json, '$.a', 1, '$.b', 2)
+      def insert(path, value, *args)
+        wrapped_function(:insert, path, value, *args)
+      end
+
+      # Returns an expression for a minified version of the JSON.
+      #
+      #   json_op.json   # json(json)
+      def json
+        JSONOp.new(SQL::Function.new(:json, self))
+      end
+      alias minify json
+
+      # Returns the JSONB format of the JSON.
+      #
+      #   json_op.jsonb   # jsonb(json)
+      def jsonb
+        JSONBOp.new(SQL::Function.new(:jsonb, self))
+      end
+
+      # Returns an expression for updating the JSON object using the RFC 7396 MergePatch algorithm
+      #
+      #   json_op.patch('{"a": 1, "b": null}') # json_patch(json, '{"a": 1, "b": null}')
+      def patch(json_patch)
+        wrapped_function(:patch, json_patch)
+      end
+
+      # Returns an expression for removing entries at the given paths from the JSON array or object.
+      #
+      #   json_op.remove('$.a')        # json_remove(json, '$.a')
+      #   json_op.remove('$.a', '$.b') # json_remove(json, '$.a', '$.b')
+      def remove(path, *paths)
+        wrapped_function(:remove, path, *paths)
+      end
+
+      # Returns an expression for replacing entries at the given paths in the JSON array or object,
+      # but not creating new entries.
+      #
+      #   json_op.replace('$.a', 1)           # json_replace(json, '$.a', 1)
+      #   json_op.replace('$.a', 1, '$.b', 2) # json_replace(json, '$.a', 1, '$.b', 2)
+      def replace(path, value, *args)
+        wrapped_function(:replace, path, value, *args)
+      end
+
+      # Returns an expression for creating or replacing entries at the given paths in the
+      # JSON array or object.
+      #
+      #   json_op.set('$.a', 1)           # json_set(json, '$.a', 1)
+      #   json_op.set('$.a', 1, '$.b', 2) # json_set(json, '$.a', 1, '$.b', 2)
+      def set(path, value, *args)
+        wrapped_function(:set, path, value, *args)
+      end
+
+      # Returns an expression for a set of information extracted from the JSON array or object, or
+      # the JSON array or object at the given path.
+      #
+      #   json_op.tree        # json_tree(json)
+      #   json_op.tree('$.a') # json_tree(json, '$.a')
+      def tree(*args)
+        SQL::Function.new(:json_tree, self, *args)
+      end
+
+      # Returns an expression for the type of the JSON value or the JSON value at the given path.
+      #
+      #   json_op.type         # json_type(json)
+      #   json_op.type('$[1]') # json_type(json, '$[1]')
+      def type(*args)
+        Sequel::SQL::StringExpression.new(:NOOP, SQL::Function.new(:json_type, self, *args))
+      end
+      alias typeof type
+
+      # Returns a boolean expression for whether the JSON is valid or not.
+      def valid
+        Sequel::SQL::BooleanExpression.new(:NOOP, SQL::Function.new(:json_valid, self))
+      end
+
+      private
+
+      # Internals of the [], get, get_json methods, using a placeholder literal string.
+      def json_op(str, args)
+        self.class.new(Sequel::SQL::PlaceholderLiteralString.new(str, [self, args]))
+      end
+
+      # Internals of the methods that return functions prefixed with +json_+.
+      def function(name, *args)
+        SQL::Function.new("#{function_prefix}_#{name}", self, *args)
+      end
+
+      # Internals of the methods that return functions prefixed with +json_+, that
+      # return JSON values.
+      def wrapped_function(*args)
+        self.class.new(function(*args))
+      end
+    end
+
+    # JSONOp is used for SQLite json-specific functions and operators.
+    class JSONOp < JSONBaseOp
+      private
+
+      def function_prefix
+        "json"
+      end
+    end
+
+    # JSONOp is used for SQLite jsonb-specific functions and operators.
+    class JSONBOp < JSONBaseOp
+      private
+
+      def function_prefix
+        "jsonb"
+      end
+    end
+
+    module JSONOpMethods
+      # Wrap the receiver in an JSONOp so you can easily use the SQLite
+      # json functions and operators with it.
+      def sqlite_json_op
+        JSONOp.new(self)
+      end
+
+      # Wrap the receiver in an JSONBOp so you can easily use the SQLite
+      # jsonb functions and operators with it.
+      def sqlite_jsonb_op
+        JSONBOp.new(self)
+      end
+    end
+  end
+
+  module SQL::Builders
+    # Return the object wrapped in an SQLite::JSONOp.
+    def sqlite_json_op(v)
+      case v
+      when SQLite::JSONOp
+        v
+      else
+        SQLite::JSONOp.new(v)
+      end
+    end
+
+    # Return the object wrapped in an SQLite::JSONBOp.
+    def sqlite_jsonb_op(v)
+      case v
+      when SQLite::JSONBOp
+        v
+      else
+        SQLite::JSONBOp.new(v)
+      end
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::SQLite::JSONOpMethods
+  end
+
+  class LiteralString
+    include Sequel::SQLite::JSONOpMethods
+  end
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQLite::JSONOpMethods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQLite::JSONOpMethods
+    end
+  end
+end
+# :nocov:

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

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+#
+# The stdio_logger extension exposes a Sequel::StdioLogger class that
+# can be used for logging with Sequel, as a minimal alternative to
+# the logger library.  It exposes debug/info/warn/error methods for the
+# different warning levels.  The debug method is a no-op, so that setting
+# the Database sql_log_level to debug will result in no output for normal
+# queries. The info/warn/error methods log the current time, log level,
+# and the given message.
+# 
+# To use this extension:
+#
+#   Sequel.extension :stdio_logger
+#
+# Then you you can use Sequel::StdioLogger to wrap IO objects that you
+# would like Sequel to log to:
+#
+#   DB.loggers << Sequel::StdioLogger.new($stdout)
+#
+#   log_file = File.open("db_queries.log", 'a')
+#   log_file.sync = true
+#   DB.loggers << Sequel::StdioLogger.new(log_file)
+#
+# This is implemented as a global extension instead of a Database extension
+# because Database loggers must be set before Database extensions are loaded.
+#
+# Related module: Sequel::StdioLogger
+
+#
+module Sequel
+  class StdioLogger
+    def initialize(device)
+      @device = device
+    end
+
+    # Do not log debug messages. This is so setting the Database
+    # sql_log_level to debug will result in no output.
+    def debug(msg)
+    end
+
+    [:info, :warn, :error].each do |meth|
+      define_method(meth) do |msg|
+        @device.write("#{Time.now.strftime('%F %T')} #{meth.to_s.upcase}: #{msg}\n")
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen-string-literal: true
+#
+# The string_agg extension adds the ability to perform database-independent
+# aggregate string concatentation.  For example, with a table like:
+#
+#   c1 | c2
+#   ---+---
+#   a  | 1
+#   a  | 2
+#   a  | 3
+#   b  | 4
+#
+# You can return a result set like:
+#
+#   c1 | c2s
+#   ---+---
+#   a  | 1,2,3
+#   b  | 4
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :string_agg
+#
+# Then you can use the Sequel.string_agg method to return a Sequel
+# expression:
+#
+#   sa = Sequel.string_agg(:column_name)
+#   # or:
+#   sa = Sequel.string_agg(:column_name, '-') # custom separator
+#
+# You can specify the order in which the concatention happens by
+# calling +order+ on the expression:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column)
+#
+# Additionally, if you want to have the concatenation only operate
+# on distinct values, you can call distinct:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column).distinct
+#
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].
+#     select_group(:c1).
+#     select_append(Sequel.string_agg(:c2))
+#
+# This extension currenly supports the following databases:
+#
+# * PostgreSQL 9+
+# * SQLAnywhere 12+
+# * Oracle 11g+ (except distinct)
+# * DB2 9.7+ (except distinct)
+# * MySQL
+# * HSQLDB
+# * H2
+# * SQLite 3.44+ (distinct only works when separator is ',')
+#
+# Related module: Sequel::SQL::StringAgg
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a StringAgg expression for an aggregate string concatentation.
+      def string_agg(*a)
+        StringAgg.new(*a)
+      end
+    end
+
+    # The StringAgg class represents an aggregate string concatentation.
+    class StringAgg < GenericExpression
+      include StringMethods
+      include StringConcatenationMethods
+      include InequalityMethods
+      include AliasMethods
+      include CastMethods
+      include OrderMethods
+      include PatternMatchMethods
+      include SubscriptMethods
+
+      # These methods are added to datasets using the string_agg
+      # extension, for the purposes of correctly literalizing StringAgg
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the StringAgg expression to the SQL query.
+        def string_agg_sql_append(sql, sa)
+          if defined?(super)
+            return super
+          end
+
+          expr = sa.expr
+          separator = sa.separator || ","
+          order = sa.order_expr
+          distinct = sa.is_distinct?
+
+          case db_type = db.database_type
+          when :sqlite
+            raise Error, "string_agg(DISTINCT) is not supported with a non-comma separator on #{db.database_type}" if distinct && separator != ","
+
+            args = [expr]
+            args << separator unless distinct
+            f = Function.new(:group_concat, *args)
+            if order
+              f = f.order(*order)
+            end
+            if distinct
+              f = f.distinct
+            end
+            literal_append(sql, f)
+          when :postgres, :sqlanywhere
+            f = Function.new(db_type == :postgres ? :string_agg : :list, expr, separator)
+            if order
+              f = f.order(*order)
+            end
+            if distinct
+              f = f.distinct
+            end
+            literal_append(sql, f)
+          when :mysql, :hsqldb, :h2
+            sql << "GROUP_CONCAT("
+            if distinct
+              sql << "DISTINCT "
+            end
+            literal_append(sql, expr)
+            if order
+              sql << " ORDER BY "
+              expression_list_append(sql, order)
+            end
+            sql << " SEPARATOR "
+            literal_append(sql, separator)
+            sql << ")"
+          when :oracle, :db2
+            if distinct
+              raise Error, "string_agg with distinct is not implemented on #{db.database_type}"
+            end
+            literal_append(sql, Function.new(:listagg, expr, separator))
+            if order
+              sql << " WITHIN GROUP (ORDER BY "
+              expression_list_append(sql, order)
+              sql << ")"
+            else
+              sql << " WITHIN GROUP (ORDER BY 1)"
+            end
+          else
+            raise Error, "string_agg is not implemented on #{db.database_type}"
+          end
+        end
+      end
+
+      # The string expression for each row that will concatenated to the output.
+      attr_reader :expr
+
+      # The separator between each string expression.
+      attr_reader :separator
+
+      # The expression that the aggregation is ordered by.
+      attr_reader :order_expr
+
+      # Set the expression and separator
+      def initialize(expr, separator=nil)
+        @expr = expr
+        @separator = separator
+        yield self if defined?(yield)
+        freeze
+      end
+
+      # Whether the current expression uses distinct expressions
+      def is_distinct?
+        @distinct == true
+      end
+
+      # Return a modified StringAgg that uses distinct expressions
+      def distinct
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@order_expr, @order_expr)
+          sa.instance_variable_set(:@distinct, true)
+        end
+      end
+
+      # Return a modified StringAgg with the given order
+      def order(*o)
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@order_expr, o.empty? ? nil : o.freeze)
+          sa.instance_variable_set(:@distinct, @distinct)
+        end
+      end
+
+      to_s_method :string_agg_sql
+    end
+  end
+
+  Dataset.register_extension(:string_agg, SQL::StringAgg::DatasetMethods)
+end

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

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+#
+# The string_date_time extension provides String instance methods
+# for converting the strings to a date (e.g. String#to_date), allowing
+# for backwards compatibility with legacy Sequel code.
+#
+# These methods calls +parse+ on the related class, and as such, can
+# result in denial of service in older versions of Ruby for large
+# untrusted input, and raise exceptions in newer versions of Ruby. 
+#
+# To load the extension:
+#
+#   Sequel.extension :string_date_time
+
+class String
+  # Converts a string into a Date object.
+  def to_date
+    Date.parse(self, Sequel.convert_two_digit_years)
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+  end
+
+  # Converts a string into a DateTime object.
+  def to_datetime
+    DateTime.parse(self, Sequel.convert_two_digit_years)
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+  end
+
+  # Converts a string into a Time or DateTime object, depending on the
+  # value of Sequel.datetime_class
+  def to_sequel_time
+    if Sequel.datetime_class == DateTime
+      DateTime.parse(self, Sequel.convert_two_digit_years)
+    else
+      Sequel.datetime_class.parse(self)
+    end
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+  end
+
+  # Converts a string into a Time object.
+  def to_time
+    Time.parse(self)
+  rescue => e
+    raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+#
+# The symbol_aref extension makes Symbol#[] support Symbol,
+# Sequel::SQL::Indentifier, and Sequel::SQL::QualifiedIdentifier instances,
+# returning appropriate Sequel::SQL::QualifiedIdentifier instances.  It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:table][:column] # table.column
+#
+# you can just write:
+#
+#   :table[:column] # table.column
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_aref
+#
+# If you are using Ruby 2+, and you would like to use refinements, there
+# is a refinement version of this in the symbol_aref_refinement extension.
+#
+# Related module: Sequel::SymbolAref
+
+if RUBY_VERSION >= '2.0'
+  module Sequel::SymbolAref
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        super
+      end
+    end
+  end
+
+  class Symbol
+    prepend Sequel::SymbolAref
+  end
+# :nocov:
+else
+  class Symbol
+    if method_defined?(:[])
+      alias_method :aref_before_sequel, :[] 
+    end
+
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        aref_before_sequel(v)
+      end
+    end
+  end
+end
+# :nocov:

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

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+#
+# The symbol_aref_refinement extension adds a refinement that makes
+# Symbol#[] support Symbol, #Sequel::SQL::Indentifier, and
+# Sequel::SQL::QualifiedIdentifier instances, returning appropriate
+# Sequel::SQL::QualifiedIdentifier instances.  It's designed as a
+# shortcut so that instead of:
+#
+#   Sequel[:table][:column] # table.column
+#
+# you can just write:
+#   
+#   :table[:column] # table.column
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_aref_refinement
+#
+# To enable the refinement for the current file:
+#
+#   using Sequel::SymbolAref
+#
+# If you would like this extension to be enabled globally instead
+# of as a refinement, use the symbol_aref extension.
+#
+# Related module: Sequel::SymbolAref
+
+# :nocov:
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
+
+module Sequel::SymbolAref
+  refine Symbol do
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        super
+      end
+    end
+  end
+end