tdiary 5.1.7 → 5.2.0

data/vendor/bundle/ruby/3.0.0/gems/sequel-5.50.0/lib/sequel/extensions/pg_range_ops.rb

@@ -0,0 +1,195 @@
+# frozen-string-literal: true
+#
+# The pg_range_ops extension adds support to Sequel's DSL to make
+# it easier to call PostgreSQL range and multirange functions and operators.
+#
+# To load the extension:
+#
+#   Sequel.extension :pg_range_ops
+#
+# The most common usage is passing an expression to Sequel.pg_range_op:
+#
+#   r = Sequel.pg_range_op(:range)
+#
+# If you have also loaded the pg_range or pg_multirange extensions, you can use
+# Sequel.pg_range or Sequel.pg_multirange as well:
+#
+#   r = Sequel.pg_range(:range)
+#   r = Sequel.pg_multirange(:range)
+#
+# Also, on most Sequel expression objects, you can call the pg_range
+# method:
+#
+#   r = Sequel[:range].pg_range
+#
+# If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
+# or you have loaded the core_refinements extension
+# and have activated refinements for the file, you can also use Symbol#pg_range:
+#
+#   r = :range.pg_range
+#
+# This creates a Sequel::Postgres::RangeOp object that can be used
+# for easier querying:
+#
+#   r.contains(:other)      # range @> other
+#   r.contained_by(:other)  # range <@ other
+#   r.overlaps(:other)      # range && other
+#   r.left_of(:other)       # range << other
+#   r.right_of(:other)      # range >> other
+#   r.starts_after(:other)  # range &> other
+#   r.ends_before(:other)   # range &< other
+#   r.adjacent_to(:other)   # range -|- other
+#
+#   r.lower            # lower(range)
+#   r.upper            # upper(range)
+#   r.isempty          # isempty(range)
+#   r.lower_inc        # lower_inc(range)
+#   r.upper_inc        # upper_inc(range)
+#   r.lower_inf        # lower_inf(range)
+#   r.upper_inf        # upper_inf(range)
+#
+# All of the above methods work for both ranges and multiranges, as long
+# as PostgreSQL supports the operation. The following methods are also
+# supported:
+#
+#   r.range_merge      # range_merge(range)
+#   r.unnest           # unnest(range)
+#   r.multirange       # multirange(range)
+#
+# +range_merge+ and +unnest+ expect the receiver to represent a multirange
+# value, while +multi_range+ expects the receiver to represent a range value.
+#   
+# See the PostgreSQL range and multirange function and operator documentation for more
+# details on what these functions and operators do.
+#
+# If you are also using the pg_range or pg_multirange extension, you should
+# load them before loading this extension.  Doing so will allow you to use
+# PGRange#op and PGMultiRange#op to get a RangeOp, allowing you to perform
+# range operations on range literals.
+#
+# Related module: Sequel::Postgres::RangeOp
+
+#
+module Sequel
+  module Postgres
+    # The RangeOp class is a simple container for a single object that
+    # defines methods that yield Sequel expression objects representing
+    # PostgreSQL range operators and functions.
+    #
+    # Most methods in this class are defined via metaprogramming, see
+    # the pg_range_ops extension documentation for details on the API.
+    class RangeOp < Sequel::SQL::Wrapper
+      OPERATORS = {
+        :contains => ["(".freeze, " @> ".freeze, ")".freeze].freeze,
+        :contained_by => ["(".freeze, " <@ ".freeze, ")".freeze].freeze,
+        :left_of => ["(".freeze, " << ".freeze, ")".freeze].freeze,
+        :right_of => ["(".freeze, " >> ".freeze, ")".freeze].freeze,
+        :ends_before => ["(".freeze, " &< ".freeze, ")".freeze].freeze,
+        :starts_after => ["(".freeze, " &> ".freeze, ")".freeze].freeze,
+        :adjacent_to => ["(".freeze, " -|- ".freeze, ")".freeze].freeze,
+        :overlaps => ["(".freeze, " && ".freeze, ")".freeze].freeze,
+      }.freeze
+
+      %w'lower upper isempty lower_inc upper_inc lower_inf upper_inf unnest'.each do |f|
+        class_eval("def #{f}; function(:#{f}) end", __FILE__, __LINE__)
+      end
+      %w'range_merge multirange'.each do |f|
+        class_eval("def #{f}; RangeOp.new(function(:#{f})) end", __FILE__, __LINE__)
+      end
+      OPERATORS.each_key do |f|
+        class_eval("def #{f}(v); operator(:#{f}, v) end", __FILE__, __LINE__)
+      end
+
+      # These operators are already supported by the wrapper, but for ranges they
+      # return ranges, so wrap the results in another RangeOp.
+      %w'+ * -'.each do |f|
+        class_eval("def #{f}(v); RangeOp.new(super) end", __FILE__, __LINE__)
+      end
+
+      # Return the receiver.
+      def pg_range
+        self
+      end
+
+      private
+
+      # Create a boolen expression for the given type and argument.
+      def operator(type, other)
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(OPERATORS[type], [value, other]))
+      end
+
+      # Return a function called with the receiver.
+      def function(name)
+        Sequel::SQL::Function.new(name, self)
+      end
+    end
+
+    module RangeOpMethods
+      # Wrap the receiver in an RangeOp so you can easily use the PostgreSQL
+      # range functions and operators with it.
+      def pg_range
+        RangeOp.new(self)
+      end
+    end
+
+    # :nocov:
+    if defined?(PGRange)
+    # :nocov:
+      class PGRange
+        # Wrap the PGRange instance in an RangeOp, allowing you to easily use
+        # the PostgreSQL range functions and operators with literal ranges.
+        def op
+          RangeOp.new(self)
+        end
+      end
+    end
+
+    # :nocov:
+    if defined?(PGMultiRange)
+    # :nocov:
+      class PGMultiRange
+        # Wrap the PGRange instance in an RangeOp, allowing you to easily use
+        # the PostgreSQL range functions and operators with literal ranges.
+        def op
+          RangeOp.new(self)
+        end
+      end
+    end
+  end
+
+  module SQL::Builders
+    # Return the expression wrapped in the Postgres::RangeOp.
+    def pg_range_op(v)
+      case v
+      when Postgres::RangeOp
+        v
+      else
+        Postgres::RangeOp.new(v)
+      end
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::Postgres::RangeOpMethods
+  end
+
+  class LiteralString
+    include Sequel::Postgres::RangeOpMethods
+  end
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::Postgres::RangeOpMethods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::RangeOpMethods
+    end
+  end
+end
+# :nocov:

