serrano-vk 0.1.0

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

@@ -0,0 +1,222 @@
+# frozen-string-literal: true
+#
+# These are extensions to core classes that Sequel enables by default.
+# They make using Sequel's DSL easier by adding methods to Array,
+# Hash, String, and Symbol to add methods that return Sequel
+# expression objects.  To load the extension:
+#
+#   Sequel.extension :core_extensions
+
+# This extension loads the core extensions.
+def Sequel.core_extensions?
+  true
+end
+
+Sequel.extension :symbol_as
+
+# Sequel extends +Array+ to add methods to implement the SQL DSL.
+# Most of these methods require that the array not be empty and that it
+# must consist solely of other arrays that have exactly two elements.
+class Array
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
+  # conditions.
+  #
+  #   ~[[:a, true]] # SQL: (a IS NOT TRUE)
+  #   ~[[:a, 1], [:b, [2, 3]]] # SQL: ((a != 1) OR (b NOT IN (2, 3)))
+  def ~
+    Sequel.~(self)
+  end
+
+  # Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
+  # default value and expression.
+  #
+  #   [[{a: [2,3]}, 1]].case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
+  #   [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+  def case(*args)
+    ::Sequel::SQL::CaseExpression.new(self, *args)
+  end
+
+  # Return a <tt>Sequel::SQL::ValueList</tt> created from this array.  Used if this array contains
+  # all two element arrays and you want it treated as an SQL value list (IN predicate) 
+  # instead of as a conditions specifier (similar to a hash).  This is not necessary if you are using
+  # this array as a value in a filter, but may be necessary if you are using it as a
+  # value with placeholder SQL:
+  #
+  #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1, 2), (3, 4)))
+  #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1 = 2) AND (3 = 4)))
+  #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: ((a, b) IN ((1, 2), (3, 4)))
+  def sql_value_list
+    ::Sequel::SQL::ValueList.new(self)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
+  # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+  # assumes that arrays of two element arrays specify this type of condition.  One case where
+  # it can be necessary to use this is if you are using the object as a value in a filter hash
+  # and want to use the = operator instead of the IN operator (which is used by default for
+  # arrays of two element arrays).
+  #
+  #   [[:a, true]].sql_expr # SQL: (a IS TRUE)
+  #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
+  def sql_expr
+    Sequel[self]
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none
+  # of the conditions.
+  #
+  #   [[:a, true]].sql_negate # SQL: (a IS NOT TRUE)
+  #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
+  def sql_negate
+    Sequel.negate(self)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching any of the
+  # conditions.
+  #
+  #   [[:a, true]].sql_or # SQL: (a IS TRUE)
+  #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
+  def sql_or
+    Sequel.or(self)
+  end
+
+  # Return a <tt>Sequel::SQL::StringExpression</tt> representing an SQL string made up of the
+  # concatenation of this array's elements.  If an argument is passed
+  # it is used in between each element of the array in the SQL
+  # concatenation.
+  #
+  #   [:a].sql_string_join # SQL: a
+  #   [:a, :b].sql_string_join # SQL: (a || b)
+  #   [:a, 'b'].sql_string_join # SQL: (a || 'b')
+  #   ['a', :b].sql_string_join(' ') # SQL: ('a' || ' ' || b)
+  def sql_string_join(joiner=nil)
+    Sequel.join(self, joiner)
+  end
+end
+
+# Sequel extends +Hash+ to add methods to implement the SQL DSL.
+class Hash
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
+  # all of the conditions in this hash and the condition specified by
+  # the given argument.
+  #
+  #   {a: 1} & :b # SQL: ((a = 1) AND b)
+  #   {a: true} & ~:b # SQL: ((a IS TRUE) AND NOT b)
+  def &(ce)
+    ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
+  # all of the conditions in this hash or the condition specified by
+  # the given argument.
+  #
+  #   {a: 1} | :b # SQL: ((a = 1) OR b)
+  #   {a: true} | ~:b # SQL: ((a IS TRUE) OR NOT b)
+  def |(ce)
+    ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, not matching all of the
+  # conditions.
+  #
+  #   ~{a: true} # SQL: (a IS NOT TRUE)
+  #   ~{a: 1, b: [2, 3]} # SQL: ((a != 1) OR (b NOT IN (2, 3)))
+  def ~
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
+  end
+
+  # Return a <tt>Sequel::SQL::CaseExpression</tt> with this hash as the conditions and the given
+  # default value.
+  #
+  #   {{a: [2,3]}=>1}.case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
+  #   {a: 1, b: 2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+  def case(*args)
+    ::Sequel::SQL::CaseExpression.new(to_a, *args)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching all of the
+  # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+  # assumes that hashes specify this type of condition.
+  #
+  #   {a: true}.sql_expr # SQL: (a IS TRUE)
+  #   {a: 1, b: [2, 3]}.sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
+  def sql_expr
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching none
+  # of the conditions.
+  #
+  #   {a: true}.sql_negate # SQL: (a IS NOT TRUE)
+  #   {a: 1, b: [2, 3]}.sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
+  def sql_negate
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
+  end
+
+  # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching any of the
+  # conditions.
+  #
+  #   {a: true}.sql_or # SQL: (a IS TRUE)
+  #   {a: 1, b: [2, 3]}.sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
+  def sql_or
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
+  end
+end
+
+# Sequel extends +String+ to add methods to implement the SQL DSL.
+class String
+  include Sequel::SQL::AliasMethods
+  include Sequel::SQL::CastMethods
+
+  # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
+  # literalization, e.g.:
+  #
+  #   DB[:items].where(abc: 'def')
+  #   # "SELECT * FROM items WHERE (abc = 'def')"
+  #
+  #   DB[:items].where(abc: 'def'.lit)
+  #   # "SELECT * FROM items WHERE (abc = def)"
+  #
+  # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
+  #
+  #   DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}
+  #   # "SELECT count(DISTINCT a) FROM items"
+  def lit(*args)
+    args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
+  end
+  
+  # Returns a <tt>Sequel::SQL::Blob</tt> that holds the same data as this string. Blobs provide proper
+  # escaping of binary data.
+  def to_sequel_blob
+    ::Sequel::SQL::Blob.new(self)
+  end
+end
+
+# Sequel extends +Symbol+ to add methods to implement the SQL DSL.
+class Symbol
+  include Sequel::SQL::CastMethods
+  include Sequel::SQL::OrderMethods
+  include Sequel::SQL::BooleanMethods
+  include Sequel::SQL::NumericMethods
+  include Sequel::SQL::QualifyingMethods
+  include Sequel::SQL::StringMethods
+  include Sequel::SQL::SubscriptMethods
+  include Sequel::SQL::ComplexExpressionMethods
+
+  # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
+  #
+  #   :a.identifier # SQL: "a"
+  def identifier
+    Sequel::SQL::Identifier.new(self)
+  end
+
+  # Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,
+  # and the given arguments.
+  #
+  #   :now.sql_function # SQL: now()
+  #   :sum.sql_function(:a) # SQL: sum(a)
+  #   :concat.sql_function(:a, :b) # SQL: concat(a, b)
+  def sql_function(*args)
+    Sequel::SQL::Function.new(self, *args)
+  end
+end

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

