serrano-vk 0.1.0

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

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+
+module Sequel
+  # A dataset represents an SQL query. Datasets
+  # can be used to select, insert, update and delete records.
+  # 
+  # Query results are always retrieved on demand, so a dataset can be kept
+  # around and reused indefinitely (datasets never cache results):
+  #
+  #   my_posts = DB[:posts].where(author: 'david') # no records are retrieved
+  #   my_posts.all # records are retrieved
+  #   my_posts.all # records are retrieved again
+  #
+  # Datasets are frozen and use a functional style where modification methods
+  # return modified copies of the the dataset.  This allows you to reuse
+  # datasets:
+  #
+  #   posts = DB[:posts]
+  #   davids_posts = posts.where(author: 'david')
+  #   old_posts = posts.where{stamp < Date.today - 7}
+  #   davids_old_posts = davids_posts.where{stamp < Date.today - 7}
+  #
+  # Datasets are Enumerable objects, so they can be manipulated using many
+  # of the Enumerable methods, such as +map+ and +inject+.  Note that there are some methods
+  # that Dataset defines that override methods defined in Enumerable and result in different
+  # behavior, such as +select+ and +group_by+.
+  #
+  # For more information, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].
+  class Dataset
+    OPTS = Sequel::OPTS
+
+    # Whether Dataset#freeze can actually freeze datasets.  True only on ruby 2.4+,
+    # as it requires clone(freeze: false)
+    TRUE_FREEZE = RUBY_VERSION >= '2.4'
+
+    include Enumerable
+    include SQL::AliasMethods
+    include SQL::BooleanMethods
+    include SQL::CastMethods
+    include SQL::ComplexExpressionMethods
+    include SQL::InequalityMethods
+    include SQL::NumericMethods
+    include SQL::OrderMethods
+    include SQL::StringMethods
+  end
+  
+  require_relative "dataset/query"
+  require_relative "dataset/actions"
+  require_relative "dataset/features"
+  require_relative "dataset/graph"
+  require_relative "dataset/prepared_statements"
+  require_relative "dataset/misc"
+  require_relative "dataset/sql"
+  require_relative "dataset/placeholder_literalizer"
+  require_relative "dataset/dataset_module"
+
+  # :nocov:
+  require_relative "dataset/deprecated_singleton_class_methods" if Dataset::TRUE_FREEZE
+  # :nocov:
+end

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