data/vendor/bundle/ruby/3.0.0/gems/sequel-5.50.0/lib/sequel/extensions/sql_log_normalizer.rb

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+#
+# The sql_log_normalizer extension normalizes the SQL that is logged,
+# removing the literal strings and numbers in the SQL, and removing the
+# logging of any bound variables:
+#
+#   ds = DB[:table].first(a: 1, b: 'something')
+#   # Without sql_log_normalizer extension
+#   # SELECT * FROM "table" WHERE (("a" = 1) AND ("b" = 'something')) LIMIT 1
+#
+#   # With sql_log_normalizer_extension
+#   # SELECT * FROM "table" WHERE (("a" = ?) AND ("b" = ?)) LIMIT ?
+#
+# The normalization is done by scanning the SQL string being executed
+# for literal strings and numbers, and replacing them with question
+# marks.  While this should work for all or almost all production queries,
+# there are pathlogical queries that will not be handled correctly, such as
+# the use of apostrophes in identifiers:
+#
+#   DB[:"asf'bar"].where(a: 1, b: 'something').first
+#   # Logged as:
+#   # SELECT * FROM "asf?something')) LIMIT ?
+#
+# The expected use case for this extension is when you want to normalize
+# logs to group similar queries, or when you want to protect sensitive
+# data from being stored in the logs.
+#
+# Related module: Sequel::SQLLogNormalizer
+
+#
+module Sequel
+  module SQLLogNormalizer
+    def self.extended(db)
+      type = case db.literal("'")
+      when "''''"
+        :standard
+      when "'\\''"
+        :backslash
+      when "N''''"
+        :n_standard
+      else
+        raise Error, "SQL log normalization is not supported on this database (' literalized as #{db.literal("'").inspect})"
+      end
+      db.instance_variable_set(:@sql_string_escape_type, type)
+    end
+
+    # Normalize the SQL before calling super.
+    def log_connection_yield(sql, conn, args=nil)
+      unless skip_logging?
+        sql = normalize_logged_sql(sql)
+        args = nil
+      end
+      super
+    end
+
+    # Replace literal strings and numbers in SQL with question mark placeholders.
+    def normalize_logged_sql(sql)
+      sql = sql.dup
+      sql.force_encoding('BINARY')
+      start_index = 0
+      check_n = @sql_string_escape_type == :n_standard
+      outside_string = true
+
+      if @sql_string_escape_type == :backslash
+        search_char = /[\\']/
+        escape_char_offset = 0
+        escape_char_value = 92 # backslash
+      else
+        search_char = "'"
+        escape_char_offset = 1
+        escape_char_value = 39 # apostrophe
+      end
+
+      # The approach used here goes against Sequel's philosophy of never attempting
+      # to parse SQL.  However, parsing the SQL is basically the only way to implement
+      # this support with Sequel's design, and it's better to be pragmatic and accept
+      # this than not be able to support this.
+
+      # Replace literal strings
+      while outside_string && (index = start_index = sql.index("'", start_index))
+        if check_n && index != 0 && sql.getbyte(index-1) == 78 # N' start
+          start_index -= 1
+        end
+        index += 1
+        outside_string = false
+
+        while (index = sql.index(search_char, index)) && (sql.getbyte(index + escape_char_offset) == escape_char_value)
+          # skip escaped characters inside string literal
+          index += 2
+        end
+
+        if index
+          # Found end of string
+          sql[start_index..index] = '?'
+          start_index += 1
+          outside_string = true
+        end
+      end
+
+      # Replace integer and decimal floating point numbers
+      sql.gsub!(/\b-?\d+(?:\.\d+)?\b/, '?')
+
+      sql
+    end
+  end
+
+  Database.register_extension(:sql_log_normalizer, SQLLogNormalizer)
+end

data/vendor/bundle/ruby/3.0.0/gems/sequel-5.50.0/lib/sequel/extensions/string_agg.rb

@@ -0,0 +1,181 @@
+# frozen-string-literal: true
+#
+# The string_agg extension adds the ability to perform database-independent
+# aggregate string concatentation.  For example, with a table like:
+#
+#   c1 | c2
+#   ---+---
+#   a  | 1
+#   a  | 2
+#   a  | 3
+#   b  | 4
+#
+# You can return a result set like:
+#
+#   c1 | c2s
+#   ---+---
+#   a  | 1,2,3
+#   b  | 4
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :string_agg
+#
+# Then you can use the Sequel.string_agg method to return a Sequel
+# expression:
+#
+#   sa = Sequel.string_agg(:column_name)
+#   # or:
+#   sa = Sequel.string_agg(:column_name, '-') # custom separator
+#
+# You can specify the order in which the concatention happens by
+# calling +order+ on the expression:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column)
+#
+# Additionally, if you want to have the concatenation only operate
+# on distinct values, you can call distinct:
+#
+#   sa = Sequel.string_agg(:column_name).order(:other_column).distinct
+#
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].
+#     select_group(:c1).
+#     select_append(Sequel.string_agg(:c2))
+#
+# This extension currenly supports the following databases:
+#
+# * PostgreSQL 9+
+# * SQLAnywhere 12+
+# * Oracle 11g+ (except distinct)
+# * DB2 9.7+ (except distinct)
+# * MySQL
+# * HSQLDB
+# * H2
+#
+# Related module: Sequel::SQL::StringAgg
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a StringAgg expression for an aggregate string concatentation.
+      def string_agg(*a)
+        StringAgg.new(*a)
+      end
+    end
+
+    # The StringAgg class represents an aggregate string concatentation.
+    class StringAgg < GenericExpression
+      include StringMethods
+      include StringConcatenationMethods
+      include InequalityMethods
+      include AliasMethods
+      include CastMethods
+      include OrderMethods
+      include PatternMatchMethods
+      include SubscriptMethods
+
+      # These methods are added to datasets using the string_agg
+      # extension, for the purposes of correctly literalizing StringAgg
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the StringAgg expression to the SQL query.
+        def string_agg_sql_append(sql, sa)
+          if defined?(super)
+            return super
+          end
+
+          expr = sa.expr
+          separator = sa.separator || ","
+          order = sa.order_expr
+          distinct = sa.is_distinct?
+
+          case db_type = db.database_type
+          when :postgres, :sqlanywhere
+            f = Function.new(db_type == :postgres ? :string_agg : :list, expr, separator)
+            if order
+              f = f.order(*order)
+            end
+            if distinct
+              f = f.distinct
+            end
+            literal_append(sql, f)
+          when :mysql, :hsqldb, :h2
+            sql << "GROUP_CONCAT("
+            if distinct
+              sql << "DISTINCT "
+            end
+            literal_append(sql, expr)
+            if order
+              sql << " ORDER BY "
+              expression_list_append(sql, order)
+            end
+            sql << " SEPARATOR "
+            literal_append(sql, separator)
+            sql << ")"
+          when :oracle, :db2
+            if distinct
+              raise Error, "string_agg with distinct is not implemented on #{db.database_type}"
+            end
+            literal_append(sql, Function.new(:listagg, expr, separator))
+            if order
+              sql << " WITHIN GROUP (ORDER BY "
+              expression_list_append(sql, order)
+              sql << ")"
+            else
+              sql << " WITHIN GROUP (ORDER BY 1)"
+            end
+          else
+            raise Error, "string_agg is not implemented on #{db.database_type}"
+          end
+        end
+      end
+
+      # The string expression for each row that will concatenated to the output.
+      attr_reader :expr
+
+      # The separator between each string expression.
+      attr_reader :separator
+
+      # The expression that the aggregation is ordered by.
+      attr_reader :order_expr
+
+      # Set the expression and separator
+      def initialize(expr, separator=nil)
+        @expr = expr
+        @separator = separator
+        yield self if defined?(yield)
+        freeze
+      end
+
+      # Whether the current expression uses distinct expressions 
+      def is_distinct?
+        @distinct == true
+      end
+
+      # Return a modified StringAgg that uses distinct expressions
+      def distinct
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@order_expr, @order_expr) if @order_expr
+          sa.instance_variable_set(:@distinct, true)
+        end
+      end
+
+      # Return a modified StringAgg with the given order
+      def order(*o)
+        self.class.new(@expr, @separator) do |sa|
+          sa.instance_variable_set(:@distinct, @distinct) if @distinct
+          sa.instance_variable_set(:@order_expr, o.empty? ? nil : o.freeze)
+        end
+      end
+
+      to_s_method :string_agg_sql
+    end
+  end
+
+  Dataset.register_extension(:string_agg, SQL::StringAgg::DatasetMethods)
+end
+