activerecord-refined 0.4.0 → 0.5.1

data/lib/active_record/refined/ast.rb

@@ -9,6 +9,9 @@ module ActiveRecord
       NAME = /[[:alpha:]_][[:alnum:]_$]*/
       ALIAS_NAME = /\A#{NAME}\z/
       FUNCTION_NAME = /\A#{NAME}(\.#{NAME})?\z/
+      # A SQL type as cast writes it: words, at most parenthesized with
+      # lengths -- double precision, decimal(10,2).
+      TYPE_NAME = /\A[[:alpha:]_][[:alnum:]_ ]*(\(\d+(, ?\d+)?\))?\z/
 
       def self.check_name(name, pattern, what)
         return name if pattern.match?(name.to_s)
@@ -60,26 +63,50 @@ module ActiveRecord
           Match.new(self, pattern, negated: true)
         end
 
+        # `!` negates any predicate, so these are here for the four that SQL
+        # spells for itself: IS NOT NULL rather than NOT (... IS NULL), and
+        # likewise NOT IN and NOT LIKE.  They mean the same thing either way,
+        # including when the column is NULL; what they save is the reading.
         def null?
           Comparison.new(self, :==, nil)
         end
 
+        def not_null?
+          Comparison.new(self, :!=, nil)
+        end
+
         def in?(values)
           In.new(self, values)
         end
 
+        def not_in?(values)
+          In.new(self, values, negated: true)
+        end
+
         def between?(min, max)
           In.new(self, min..max)
         end
 
+        def not_between?(min, max)
+          In.new(self, min..max, negated: true)
+        end
+
         def like?(pattern)
           Like.new(self, pattern)
         end
 
+        def not_like?(pattern)
+          Like.new(self, pattern, negated: true)
+        end
+
         def ilike?(pattern)
           Like.new(self, pattern, nil, case_sensitive: false)
         end
 
+        def not_ilike?(pattern)
+          Like.new(self, pattern, nil, case_sensitive: false, negated: true)
+        end
+
         # Case-insensitive equality, folded on both sides rather than left to
         # the collation, so it means the same thing on every adapter.
         def casecmp?(value)
@@ -218,6 +245,15 @@ module ActiveRecord
           else operand
           end
         end
+
+        # Resolves a function argument: a column or an expression as above,
+        # anything else a value to be quoted.
+        def to_arel_argument(arg, table)
+          case arg
+          when Node, Symbol then to_arel_operand(arg, table)
+          else Arel::Nodes.build_quoted(arg)
+          end
+        end
       end
 
       class Predicate < Node
@@ -234,6 +270,29 @@ module ActiveRecord
         end
       end
 
+      # A literal standing where an expression would: `select { value(0).as(:depth) }`.
+      #
+      # Values reach the SQL quoted wherever they appear as an operand, but the
+      # top of a select list is ActiveRecord's, and a bare string there is SQL
+      # rather than a string.  Saying `value` is how you ask for the other
+      # meaning, and it carries the predications with it, so a literal can be
+      # compared and combined like anything else.
+      class Value < Node
+        include Predications
+        include Arithmetics
+        include Aggregations
+
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_arel(_table)
+          Arel::Nodes.build_quoted(value)
+        end
+      end
+
       class Column < Node
         include Predications
         include Arithmetics
@@ -351,16 +410,80 @@ module ActiveRecord
         end
 
         def to_arel(table)
-          arel_args = args.map do |arg|
-            case arg
-            when Node, Symbol then to_arel_operand(arg, table)
-            else Arel::Nodes.build_quoted(arg)
-            end
-          end
+          arel_args = args.map {|arg| to_arel_argument(arg, table) }
           Arel::Nodes::NamedFunction.new(name, arel_args)
         end
       end
 
