activerecord-refined 0.9.0 → 0.10.1

data/lib/active_record/refined/dialect/mariadb.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # MariaDB, which answers to the MySQL adapter but has no JSON type and no
+      # LATERAL.
+      class Mariadb < MysqlCompat
+        def check_lateral(_model)
+          raise NotImplementedError, "a lateral join has no equivalent on MariaDB"
+        end
+
+        # MariaDB has no JSON type, so a JSON comparison is refused.
+        def json_literal(_json, _model)
+          raise NotImplementedError,
+            "a JSON comparison has no equivalent on MariaDB; dig_text gives the value"
+        end
+
+        def check_json_aggregate_window(source, _model)
+          raise NotImplementedError, "#{source} over a window has no equivalent on MariaDB"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/refined/dialect/mysql.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # MySQL proper, which has a JSON type of its own where MariaDB has only
+      # the text.
+      class Mysql < MysqlCompat
+        # MySQL has a JSON type, so a Ruby value is cast to it; a bare string
+        # beside JSON would be a JSON string, outranking every number.
+        def json_literal(json, _model)
+          Arel::Nodes::NamedFunction.new(
+            "CAST", [Arel::Nodes::As.new(json, Arel::Nodes::SqlLiteral.new("JSON"))])
+        end
+      end
+    end
+  end
+end

data/lib/active_record/refined/dialect/mysql_compat.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # What MySQL and MariaDB share, which is most of it; the two part company
+      # only in the Mysql and Mariadb subclasses.
+      class MysqlCompat < Dialect
+        FUNCTIONS = { trunc: "TRUNCATE", date_trunc: nil, format: nil }.freeze
+
+        def full_outer_join_supported? = false
+        def filter_supported? = false
+
+        def bit_count(expr, _model)
+          AST::Function.new("BIT_COUNT", [expr])
+        end
+
+        # The excluded row is VALUES(column), which takes the column bare.
+        def excluded(column, model)
+          quoted = model.with_connection { |connection| connection.quote_column_name(column) }
+          AST::Function.new("VALUES", [Arel::Nodes::SqlLiteral.new(quoted)])
+        end
+
+        def bitwise_xor(left, right)
+          Arel::Nodes::BitwiseXor.new(left, right)
+        end
+
+        def json_path(document, dollar_path, _steps, json_value, _model)
+          extracted = Arel::Nodes::NamedFunction.new(
+            "JSON_EXTRACT", [document, Arel::Nodes.build_quoted(dollar_path)])
+          return extracted if json_value
+          Arel::Nodes::NamedFunction.new("JSON_UNQUOTE", [extracted])
+        end
+
+        def json_contains(document, json, _model)
+          Arel::Nodes::NamedFunction.new("JSON_CONTAINS", [document, json])
+        end
+
+        def json_has_key(document, _name, path, _model)
+          Arel::Nodes::NamedFunction.new(
+            "JSON_CONTAINS_PATH", [document, Arel::Nodes.build_quoted("one"), path])
+        end
+
+        def json_aggregate_filter_supported? = false
+
+        # GROUP_CONCAT, its separator a keyword after the operand and after
+        # the ORDER BY when there is one.
+        def string_agg(operand, separator, orders, _string, model)
+          order = orders.empty? ? "" : " ORDER BY #{compile_list(orders, model)}"
+          Arel.sql("GROUP_CONCAT(#{compile(operand, model)}#{order} " \
+                   "SEPARATOR #{quote(separator, model)})")
+        end
+
+        def check_string_aggregate_window(model)
+          raise NotImplementedError,
+            "string_agg over a window has no equivalent on #{model.connection_db_config.adapter}"
+        end
+
+        def json_list_by_element? = true
+
+        def grouping_supported?(kind) = kind == :rollup
+
+        def grouping_by_with_rollup? = true
+      end
+    end
+  end
+end

