serrano-vk 0.1.0

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

@@ -0,0 +1,217 @@
+# frozen-string-literal: true
+#
+# The pg_row_ops extension adds support to Sequel's DSL to make
+# it easier to deal with PostgreSQL row-valued/composite types.
+#
+# To load the extension:
+#
+#   Sequel.extension :pg_row_ops
+#
+# The most common usage is passing an expression to Sequel.pg_row_op:
+#
+#   r = Sequel.pg_row_op(:row_column)
+#
+# If you have also loaded the pg_row extension, you can use
+# Sequel.pg_row as well:
+#
+#   r = Sequel.pg_row(:row_column)
+#
+# Also, on most Sequel expression objects, you can call the pg_row
+# method:
+#
+#   r = Sequel[:row_column].pg_row
+#
+# 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#pg_row:
+#
+#   r = :row_column.pg_row
+#
+# There's only fairly basic support currently.  You can use the [] method to access
+# a member of the composite type:
+#
+#   r[:a] # (row_column).a
+#
+# This can be chained:
+#
+#   r[:a][:b] # ((row_column).a).b
+#
+# If you've loaded the pg_array_ops extension, you there is also support for composite
+# types that include arrays, or arrays of composite types:
+#
+#   r[1][:a] # (row_column[1]).a
+#   r[:a][1] # (row_column).a[1]
+#
+# The only other support is the splat method:
+#
+#   r.splat # (row_column.*)
+#
+# The splat method is necessary if you are trying to reference a table's type when the
+# table has the same name as one of it's columns.  For example:
+#
+#   DB.create_table(:a){Integer :a; Integer :b}
+#
+# Let's say you want to reference the composite type for the table:
+#
+#   a = Sequel.pg_row_op(:a)
+#   DB[:a].select(a[:b]) # SELECT (a).b FROM a
+#
+# Unfortunately, that doesn't work, as it references the integer column, not the table.
+# The splat method works around this:
+#
+#   DB[:a].select(a.splat[:b]) # SELECT (a.*).b FROM a
+#
+# Splat also takes an argument which is used for casting.  This is necessary if you
+# want to return the composite type itself, instead of the columns in the composite
+# type.  For example:
+#
+#   DB[:a].select(a.splat).first # SELECT (a.*) FROM a
+#   # => {:a=>1, :b=>2}
+#
+# By casting the expression, you can get a composite type returned:
+#
+#   DB[:a].select(a.splat(:a)).first # SELECT (a.*)::a FROM a
+#   # => {:a=>"(1,2)"} # or {:a=>{:a=>1, :b=>2}} if the "a" type has been registered
+#                      # with the pg_row extension
+#
+# This feature is mostly useful for a different way to graph tables:
+#
+#   DB[:a].join(:b, id: :b_id).select(Sequel.pg_row_op(:a).splat(:a),
+#                                     Sequel.pg_row_op(:b).splat(:b))
+#   # SELECT (a.*)::a, (b.*)::b FROM a INNER JOIN b ON (b.id = a.b_id)
+#   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
+#
+# Related module: Sequel::Postgres::PGRowOp
+
+#
+module Sequel
+  module Postgres
+    # This class represents a composite type expression reference.
+    class PGRowOp < SQL::PlaceholderLiteralString
+      ROW = ['(', '.*)'].freeze.each(&:freeze)
+      ROW_CAST = ['(', '.*)::'].freeze.each(&:freeze)
+      QUALIFY = ['(', ').'].freeze.each(&:freeze)
+      WRAP = [""].freeze.each(&:freeze)
+
+      # Wrap the expression in a PGRowOp, without changing the
+      # SQL it would use.
+      def self.wrap(expr)
+        PGRowOp.new(WRAP, [expr])
+      end
+
+      # Access a member of the composite type if given a
+      # symbol or an SQL::Identifier.  For all other access,
+      # assuming the pg_array_ops extension is loaded and
+      # that it represents an array access.  In either
+      # case, return a PgRowOp so that access can be cascaded.
+      def [](member)
+        case member
+        when Symbol, SQL::Identifier
+          PGRowOp.new(QUALIFY, [self, member])
+        else
+          PGRowOp.wrap(Sequel.pg_array_op(self)[member])
+        end
+      end
+
+      # Use the (identifier).* syntax to reference the members
+      # of the composite type as separate columns.  Generally
+      # used when you want to expand the columns of a composite
+      # type to be separate columns in the result set.
+      #
+      #   Sequel.pg_row_op(:a).*     # (a).*
+      #   Sequel.pg_row_op(:a)[:b].* # ((a).b).*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new([self])
+        else
+          super(ce)
+        end
+      end
+
+      # Use the (identifier.*) syntax to indicate that this
+      # expression represents the composite type of one
+      # of the tables being referenced, if it has the same
+      # name as one of the columns.  If the cast_to argument
+      # is given, also cast the expression to that type
+      # (which should be a symbol representing the composite type).
+      # This is used if you want to return whole table row as a
+      # composite type.
+      #
+      #   Sequel.pg_row_op(:a).splat[:b] # (a.*).b
+      #   Sequel.pg_row_op(:a).splat(:a) # (a.*)::a
+      def splat(cast_to=nil)
+        if args.length > 1
+          raise Error, 'cannot splat a PGRowOp with multiple arguments'
+        end
+
+        if cast_to
+          PGRowOp.new(ROW_CAST, args + [cast_to])
+        else
+          PGRowOp.new(ROW, args)
+        end
+      end
+
+      module ExpressionMethods
+        # Return a PGRowOp wrapping the receiver.
+        def pg_row
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+
+    # :nocov:
+    if defined?(PGRow::ArrayRow)
+    # :nocov:
+      class PGRow::ArrayRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+
+    # :nocov:
+    if defined?(PGRow::HashRow)
+    # :nocov:
+      class PGRow::HashRow
+        # Wrap the PGRow::ArrayRow instance in an PGRowOp, allowing you to easily use
+        # the PostgreSQL row functions and operators with literal rows.
+        def op
+          Sequel.pg_row_op(self)
+        end
+      end
+    end
+  end
+
+  module SQL::Builders
+    # Return a PGRowOp wrapping the given expression.
+    def pg_row_op(expr)
+      Postgres::PGRowOp.wrap(expr)
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::Postgres::PGRowOp::ExpressionMethods
+  end
+
+  class LiteralString
+    include Sequel::Postgres::PGRowOp::ExpressionMethods
+  end
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::Postgres::PGRowOp::ExpressionMethods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::Postgres::PGRowOp::ExpressionMethods
+    end
+  end
+end
+# :nocov:

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

