serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/utils/mysql_prepared_statements.rb

@@ -0,0 +1,56 @@
+# frozen-string-literal: true
+
+module Sequel
+  module MySQL
+    module PreparedStatements
+      module DatabaseMethods
+        private
+
+        # Executes a prepared statement on an available connection.  If the
+        # prepared statement already exists for the connection and has the same
+        # SQL, reuse it, otherwise, prepare the new statement.  Issue a SET
+        # query with literalized values for each argument, then an EXECUTE to
+        # execute the query with the arguments.
+        def execute_prepared_statement(ps_name, opts, &block)
+          args = opts[:arguments]
+          ps = prepared_statement(ps_name)
+          sql = ps.prepared_sql
+          synchronize(opts[:server]) do |conn|
+            unless conn.prepared_statements[ps_name] == sql
+              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+              conn.prepared_statements[ps_name] = sql
+            end
+            i = 0
+            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
+            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        module CallableStatementMethods
+          # Extend given dataset with this module so subselects inside subselects in
+          # prepared statements work.
+          def subselect_sql_append(sql, ds)
+            ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+              send(:to_prepared_statement, :select, nil, :extend=>bound_variable_modules).
+              prepared_sql
+          end
+        end
+        
+        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, Sequel::Dataset::UnnumberedArgumentMapper)
+        
+        private
+
+        def bound_variable_modules
+          [CallableStatementMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/utils/replace.rb

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    module Replace
+      # Execute a REPLACE statement on the database (deletes any duplicate
+      # rows before inserting).
+      def replace(*values)
+        execute_insert(replace_sql(*values))
+      end
+
+      # SQL statement for REPLACE
+      def replace_sql(*values)
+        clone(:replace=>true).insert_sql(*values)
+      end
+
+      # Replace multiple rows in a single query.
+      def multi_replace(*values)
+        clone(:replace=>true).multi_insert(*values)
+      end
+
+      # Databases using this module support REPLACE.
+      def supports_replace?
+        true
+      end
+
+      private
+
+      # If this is an replace instead of an insert, use replace instead
+      def insert_insert_sql(sql)
+        sql << (@opts[:replace] ? 'REPLACE' : 'INSERT')
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/utils/split_alter_table.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+module Sequel::Database::SplitAlterTable
+  private
+
+  # Preprocess the array of operations.  If it looks like some operations depend
+  # on results of earlier operations and may require reloading the schema to
+  # work correctly, split those operations into separate lists, and between each
+  # list, remove the cached schema so that the later operations deal with the
+  # then current table schema.
+  def apply_alter_table(name, ops)
+    modified_columns = []
+    op_groups = [[]]
+    ops.each do |op|
+      case op[:op]
+      when :add_column, :set_column_type, :set_column_null, :set_column_default
+        if modified_columns.include?(op[:name])
+          op_groups << []
+        else
+          modified_columns << op[:name]
+        end
+      when :rename_column
+        if modified_columns.include?(op[:name]) || modified_columns.include?(op[:new_name])
+          op_groups << []
+        end
+        modified_columns << op[:name] unless modified_columns.include?(op[:name])
+        modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
+      end
+      if split_alter_table_op?(op)
+        op_groups << []
+      end
+      op_groups.last << op
+    end
+
+    op_groups.each do |opgs|
+      next if opgs.empty?
+      alter_table_sql_list(name, opgs).each{|sql| execute_ddl(sql)}
+      remove_cached_schema(name)
+    end
+  end
+
+  # Whether the given alter table op should start a new group.
+  def split_alter_table_op?(op)
+    false
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/utils/stored_procedures.rb

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+
+module Sequel 
+  class Dataset
+    module StoredProcedureMethods
+      # The name of the stored procedure to call
+      def sproc_name
+        @opts[:sproc_name]
+      end
+      
+      # Call the stored procedure with the given args
+      def call(*args, &block)
+        clone(:sproc_args=>args).run(&block)
+      end
+
+      # Programmer friendly string showing this is a stored procedure,
+      # showing the name of the procedure.
+      def inspect
+        "<#{self.class.name}/StoredProcedure name=#{@sproc_name}>"
+      end
+      
+      # Run the stored procedure with the current args on the database
+      def run(&block)
+        case @opts[:sproc_type]
+        when :select, :all
+          all(&block)
+        when :first
+          first
+        when :insert
+          insert
+        when :update
+          update
+        when :delete
+          delete
+        end
+      end
+    end
+  
+    module StoredProcedures
+      # For the given type (:select, :first, :insert, :update, or :delete),
+      # run the database stored procedure with the given name with the given
+      # arguments.
+      def call_sproc(type, name, *args)
+        prepare_sproc(type, name).call(*args)
+      end
+      
+      # Transform this dataset into a stored procedure that you can call
+      # multiple times with new arguments.
+      def prepare_sproc(type, name)
+        prepare_extend_sproc(self).clone(:sproc_type=>type, :sproc_name=>name, :sql=>'')
+      end
+      
+      private
+      
+      # Extend the dataset with the stored procedure methods.
+      def prepare_extend_sproc(ds)
+        ds.with_extend(StoredProcedureMethods)
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/utils/unmodified_identifiers.rb

@@ -0,0 +1,28 @@
+# frozen-string-literal: true
+
+module Sequel
+  module UnmodifiedIdentifiers
+    module DatabaseMethods
+      private
+
+      # Databases that use this module for unquoted identifiers to lowercase.
+      def folds_unquoted_identifiers_to_uppercase?
+        false
+      end
+    end
+
+    module DatasetMethods
+      private
+
+      # Turn the given symbol/string into a symbol, keeping the current case.
+      def output_identifier(v)
+        v == '' ? :untitled : v.to_sym
+      end
+
+      # Turn the given symbol/string into a string, keeping the current case.
+      def input_identifier(v)
+        v.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen-string-literal: true
+
+module Sequel
+  # The +ASTTransformer+ class is designed to handle the abstract syntax trees
+  # that Sequel uses internally and produce modified copies of them.  By itself
+  # it only produces a straight copy.  It's designed to be subclassed and have
+  # subclasses returned modified copies of the specific nodes that need to
+  # be modified.
+  class ASTTransformer
+    # Return +obj+ or a potentially transformed version of it.
+    def transform(obj)
+      v(obj)
+    end
+
+    private
+
+    # Recursive version that handles all of Sequel's internal object types
+    # and produces copies of them.
+    def v(o)
+      case o
+      when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
+        o
+      when Array
+        o.map{|x| v(x)}
+      when Hash
+        h = {}
+        o.each{|k, val| h[v(k)] = v(val)}
+        h
+      when Set
+        Set.new(o.map{|x| v(x)})
+      when SQL::NumericExpression
+        if o.op == :extract
+          o.class.new(o.op, o.args[0], v(o.args[1]))
+        else
+          o.class.new(o.op, *v(o.args))
+        end
+      when SQL::ComplexExpression
+        o.class.new(o.op, *v(o.args))
+      when SQL::Identifier
+        SQL::Identifier.new(v(o.value))
+      when SQL::QualifiedIdentifier
+        SQL::QualifiedIdentifier.new(v(o.table), v(o.column))
+      when SQL::OrderedExpression
+        SQL::OrderedExpression.new(v(o.expression), o.descending, :nulls=>o.nulls)
+      when SQL::AliasedExpression
+        SQL::AliasedExpression.new(v(o.expression), o.alias, o.columns)
+      when SQL::CaseExpression
+        args = [v(o.conditions), v(o.default)]
+        args << v(o.expression) if o.expression?
+        SQL::CaseExpression.new(*args)
+      when SQL::Cast
+        SQL::Cast.new(v(o.expr), o.type)
+      when SQL::Function
+        h = {}
+        o.opts.each do |k, val|
+          h[k] = v(val)
+        end
+        SQL::Function.new!(o.name, v(o.args), h)
+      when SQL::Subscript
+        SQL::Subscript.new(v(o.expression), v(o.sub))
+      when SQL::Window
+        opts = o.opts.dup
+        opts[:partition] = v(opts[:partition]) if opts[:partition]
+        opts[:order] = v(opts[:order]) if opts[:order]
+        SQL::Window.new(opts)
+      when SQL::PlaceholderLiteralString
+        args = if o.args.is_a?(Hash)
+          h = {}
+          o.args.each{|k,val| h[k] = v(val)}
+          h
+        else
+          v(o.args)
+        end
+        SQL::PlaceholderLiteralString.new(o.str, args, o.parens)
+      when SQL::JoinOnClause
+        SQL::JoinOnClause.new(v(o.on), o.join_type, v(o.table_expr))
+      when SQL::JoinUsingClause
+        SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table_expr))
+      when SQL::JoinClause
+        SQL::JoinClause.new(o.join_type, v(o.table_expr))
+      when SQL::DelayedEvaluation
+        SQL::DelayedEvaluation.new(lambda{|ds| v(o.call(ds))})
+      when SQL::Wrapper
+        SQL::Wrapper.new(v(o.value))
+      when SQL::Expression
+        if o.respond_to?(:sequel_ast_transform)
+          o.sequel_ast_transform(method(:v))
+        else
+          o
+        end
+      else
+        o
+      end
+    end
+  end
+
+  # Handles qualifying existing datasets, so that unqualified columns
+  # in the dataset are qualified with a given table name.
+  class Qualifier < ASTTransformer
+    # Set the table used to qualify unqualified columns
+    def initialize(table)
+      @table = table
+    end
+
+    private
+
+    # Turn <tt>SQL::Identifier</tt>s and symbols that aren't implicitly
+    # qualified into <tt>SQL::QualifiedIdentifier</tt>s.  For symbols that
+    # are not implicitly qualified by are implicitly aliased, return an
+    # <tt>SQL::AliasedExpression</tt>s with a qualified version of the symbol.
+    def v(o)
+      case o
+      when Symbol
+        t, column, aliaz = Sequel.split_symbol(o)
+        if t
+          o
+        elsif aliaz
+          SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(@table, SQL::Identifier.new(column)), aliaz)
+        else
+          SQL::QualifiedIdentifier.new(@table, o)
+        end
+      when SQL::Identifier
+        SQL::QualifiedIdentifier.new(@table, o)
+      when SQL::QualifiedIdentifier, SQL::JoinClause
+        # Return these directly, so we don't accidentally qualify symbols in them.
+        o
+      else
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen-string-literal: true
+
+# A ShardedSingleConnectionPool is a single threaded connection pool that
+# works with multiple shards/servers.
+class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
+  # The single threaded pool takes the following options:
+  #
+  # :servers :: A hash of servers to use.  Keys should be symbols.  If not
+  #             present, will use a single :default server.
+  # :servers_hash :: The base hash to use for the servers.  By default,
+  #                  Sequel uses Hash.new(:default).  You can use a hash with a default proc
+  #                  that raises an error if you want to catch all cases where a nonexistent
+  #                  server is used.
+  def initialize(db, opts=OPTS)
+    super
+    @conns = {}
+    @servers = opts.fetch(:servers_hash, Hash.new(:default))
+    add_servers([:default])
+    add_servers(opts[:servers].keys) if opts[:servers]
+  end
+  
+  # Adds new servers to the connection pool. Primarily used in conjunction with primary/replica
+  # or sharded configurations. Allows for dynamic expansion of the potential replicas/shards
+  # at runtime. +servers+ argument should be an array of symbols. 
+  def add_servers(servers)
+    servers.each{|s| @servers[s] = s}
+  end
+
+  # Yield all of the currently established connections
+  def all_connections
+    @conns.values.each{|c| yield c}
+  end
+  
+  # The connection for the given server.
+  def conn(server=:default)
+    @conns[@servers[server]]
+  end
+  
+  # Disconnects from the database. Once a connection is requested using
+  # #hold, the connection is reestablished. Options:
+  # :server :: Should be a symbol specifing the server to disconnect from,
+  #            or an array of symbols to specify multiple servers.
+  def disconnect(opts=OPTS)
+    (opts[:server] ? Array(opts[:server]) : servers).each do |s|
+      raise Sequel::Error, "invalid server: #{s}" unless @servers.has_key?(s)
+      disconnect_server(s)
+    end
+  end
+
+  def freeze
+    @servers.freeze
+    super
+  end
+  
+  # Yields the connection to the supplied block for the given server.
+  # This method simulates the ConnectionPool#hold API.
+  def hold(server=:default)
+    server = pick_server(server)
+    yield(@conns[server] ||= make_new(server))
+  rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+    disconnect_server(server) if disconnect_error?(e)
+    raise
+  end
+  
+  # The ShardedSingleConnectionPool always has a maximum size of 1.
+  def max_size
+    1
+  end
+  
+  # Remove servers from the connection pool. Similar to disconnecting from all given servers,
+  # except that after it is used, future requests for the server will use the
+  # :default server instead.
+  def remove_servers(servers)
+    raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
+    servers.each do |server|
+      disconnect_server(server)
+      @servers.delete(server)
+    end
+  end
+  
+  # Return an array of symbols for servers in the connection pool.
+  def servers
+    @servers.keys
+  end
+  
+  # The number of different shards/servers this pool is connected to.
+  def size
+    @conns.length
+  end
+  
+  def pool_type
+    :sharded_single
+  end
+  
+  private
+  
+  # Disconnect from the given server, if connected.
+  def disconnect_server(server)
+    if conn = @conns.delete(server)
+      disconnect_connection(conn)
+    end
+  end
+
+  # If the server given is in the hash, return it, otherwise, return the default server.
+  def pick_server(server)
+    @servers[server]
+  end
+  
+  # Make sure there is a valid connection for each server.
+  def preconnect(concurrent = nil)
+    servers.each{|s| hold(s){}}
+  end
+end