data/lib/active_record/refined/dialect/oracle.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # Oracle, reached through oracle_enhanced.  Loaded only when a query is
+      # built for it.
+      class Oracle < Dialect
+        FUNCTIONS = {
+          char_length: "LENGTH",
+          degrees: nil, radians: nil, pi: nil, log2: nil, log10: nil,
+          now: nil, date_trunc: nil, rand: nil, format: nil,
+          bit_and: nil, bit_or: nil, bit_xor: nil,
+        }.freeze
+
+        # An INTERVAL literal would do, but its leading field is two digits
+        # wide unless told otherwise, so INTERVAL '100' DAY is an error.  The
+        # functions that make an interval of a number take any size, one for
+        # the year-month intervals and one for the day-second.
+        def add_interval(date, amount, unit, subtract, _date_only)
+          interval = Arel::Nodes::NamedFunction.new(
+            unit == :year || unit == :month ? "NUMTOYMINTERVAL" : "NUMTODSINTERVAL",
+            [Arel::Nodes.build_quoted(amount), Arel::Nodes.build_quoted(unit.to_s.upcase)])
+          Arel::Nodes::Grouping.new(
+            Arel::Nodes::InfixOperation.new(subtract ? :- : :+, date, interval))
+        end
+
+        # Oracle keeps scalars and structures in different functions: JSON_VALUE
+        # reads a scalar out as text, JSON_QUERY a fragment as JSON.  dig keeps
+        # JSON, so it takes JSON_QUERY with 23ai's ALLOW SCALARS, which returns
+        # a scalar leaf as itself rather than wrapping or refusing it.
+        def json_path(document, dollar_path, _steps, json_value, model)
+          unless json_value
+            return Arel::Nodes::NamedFunction.new(
+              "JSON_VALUE", [document, Arel::Nodes.build_quoted(dollar_path)])
+          end
+          Arel.sql(
+            "JSON_QUERY(#{compile(document, model)}, " \
+            "#{quote(dollar_path, model)} RETURNING VARCHAR2(4000) ALLOW SCALARS " \
+            "NULL ON EMPTY)")
+        end
+
+        def json_has_key(document, _name, path, _model)
+          Arel::Nodes::NamedFunction.new("JSON_EXISTS", [document, path])
+        end
+
+        # No JSON_KEYS, and the keys reach only through a JSON_TABLE unnest not
+        # written yet.
+        def json_keys(_document, model)
+          raise NotImplementedError,
+            "keys has no equivalent on #{model.connection_db_config.adapter}"
+        end
+
+        def json_argument(value, model)
+          Arel.sql("#{quote(JSON.generate(value), model)} FORMAT JSON")
+        end
+
+        # JSON_TRANSFORM is Oracle's one editing function; its SET and the value
+        # beside it are grammar, so the call is written out, RETURNING text that
+        # ruby-oci8 can fetch.
+        def json_set(document, _steps, dollar_path, value, expression, model)
+          model.with_connection do |connection|
+            set =
+              if expression
+                connection.visitor.compile(expression)
+              elsif json_document_value?(value)
+                "#{connection.quote(JSON.generate(value))} FORMAT JSON"
+              else
+                connection.quote(value)
+              end
+            Arel.sql(
+              "JSON_TRANSFORM(#{connection.visitor.compile(document)}, " \
+              "SET #{connection.quote(dollar_path)} = #{set} RETURNING VARCHAR2(4000))")
+          end
+        end
+
+        def json_remove(document, dollar_paths, _steps, model)
+          model.with_connection do |connection|
+            removes = dollar_paths.map { |path| "REMOVE #{connection.quote(path)}" }
+            Arel.sql(
+              "JSON_TRANSFORM(#{connection.visitor.compile(document)}, " \
+              "#{removes.join(', ')} RETURNING VARCHAR2(4000))")
+          end
+        end
+
+        # Oracle pairs a key with its value by the VALUE keyword rather than by
+        # position, keeps a NULL only when told NULL ON NULL, and returns the
+        # native JSON type unless a RETURNING asks for text ruby-oci8 can fetch.
+        def json_build(kind, keys, args, model)
+          model.with_connection do |connection|
+            compiled = args.map { |arg| connection.visitor.compile(arg) }
+            body =
+              if kind == :array
+                compiled.join(", ")
+              else
+                keys.zip(compiled).map { |key, arg| "#{connection.quote(key)} VALUE #{arg}" }.join(", ")
+              end
+            Arel.sql("JSON_#{kind.to_s.upcase}(#{body} NULL ON NULL RETURNING VARCHAR2(4000))")
+          end
+        end
+
+        def check_json_aggregate_window(source, model)
+          raise NotImplementedError,
+            "#{source} over a window has no equivalent on " \
+            "#{model.connection_db_config.adapter}"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/refined/dialect/postgresql.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # PostgreSQL, and the adapters that answer for the same server.
+      class Postgresql < Dialect
+        FUNCTIONS = { log2: nil, rand: "RANDOM" }.freeze
+
+        # PostgreSQL counts the bits of a bit string rather than a number, so
+        # the argument is cast, to bit(64) for a negative to come back as the
+        # MySQL family has it.
+        def bit_count(expr, _model)
+          AST::Function.new("BIT_COUNT", [AST::Cast.new(expr, "bit(64)")])
+        end
+
+        # PostgreSQL's XOR is #, where ^ is exponentiation.
+        def bitwise_xor(left, right)
+          Arel::Nodes::InfixOperation.new("#", left, right)
+        end
+
+        def json_path(document, _dollar_path, steps, json_value, _model)
+          Arel::Nodes::InfixOperation.new(
+            json_value ? :"#>" : :"#>>", document, Arel::Nodes.build_quoted(steps))
+        end
+
+        # An untyped JSON literal beside a jsonb operand coerces to jsonb, so
+        # it passes as it is.
+        def json_literal(json, _model)
+          json
+        end
+
+        def json_contains(document, json, _model)
+          Arel::Nodes::Contains.new(document, json)
+        end
+
+        # The ? operator, which a GIN index matches where jsonb_exists never is.
+        def json_has_key(document, name, _path, _model)
+          Arel::Nodes::InfixOperation.new(:"?", document, name)
+        end
+
+        def json_keys(document, model)
+          sql = compile(document, model)
+          Arel.sql("CASE WHEN jsonb_typeof(#{sql}) = 'object' " \
+                   "THEN COALESCE((SELECT jsonb_agg(k) FROM jsonb_object_keys(#{sql}) k), " \
+                   "CAST('[]' AS jsonb)) END")
+        end
+
+        # jsonb_set takes jsonb: an expression is turned into it, and a Ruby
+        # value goes in as the JSON that says it -- '"x"' rather than 'x'.
+        def json_set(document, steps, _dollar_path, value, expression, _model)
+          set = expression ? Arel::Nodes::NamedFunction.new("to_jsonb", [expression]) :
+                             Arel::Nodes.build_quoted(JSON.generate(value))
+          Arel::Nodes::NamedFunction.new(
+            "jsonb_set", [document, Arel::Nodes.build_quoted(steps), set])
+        end
+
+        # jsonb subtracts an array of keys; an untyped array literal would be
+        # read as a single key, so it is cast to text[].
+        def json_remove(document, _dollar_paths, steps, _model)
+          keys = Arel::Nodes::NamedFunction.new(
+            "CAST", [Arel::Nodes::As.new(
+              Arel::Nodes.build_quoted(steps), Arel::Nodes::SqlLiteral.new("text[]"))])
+          # Grouped because - binds tighter than #>.
+          Arel::Nodes::InfixOperation.new(:-, Arel::Nodes::Grouping.new(document), keys)
+        end
+
+        def json_build(kind, keys, args, _model)
+          Arel::Nodes::NamedFunction.new(
+            kind == :array ? "jsonb_build_array" : "jsonb_build_object",
+            json_build_body(kind, keys, args))
+        end
+
+        # jsonb_build_* takes typed arguments, so a JSON literal is cast; left
+        # untyped it would be text, and land as a string.
+        def json_build_argument(value, _model)
+          Arel::Nodes::NamedFunction.new(
+            "CAST", [Arel::Nodes::As.new(
+              Arel::Nodes.build_quoted(JSON.generate(value)),
+              Arel::Nodes::SqlLiteral.new("jsonb"))])
+        end
+
+        def json_aggregate_name(kind)
+          kind == :arrayagg ? "jsonb_agg" : "jsonb_object_agg"
+        end
+
+        # STRING_AGG takes text and nothing else -- over an integer column it
+        # is a function that does not exist -- so the operand is cast unless
+        # the model says it is a string already.
+        def string_agg(operand, separator, orders, string, model)
+          unless string
+            operand = Arel::Nodes::NamedFunction.new(
+              "CAST", [Arel::Nodes::As.new(operand, Arel::Nodes::SqlLiteral.new("text"))])
+          end
+          string_agg_call("STRING_AGG", operand, separator, orders, model)
+        end
+
+        def grouping_supported?(_kind) = true
+
+        # The names PostgreSQL knows, letters and digits and the _ . - its
+        # catalog spells them with.  Wider than the bare families' plain
+        # identifier because the name is quoted, so a hyphen is safe -- and
+        # every ICU collation, en-US-x-icu among them, is spelled with one.
+        # @private
+        COLLATION_NAME = /\A[[:alnum:]_.-]+\z/
+
+        # PostgreSQL's own collation names are case-sensitive and upper, "C",
+        # "POSIX", so the name is quoted as an identifier to keep it from
+        # folding to lower case.  The quoter is asked to spell it, as
+        # excluded's VALUES(column) is on MySQL.
+        def collate(operand, name, model)
+          AST.check_name(name, COLLATION_NAME, "collation name")
+          quoted = model.with_connection { |connection| connection.quote_column_name(name) }
+          Arel::Nodes::InfixOperation.new(
+            "COLLATE", operand, Arel::Nodes::SqlLiteral.new(quoted))
+        end
+      end
+    end
+  end
+end

