serrano-vk 0.1.0

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

@@ -0,0 +1,84 @@
+# frozen-string-literal: true
+#
+# The mssql_emulate_lateral_with_apply extension converts
+# queries that use LATERAL into queries that use CROSS/OUTER
+# APPLY, allowing code that works on databases that support
+# LATERAL via Dataset#lateral to run on Microsoft SQL Server
+# and Sybase SQLAnywhere.
+#
+# This is available as a separate extension instead of
+# integrated into the Microsoft SQL Server and Sybase
+# SQLAnywhere support because few people need it and there
+# is a performance hit to code that doesn't use it.
+#
+# It is possible there are cases where this emulation does
+# not work.  Users should probably verify that correct
+# results are returned when using this extension.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:mssql_emulate_lateral_with_apply)
+#
+# Or you can load it into all of a database's datasets:
+#
+#   DB.extension(:mssql_emulate_lateral_with_apply)
+#
+# Related module: Sequel::MSSQL::EmulateLateralWithApply
+
+#
+module Sequel
+  module MSSQL
+    module EmulateLateralWithApply
+      # If the table is a dataset that uses LATERAL,
+      # convert it to a CROSS APPLY if it is a INNER
+      # or CROSS JOIN, and an OUTER APPLY if it is a
+      # LEFT JOIN.
+      def join_table(type, table, expr=nil, *)
+        if table.is_a?(Dataset) && table.opts[:lateral]
+          table = table.clone(:lateral=>nil)
+          case type
+          when :inner
+            type = :cross_apply
+            table = table.where(expr)
+            expr = nil
+          when :cross
+            type = :cross_apply
+          when :left, :left_outer
+            type = :outer_apply
+            table = table.where(expr)
+            expr = nil
+          end
+        end
+        super
+      end
+
+      # When a FROM entry uses a LATERAL subquery,
+      # convert that entry into a CROSS APPLY.
+      def from(*source, &block)
+        virtual_row_columns(source, block)
+        lateral, source = source.partition{|t| t.is_a?(Sequel::Dataset) && t.opts[:lateral] || (t.is_a?(Sequel::SQL::AliasedExpression) && t.expression.is_a?(Sequel::Dataset) && t.expression.opts[:lateral])} unless source.empty?
+        return super(*source, &nil) if !lateral || lateral.empty?
+
+        ds = from(*source)
+        lateral.each do |l|
+          l = if l.is_a?(Sequel::SQL::AliasedExpression)
+            l.expression.clone(:lateral=>nil).as(l.alias)
+          else
+            l.clone(:lateral=>nil)
+          end
+          ds = ds.cross_apply(l)
+        end
+        ds
+      end
+      
+      # MSSQL can emulate lateral subqueries via CROSS/OUTER APPLY
+      # when using this extension.
+      def supports_lateral_subqueries?
+        true
+      end
+    end
+  end
+
+  Dataset.register_extension(:mssql_emulate_lateral_with_apply, MSSQL::EmulateLateralWithApply)
+end

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