@@ -0,0 +1,244 @@
+# frozen-string-literal: true
+#
+# These are refinements to core classes that allow the Sequel
+# DSL to be used without modifying the core classes directly.
+# After loading the extension via:
+#
+#   Sequel.extension :core_refinements
+#
+# you can enable the refinements for particular files:
+#
+#   using Sequel::CoreRefinements
+
+# :nocov:
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
+
+module Sequel::CoreRefinements
+  # :nocov:
+  include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  # :nocov:
+  INCLUDE_METH = include_meth
+  private_constant :INCLUDE_METH
+
+  refine Array do
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
+    # conditions.
+    #
+    #   ~[[:a, true]] # SQL: (a IS NOT TRUE)
+    #   ~[[:a, 1], [:b, [2, 3]]] # SQL: ((a != 1) OR (b NOT IN (2, 3)))
+    def ~
+      Sequel.~(self)
+    end
+
+    # Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
+    # default value and expression.
+    #
+    #   [[{a: [2,3]}, 1]].case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
+    #   [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+    def case(*args)
+      ::Sequel::SQL::CaseExpression.new(self, *args)
+    end
+
+    # Return a <tt>Sequel::SQL::ValueList</tt> created from this array.  Used if this array contains
+    # all two element arrays and you want it treated as an SQL value list (IN predicate) 
+    # instead of as a conditions specifier (similar to a hash).  This is not necessary if you are using
+    # this array as a value in a filter, but may be necessary if you are using it as a
+    # value with placeholder SQL:
+    #
+    #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1, 2), (3, 4)))
+    #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1 = 2) AND (3 = 4)))
+    #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: ((a, b) IN ((1, 2), (3, 4)))
+    def sql_value_list
+      ::Sequel::SQL::ValueList.new(self)
+    end
+    
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
+    # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+    # assumes that arrays of two element arrays specify this type of condition.  One case where
+    # it can be necessary to use this is if you are using the object as a value in a filter hash
+    # and want to use the = operator instead of the IN operator (which is used by default for
+    # arrays of two element arrays).
+    #
+    #   [[:a, true]].sql_expr # SQL: (a IS TRUE)
+    #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
+    def sql_expr
+      Sequel[self]
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none
+    # of the conditions.
+    #
+    #   [[:a, true]].sql_negate # SQL: (a IS NOT TRUE)
+    #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
+    def sql_negate
+      Sequel.negate(self)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching any of the
+    # conditions.
+    #
+    #   [[:a, true]].sql_or # SQL: (a IS TRUE)
+    #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
+    def sql_or
+      Sequel.or(self)
+    end
+
+    # Return a <tt>Sequel::SQL::StringExpression</tt> representing an SQL string made up of the
+    # concatenation of this array's elements.  If an argument is passed
+    # it is used in between each element of the array in the SQL
+    # concatenation.
+    #
+    #   [:a].sql_string_join # SQL: a
+    #   [:a, :b].sql_string_join # SQL: (a || b)
+    #   [:a, 'b'].sql_string_join # SQL: (a || 'b')
+    #   ['a', :b].sql_string_join(' ') # SQL: ('a' || ' ' || b)
+    def sql_string_join(joiner=nil)
+      Sequel.join(self, joiner)
+    end
+  end
+
+  refine Hash do
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
+    # all of the conditions in this hash and the condition specified by
+    # the given argument.
+    #
+    #   {a: 1} & :b # SQL: ((a = 1) AND b)
+    #   {a: true} & ~:b # SQL: ((a IS TRUE) AND NOT b)
+    def &(ce)
+      ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching
+    # all of the conditions in this hash or the condition specified by
+    # the given argument.
+    #
+    #   {a: 1} | :b # SQL: ((a = 1) OR b)
+    #   {a: true} | ~:b # SQL: ((a IS TRUE) OR NOT b)
+    def |(ce)
+      ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, not matching all of the
+    # conditions.
+    #
+    #   ~{a: true} # SQL: (a IS NOT TRUE)
+    #   ~{a: 1, b: [2, 3]} # SQL: ((a != 1) OR (b NOT IN (2, 3)))
+    def ~
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
+    end
+
+    # Return a <tt>Sequel::SQL::CaseExpression</tt> with this hash as the conditions and the given
+    # default value.
+    #
+    #   {{a: [2,3]}=>1}.case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
+    #   {a: 1, b: 2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
+    def case(*args)
+      ::Sequel::SQL::CaseExpression.new(to_a, *args)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching all of the
+    # conditions.  Rarely do you need to call this explicitly, as Sequel generally
+    # assumes that hashes specify this type of condition.
+    #
+    #   {a: true}.sql_expr # SQL: (a IS TRUE)
+    #   {a: 1, b: [2, 3]}.sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
+    def sql_expr
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching none
+    # of the conditions.
+    #
+    #   {a: true}.sql_negate # SQL: (a IS NOT TRUE)
+    #   {a: 1, b: [2, 3]}.sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
+    def sql_negate
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
+    end
+
+    # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching any of the
+    # conditions.
+    #
+    #   {a: true}.sql_or # SQL: (a IS TRUE)
+    #   {a: 1, b: [2, 3]}.sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
+    def sql_or
+      ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
+    end
+  end
+
+  refine String do
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
+
+    # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
+    # literalization, e.g.:
+    #
+    #   DB[:items].where(abc: 'def')
+    #   # "SELECT * FROM items WHERE (abc = 'def')"
+    #
+    #   DB[:items].where(abc: 'def'.lit)
+    #   # "SELECT * FROM items WHERE (abc = def)"
+    #
+    # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
+    #
+    #   DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}
+    #   # "SELECT count(DISTINCT a) FROM items"
+    def lit(*args)
+      args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
+    end
+    
+    # Returns a <tt>Sequel::SQL::Blob</tt> that holds the same data as this string. Blobs provide proper
+    # escaping of binary data.
+    def to_sequel_blob
+      ::Sequel::SQL::Blob.new(self)
+    end
+  end
+
+  refine Symbol do
+    send include_meth, Sequel::SQL::AliasMethods
+    send include_meth, Sequel::SQL::CastMethods
+    send include_meth, Sequel::SQL::OrderMethods
+    send include_meth, Sequel::SQL::BooleanMethods
+    send include_meth, Sequel::SQL::NumericMethods
+
+    # :nocov:
+    remove_method :* if RUBY_VERSION >= '3.1'
+    # :nocov:
+
+    send include_meth, Sequel::SQL::QualifyingMethods
+    send include_meth, Sequel::SQL::StringMethods
+    send include_meth, Sequel::SQL::SubscriptMethods
+    send include_meth, Sequel::SQL::ComplexExpressionMethods
+
+    # :nocov:
+    if RUBY_VERSION >= '3.1'
+      remove_method :*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new(self)
+        else
+          Sequel::SQL::NumericExpression.new(:*, self, ce)
+        end
+      end
+
+    end
+    # :nocov:
+
+    # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
+    #
+    #   :ab.identifier # SQL: "a"
+    def identifier
+      Sequel::SQL::Identifier.new(self)
+    end
+
+    # Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,
+    # and the given arguments.
+    #
+    #   :now.sql_function # SQL: now()
+    #   :sum.sql_function(:a) # SQL: sum(a)
+    #   :concat.sql_function(:a, :b) # SQL: concat(a, b)
+    def sql_function(*args)
+      Sequel::SQL::Function.new(self, *args)
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen-string-literal: true
+#
+# The current_datetime_timestamp extension makes Dataset#current_datetime
+# return an object that operates like Sequel.datetime_class.now, but will
+# be literalized as CURRENT_TIMESTAMP.
+#
+# This allows you to use the defaults_setter, timestamps, and touch
+# model plugins and make sure that CURRENT_TIMESTAMP is used instead of
+# a literalized timestamp value.
+#
+# The reason that CURRENT_TIMESTAMP is better than a literalized version
+# of the timestamp is that it obeys correct transactional semantics
+# (all calls to CURRENT_TIMESTAMP in the same transaction return the
+# same timestamp, at least on some databases).
+#
+# To have current_datetime be literalized as CURRENT_TIMESTAMP for
+# a single dataset:
+#
+#   ds = ds.extension(:current_datetime_timestamp)
+#
+# To have current_datetime be literalized as CURRENT_TIMESTAMP for all
+# datasets of a given database.
+#
+#   DB.extension(:current_datetime_timestamp)
+#
+# Related module: Sequel::CurrentDateTimeTimestamp
+
+#
+module Sequel
+  module CurrentDateTimeTimestamp
+    module DatasetMethods
+      # Return an instance of Sequel.datetime_class that will be literalized
+      # as CURRENT_TIMESTAMP.
+      def current_datetime
+        (Sequel.datetime_class == ::Time ? Time : DateTime).now
+      end
+
+      private
+
+      # Literalize custom DateTime subclass objects as CURRENT_TIMESTAMP.
+      def literal_datetime_append(sql, v)
+        v.is_a?(DateTime) ? literal_append(sql, Sequel::CURRENT_TIMESTAMP) : super
+      end
+
+      # Literalize custom Time subclass objects as CURRENT_TIMESTAMP.
+      def literal_time_append(sql, v)
+        v.is_a?(Time) ? literal_append(sql, Sequel::CURRENT_TIMESTAMP) : super
+      end
+    end
+
+    # Time subclass literalized as CURRENT_TIMESTAMP
+    class Time < ::Time; end
+
+    # DateTime subclass literalized as CURRENT_TIMESTAMP
+    class DateTime < ::DateTime; end
+  end
+
+  Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)
+end

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

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+#
+# The dataset_run extension is designed for cases where you want
+# to use dataset methods to build a query, but want to run that
+# query without returning a result.  The most common need would
+# be to easily use placeholders in an SQL string, which Database#run
+# does not support directly.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB["GRANT SELECT ON ? TO ?", :table, :user]
+#   ds = ds.extension(:dataset_run)
+#   ds.run
+#
+# 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(:dataset_run)
+#   DB["GRANT SELECT ON ? TO ?", :table, :user].run
+#
+# Related module: Sequel::DatasetRun
+
+#
+module Sequel
+  module DatasetRun
+    # Run the dataset's SQL on the database.  Returns NULL.  This is
+    # useful when you want to run SQL without returning a result.
+    #
+    #   DB["GRANT SELECT ON ? TO ?", :table, :user].run
+    #   # GRANT SELECT ON "table" TO "user"
+    def run
+      if server = @opts[:server]
+        db.run(sql, :server=>server)
+      else
+        db.run(sql)
+      end
+    end
+  end
+
+  Dataset.register_extension(:dataset_run, DatasetRun)
+end

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

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+#
+# The dataset_source_alias extension changes Sequel's
+# default behavior of automatically aliasing datasets
+# from using t1, t2, etc. to using an alias based on
+# the source of the dataset.  Example:
+#
+#   DB.from(DB.from(:a))
+#   # default: SELECT * FROM (SELECT * FROM a) AS t1
+#   # with extension: SELECT * FROM (SELECT * FROM a) AS a
+#
+# This also works when joining:
+#
+#   DB[:a].join(DB[:b], [:id])
+#   # SELECT * FROM a INNER JOIN (SELECT * FROM b) AS b USING (id)
+#
+# To avoid conflicting aliases, this attempts to alias tables
+# uniquely if it detects a conflict:
+#
+#   DB.from(:a, DB.from(:a))
+#   # SELECT * FROM a, (SELECT * FROM a) AS a_0
+#
+# Note that not all conflicts are correctly detected and handled.
+# It is encouraged to alias your datasets manually instead of
+# relying on the auto-aliasing if there would be a conflict.
+#
+# In the places where Sequel cannot determine the
+# appropriate alias to use for the dataset, it will fallback to
+# the standard t1, t2, etc. aliasing.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:dataset_source_alias)
+#
+# 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(:dataset_source_alias)
+#
+# Related module: Sequel::Dataset::DatasetSourceAlias
+
+#
+module Sequel
+  class Dataset
+    module DatasetSourceAlias
+      # Preprocess the list of sources and attempt to alias any
+      # datasets in the sources to the first source of the respective
+      # dataset.
+      def from(*source, &block)
+        virtual_row_columns(source, block)
+        table_aliases = []
+        source = source.map do |s|
+          case s
+          when Dataset
+            s = dataset_source_alias_expression(s, table_aliases)
+          when Symbol, String, SQL::AliasedExpression, SQL::Identifier, SQL::QualifiedIdentifier
+            table_aliases << alias_symbol(s)
+          end
+          s
+        end
+        super(*source, &nil)
+      end
+
+      # If a Dataset is given as the table argument, attempt to alias
+      # it to its source.
+      def join_table(type, table, expr=nil, options=OPTS)
+        if table.is_a?(Dataset) && !options[:table_alias]
+          table = dataset_source_alias_expression(table)
+        end
+        super
+      end
+
+      private
+
+      # Attempt to automatically alias the given dataset to its source.
+      # If the dataset cannot be automatically aliased to its source,
+      # return it unchanged.  The table_aliases argument is a list of
+      # already used alias symbols, which will not be used as the alias.
+      def dataset_source_alias_expression(ds, table_aliases=[])
+        base = ds.first_source if ds.opts[:from]
+        case base
+        when Symbol, String, SQL::AliasedExpression, SQL::Identifier, SQL::QualifiedIdentifier
+          aliaz = unused_table_alias(base, table_aliases)
+          table_aliases << aliaz
+          ds.as(aliaz)
+        else
+          ds
+        end
+      end
+    end
+
+    register_extension(:dataset_source_alias, DatasetSourceAlias)
+  end
+end