@@ -0,0 +1,90 @@
+# frozen-string-literal: true
+#
+# The pg_schema_caching extension builds on top of the schema_caching
+# extension, and allows it to handle custom PostgreSQL types. On
+# PostgreSQL, column schema hashes include an :oid entry for the OID
+# for the column's type.  For custom types, this OID is dependent on
+# the PostgreSQL database, so in most cases, test and development
+# versions of the same database, created with the same migrations,
+# will have different OIDs.
+#
+# To fix this case, the pg_schema_caching extension removes custom
+# OIDs from the schema cache when dumping the schema, replacing them
+# with a placeholder. When loading the cached schema, the Database
+# object makes a single query to get the OIDs for all custom types
+# used by the cached schema, and it updates all related column
+# schema hashes to set the correct :oid entry for the current
+# database.
+#
+# Related module: Sequel::Postgres::SchemaCaching
+
+require_relative "schema_caching"
+
+module Sequel
+  module Postgres
+    module SchemaCaching
+      include Sequel::SchemaCaching
+
+      private
+
+      # Load custom oids from database when loading schema cache file.
+      def load_schema_cache_file(file)
+        set_custom_oids_for_cached_schema(super)
+      end
+
+      # Find all column schema hashes that use custom types.
+      # Load the oids for custom types in a single query, and update
+      # each related column schema hash with the correct oid.
+      def set_custom_oids_for_cached_schema(schemas)
+        custom_oid_rows = {}
+
+        schemas.each_value do |cols|
+          cols.each do |_, h|
+            if h[:oid] == :custom
+              (custom_oid_rows[h[:db_type]] ||= []) << h
+            end
+          end
+        end
+
+        unless custom_oid_rows.empty?
+          from(:pg_type).where(:typname=>custom_oid_rows.keys).select_hash(:typname, :oid).each do |name, oid|
+            custom_oid_rows.delete(name).each do |row|
+              row[:oid] = oid
+            end
+          end
+        end
+
+        unless custom_oid_rows.empty?
+          warn "Could not load OIDs for the following custom types: #{custom_oid_rows.keys.sort.join(", ")}", uplevel: 3
+
+          schemas.keys.each do |k|
+            if schemas[k].any?{|_,h| h[:oid] == :custom}
+              # Remove schema entry for table, so it will be queried at runtime to get the correct oids
+              schemas.delete(k)
+            end
+          end
+        end
+
+        schemas
+      end
+
+      # Replace :oid entries for custom types with :custom.
+      def dumpable_schema_cache
+        sch = super
+
+        sch.each_value do |cols|
+          cols.each do |_, h|
+            if (oid = h[:oid]) && oid >= 10000
+              h[:oid] = :custom
+            end
+          end
+        end
+
+        sch
+      end
+    end
+  end
+
+  Database.register_extension(:pg_schema_caching, Postgres::SchemaCaching)
+end
+

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