@@ -0,0 +1,184 @@
+# frozen-string-literal: true
+#
+# Allows the use of named timezones via TZInfo (requires tzinfo).
+# Forces the use of DateTime as Sequel's datetime_class, since
+# historically, Ruby's Time class doesn't support timezones other
+# than local and UTC. To continue using Ruby's Time class when using
+# the named_timezones extension:
+#
+#   # Load the extension
+#   Sequel.extension :named_timezones
+#
+#   # Set Sequel.datetime_class back to Time
+#   Sequel.datetime_class = Time
+#
+# This allows you to either pass strings or TZInfo::Timezone
+# instance to Sequel.database_timezone=, application_timezone=, and
+# typecast_timezone=.  If a string is passed, it is converted to a
+# TZInfo::Timezone using TZInfo::Timezone.get.
+#
+# Let's say you have the database server in New York and the
+# application server in Los Angeles.  For historical reasons, data
+# is stored in local New York time, but the application server only
+# services clients in Los Angeles, so you want to use New York
+# time in the database and Los Angeles time in the application.  This
+# is easily done via:
+#
+#   Sequel.database_timezone = 'America/New_York'
+#   Sequel.application_timezone = 'America/Los_Angeles'
+#
+# Then, before data is stored in the database, it is converted to New
+# York time.  When data is retrieved from the database, it is
+# converted to Los Angeles time.
+#
+# If you are using database specific timezones, you may want to load
+# this extension into the database in order to support similar API:
+#
+#   DB.extension :named_timezones
+#   DB.timezone = 'America/New_York'
+#
+# Note that typecasting from the database timezone to the application
+# timezone when fetching rows is dependent on the database adapter,
+# and only works on adapters where Sequel itself does the conversion.
+# It should work with the mysql, postgres, sqlite, ibmdb, and jdbc
+# adapters.
+#
+# Related module: Sequel::NamedTimezones
+
+require 'tzinfo'
+
+#
+module Sequel
+  self.datetime_class = DateTime
+  
+  module NamedTimezones
+    module DatabaseMethods
+      def timezone=(tz)
+        super(Sequel.send(:convert_timezone_setter_arg, tz))
+      end
+    end
+
+    # Handles TZInfo::AmbiguousTime exceptions automatically by providing a
+    # proc called with both the datetime value being converted as well as
+    # the array of TZInfo::TimezonePeriod results. Example:
+    #
+    #   Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
+    attr_accessor :tzinfo_disambiguator
+
+    private 
+    
+    if RUBY_VERSION >= '2.6'
+      # Whether Time.at with :nsec and :in is broken.  True on JRuby < 9.3.9.0.
+      BROKEN_TIME_AT_WITH_NSEC = defined?(JRUBY_VERSION) && (JRUBY_VERSION < '9.3' || (JRUBY_VERSION < '9.4' && JRUBY_VERSION.split('.')[2].to_i < 9))
+      private_constant :BROKEN_TIME_AT_WITH_NSEC
+
+      # Convert the given input Time (which must be in UTC) to the given input timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_input_time_other(v, input_timezone)
+        Time.new(v.year, v.mon, v.day, v.hour, v.min, (v.sec + Rational(v.nsec, 1000000000)), input_timezone)
+      rescue TZInfo::AmbiguousTime
+        raise unless disamb = tzinfo_disambiguator_for(v)
+        period = input_timezone.period_for_local(v, &disamb)
+        offset = period.utc_total_offset
+        # :nocov:
+        if BROKEN_TIME_AT_WITH_NSEC
+          Time.at(v.to_i - offset, :in => input_timezone) + v.nsec/1000000000.0
+        # :nocov:
+        else
+          Time.at(v.to_i - offset, v.nsec, :nsec, :in => input_timezone)
+        end
+      end
+
+      # Convert the given input Time to the given output timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_output_time_other(v, output_timezone)
+        # :nocov:
+        if BROKEN_TIME_AT_WITH_NSEC
+          Time.at(v.to_i, :in => output_timezone) + v.nsec/1000000000.0
+        # :nocov:
+        else
+          Time.at(v.to_i, v.nsec, :nsec, :in => output_timezone)
+        end
+      end
+      # :nodoc:
+      # :nocov:
+    else
+      def convert_input_time_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0 
+      end
+
+      if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0 + local_offset
+        end
+      else
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + v.nsec/1000000000.0
+        end
+      end
+      # :nodoc:
+      # :nocov:
+    end
+
+    # Handle both TZInfo 1 and TZInfo 2
+    if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      def convert_output_datetime_other(v, output_timezone)
+        v = output_timezone.utc_to_local(v.new_offset(0))
+
+        # Force DateTime output instead of TZInfo::DateTimeWithOffset
+        DateTime.civil(v.year, v.month, v.day, v.hour, v.minute, v.second + v.sec_fraction, v.offset, v.start)
+      end
+      # :nodoc:
+      # :nocov:
+    else
+      # Assume the given DateTime has a correct time but a wrong timezone.  It is
+      # currently in UTC timezone, but it should be converted to the input_timezone.
+      # Keep the time the same but convert the timezone to the input_timezone.
+      # Expects the input_timezone to be a TZInfo::Timezone instance.
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      # Convert the given DateTime to use the given output_timezone.
+      # Expects the output_timezone to be a TZInfo::Timezone instance.
+      def convert_output_datetime_other(v, output_timezone)
+        # TZInfo 1 converts times, but expects the given DateTime to have an offset
+        # of 0 and always leaves the timezone offset as 0
+        v = output_timezone.utc_to_local(v.new_offset(0))
+        local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        # Convert timezone offset from UTC to the offset for the output_timezone
+        (v - local_offset).new_offset(local_offset)
+      end
+      # :nodoc:
+      # :nocov:
+    end
+    
+    # Returns TZInfo::Timezone instance if given a String.
+    def convert_timezone_setter_arg(tz)
+      tz.is_a?(String) ? TZInfo::Timezone.get(tz) : super
+    end
+
+    # Return a disambiguation proc that provides both the datetime value
+    # and the periods, in order to allow the choice of period to depend
+    # on the datetime value.
+    def tzinfo_disambiguator_for(v)
+      if pr = @tzinfo_disambiguator
+        proc{|periods| pr.call(v, periods)}
+      end
+    end
+  end
+  
+  extend NamedTimezones
+  Database.register_extension(:named_timezones, NamedTimezones::DatabaseMethods)
+end

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