@@ -0,0 +1,70 @@
+# frozen-string-literal: true
+
+module Sequel
+  # This module makes it easy to print deprecation warnings with optional backtraces to a given stream.
+  # There are a two accessors you can use to change how/where the deprecation methods are printed
+  # and whether/how backtraces should be included:
+  #
+  #   Sequel::Deprecation.output = $stderr # print deprecation messages to standard error (default)
+  #   Sequel::Deprecation.output = File.open('deprecated_calls.txt', 'wb') # use a file instead
+  #   Sequel::Deprecation.output = false # do not output deprecation messages
+  #
+  #   Sequel::Deprecation.prefix = "SEQUEL DEPRECATION WARNING: " # prefix deprecation messages with a given string (default)
+  #   Sequel::Deprecation.prefix = false # do not prefix deprecation messages
+  #
+  #   Sequel::Deprecation.backtrace_filter = false # don't include backtraces
+  #   Sequel::Deprecation.backtrace_filter = true # include full backtraces
+  #   Sequel::Deprecation.backtrace_filter = 10 # include 10 backtrace lines (default)
+  #   Sequel::Deprecation.backtrace_filter = 1 # include 1 backtrace line
+  #   Sequel::Deprecation.backtrace_filter = lambda{|line, line_no| line_no < 3 || line =~ /my_app/} # select backtrace lines to output
+  module Deprecation
+    @backtrace_filter = 10
+    @output = $stderr
+    @prefix = "SEQUEL DEPRECATION WARNING: ".freeze
+
+    class << self
+      # How to filter backtraces.  +false+ does not include backtraces, +true+ includes
+      # full backtraces, an Integer includes that number of backtrace lines, and
+      # a proc is called with the backtrace line and line number to select the backtrace
+      # lines to include.  The default is 10 backtrace lines.
+      attr_accessor :backtrace_filter
+
+      # Where deprecation messages should be output, must respond to puts.  $stderr by default.
+      attr_accessor :output
+
+      # Where deprecation messages should be prefixed with ("SEQUEL DEPRECATION WARNING: " by default).
+      attr_accessor :prefix
+    end
+
+    # Print the message and possibly backtrace to the output.
+    def self.deprecate(method, instead=nil)
+      return unless output
+      message = instead ? "#{method} is deprecated and will be removed in Sequel 6.  #{instead}." : method
+      message = "#{prefix}#{message}" if prefix
+      output.puts(message)
+      case b = backtrace_filter
+      when Integer
+        caller.each do |c|
+          b -= 1
+          output.puts(c)
+          break if b <= 0
+        end
+      when true
+        caller.each{|c| output.puts(c)}
+      when Proc
+        caller.each_with_index{|line, line_no| output.puts(line) if b.call(line, line_no)}
+      end
+      nil
+    end
+
+    # If using ruby 2.3+, use Module#deprecate_constant to deprecate the constant,
+    # otherwise do nothing as the ruby implementation does not support constant deprecation.
+    def self.deprecate_constant(mod, constant)
+      # :nocov:
+      if RUBY_VERSION > '2.3'
+      # :nocov:
+        mod.deprecate_constant(constant)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen-string-literal: true
+
+module Sequel
+  # The default exception class for exceptions raised by Sequel.
+  # All exception classes defined by Sequel are descendants of this class.
+  class Error < ::StandardError
+    # If this exception wraps an underlying exception, the underlying
+    # exception is held here.
+    attr_accessor :wrapped_exception
+
+    # :nocov:
+    if RUBY_VERSION >= '2.1'
+    # :nocov:
+      # Returned the wrapped exception if one exists, otherwise use
+      # ruby's default behavior.
+      def cause
+        wrapped_exception || super
+      end
+    end
+  end  
+
+  (
+  # Error raised when there is a failed attempt to acquire an advisory lock.
+  AdvisoryLockError = Class.new(Error)
+  ).name
+    
+  (
+  # Error raised when the adapter requested doesn't exist or can't be loaded.
+  AdapterNotFound = Class.new(Error)
+  ).name
+
+  (
+  # Generic error raised by the database adapters, indicating a
+  # problem originating from the database server.  Usually raised
+  # because incorrect SQL syntax is used.
+  DatabaseError = Class.new(Error)
+  ).name
+  
+  (
+  # Error raised when the Sequel is unable to connect to the database with the
+  # connection parameters it was given.
+  DatabaseConnectionError = Class.new(DatabaseError)
+  ).name
+
+  (
+  # Error raised by adapters when they determine that the connection
+  # to the database has been lost.  Instructs the connection pool code to 
+  # remove that connection from the pool so that other connections can be acquired
+  # automatically.
+  DatabaseDisconnectError = Class.new(DatabaseError)
+  ).name
+
+  (
+  # Generic error raised when Sequel determines a database constraint has been violated.
+  ConstraintViolation = Class.new(DatabaseError)
+  ).name
+
+  (
+  # Error raised when Sequel determines a database check constraint has been violated.
+  CheckConstraintViolation = Class.new(ConstraintViolation)
+  ).name
+
+  (
+  # Error raised when Sequel determines a database foreign key constraint has been violated.
+  ForeignKeyConstraintViolation = Class.new(ConstraintViolation)
+  ).name
+
+  (
+  # Error raised when Sequel determines a database NOT NULL constraint has been violated.
+  NotNullConstraintViolation = Class.new(ConstraintViolation)
+  ).name
+
+  (
+  # Error raised when Sequel determines a database unique constraint has been violated.
+  UniqueConstraintViolation = Class.new(ConstraintViolation)
+  ).name
+
+  (
+  # Error raised when Sequel determines a serialization failure/deadlock in the database.
+  SerializationFailure = Class.new(DatabaseError)
+  ).name
+
+  (
+  # Error raised when Sequel determines the database could not acquire a necessary lock
+  # before timing out. Use of Dataset#nowait can often cause this exception when
+  # retrieving rows.
+  DatabaseLockTimeout = Class.new(DatabaseError)
+  ).name
+
+  (
+  # Error raised on an invalid operation, such as trying to update or delete
+  # a joined or grouped dataset when the database does not support that.
+  InvalidOperation = Class.new(Error)
+  ).name
+
+  (
+  # Error raised when attempting an invalid type conversion.
+  InvalidValue = Class.new(Error)
+  ).name
+
+  # Error raised when the user requests a record via the first! or similar
+  # method, and the dataset does not yield any rows.
+  class NoMatchingRow < Error
+    # The dataset that raised this NoMatchingRow exception.
+    attr_accessor :dataset
+
+    # If the first argument is a Sequel::Dataset, set the dataset related to
+    # the exception to that argument, instead of assuming it is the exception message.
+    def initialize(msg=nil)
+      if msg.is_a?(Sequel::Dataset)
+        @dataset = msg
+        msg = nil
+      end
+      super
+    end
+  end
+
+  (
+  # Error raised when the connection pool cannot acquire a database connection
+  # before the timeout.
+  PoolTimeout = Class.new(Error)
+  ).name
+
+  (
+  # Error that you should raise to signal a rollback of the current transaction.
+  # The transaction block will catch this exception, rollback the current transaction,
+  # and won't reraise it (unless a reraise is requested).
+  Rollback = Class.new(Error)
+  ).name
+end

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

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module ConstraintValidations
+      module DatabaseMethods
+        # A hash of validation method call metadata for all tables in the database.
+        # The hash is keyed by table name string and contains arrays of validation
+        # method call arrays.
+        attr_accessor :constraint_validations
+      end
+    end
+  end
+
+  Database.register_extension(:_model_constraint_validations, Plugins::ConstraintValidations::DatabaseMethods)
+end

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

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module PgRow
+      module DatabaseMethods
+        # Handle Sequel::Model instances in bound variables.
+        def bound_variable_arg(arg, conn)
+          case arg
+          when Sequel::Model
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(',')})"
+          else
+            super
+          end
+        end
+
+        # If a Sequel::Model instance is given, return it as-is
+        # instead of attempting to convert it.
+        def row_type(db_type, v)
+          if v.is_a?(Sequel::Model)
+            v
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:_model_pg_row, Plugins::PgRow::DatabaseMethods)
+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,85 @@
+# frozen-string-literal: true
+#
+# This _pretty_table extension is only for internal use.
+# It adds the Sequel::PrettyTable class without modifying 
+# Sequel::Dataset.
+#
+# To load the extension:
+#
+#   Sequel.extension :_pretty_table
+#
+# Related module: Sequel::PrettyTable
+
+#
+module Sequel
+  module PrettyTable
+    # Prints nice-looking plain-text tables via puts
+    # 
+    #   +--+-------+
+    #   |id|name   |
+    #   |--+-------|
+    #   |1 |fasdfas|
+    #   |2 |test   |
+    #   +--+-------+
+    def self.print(records, columns=nil)
+      puts string(records, columns)
+    end
+
+    # Return the string that #print will print via puts.
+    def self.string(records, columns = nil) # records is an array of hashes
+      columns ||= records.first.keys.sort
+      sizes = column_sizes(records, columns)
+      sep_line = separator_line(columns, sizes)
+
+      array = [sep_line, header_line(columns, sizes), sep_line]
+      records.each {|r| array << data_line(columns, sizes, r)}
+      array << sep_line
+      array.join("\n")
+    end
+
+    # Hash of the maximum size of the value for each column 
+    def self.column_sizes(records, columns) # :nodoc:
+      sizes = Hash.new(0)
+      columns.each do |c|
+        sizes[c] = c.to_s.size
+      end
+      records.each do |r|
+        columns.each do |c|
+          s = r[c].to_s.size
+          sizes[c] = s if s > sizes[c]
+        end
+      end
+      sizes
+    end
+    
+    # String for each data line
+    def self.data_line(columns, sizes, record) # :nodoc:
+      String.new << '|' << columns.map {|c| format_cell(sizes[c], record[c])}.join('|') << '|'
+    end
+    
+    # Format the value so it takes up exactly size characters
+    def self.format_cell(size, v) # :nodoc:
+      case v
+      when Integer
+        "%#{size}d" % v
+      when Float, BigDecimal
+        "%#{size}g" % v
+      else
+        "%-#{size}s" % v.to_s
+      end
+    end
+    
+    # String for header line
+    def self.header_line(columns, sizes) # :nodoc:
+      String.new << '|' << columns.map {|c| "%-#{sizes[c]}s" % c.to_s}.join('|') << '|'
+    end
+
+    # String for separtor line
+    def self.separator_line(columns, sizes) # :nodoc:
+      String.new << '+' << columns.map {|c| '-' * sizes[c]}.join('+') << '+'
+    end
+
+    private_class_method :column_sizes, :data_line, :format_cell, :header_line, :separator_line
+  end
+end
+

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

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+#
+# The any_not_empty extension changes the behavior of Dataset#any?
+# if called without a block.  By default, this method uses the
+# standard Enumerable behavior of enumerating results and seeing
+# if any result is not false or nil.  With this extension, it
+# just checks whether the dataset is empty.  This approach can
+# be much faster if the dataset is currently large.
+#
+#   DB[:table].any?
+#   # SELECT * FROM table
+#
+#   DB[:table].extension(:any_not_empty).any?
+#   # SELECT 1 as one FROM table LIMIT 1
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:any_not_empty)
+#
+# 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(:any_not_empty)
+#
+# Note that this can result in any? returning a different result if
+# the dataset has a row_proc that can return false or nil.
+#
+# Related module: Sequel::AnyNotEmpty
+
+#
+module Sequel
+  module AnyNotEmpty
+    # If a block is not given, return whether the dataset is not empty.
+    def any?(*a)
+      if !a.empty? || defined?(yield)
+        super
+      else
+        !empty?
+      end
+    end
+  end
+
+  Dataset.register_extension(:any_not_empty, AnyNotEmpty)
+end

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