@@ -0,0 +1,144 @@
+# frozen-string-literal: true
+#
+# The pg_static_cache_updater extension is designed to
+# automatically update the caches in the models using the
+# static_cache plugin when changes to the underlying tables
+# are detected.
+#
+# Before using the extension in production, you have to add
+# triggers to the tables for the classes where you want the
+# caches updated automatically.  You would generally do this
+# during a migration:
+#
+#   Sequel.migration do
+#     up do
+#       extension :pg_static_cache_updater
+#       create_static_cache_update_function
+#       create_static_cache_update_trigger(:table_1)
+#       create_static_cache_update_trigger(:table_2)
+#     end
+#     down do
+#       extension :pg_static_cache_updater
+#       drop_trigger(:table_2, default_static_cache_update_name)
+#       drop_trigger(:table_1, default_static_cache_update_name)
+#       drop_function(default_static_cache_update_name)
+#     end
+#   end
+#
+# After the triggers have been added, in your application process,
+# after setting up your models, you need to listen for changes to
+# the underlying tables:
+#
+#   class Model1 < Sequel::Model(:table_1)
+#     plugin :static_cache
+#   end
+#   class Model2 < Sequel::Model(:table_2)
+#     plugin :static_cache
+#   end
+#
+#   DB.extension :pg_static_cache_updater
+#   DB.listen_for_static_cache_updates([Model1, Model2])
+#
+# When an INSERT/UPDATE/DELETE happens on the underlying table,
+# the trigger will send a notification with the table's OID.
+# The application(s) listening on that channel will receive
+# the notification, check the oid to see if it matches one
+# for the model tables it is interested in, and tell that model
+# to reload the cache if there is a match.
+#
+# Note that listen_for_static_cache_updates spawns a new thread
+# which will reserve its own database connection.  This thread
+# runs until the application process is shutdown.
+#
+# Also note that PostgreSQL does not send notifications to
+# channels until after the transaction including the changes
+# is committed.  Also, because a separate thread is used to
+# listen for notifications, there may be a slight delay between
+# when the transaction is committed and when the cache is
+# reloaded.
+#
+# Requirements:
+# * PostgreSQL 9.0+
+# * Listening Database object must be using the postgres adapter
+#   with the pg driver (the model classes do not have to
+#   use the same Database).
+# * Must be using a thread-safe connection pool (the default).
+#
+# Related module: Sequel::Postgres::StaticCacheUpdater
+
+#
+module Sequel
+  module Postgres
+    module StaticCacheUpdater
+      # Add the static cache update function to the PostgreSQL database.
+      # This must be added before any triggers using this function are
+      # added.
+      #
+      # Options:
+      # :channel_name :: Override the channel name to use.
+      # :function_name :: Override the function name to use.
+      def create_static_cache_update_function(opts=OPTS)
+        create_function(opts[:function_name]||default_static_cache_update_name, <<SQL, :returns=>:trigger, :language=>:plpgsql)
+BEGIN
+  PERFORM pg_notify(#{literal((opts[:channel_name]||default_static_cache_update_name).to_s)}, TG_RELID::text);
+  RETURN NULL;
+END
+SQL
+      end
+
+      # Add a trigger to the given table that calls the function
+      # which will notify about table changes.
+      #
+      # Options:
+      # :function_name :: Override the function name to use.
+      # :trigger_name :: Override the trigger name to use.
+      def create_static_cache_update_trigger(table, opts=OPTS)
+        create_trigger(table, opts[:trigger_name]||default_static_cache_update_name, opts[:function_name]||default_static_cache_update_name, :after=>true)
+      end
+
+      # The default name for the function, trigger, and notification channel
+      # for this extension.
+      def default_static_cache_update_name
+        :sequel_static_cache_update
+      end
+
+      # Listen on the notification channel for changes to any of tables for
+      # the models given in a new thread. If notified about a change to one of the tables,
+      # reload the cache for the related model.  Options given are also
+      # passed to Database#listen.
+      #
+      # Note that this implementation does not currently support multiple
+      # models that use the same underlying table.
+      #
+      # Options:
+      # :channel_name :: Override the channel name to use.
+      # :before_thread_exit :: An object that responds to +call+ that is called before the 
+      #                        the created thread exits.
+      def listen_for_static_cache_updates(models, opts=OPTS)
+        raise Error, "this database object does not respond to listen, use the postgres adapter with the pg driver" unless respond_to?(:listen)
+        models = [models] unless models.is_a?(Array)
+        raise Error, "array of models to listen for changes cannot be empty" if models.empty?
+
+        oid_map = {}
+        models.each do |model|
+          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache)
+          oid_map[get(regclass_oid(model.dataset.first_source_table))] = model
+        end
+
+        Thread.new do
+          begin
+            listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge!(opts)) do |_, _, oid|
+              if model = oid_map[oid.to_i]
+                model.load_cache
+              end
+            end
+          ensure
+            opts[:before_thread_exit].call if opts[:before_thread_exit]
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:pg_static_cache_updater, Postgres::StaticCacheUpdater)
+end

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

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+#
+# The pg_timestamptz extension changes the default timestamp
+# type for the database to be +timestamptz+ (<tt>timestamp with time zone</tt>)
+# instead of +timestamp+ (<tt>timestamp without time zone</tt>).  This is
+# recommended if you are dealing with multiple timezones in your application.
+#
+# If you are using the auto_cast_date_and_time extension, the pg_timestamptz
+# extension will automatically cast Time and DateTime values to
+# <tt>TIMESTAMP WITH TIME ZONE</tt> instead of +TIMESTAMP+.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :pg_timestamptz
+#
+# To load the extension into individual datasets:
+#
+#   ds = ds.extension(:pg_timestamptz)
+#
+# Note that the loading into individual datasets only affects the integration
+# with the auto_cast_date_and_time extension.
+#
+# Related modules: Sequel::Postgres::Timestamptz, Sequel::Postgres::TimestamptzDatasetMethods
+
+#
+module Sequel
+  module Postgres
+    module Timestamptz
+      def self.extended(db)
+        db.extend_datasets(TimestamptzDatasetMethods)
+      end
+
+      private
+
+      # Use timestamptz by default for generic timestamp value.
+      def type_literal_generic_datetime(column)
+        :timestamptz
+      end
+    end
+
+    module TimestamptzDatasetMethods
+      private
+
+      def literal_datetime_timestamp_cast
+        'TIMESTAMP WITH TIME ZONE '
+      end
+    end
+  end
+
+  Dataset.register_extension(:pg_timestamptz, Postgres::TimestamptzDatasetMethods)
+  Database.register_extension(:pg_timestamptz, Postgres::Timestamptz)
+end

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