@@ -0,0 +1,4 @@
+# frozen-string-literal: true
+
+Sequel::Database.register_extension(:no_auto_literal_strings){}
+Sequel::Dataset.register_extension(:no_auto_literal_strings){}

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

@@ -0,0 +1,109 @@
+# frozen-string-literal: true
+#
+# The null_dataset extension adds the Dataset#nullify method, which
+# returns a cloned dataset that will never issue a query to the
+# database.  It implements the null object pattern for datasets.
+#
+# The most common usage is probably in a method that must return
+# a dataset, where the method knows the dataset shouldn't return
+# anything.  With standard Sequel, you'd probably just add a
+# WHERE condition that is always false, but that still results
+# in a query being sent to the database, and can be overridden
+# using #unfiltered, the OR operator, or a UNION.
+#
+# Usage:
+#
+#   ds = DB[:items].nullify.where(a: :b).select(:c)
+#   ds.sql # => "SELECT c FROM items WHERE (a = b)"
+#   ds.all # => [] # no query sent to the database
+#
+# Note that there is one case where a null dataset will sent
+# a query to the database.  If you call #columns on a nulled
+# dataset and the dataset doesn't have an already cached
+# version of the columns, it will create a new dataset with
+# the same options to get the columns.
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
+#
+# To add the nullify method to a single dataset:
+#
+#   ds = ds.extension(:null_dataset)
+#
+# To add the nullify method to all datasets on a single database:
+#
+#   DB.extension(:null_dataset)
+#
+# Related modules: Sequel::Dataset::Nullifiable, Sequel::Dataset::NullDataset
+
+#
+module Sequel
+  class Dataset
+    module Nullifiable
+      # Return a cloned nullified dataset.
+      def nullify
+        cached_dataset(:_nullify_ds) do
+          with_extend(NullDataset)
+        end
+      end
+    end
+
+    module NullDataset
+      # Create a new dataset from the dataset (which won't
+      # be nulled) to get the columns if they aren't already cached.
+      def columns
+        if cols = _columns
+          return cols
+        end
+        self.columns = db.dataset.clone(@opts).columns
+      end
+
+      # Return 0 without sending a database query.
+      def delete
+        0
+      end
+
+      # Return self without sending a database query, never yielding.
+      def each(&_)
+        self
+      end
+
+      # Return nil without sending a database query, never yielding.
+      def fetch_rows(sql, &_)
+        nil
+      end
+
+      # Return nil without sending a database query.
+      def insert(*)
+        nil
+      end
+
+      # Return nil without sending a database query.
+      def truncate
+        nil
+      end
+
+      # Return 0 without sending a database query.
+      def update(v=OPTS)
+        0
+      end
+
+      protected
+
+      # Return nil without sending a database query.
+      def _import(columns, values, opts)
+        nil
+      end
+
+      private
+
+      # Just in case these are called directly by some internal code,
+      # make them noops.  There's nothing we can do if the db
+      # is accessed directly to make a change, though.
+      (%w'_ddl _dui _insert' << '').each do |m|
+        class_eval("private; def execute#{m}(sql, opts=OPTS) end", __FILE__, __LINE__)
+      end
+    end
+  end
+
+  Dataset.register_extension(:null_dataset, Dataset::Nullifiable)
+end

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

