serrano-vk 0.1.0

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

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # This Module subclass is used by Database#extend_datasets
+    # and Dataset#with_extend to add dataset methods to classes.
+    # It adds some helper methods inside the module that can define
+    # named methods on the dataset instances which do specific actions.
+    # For example:
+    #
+    #   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
+    class DatasetModule < ::Module
+      meths = (<<-METHS).split.map(&:to_sym)
+        where exclude exclude_having having
+        distinct grep group group_and_count group_append 
+        limit offset order order_append order_prepend reverse 
+        select select_all select_append select_group select_prepend server
+      METHS
+
+      # Define a method in the module
+      def self.def_dataset_caching_method(mod, meth)
+        mod.send(:define_method, meth) do |name, *args, &block|
+          if block
+            define_method(name){public_send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            define_method(name) do
+              cached_dataset(key){public_send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths.each do |meth|
+        def_dataset_caching_method(self, meth)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # This module implements methods to support deprecated use of extensions registered
+    # not using a module.  In such cases, for backwards compatibility, Sequel has to use
+    # a singleton class for the dataset.
+    module DeprecatedSingletonClassMethods
+      # Load the extension into a clone of the receiver.
+      def extension(*a)
+        c = _clone(:freeze=>false)
+        c.send(:_extension!, a)
+        c.freeze
+      end
+
+      # Extend the cloned of the receiver with the given modules, instead of the default
+      # approach of creating a subclass of the receiver's class and including the modules
+      # into that.
+      def with_extend(*mods, &block)
+        c = _clone(:freeze=>false)
+        c.extend(*mods) unless mods.empty?
+        c.extend(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"}) if block
+        c.freeze
+      end
+
+      private
+
+      # Load the extensions into the receiver.
+      def _extension!(exts)
+        Sequel.extension(*exts)
+        exts.each do |ext|
+          if pr = Sequel.synchronize{EXTENSIONS[ext]}
+            pr.call(self)
+          else
+            raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+          end
+        end
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,284 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # ---------------------
+    # :section: 4 - Methods that describe what the dataset supports
+    # These methods all return booleans, with most describing whether or not the
+    # dataset supports a feature.
+    # ---------------------
+    
+    # Whether this dataset quotes identifiers.
+    def quote_identifiers?
+      @opts.fetch(:quote_identifiers, true)
+    end
+    
+    # Whether this dataset will provide accurate number of rows matched for
+    # delete and update statements, true by default.  Accurate in this case is the number of
+    # rows matched by the dataset's filter.
+    def provides_accurate_rows_matched?
+      true
+    end
+    
+    # Whether you must use a column alias list for recursive CTEs, false by default.
+    def recursive_cte_requires_column_aliases?
+      false
+    end
+
+    # :nocov:
+
+    # Whether the dataset requires SQL standard datetimes. False by default,
+    # as most allow strings with ISO 8601 format. Only for backwards compatibility,
+    # no longer used internally, do not use in new code.
+    def requires_sql_standard_datetimes?
+      # SEQUEL6: Remove
+      false
+    end
+    # :nocov:
+
+    # Whether type specifiers are required for prepared statement/bound
+    # variable argument placeholders (i.e. :bv__integer), false by default.
+    def requires_placeholder_type_specifiers?
+      false
+    end
+
+    # Whether the dataset supports common table expressions, false by default.
+    # If given, +type+ can be :select, :insert, :update, or :delete, in which case it
+    # determines whether WITH is supported for the respective statement type.
+    def supports_cte?(type=:select)
+      false
+    end
+
+    # Whether the dataset supports common table expressions in subqueries, false by default.
+    # If false, applies the WITH clause to the main query, which can cause issues
+    # if multiple WITH clauses use the same name.
+    def supports_cte_in_subqueries?
+      false
+    end
+
+    # Whether deleting from joined datasets is supported, false by default.
+    def supports_deleting_joins?
+      supports_modifying_joins?
+    end
+    
+    # Whether the database supports derived column lists (e.g.
+    # "table_expr AS table_alias(column_alias1, column_alias2, ...)"), true by
+    # default.
+    def supports_derived_column_lists?
+      true
+    end
+
+    # Whether the dataset supports or can emulate the DISTINCT ON clause, false by default.
+    def supports_distinct_on?
+      false
+    end
+
+    # Whether the dataset supports CUBE with GROUP BY, false by default.
+    def supports_group_cube?
+      false
+    end
+
+    # Whether the dataset supports ROLLUP with GROUP BY, false by default.
+    def supports_group_rollup?
+      false
+    end
+
+    # Whether the dataset supports GROUPING SETS with GROUP BY, false by default.
+    def supports_grouping_sets?
+      false
+    end
+
+    # Whether this dataset supports the +insert_select+ method for returning all columns values
+    # directly from an insert query, false by default.
+    def supports_insert_select?
+      supports_returning?(:insert)
+    end
+
+    # Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
+    def supports_intersect_except?
+      true
+    end
+
+    # Whether the dataset supports the INTERSECT ALL and EXCEPT ALL compound operations, true by default.
+    def supports_intersect_except_all?
+      true
+    end
+
+    # Whether the dataset supports the IS TRUE syntax, true by default.
+    def supports_is_true?
+      true
+    end
+    
+    # Whether the dataset supports the JOIN table USING (column1, ...) syntax, true by default.
+    # If false, support is emulated using JOIN table ON (table.column1 = other_table.column1).
+    def supports_join_using?
+      true
+    end
+    
+    # Whether the dataset supports LATERAL for subqueries in the FROM or JOIN clauses, false by default.
+    def supports_lateral_subqueries?
+      false
+    end
+
+    # Whether limits are supported in correlated subqueries, true by default.
+    def supports_limits_in_correlated_subqueries?
+      true
+    end
+    
+    # Whether the dataset supports skipping raising an error instead of waiting for locked rows when returning data, false by default.
+    def supports_nowait?
+      false
+    end
+
+    # Whether the MERGE statement is supported, false by default.
+    def supports_merge?
+      false
+    end
+
+    # Whether modifying joined datasets is supported, false by default.
+    def supports_modifying_joins?
+      false
+    end
+    
+    # Whether the IN/NOT IN operators support multiple columns when an
+    # array of values is given, true by default.
+    def supports_multiple_column_in?
+      true
+    end
+
+    # Whether offsets are supported in correlated subqueries, true by default.
+    def supports_offsets_in_correlated_subqueries?
+      true
+    end
+
+    # Whether the dataset supports or can fully emulate the DISTINCT ON clause,
+    # including respecting the ORDER BY clause, false by default.
+    def supports_ordered_distinct_on?
+      supports_distinct_on?
+    end
+    
+    # Whether placeholder literalizers are supported, true by default.
+    def supports_placeholder_literalizer?
+      true
+    end
+
+    # Whether the dataset supports pattern matching by regular expressions, false by default.
+    def supports_regexp?
+      false
+    end
+
+    # Whether the dataset supports REPLACE syntax, false by default.
+    def supports_replace?
+      false
+    end
+
+    # Whether the RETURNING clause is supported for the given type of query, false by default.
+    # +type+ can be :insert, :update, or :delete.
+    def supports_returning?(type)
+      false
+    end
+
+    # Whether the dataset supports skipping locked rows when returning data, false by default.
+    def supports_skip_locked?
+      false
+    end
+
+    # Whether the database supports <tt>SELECT *, column FROM table</tt>, true by default.
+    def supports_select_all_and_column?
+      true
+    end
+
+    # :nocov:
+
+    # Whether the dataset supports timezones in literal timestamps, false by default.
+    def supports_timestamp_timezones?
+      # SEQUEL6: Remove
+      false
+    end
+    # :nocov:
+    
+    # Whether the dataset supports fractional seconds in literal timestamps, true by default.
+    def supports_timestamp_usecs?
+      true
+    end
+    
+    # Whether updating joined datasets is supported, false by default.
+    def supports_updating_joins?
+      supports_modifying_joins?
+    end
+    
+    # Whether the dataset supports the WINDOW clause to define windows used by multiple
+    # window functions, false by default.
+    def supports_window_clause?
+      false
+    end
+
+    # Whether the dataset supports window functions, false by default.
+    def supports_window_functions?
+      false
+    end
+    
+    # Whether the dataset supports the given window function option.  True by default.
+    # This should only be called if supports_window_functions? is true. Possible options
+    # are :rows, :range, :groups, :offset, :exclude.
+    def supports_window_function_frame_option?(option)
+      case option
+      when :rows, :range, :offset
+        true
+      else
+        false
+      end
+    end
+    
+    # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
+    # that use 1 for true), true by default.
+    def supports_where_true?
+      true
+    end
+
+    private
+
+    # Whether insert(nil) or insert({}) must be emulated by
+    # using at least one value.
+    def insert_supports_empty_values?
+      true
+    end
+
+    # Whether the dataset needs ESCAPE for LIKE for correct behavior.
+    def requires_like_escape?
+      true
+    end
+
+    # Whether ORDER BY col NULLS FIRST/LAST must be emulated.
+    def requires_emulating_nulls_first?
+      false
+    end
+
+    # Whether common table expressions are supported in UNION/INTERSECT/EXCEPT clauses.
+    def supports_cte_in_compounds?
+      supports_cte_in_subqueries?
+    end
+
+    # Whether the dataset supports the FILTER clause for aggregate functions.
+    # If not, support is emulated using CASE.
+    def supports_filtered_aggregates?
+      false
+    end
+
+    # Whether the database supports quoting function names.
+    def supports_quoted_function_names?
+      false
+    end
+
+    # Whether the RETURNING clause is used for the given dataset.
+    # +type+ can be :insert, :update, or :delete.
+    def uses_returning?(type)
+      opts[:returning] && !@opts[:sql] && supports_returning?(type)
+    end
+    
+    # Whether the dataset uses WITH ROLLUP/CUBE instead of ROLLUP()/CUBE().
+    def uses_with_rollup?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,297 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # ---------------------
+    # :section: 5 - Methods related to dataset graphing
+    # Dataset graphing automatically creates unique aliases columns in join
+    # tables that overlap with already selected column aliases. 
+    # All of these methods return modified copies of the receiver.
+    # ---------------------
+    
+    # Adds the given graph aliases to the list of graph aliases to use,
+    # unlike +set_graph_aliases+, which replaces the list (the equivalent
+    # of +select_append+ when graphing).  See +set_graph_aliases+.
+    #
+    #   DB[:table].add_graph_aliases(some_alias: [:table, :column])
+    #   # SELECT ..., table.column AS some_alias
+    def add_graph_aliases(graph_aliases)
+      graph = opts[:graph]
+      unless (graph && (ga = graph[:column_aliases]))
+        raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
+      end
+      columns, graph_aliases = graph_alias_columns(graph_aliases)
+      select_append(*columns).clone(:graph => graph.merge(:column_aliases=>ga.merge(graph_aliases).freeze).freeze)
+    end
+
+    # Similar to Dataset#join_table, but uses unambiguous aliases for selected
+    # columns and keeps metadata about the aliases for use in other methods.
+    #
+    # Arguments:
+    # dataset :: Can be a symbol (specifying a table), another dataset,
+    #            or an SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression.
+    # join_conditions :: Any condition(s) allowed by +join_table+.
+    # block :: A block that is passed to +join_table+.
+    #
+    # Options:
+    # :from_self_alias :: The alias to use when the receiver is not a graphed
+    #                     dataset but it contains multiple FROM tables or a JOIN.  In this case,
+    #                     the receiver is wrapped in a from_self before graphing, and this option
+    #                     determines the alias to use.
+    # :implicit_qualifier :: The qualifier of implicit conditions, see #join_table.
+    # :join_only :: Only join the tables, do not change the selected columns.
+    # :join_type :: The type of join to use (passed to +join_table+).  Defaults to :left_outer.
+    # :qualify:: The type of qualification to do, see #join_table.
+    # :select :: An array of columns to select.  When not used, selects
+    #            all columns in the given dataset.  When set to false, selects no
+    #            columns and is like simply joining the tables, though graph keeps
+    #            some metadata about the join that makes it important to use +graph+ instead
+    #            of +join_table+.
+    # :table_alias :: The alias to use for the table.  If not specified, doesn't
+    #                 alias the table.  You will get an error if the alias (or table) name is
+    #                 used more than once.
+    def graph(dataset, join_conditions = nil, options = OPTS, &block)
+      # Allow the use of a dataset or symbol as the first argument
+      # Find the table name/dataset based on the argument
+      table_alias = options[:table_alias]
+      table = dataset
+      create_dataset = true
+
+      case dataset
+      when Symbol
+        # let alias be the same as the table name (sans any optional schema)
+        # unless alias explicitly given in the symbol using ___ notation and symbol splitting is enabled
+        table_alias ||= split_symbol(table).compact.last
+      when Dataset
+        if dataset.simple_select_all?
+          table = dataset.opts[:from].first
+          table_alias ||= table
+        else
+          table_alias ||= dataset_alias((@opts[:num_dataset_sources] || 0)+1)
+        end
+        create_dataset = false
+      when SQL::Identifier
+        table_alias ||= table.value
+      when SQL::QualifiedIdentifier
+        table_alias ||= split_qualifiers(table).last
+      when SQL::AliasedExpression
+        return graph(table.expression, join_conditions, {:table_alias=>table.alias}.merge!(options), &block)
+      else
+        raise Error, "The dataset argument should be a symbol or dataset"
+      end
+      table_alias = table_alias.to_sym
+
+      if create_dataset
+        dataset = db.from(table)
+      end
+
+      # Raise Sequel::Error with explanation that the table alias has been used
+      raise_alias_error = lambda do
+        raise(Error, "this #{options[:table_alias] ? 'alias' : 'table'} has already been been used, please specify " \
+          "#{options[:table_alias] ? 'a different alias' : 'an alias via the :table_alias option'}") 
+      end
+
+      # Only allow table aliases that haven't been used
+      raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
+      
+      table_alias_qualifier = qualifier_from_alias_symbol(table_alias, table)
+      implicit_qualifier = options[:implicit_qualifier]
+      joined_dataset = joined_dataset?
+      ds = self
+      graph = opts[:graph]
+
+      if !graph && (select = @opts[:select]) && !select.empty?
+        select_columns = nil
+
+        unless !joined_dataset && select.length == 1 && (select[0].is_a?(SQL::ColumnAll))
+          force_from_self = false
+          select_columns = select.map do |sel|
+            unless col = _hash_key_symbol(sel)
+              force_from_self = true
+              break
+            end
+
+            [sel, col]
+          end
+
+          select_columns = nil if force_from_self
+        end
+      end
+
+      # Use a from_self if this is already a joined table (or from_self specifically disabled for graphs)
+      if (@opts[:graph_from_self] != false && !graph && (joined_dataset || force_from_self))
+        from_selfed = true
+        implicit_qualifier = options[:from_self_alias] || first_source
+        ds = ds.from_self(:alias=>implicit_qualifier)
+      end
+      
+      # Join the table early in order to avoid cloning the dataset twice
+      ds = ds.join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias_qualifier, :implicit_qualifier=>implicit_qualifier, :qualify=>options[:qualify], &block)
+
+      return ds if options[:join_only]
+
+      opts = ds.opts
+
+      # Whether to include the table in the result set
+      add_table = options[:select] == false ? false : true
+
+      if graph
+        graph = graph.dup
+        select = opts[:select].dup
+        [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
+      else
+        # Setup the initial graph data structure if it doesn't exist
+        qualifier = ds.first_source_alias
+        master = alias_symbol(qualifier)
+        raise_alias_error.call if master == table_alias
+
+        # Master hash storing all .graph related information
+        graph = {}
+
+        # Associates column aliases back to tables and columns
+        column_aliases = graph[:column_aliases] = {}
+
+        # Associates table alias (the master is never aliased)
+        table_aliases = graph[:table_aliases] = {master=>self}
+
+        # Keep track of the alias numbers used
+        ca_num = graph[:column_alias_num] = Hash.new(0)
+
+        select = if select_columns
+          select_columns.map do |sel, column|
+            column_aliases[column] = [master, column]
+            if from_selfed
+              # Initial dataset was wrapped in subselect, selected all
+              # columns in the subselect, qualified by the subselect alias.
+              Sequel.qualify(qualifier, Sequel.identifier(column))
+            else
+              # Initial dataset not wrapped in subslect, just make
+              # sure columns are qualified in some way.
+              qualified_expression(sel, qualifier)
+            end
+          end
+        else
+          columns.map do |column|
+            column_aliases[column] = [master, column]
+            SQL::QualifiedIdentifier.new(qualifier, column)
+          end
+        end
+      end
+
+      # Add the table alias to the list of aliases
+      # Even if it isn't been used in the result set,
+      # we add a key for it with a nil value so we can check if it
+      # is used more than once
+      table_aliases = graph[:table_aliases]
+      table_aliases[table_alias] = add_table ? dataset : nil
+
+      # Add the columns to the selection unless we are ignoring them
+      if add_table
+        column_aliases = graph[:column_aliases]
+        ca_num = graph[:column_alias_num]
+        # Which columns to add to the result set
+        cols = options[:select] || dataset.columns
+        # If the column hasn't been used yet, don't alias it.
+        # If it has been used, try table_column.
+        # If that has been used, try table_column_N 
+        # using the next value of N that we know hasn't been
+        # used
+        cols.each do |column|
+          col_alias, identifier = if column_aliases[column]
+            column_alias = :"#{table_alias}_#{column}"
+            if column_aliases[column_alias]
+              column_alias_num = ca_num[column_alias]
+              column_alias = :"#{column_alias}_#{column_alias_num}" 
+              ca_num[column_alias] += 1
+            end
+            [column_alias, SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(table_alias_qualifier, column), column_alias)]
+          else
+            ident = SQL::QualifiedIdentifier.new(table_alias_qualifier, column)
+            [column, ident]
+          end
+          column_aliases[col_alias] = [table_alias, column].freeze
+          select.push(identifier)
+        end
+      end
+      [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k].freeze}
+      ds = ds.clone(:graph=>graph.freeze)
+      ds.select(*select)
+    end
+
+    # This allows you to manually specify the graph aliases to use
+    # when using graph.  You can use it to only select certain
+    # columns, and have those columns mapped to specific aliases
+    # in the result set.  This is the equivalent of +select+ for a
+    # graphed dataset, and must be used instead of +select+ whenever
+    # graphing is used.
+    #
+    # graph_aliases should be a hash with keys being symbols of
+    # column aliases, and values being either symbols or arrays with one to three elements.
+    # If the value is a symbol, it is assumed to be the same as a one element
+    # array containing that symbol.
+    # The first element of the array should be the table alias symbol.
+    # The second should be the actual column name symbol.  If the array only
+    # has a single element the column name symbol will be assumed to be the
+    # same as the corresponding hash key. If the array
+    # has a third element, it is used as the value returned, instead of
+    # table_alias.column_name.
+    #
+    #   DB[:artists].graph(:albums, :artist_id: :id).
+    #     set_graph_aliases(name: :artists,
+    #                       album_name: [:albums, :name],
+    #                       forty_two: [:albums, :fourtwo, 42]).first
+    #   # SELECT artists.name, albums.name AS album_name, 42 AS forty_two ...
+    def set_graph_aliases(graph_aliases)
+      columns, graph_aliases = graph_alias_columns(graph_aliases)
+      if graph = opts[:graph]
+        select(*columns).clone(:graph => graph.merge(:column_aliases=>graph_aliases.freeze).freeze)
+      else
+        raise Error, "cannot call #set_graph_aliases on an ungraphed dataset"
+      end
+    end
+
+    # Remove the splitting of results into subhashes, and all metadata
+    # related to the current graph (if any).
+    def ungraphed
+      return self unless opts[:graph]
+      clone(:graph=>nil)
+    end
+
+    private
+
+    # Wrap the alias symbol in an SQL::Identifier if the identifier on which is based
+    # is an SQL::Identifier.  This works around cases where symbol splitting is enabled and the alias symbol contains
+    # double embedded underscores which would be considered an implicit qualified identifier
+    # if not wrapped in an SQL::Identifier.
+    def qualifier_from_alias_symbol(aliaz, identifier)
+      case identifier
+      when SQL::QualifiedIdentifier
+        if identifier.column.is_a?(String)
+          Sequel.identifier(aliaz)
+        else
+          aliaz
+        end
+      when SQL::Identifier
+        Sequel.identifier(aliaz)
+      else
+        aliaz
+      end
+    end
+
+    # Transform the hash of graph aliases and return a two element array
+    # where the first element is an array of identifiers suitable to pass to
+    # a select method, and the second is a new hash of preprocessed graph aliases.
+    def graph_alias_columns(graph_aliases)
+      gas = {}
+      identifiers = graph_aliases.map do |col_alias, tc| 
+        table, column, value = Array(tc)
+        column ||= col_alias
+        gas[col_alias] = [table, column].freeze
+        identifier = value || SQL::QualifiedIdentifier.new(table, column)
+        identifier = SQL::AliasedExpression.new(identifier, col_alias) if value || column != col_alias
+        identifier
+      end
+      [identifiers, gas]
+    end
+  end
+end