@@ -0,0 +1,40 @@
+# frozen-string-literal: true
+#
+# The pretty_table extension adds Sequel::Dataset#print and the
+# Sequel::PrettyTable class for creating nice-looking plain-text
+# tables.  Example:
+#
+#   +--+-------+
+#   |id|name   |
+#   |--+-------|
+#   |1 |fasdfas|
+#   |2 |test   |
+#   +--+-------+
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:pretty_table)
+#
+# 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(:pretty_table)
+#
+# Related module: Sequel::DatasetPrinter
+
+#
+module Sequel
+  extension :_pretty_table
+
+  module DatasetPrinter
+    # Pretty prints the records in the dataset as plain-text table.
+    def print(*cols)
+      ds = naked
+      rows = ds.all
+      Sequel::PrettyTable.print(rows, cols.empty? ? ds.columns : cols)
+    end
+  end
+
+  Dataset.register_extension(:pretty_table, DatasetPrinter)
+end

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

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+#
+# The provenance dataset extension tracks the locations of all
+# dataset clones that resulted in the current dataset, and includes
+# the information as a comment in the dataset's SQL.  This makes it
+# possible to see how a query was built, which can aid debugging.
+# Example:
+#
+#   DB[:table].
+#     select(:a).
+#     where{b > 10}.
+#     order(:c).
+#     limit(10)
+#   # SQL:
+#   # SELECT a FROM table WHERE (b > 10) ORDER BY c LIMIT 10 --
+#   #  -- Dataset Provenance
+#   #  -- Keys:[:from] Source:(eval at bin/sequel:257):2:in `<main>'
+#   #  -- Keys:[:select] Source:(eval at bin/sequel:257):3:in `<main>'
+#   #  -- Keys:[:where] Source:(eval at bin/sequel:257):4:in `<main>'
+#   #  -- Keys:[:order] Source:(eval at bin/sequel:257):5:in `<main>'
+#   #  -- Keys:[:limit] Source:(eval at bin/sequel:257):6:in `<main>'
+#
+# With the above example, the source is fairly obvious and not helpful,
+# but in real applications, where datasets can be built from multiple
+# files, seeing where each dataset clone was made can be helpful.
+#
+# The Source listed will skip locations in the Ruby standard library
+# as well as Sequel itself.  Other locations can be skipped by
+# providing a Database :provenance_caller_ignore Regexp option:
+#
+#   DB.opts[:provenance_caller_ignore] = /\/gems\/library_name-/
+#
+# Related module: Sequel::Dataset::Provenance
+
+#
+module Sequel
+  class Dataset
+    module Provenance
+      SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
+      RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+      INTERNAL = '<internal'
+
+      if TRUE_FREEZE
+        # Include provenance information when cloning datasets.
+        def clone(opts = nil || (return self))
+          super(provenance_opts(opts))
+        end
+      else
+        # :nocov:
+        def clone(opts = OPTS) # :nodoc:
+          super(provenance_opts(opts))
+        end
+        # :nocov:
+      end
+
+      %w'select insert update delete'.each do |type|
+        # Include the provenance information as a comment when preparing dataset SQL
+        define_method(:"#{type}_sql") do |*a|
+          sql = super(*a)
+
+          if provenance = @opts[:provenance]
+            comment = provenance.map do |hash|
+              " -- Keys:#{hash[:keys].inspect} Source:#{hash[:source]}".to_s.gsub(/\s+/, ' ')
+            end
+            comment << ""
+            comment.unshift " -- Dataset Provenance"
+            comment.unshift " -- "
+            comment = comment.join("\n")
+
+            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
+
+      # Return a copy of opts with provenance information added.
+      def provenance_opts(opts)
+        provenance = {source: provenance_source, keys: opts.keys.freeze}.freeze
+        opts = opts.dup
+        opts[:provenance] = ((@opts[:provenance] || EMPTY_ARRAY).dup << provenance).freeze
+        opts
+      end
+
+      # Return the caller line for the provenance change. This skips
+      # Sequel itself and the standard library.  Additional locations
+      # can be skipped using the :provenance_caller_ignore Dataset option.
+      def provenance_source
+        ignore = db.opts[:provenance_caller_ignore]
+        caller.find do |line|
+          !(line.start_with?(SEQUEL_LIB_PATH, RUBY_STDLIB, INTERNAL) ||
+            (ignore && line =~ ignore))
+        end
+      end
+    end
+
+    register_extension(:provenance, Provenance)
+  end
+end