data/lib/active_record/refined/dialect/sql_server.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # Microsoft SQL Server, reached through the sqlserver adapter over
+      # tiny_tds.  Loaded only when a query is built for it.
+      class SqlServer < Dialect
+        # LEN is its length; it has no printf FORMAT, no per-row random it
+        # would spell RAND, no date_trunc, and none of the bit aggregates.
+        # Of the datetime value functions it has CURRENT_TIMESTAMP alone:
+        # the other four are reserved words there that stand for nothing.
+        FUNCTIONS = {
+          char_length: "LEN",
+          format: nil, rand: nil, date_trunc: nil,
+          bit_and: nil, bit_or: nil, bit_xor: nil,
+          current_date: nil, current_time: nil, localtime: nil, localtimestamp: nil,
+        }.freeze
+
+        # No FILTER clause, so the aggregate node builds the CASE instead.
+        def filter_supported? = false
+
+        # No EXTRACT (it has DATEPART), and its datetime value functions take
+        # no precision.
+        def extract_supported? = false
+        def datetime_precision_supported? = false
+
+        # No boolean type: the column is a bit.  ISNULL reads a NULL as the
+        # value the test is not looking for -- 0 for true?, 1 for false? --
+        # so the plain form drops it and, being never NULL itself, the
+        # negation is exactly NOT of the plain form, matching what ! builds.
+        def truth_value(operand, value, negated, _model)
+          equals = Arel::Nodes::Equality.new(
+            Arel::Nodes::NamedFunction.new("ISNULL", [operand, value ? 0 : 1]),
+            value ? 1 : 0)
+          negated ? Arel::Nodes::Not.new(equals) : equals
+        end
+
+        # DATEADD(day, 3, x), the unit a bare keyword; a subtraction is a
+        # negative amount, there being no DATESUB.
+        def add_interval(date, amount, unit, subtract, _date_only)
+          Arel::Nodes::NamedFunction.new(
+            "DATEADD",
+            [Arel::Nodes::SqlLiteral.new(unit.to_s),
+             Arel::Nodes.build_quoted(subtract ? -amount : amount), date])
+        end
+
+        # STRING_AGG, with the WITHIN GROUP only when there is an order to
+        # put in it.
+        def string_agg(operand, separator, orders, _string, model)
+          call = Arel::Nodes::NamedFunction.new(
+            "STRING_AGG", [operand, Arel::Nodes.build_quoted(separator)])
+          return call if orders.empty?
+          Arel.sql("#{compile(call, model)} WITHIN GROUP " \
+                   "(ORDER BY #{compile_list(orders, model)})")
+        end
+
+        def check_string_aggregate_window(model)
+          raise NotImplementedError,
+            "string_agg over a window has no equivalent on #{model.connection_db_config.adapter}"
+        end
+
+        # dig_text reads a scalar out with JSON_VALUE; dig keeps JSON with
+        # JSON_QUERY, which returns a fragment and NULL for a scalar leaf.
+        def json_path(document, dollar_path, _steps, json_value, _model)
+          Arel::Nodes::NamedFunction.new(
+            json_value ? "JSON_QUERY" : "JSON_VALUE",
+            [document, Arel::Nodes.build_quoted(dollar_path)])
+        end
+
+        # JSON_PATH_EXISTS returns a bit, which the condition compares to 1.
+        def json_has_key(document, _name, path, _model)
+          Arel::Nodes::Equality.new(
+            Arel::Nodes::NamedFunction.new("JSON_PATH_EXISTS", [document, path]),
+            Arel::Nodes.build_quoted(1))
+        end
+
+        # A document, a boolean or a bare scalar written where JSON is wanted
+        # rides in through JSON_QUERY as the JSON it spells.
+        def json_argument(value, _model)
+          Arel::Nodes::NamedFunction.new(
+            "JSON_QUERY", [Arel::Nodes.build_quoted(JSON.generate(value))])
+        end
+
+        # bury: JSON_MODIFY sets a value at a path.
+        def json_set(document, _steps, dollar_path, value, expression, model)
+          Arel::Nodes::NamedFunction.new(
+            "JSON_MODIFY",
+            [document, Arel::Nodes.build_quoted(dollar_path),
+             json_modify_value(value, expression, model)])
+        end
+
+        # except: JSON_MODIFY deletes a key when it sets it to a literal NULL,
+        # one nested call per key.
+        def json_remove(document, dollar_paths, _steps, _model)
+          dollar_paths.reduce(document) do |doc, path|
+            Arel::Nodes::NamedFunction.new(
+              "JSON_MODIFY",
+              [doc, Arel::Nodes.build_quoted(path), Arel::Nodes::SqlLiteral.new("NULL")])
+          end
+        end
+
+        private
+          # A document or array goes in through JSON_QUERY, which wants an
+          # object or an array and refuses a scalar; a bare scalar is quoted.
+          # A boolean, a null or a dug scalar is bury's business the tests skip.
+          def json_modify_value(value, expression, model)
+            return expression if expression
+            return json_argument(value, model) if value.is_a?(::Hash) || value.is_a?(::Array)
+            Arel::Nodes.build_quoted(value)
+          end
+      end
+    end
+  end
+end