@@ -0,0 +1,140 @@
+# frozen-string-literal: true
+#
+# The pagination extension adds the Sequel::Dataset#paginate and #each_page methods,
+# which return paginated (limited and offset) datasets with the following methods
+# added that make creating a paginated display easier:
+#
+# * +page_size+
+# * +page_count+
+# * +page_range+
+# * +current_page+
+# * +next_page+
+# * +prev_page+
+# * +first_page?+
+# * +last_page?+
+# * +pagination_record_count+
+# * +current_page_record_count+
+# * +current_page_record_range+
+#
+# This extension uses Object#extend at runtime, which can hurt performance.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:pagination)
+#
+# 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(:pagination)
+#
+# Related modules: Sequel::DatasetPagination, Sequel::Dataset::Pagination
+
+#
+module Sequel
+  module DatasetPagination
+    # Returns a paginated dataset. The returned dataset is limited to
+    # the page size at the correct offset, and extended with the Pagination
+    # module.  If a record count is not provided, does a count of total
+    # number of records for this dataset.
+    def paginate(page_no, page_size, record_count=nil)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+
+      record_count ||= count
+      page_count = (record_count / page_size.to_f).ceil
+      page_count = 1 if page_count == 0
+
+      limit(page_size, (page_no - 1) * page_size).
+        with_extend(Dataset::Pagination).
+        clone(:page_size=>page_size, :current_page=>page_no, :pagination_record_count=>record_count, :page_count=>page_count)
+    end
+      
+    # Yields a paginated dataset for each page and returns the receiver. Does
+    # a count to find the total number of records for this dataset. Returns
+    # an enumerator if no block is given.
+    def each_page(page_size)
+      raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
+      return to_enum(:each_page, page_size) unless defined?(yield)
+      record_count = count
+      total_pages = (record_count / page_size.to_f).ceil
+      (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}
+      self
+    end
+  end
+
+  class Dataset
+    # Holds methods that only relate to paginated datasets. Paginated dataset
+    # have pages starting at 1 (page 1 is offset 0, page 2 is offset 1 * page_size).
+    module Pagination
+      # The number of records per page (the final page may have fewer than
+      # this number of records).
+      def page_size
+        @opts[:page_size]
+      end
+
+      # The number of pages in the dataset before pagination, of which
+      # this paginated dataset is one.  Empty datasets are considered
+      # to have a single page.
+      def page_count
+        @opts[:page_count]
+      end
+
+      # The current page of the dataset, starting at 1 and not 0.
+      def current_page
+        @opts[:current_page]
+      end
+
+      # The total number of records in the dataset before pagination.
+      def pagination_record_count
+        @opts[:pagination_record_count]
+      end
+
+      # Returns the record range for the current page
+      def current_page_record_range
+        return (0..0) if current_page > page_count
+        
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
+        a..b
+      end
+
+      # Returns the number of records in the current page
+      def current_page_record_count
+        return 0 if current_page > page_count
+        
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
+        b - a + 1
+      end
+
+      # Returns true if the current page is the first page
+      def first_page?
+        current_page == 1
+      end
+
+      # Returns true if the current page is the last page
+      def last_page?
+        current_page == page_count
+      end
+
+      # Returns the next page number or nil if the current page is the last page
+      def next_page
+        current_page < page_count ? (current_page + 1) : nil
+      end
+      
+      # Returns the page range
+      def page_range
+        1..page_count
+      end
+      
+      # Returns the previous page number or nil if the current page is the first
+      def prev_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+    end
+  end
+
+  Dataset.register_extension(:pagination, DatasetPagination)
+end