+      # EXTRACT(field FROM expr).  The field is grammar rather than a value --
+      # a keyword the adapter reads bare -- so it has to be a plain name,
+      # which Arel upcases on the way out.
+      class Extract < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :field, :operand
+
+        def initialize(field, operand)
+          @field = AST.check_name(field, ALIAS_NAME, "extract field")
+          @operand = operand
+        end
+
+        def to_arel(table)
+          Arel::Nodes::Extract.new(to_arel_argument(operand, table), field.to_s)
+        end
+      end
+
+      # CAST(expr AS type).  The type is grammar too, written into the SQL as
+      # given -- it is the adapter's own name for the type, and whether it
+      # exists is the database's to say -- so it has to look like one:
+      # a plain name, at most parenthesized with lengths.
+      class Cast < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :operand, :sql_type
+
+        def initialize(operand, sql_type)
+          @operand = operand
+          @sql_type = AST.check_name(sql_type, TYPE_NAME, "SQL type")
+        end
+
+        def to_arel(table)
+          Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [Arel::Nodes::As.new(to_arel_argument(operand, table),
+                                 Arel::Nodes::SqlLiteral.new(sql_type.to_s))])
+        end
+      end
+
+      # CURRENT_TIMESTAMP and its relatives, what the SQL grammar calls a
+      # datetime value function.  The grammar has them bare, and PostgreSQL
+      # and SQLite reject them written as calls, so unlike Function the name
+      # is emitted without parentheses.  A precision is the one thing that
+      # does go into parentheses, and it is written into the SQL as given, so
+      # only an Integer is accepted.
+      class DatetimeValueFunction < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :name, :precision
+
+        def initialize(name, precision = nil)
+          unless precision.nil? || precision.is_a?(Integer)
+            raise ArgumentError,
+              "#{precision.inspect} is not an Integer precision"
+          end
+          @name = name
+          @precision = precision
+        end
+
+        def to_arel(_table)
+          Arel::Nodes::SqlLiteral.new(
+            precision ? "#{name}(#{precision})" : name)
+        end
+      end
+
       # A plain SQL comparison. The value is passed through as it is, so a Range
       # or an Array compares against a PostgreSQL range or array column, the way
       # ActiveRecord's own force_equality? types do.
@@ -406,19 +529,21 @@ module ActiveRecord
       # IN for a list of values, BETWEEN for a range, IN (SELECT ...) for a
       # relation.
       class In < Predicate
-        attr_reader :operand, :values
+        attr_reader :operand, :values, :negated
 
-        def initialize(operand, values)
+        def initialize(operand, values, negated: false)
           @operand = operand
           @values = values
+          @negated = negated
         end
 
         def to_arel(table)
           arel_operand = to_arel_operand(operand, table)
-          case values
-          when Range then arel_operand.between(values)
-          when ActiveRecord::Relation then arel_operand.in(subquery(values))
-          else arel_operand.in(values)
+          if values.is_a?(Range)
+            arel_operand.public_send(negated ? :not_between : :between, values)
+          else
+            arg = values.is_a?(ActiveRecord::Relation) ? subquery(values) : values
+            arel_operand.public_send(negated ? :not_in : :in, arg)
           end
         end
 
@@ -479,19 +604,23 @@ module ActiveRecord
             inject {|left, right| Or.new(left, right) }
         end
 
-        attr_reader :operand, :pattern, :escape, :case_sensitive
+        attr_reader :operand, :pattern, :escape, :case_sensitive, :negated
 
-        def initialize(operand, pattern, escape = nil, case_sensitive: true)
+        def initialize(operand, pattern, escape = nil, case_sensitive: true,
+                       negated: false)
           @operand = operand
           @pattern = pattern
           @escape = escape
           @case_sensitive = case_sensitive
+          @negated = negated
         end
 
         def to_arel(table)
           # Arel matches case-insensitively unless told otherwise, which is
           # what picks ILIKE over LIKE on PostgreSQL.
-          to_arel_operand(operand, table).matches(pattern, escape, case_sensitive)
+          to_arel_operand(operand, table).
+            public_send(negated ? :does_not_match : :matches,
+                        pattern, escape, case_sensitive)
         end
       end
 