data/lib/active_record/refined/dialect/sqlite.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Refined
+    class Dialect
+      # SQLite: the fewest of the extras, and a JSON path through its own
+      # operators.
+      class Sqlite < Dialect
+        FUNCTIONS = {
+          char_length: "LENGTH", greatest: "MAX", least: "MIN",
+          now: nil, date_trunc: nil, rand: "RANDOM",
+          bit_and: nil, bit_or: nil, bit_xor: nil,
+          localtime: nil, localtimestamp: nil,
+        }.freeze
+
+        def datetime_precision_supported? = false
+        def extract_supported? = false
+        def quantifiers_supported? = false
+
+        def check_lateral(model)
+          raise NotImplementedError,
+            "a lateral join has no equivalent on #{model.connection_db_config.adapter}"
+        end
+
+        # A date is moved by a modifier to date() or datetime(), '+3 day';
+        # the unit's own name reads there, singular.  datetime() answers with a
+        # time of day whatever it is given, so a date column, as the node
+        # tells one, goes through date() and stays a date.
+        def add_interval(date, amount, unit, subtract, date_only)
+          modifier = format("%+d %s", subtract ? -amount : amount, unit)
+          Arel::Nodes::NamedFunction.new(
+            date_only ? "date" : "datetime", [date, Arel::Nodes.build_quoted(modifier)])
+        end
+
+        def json_keys(document, model)
+          sql = compile(document, model)
+          Arel.sql("CASE WHEN json_type(#{sql}) = 'object' " \
+                   "THEN (SELECT json_group_array(key) FROM json_each(#{sql})) END")
+        end
+
+        def json_argument(value, _model)
+          Arel::Nodes::NamedFunction.new(
+            "json", [Arel::Nodes.build_quoted(JSON.generate(value))])
+        end
+
+        def json_aggregate_name(kind)
+          kind == :arrayagg ? "json_group_array" : "json_group_object"
+        end
+
+        # group_concat, with the ORDER BY inside the call from 3.44 on.
+        def string_agg(operand, separator, orders, _string, model)
+          string_agg_call("group_concat", operand, separator, orders, model)
+        end
+      end
+    end
+  end
+end