@@ -0,0 +1,114 @@
+# frozen-string-literal: true
+#
+# The arbitrary_servers extension allows you to connect to arbitrary
+# servers/shards that were not defined when you created the database.
+# To use it, you first load the extension into the Database object:
+#
+#   DB.extension :arbitrary_servers
+#
+# Then you can pass arbitrary connection options for the server/shard
+# to use as a hash:
+#
+#   DB[:table].server(host: '...', database: '...').all
+#
+# Because Sequel can never be sure that the connection will be reused,
+# arbitrary connections are disconnected as soon as the outermost block
+# that uses them exits.  So this example uses the same connection:
+#
+#   DB.transaction(server: {host: '...', database: '...'}) do |c|
+#     DB.transaction(server: {host: '...', database: '...'}) do |c2|
+#       # c == c2
+#     end
+#   end
+#
+# But this example does not:
+#
+#   DB.transaction(server: {host: '...', database: '...'}) do |c|
+#   end
+#   DB.transaction(server: {host: '...', database: '...'}) do |c2|
+#     # c != c2
+#   end
+#
+# You can use this extension in conjunction with the server_block
+# extension:
+#
+#   DB.with_server(host: '...', database: '...') do
+#     DB.synchronize do
+#       # All of these use the host/database given to with_server
+#       DB[:table].insert(c: 1)
+#       DB[:table].update(c: 2)
+#       DB.tables
+#       DB[:table].all
+#     end
+#   end
+#
+# Anyone using this extension in conjunction with the server_block
+# extension may want to do the following to so that you don't need
+# to call synchronize separately:
+#
+#   def DB.with_server(*a)
+#     super(*a){synchronize{yield}}
+#   end
+#
+# Note that this extension only works with the sharded threaded connection
+# pool.  If you are using the sharded single connection pool, you need
+# to switch to the sharded threaded connection pool before using this
+# extension.
+#
+# Related module: Sequel::ArbitraryServers
+
+#
+module Sequel
+  module ArbitraryServers
+    private
+
+    # If server is a hash, create a new connection for
+    # it, and cache it first by thread and then server.
+    def acquire(thread, server)
+      if server.is_a?(Hash)
+        sync{@allocated[thread] ||= {}}[server] = make_new(server)
+      else
+        super
+      end
+    end
+    
+    # If server is a hash, the entry for it probably doesn't
+    # exist in the @allocated hash, so check for existence to
+    # avoid calling nil.[]
+    def owned_connection(thread, server)
+      if server.is_a?(Hash)
+        if a = sync{@allocated[thread]}
+          a[server]
+        end
+      else
+        super
+      end
+    end
+
+    # If server is a hash, return it directly.
+    def pick_server(server)
+      if server.is_a?(Hash)
+        server
+      else
+        super
+      end
+    end
+
+    # If server is a hash, delete the thread from the allocated
+    # connections for that server.  Additionally, if this was the last thread
+    # using that server, delete the server from the @allocated hash.
+    def release(thread, conn, server)
+      if server.is_a?(Hash)
+        a = @allocated[thread]
+        a.delete(server)
+        @allocated.delete(thread) if a.empty?
+        disconnect_connection(conn)
+      else  
+        super
+      end
+    end
+  end
+
+  Database.register_extension(:arbitrary_servers){|db| db.pool.extend(ArbitraryServers)}
+end
+