data/lib/active_record/refined.rb

@@ -22,6 +22,18 @@ module ActiveRecord
           AST::Column.new(self, column_name)
         end
       end
+
+      # Shorthand for `value(0).as(:depth)` and the like.  Numbers only: a
+      # string in a select list already means SQL rather than a string, so
+      # giving String this would make the same literal mean two things
+      # depending on whether it had been sent a message.
+      [Integer, Float].each do |klass|
+        refine klass do
+          def as(alias_name)
+            AST::As.new(AST::Value.new(self), alias_name)
+          end
+        end
+      end
     end
 
     class BlockContext
@@ -55,13 +67,20 @@ module ActiveRecord
       # Availability was checked by calling each one; the SQLite figures
       # assume the math functions its build usually enables.
       SCALAR_FUNCTIONS = {
-        abs: {}, ceil: {}, coalesce: {}, concat: {}, exp: {}, floor: {},
-        length: {}, ln: {}, log: {}, lower: {}, ltrim: {}, mod: {},
-        nullif: {}, power: {}, replace: {}, round: {}, rtrim: {}, sqrt: {},
-        substr: {}, trim: {}, upper: {},
+        abs: {}, acos: {}, asin: {}, atan: {}, atan2: {}, ceil: {},
+        coalesce: {}, concat: {}, cos: {}, degrees: {}, exp: {}, floor: {},
+        length: {}, ln: {}, log: {}, log10: {}, lower: {}, ltrim: {},
+        mod: {}, nullif: {}, pi: {}, power: {}, radians: {}, replace: {},
+        round: {}, rtrim: {}, sign: {}, sin: {}, sqrt: {}, substr: {},
+        tan: {}, trim: {}, upper: {},
         char_length: {sqlite: 'LENGTH'},
         greatest: {sqlite: 'MAX'},
         least: {sqlite: 'MIN'},
+        # PostgreSQL spells log2(x) as log(2, x), which no renaming carries.
+        log2: {postgresql: nil},
+        # MySQL's TRUNCATE insists on the second argument, where the others
+        # default it to zero; SQLite's trunc takes only the one.
+        trunc: {mysql: 'TRUNCATE'},
         now: {sqlite: nil},
         date_trunc: {sqlite: nil, mysql: nil},
         # Named for Kernel#rand, which it also takes back: a block calling
@@ -83,7 +102,65 @@ module ActiveRecord
       }.freeze
 
       SCALAR_FUNCTIONS.each_key do |name|
-        define_method(name) {|*args| AST::Function.new(function_name(name), args) }
+        define_method(name) do |*args|
+          AST::Function.new(function_name(name, SCALAR_FUNCTIONS), args)
+        end
+      end
+
+      # The datetime value functions, as the SQL grammar calls them.  These
+      # the grammar has bare -- PostgreSQL and SQLite reject them written with
+      # parentheses -- and the one thing that does go into parentheses is an
+      # optional precision, current_timestamp(3), which current_date never
+      # takes and SQLite never accepts.  The table reads like
+      # SCALAR_FUNCTIONS; current_timestamp is the portable spelling of what
+      # now means, reaching SQLite where now does not.
+      DATETIME_VALUE_FUNCTIONS = {
+        current_date: {},
+        current_time: {},
+        current_timestamp: {},
+        localtime: {sqlite: nil},
+        localtimestamp: {sqlite: nil},
+      }.freeze
+
+      def current_date
+        AST::DatetimeValueFunction.new(
+          function_name(:current_date, DATETIME_VALUE_FUNCTIONS))
+      end
+
+      (DATETIME_VALUE_FUNCTIONS.keys - [:current_date]).each do |name|
+        define_method(name) do |precision = nil|
+          # Built first so that a precision of the wrong type is an
+          # ArgumentError on every adapter, before SQLite gets to say it takes
+          # none at all.
+          node = AST::DatetimeValueFunction.new(
+            function_name(name, DATETIME_VALUE_FUNCTIONS), precision)
+          if precision && adapter_family == :sqlite
+            raise NotImplementedError,
+              "#{name} takes no precision on #{@model.connection_db_config.adapter}"
+          end
+          node
+        end
+      end
+
+      # EXTRACT(field FROM expr).  The field is a keyword, not a value, so it
+      # has to be a plain name; the node checks it.  SQLite spells all of
+      # this as strftime formats, which no renaming carries, so it raises
+      # there -- after the node is built, so that a bad field is an
+      # ArgumentError on every adapter.
+      def extract(field, expr)
+        node = AST::Extract.new(field, expr)
+        if adapter_family == :sqlite
+          raise NotImplementedError,
+            "extract has no equivalent on #{@model.connection_db_config.adapter}"
+        end
+        node
+      end
+
+      # CAST(expr AS type).  The type is the adapter's own name for it,
+      # checked for shape by the node; whether it exists is the database's to
+      # say.
+      def cast(expr, type)
+        AST::Cast.new(expr, type)
       end
 
       # Escape hatch for functions without a method of their own.  The name is
