serrano-vk 0.1.0

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

@@ -0,0 +1,349 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Database
+    # ---------------------
+    # :section: 4 - Methods relating to adapters, connecting, disconnecting, and sharding
+    # This methods involve the Database's connection pool.
+    # ---------------------
+
+    # Array of supported database adapters
+    ADAPTERS = %w'ado amalgalite ibmdb jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite tinytds trilogy'.map(&:to_sym)
+
+    # The Database subclass for the given adapter scheme.
+    # Raises Sequel::AdapterNotFound if the adapter
+    # could not be loaded.
+    def self.adapter_class(scheme)
+      scheme.is_a?(Class) ? scheme : load_adapter(scheme.to_sym)
+    end
+
+    # Returns the scheme symbol for the Database class.
+    def self.adapter_scheme
+      @scheme
+    end
+    
+    # Connects to a database.  See Sequel.connect.
+    def self.connect(conn_string, opts = OPTS)
+      case conn_string
+      when String
+        if conn_string.start_with?('jdbc:')
+          c = adapter_class(:jdbc)
+          opts = opts.merge(:orig_opts=>opts.dup)
+          opts = {:uri=>conn_string}.merge!(opts)
+        else
+          uri = URI.parse(conn_string)
+          scheme = uri.scheme
+          c = adapter_class(scheme)
+          opts = c.send(:options_from_uri, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
+        end
+      when Hash
+        opts = conn_string.merge(opts)
+        opts = opts.merge(:orig_opts=>opts.dup)
+        c = adapter_class(opts[:adapter_class] || opts[:adapter] || opts['adapter'])
+      else
+        raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
+      end
+
+      opts = opts.inject({}) do |m, (k,v)|
+        k = :user if k.to_s == 'username'
+        m[k.to_sym] = v
+        m
+      end
+
+      begin
+        db = c.new(opts)
+        if defined?(yield)
+          return yield(db)
+        end
+      ensure
+        if defined?(yield)
+          db.disconnect if db
+          Sequel.synchronize{::Sequel::DATABASES.delete(db)}
+        end
+      end
+      db
+    end
+    
+    # Load the adapter from the file system.  Raises Sequel::AdapterNotFound
+    # if the adapter cannot be loaded, or if the adapter isn't registered
+    # correctly after being loaded. Options:
+    # :map :: The Hash in which to look for an already loaded adapter (defaults to ADAPTER_MAP).
+    # :subdir :: The subdirectory of sequel/adapters to look in, only to be used for loading
+    #            subadapters.
+    def self.load_adapter(scheme, opts=OPTS)
+      map = opts[:map] || ADAPTER_MAP
+      if subdir = opts[:subdir]
+        file = "#{subdir}/#{scheme}"
+      else
+        file = scheme
+      end
+      
+      unless obj = Sequel.synchronize{map[scheme]}
+        # attempt to load the adapter file
+        begin
+          require "sequel/adapters/#{file}"
+        rescue LoadError => e
+          # If subadapter file doesn't exist, just return, 
+          # using the main adapter class without database customizations.
+          return if subdir
+          raise Sequel.convert_exception_class(e, AdapterNotFound)
+        end
+        
+        # make sure we actually loaded the adapter
+        unless obj = Sequel.synchronize{map[scheme]}
+          raise AdapterNotFound, "Could not load #{file} adapter: adapter class not registered in ADAPTER_MAP"
+        end
+      end
+
+      obj
+    end
+
+    # Sets the adapter scheme for the Database class. Call this method in
+    # descendants of Database to allow connection using a URL. For example the
+    # following:
+    #
+    #   class Sequel::MyDB::Database < Sequel::Database
+    #     set_adapter_scheme :mydb
+    #     ...
+    #   end
+    #
+    # would allow connection using:
+    #
+    #   Sequel.connect('mydb://user:password@dbserver/mydb')
+    def self.set_adapter_scheme(scheme) # :nodoc:
+      @scheme = scheme
+      Sequel.synchronize{ADAPTER_MAP[scheme] = self}
+    end
+    private_class_method :set_adapter_scheme
+
+    # Sets the given module as the shared adapter module for the given scheme.
+    # Used to register shared adapters for use by the mock adapter. Example:
+    #
+    #   # in file sequel/adapters/shared/mydb.rb
+    #   module Sequel::MyDB
+    #     Sequel::Database.set_shared_adapter_scheme :mydb, self
+    #
+    #     def self.mock_adapter_setup(db)
+    #       # ...
+    #     end
+    #
+    #     module DatabaseMethods
+    #       # ...
+    #     end
+    #
+    #     module DatasetMethods
+    #       # ...
+    #     end
+    #   end
+    #
+    # would allow the mock adapter to return a Database instance that supports
+    # the MyDB syntax via:
+    #
+    #   Sequel.connect('mock://mydb')
+    def self.set_shared_adapter_scheme(scheme, mod)
+      Sequel.synchronize{SHARED_ADAPTER_MAP[scheme] = mod}
+    end
+    
+    # The connection pool for this Database instance.  All Database instances have
+    # their own connection pools.
+    attr_reader :pool
+
+    # Returns the scheme symbol for this instance's class, which reflects which
+    # adapter is being used.  In some cases, this can be the same as the
+    # +database_type+ (for native adapters), in others (i.e. adapters with
+    # subadapters), it will be different.
+    #
+    #   Sequel.connect('jdbc:postgres://...').adapter_scheme
+    #   # => :jdbc
+    def adapter_scheme
+      self.class.adapter_scheme
+    end
+
+    # Dynamically add new servers or modify server options at runtime. Also adds new
+    # servers to the connection pool. Only usable when using a sharded connection pool.
+    #
+    # servers argument should be a hash with server name symbol keys and hash or
+    # proc values.  If a servers key is already in use, it's value is overridden
+    # with the value provided.
+    #
+    #   DB.add_servers(f: {host: "hash_host_f"})
+    def add_servers(servers)
+      unless sharded?
+        raise Error, "cannot call Database#add_servers on a Database instance that does not use a sharded connection pool"
+      end
+
+      h = @opts[:servers]
+      Sequel.synchronize{h.merge!(servers)}
+      @pool.add_servers(servers.keys)
+    end
+
+    # The database type for this database object, the same as the adapter scheme
+    # by default.  Should be overridden in adapters (especially shared adapters)
+    # to be the correct type, so that even if two separate Database objects are
+    # using different adapters you can tell that they are using the same database
+    # type.  Even better, you can tell that two Database objects that are using
+    # the same adapter are connecting to different database types.
+    #
+    #   Sequel.connect('jdbc:postgres://...').database_type
+    #   # => :postgres
+    def database_type
+      adapter_scheme
+    end
+    
+    # Disconnects all available connections from the connection pool.  Any
+    # connections currently in use will not be disconnected. Options:
+    # :server :: Should be a symbol specifing the server to disconnect from,
+    #             or an array of symbols to specify multiple servers.
+    #
+    # Example:
+    #
+    #   DB.disconnect # All servers
+    #   DB.disconnect(server: :server1) # Single server
+    #   DB.disconnect(server: [:server1, :server2]) # Multiple servers
+    def disconnect(opts = OPTS)
+      pool.disconnect(opts)
+    end
+
+    # Should only be called by the connection pool code to disconnect a connection.
+    # By default, calls the close method on the connection object, since most
+    # adapters use that, but should be overwritten on other adapters.
+    def disconnect_connection(conn)
+      conn.close
+    end
+
+    # Dynamically remove existing servers from the connection pool. Only usable
+    # when using a sharded connection pool
+    #
+    # servers should be symbols or arrays of symbols.  If a nonexistent server
+    # is specified, it is ignored.  If no servers have been specified for
+    # this database, no changes are made. If you attempt to remove the :default server,
+    # an error will be raised.
+    #
+    #   DB.remove_servers(:f1, :f2)
+    def remove_servers(*servers)
+      unless sharded?
+        raise Error, "cannot call Database#remove_servers on a Database instance that does not use a sharded connection pool"
+      end
+
+      h = @opts[:servers]
+      servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
+      @pool.remove_servers(servers)
+    end
+    
+    # An array of servers/shards for this Database object.
+    #
+    #   DB.servers # Unsharded: => [:default]
+    #   DB.servers # Sharded:   => [:default, :server1, :server2]
+    def servers
+      pool.servers
+    end
+
+    # Connect to the given server/shard. Handles database-generic post-connection
+    # setup not handled by #connect, using the :after_connect and :connect_sqls
+    # options.
+    def new_connection(server)
+      conn = connect(server)
+      opts = server_opts(server)
+
+      if ac = opts[:after_connect]
+        if ac.arity == 2
+          ac.call(conn, server)
+        else
+          ac.call(conn)
+        end
+      end
+
+      if cs = opts[:connect_sqls]
+        cs.each do |sql|
+          log_connection_execute(conn, sql)
+        end
+      end
+
+      conn
+    end
+
+    # Returns true if the database is using a single-threaded connection pool.
+    def single_threaded?
+      @single_threaded
+    end
+    
+    # Acquires a database connection, yielding it to the passed block. This is
+    # useful if you want to make sure the same connection is used for all
+    # database queries in the block.  It is also useful if you want to gain
+    # direct access to the underlying connection object if you need to do
+    # something Sequel does not natively support.
+    #
+    # If a server option is given, acquires a connection for that specific
+    # server, instead of the :default server.
+    #
+    #   DB.synchronize do |conn|
+    #     # ...
+    #   end
+    def synchronize(server=nil, &block)
+      @pool.hold(server || :default, &block)
+    end
+    
+    # Attempts to acquire a database connection.  Returns true if successful.
+    # Will probably raise an Error if unsuccessful.  If a server argument
+    # is given, attempts to acquire a database connection to the given
+    # server/shard.
+    def test_connection(server=nil)
+      synchronize(server){|conn|}
+      true
+    end
+
+    # Check whether the given connection is currently valid, by
+    # running a query against it.  If the query fails, the
+    # connection should probably be removed from the connection
+    # pool.
+    def valid_connection?(conn)
+      sql = valid_connection_sql
+      begin
+        log_connection_execute(conn, sql)
+      rescue Sequel::DatabaseError, *database_error_classes
+        false
+      else
+        true
+      end
+    end
+
+    private
+    
+    # The default options for the connection pool.
+    def connection_pool_default_options
+      {}
+    end
+    
+    # Return the options for the given server by merging the generic
+    # options for all server with the specific options for the given
+    # server specified in the :servers option.
+    def server_opts(server)
+      opts = if @opts[:servers] and server_options = @opts[:servers][server]
+        case server_options
+        when Hash
+          @opts.merge(server_options)
+        when Proc
+          @opts.merge(server_options.call(self))
+        else
+          raise Error, 'Server opts should be a hash or proc'
+        end
+      elsif server.is_a?(Hash)
+        @opts.merge(server)
+      else
+        @opts.dup
+      end
+
+      if pr = opts[:connect_opts_proc]
+        pr.call(opts)
+      end
+
+      opts.delete(:servers)
+      opts
+    end
+
+    # The SQL query to issue to check if a connection is valid.
+    def valid_connection_sql
+      @valid_connection_sql ||= select(nil).sql
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Database
+    # ---------------------
+    # :section: 3 - Methods that create datasets
+    # These methods all return instances of this database's dataset class.
+    # ---------------------
+
+    # Returns a dataset for the database. If the first argument is a string,
+    # the method acts as an alias for Database#fetch, returning a dataset for
+    # arbitrary SQL, with or without placeholders:
+    #
+    #   DB['SELECT * FROM items'].all
+    #   DB['SELECT * FROM items WHERE name = ?', my_name].all
+    #
+    # Otherwise, acts as an alias for Database#from, setting the primary
+    # table for the dataset:
+    #
+    #   DB[:items].sql #=> "SELECT * FROM items"
+    def [](*args)
+      args.first.is_a?(String) ? fetch(*args) : from(*args)
+    end
+    
+    # Returns a blank dataset for this database.
+    #
+    #   DB.dataset # SELECT *
+    #   DB.dataset.from(:items) # SELECT * FROM items
+    def dataset
+      @dataset_class.new(self)
+    end
+
+    # Returns a dataset instance for the given SQL string:
+    #
+    #   ds = DB.fetch('SELECT * FROM items')
+    #
+    # You can then call methods on the dataset to retrieve results:
+    #
+    #   ds.all
+    #   # SELECT * FROM items
+    #   # => [{:column=>value, ...}, ...]
+    #
+    # If a block is given, it is passed to #each on the resulting dataset to
+    # iterate over the records returned by the query:
+    #
+    #   DB.fetch('SELECT * FROM items'){|r| p r}
+    #   # {:column=>value, ...}
+    #   # ...
+    #
+    # +fetch+ can also perform parameterized queries for protection against SQL
+    # injection:
+    #
+    #   ds = DB.fetch('SELECT * FROM items WHERE name = ?', "my name")
+    #   ds.all
+    #   # SELECT * FROM items WHERE name = 'my name'
+    #
+    # See caveats listed in Dataset#with_sql regarding datasets using custom
+    # SQL and the methods that can be called on them.
+    def fetch(sql, *args, &block)
+      ds = @default_dataset.with_sql(sql, *args)
+      ds.each(&block) if block
+      ds
+    end
+    
+    # Returns a new dataset with the +from+ method invoked. If a block is given,
+    # it acts as a virtual row block
+    #
+    #   DB.from(:items) # SELECT * FROM items
+    #   DB.from{schema[:table]} # SELECT * FROM schema.table
+    def from(*args, &block)
+      if block
+        @default_dataset.from(*args, &block)
+      elsif args.length == 1 && (table = args[0]).is_a?(Symbol)
+        @default_dataset.send(:cached_dataset, :"_from_#{table}_ds"){@default_dataset.from(table)}
+      else
+        @default_dataset.from(*args)
+      end
+    end
+    
+    # Returns a new dataset with the select method invoked.
+    #
+    #   DB.select(1) # SELECT 1
+    #   DB.select{server_version.function} # SELECT server_version()
+    #   DB.select(:id).from(:items) # SELECT id FROM items
+    def select(*args, &block)
+      @default_dataset.select(*args, &block)
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Database
+    # ---------------------
+    # :section: 5 - Methods that set defaults for created datasets
+    # This methods change the default behavior of this database's datasets.
+    # ---------------------
+
+    # The class to use for creating datasets.  Should respond to
+    # new with the Database argument as the first argument, and
+    # an optional options hash.
+    attr_reader :dataset_class
+
+    # If the database has any dataset modules associated with it,
+    # use a subclass of the given class that includes the modules
+    # as the dataset class.
+    def dataset_class=(c)
+      unless @dataset_modules.empty?
+        c = Sequel.set_temp_name(Class.new(c)){"Sequel::Dataset::_Subclass"}
+        @dataset_modules.each{|m| c.send(:include, m)}
+      end
+      @dataset_class = c
+      reset_default_dataset
+    end
+
+    # Equivalent to extending all datasets produced by the database with a
+    # module.  What it actually does is use a subclass of the current dataset_class
+    # as the new dataset_class, and include the module in the subclass.
+    # Instead of a module, you can provide a block that is used to create an
+    # anonymous module.
+    #
+    # This allows you to override any of the dataset methods even if they are
+    # defined directly on the dataset class that this Database object uses.
+    #
+    # If a block is given, a Dataset::DatasetModule instance is created, allowing
+    # for the easy creation of named dataset methods that will do caching.
+    #
+    # Examples:
+    #
+    #   # Introspect columns for all of DB's datasets
+    #   DB.extend_datasets(Sequel::ColumnsIntrospection)
+    #   
+    #   # Trace all SELECT queries by printing the SQL and the full backtrace
+    #   DB.extend_datasets do
+    #     def fetch_rows(sql)
+    #       puts sql
+    #       puts caller
+    #       super
+    #     end
+    #   end
+    #
+    #   # Add some named dataset methods
+    #   DB.extend_datasets do
+    #     order :by_id, :id
+    #     select :with_id_and_name, :id, :name
+    #     where :active, :active
+    #   end
+    #
+    #   DB[:table].active.with_id_and_name.by_id
+    #   # SELECT id, name FROM table WHERE active ORDER BY id
+    def extend_datasets(mod=nil, &block)
+      raise(Error, "must provide either mod or block, not both") if mod && block
+      mod = Sequel.set_temp_name(Dataset::DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location[0,2].join(':')})"} if block
+      if @dataset_modules.empty?
+       @dataset_modules = [mod]
+       @dataset_class = Sequel.set_temp_name(Class.new(@dataset_class)){"Sequel::Dataset::_Subclass"}
+      else
+       @dataset_modules << mod
+      end
+      @dataset_class.send(:include, mod)
+      reset_default_dataset
+    end
+
+    private
+    
+    # The default dataset class to use for the database
+    def dataset_class_default
+      Sequel::Dataset
+    end
+
+    # Reset the default dataset used by most Database methods that create datasets.
+    def reset_default_dataset
+      Sequel.synchronize{@symbol_literal_cache.clear}
+      @default_dataset = dataset
+    end
+
+    # Whether to quote identifiers by default for this database, true by default.
+    def quote_identifiers_default
+      true
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Database
+    # ---------------------
+    # :section: 9 - Methods that describe what the database supports
+    # These methods all return booleans, with most describing whether or not the
+    # database supprots a given feature.
+    # ---------------------
+    
+    # Whether the database uses a global namespace for the index, true by default.  If
+    # false, the indexes are going to be namespaced per table.
+    def global_index_namespace?
+      true
+    end
+
+    # Whether the database supports CREATE TABLE IF NOT EXISTS syntax,
+    # false by default.
+    def supports_create_table_if_not_exists?
+      false
+    end
+
+    # Whether the database supports deferrable constraints, false
+    # by default as few databases do.
+    def supports_deferrable_constraints?
+      false
+    end
+
+    # Whether the database supports deferrable foreign key constraints,
+    # false by default as few databases do.
+    def supports_deferrable_foreign_key_constraints?
+      supports_deferrable_constraints?
+    end
+
+    # Whether the database supports DROP TABLE IF EXISTS syntax,
+    # false by default.
+    def supports_drop_table_if_exists?
+      supports_create_table_if_not_exists?
+    end
+
+    # Whether the database supports Database#foreign_key_list for
+    # parsing foreign keys.
+    def supports_foreign_key_parsing?
+      respond_to?(:foreign_key_list)
+    end
+
+    # Whether the database supports Database#indexes for parsing indexes.
+    def supports_index_parsing?
+      respond_to?(:indexes)
+    end
+
+    # Whether the database supports partial indexes (indexes on a subset of a table),
+    # false by default.
+    def supports_partial_indexes?
+      false
+    end
+
+    # Whether the database and adapter support prepared transactions
+    # (two-phase commit), false by default.
+    def supports_prepared_transactions?
+      false
+    end
+
+    # Whether the database and adapter support savepoints, false by default.
+    def supports_savepoints?
+      false
+    end
+
+    # Whether the database and adapter support savepoints inside prepared transactions
+    # (two-phase commit), false by default.
+    def supports_savepoints_in_prepared_transactions?
+      supports_prepared_transactions? && supports_savepoints?
+    end
+
+    # Whether the database supports schema parsing via Database#schema.
+    def supports_schema_parsing?
+      respond_to?(:schema_parse_table, true)
+    end
+
+    # Whether the database supports Database#tables for getting list of tables.
+    def supports_table_listing?
+      respond_to?(:tables)
+    end
+    #
+    # Whether the database supports Database#views for getting list of views.
+    def supports_view_listing?
+      respond_to?(:views)
+    end
+
+    # Whether the database and adapter support transaction isolation levels, false by default.
+    def supports_transaction_isolation_levels?
+      false
+    end
+
+    # Whether DDL statements work correctly in transactions, false by default.
+    def supports_transactional_ddl?
+      false
+    end
+
+    # Whether CREATE VIEW ... WITH CHECK OPTION is supported, false by default.
+    def supports_views_with_check_option?
+      !!view_with_check_option_support
+    end
+
+    # Whether CREATE VIEW ... WITH LOCAL CHECK OPTION is supported, false by default.
+    def supports_views_with_local_check_option?
+      view_with_check_option_support == :local
+    end
+
+    private
+
+    # Whether the database supports adding primary key constraints on NULLable columns,
+    # automatically making them NOT NULL.  If false, the columns must be set NOT NULL
+    # before the primary key constraint is added.
+    def can_add_primary_key_constraint_on_nullable_columns?
+      true
+    end
+
+    # Whether this dataset considers unquoted identifiers as uppercase. True
+    # by default as that is the SQL standard
+    def folds_unquoted_identifiers_to_uppercase?
+      true
+    end
+    
+    # Whether the database supports combining multiple alter table
+    # operations into a single query, false by default.
+    def supports_combining_alter_table_ops?
+      false
+    end
+
+    # Whether the database supports CREATE OR REPLACE VIEW.  If not, support
+    # will be emulated by dropping the view first. false by default.
+    def supports_create_or_replace_view?
+      false
+    end
+
+    # Whether the database supports named column constraints. True
+    # by default.  Those that don't support named column constraints
+    # have to have column constraints converted to table constraints
+    # if the column constraints have names.
+    def supports_named_column_constraints?
+      true
+    end
+
+    # Don't advertise support for WITH CHECK OPTION by default.
+    def view_with_check_option_support
+      nil
+    end
+  end
+end