@@ -99,10 +176,21 @@ module ActiveRecord
         AST::Exists.new(relation)
       end
 
+      # A literal where an expression is expected, quoted like any other value:
+      #
+      #   select { [:id, value(0).as(:depth)] }
+      #
+      # Needed because the top of a select list is ActiveRecord's, and a bare
+      # string there is SQL rather than a string.  Numbers have a shorthand --
+      # `0.as(:depth)` -- since nothing else could be meant by one.
+      def value(literal)
+        AST::Value.new(literal)
+      end
+
       private
 
-      def function_name(name)
-        spellings = SCALAR_FUNCTIONS.fetch(name)
+      def function_name(name, functions)
+        spellings = functions.fetch(name)
         return name.to_s.upcase unless spellings.key?(adapter_family)
         spellings.fetch(adapter_family) ||
           raise(NotImplementedError,
@@ -165,9 +253,8 @@ module ActiveRecord
       end
 
       # A symbol names a table, which ActiveRecord's own from only takes as a
-      # string.  With `as` it is selected under another name, which is how a
-      # CTE stands in for the model's own table:
-      # with_recursive(tree: [...]).from(:tree, as: :nodes)
+      # string.  With `as` it is selected under another name; when that name
+      # is the model's own, from_cte says the same thing without repeating it.
       def from(value, subquery_name = nil, as: nil)
         unless value.is_a?(Symbol)
           if as
@@ -180,6 +267,18 @@ module ActiveRecord
         super(arel_table, subquery_name)
       end
 
+      # Selects a CTE in place of the model's own table.  The alias is not a
+      # choice -- ActiveRecord keeps qualifying columns with the table name,
+      # so the model's is the only name that works -- which is why it is
+      # taken from the model rather than asked for:
+      # with_recursive(tree: [...]).from_cte(:tree)
+      def from_cte(name)
+        unless name.is_a?(Symbol)
+          raise ArgumentError, "from_cte takes the CTE's name as a symbol"
+        end
+        from(name, as: klass.table_name)
+      end
+
       # `as` names the table within the query, which is what makes a self
       # join expressible: joins(:employees, as: :managers) { ... }.
       def joins(*args, as: nil, &block)

data/lib/activerecord-refined/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Refined
-    VERSION = '0.4.0'
+    VERSION = '0.5.1'
   end
 end

data/lib/activerecord-refined.rb

@@ -5,3 +5,7 @@ require 'active_record/refined/ast'
 require 'active_record/refined'
 
 ActiveRecord::QueryMethods.prepend ActiveRecord::Refined::QueryMethods
+
+# The methods above are ActiveRecord's own, so a model already forwards them
+# to its relation.  from_cte is new, and has to be added to that list itself.
+ActiveRecord::Base.singleton_class.delegate :from_cte, to: :all