activerecord-refined 0.3.3 → 0.5.0

data/lib/active_record/refined.rb

@@ -3,10 +3,8 @@ module ActiveRecord
     module BlockSyntax
       refine Symbol do
         import_methods AST::Predications
-
-        %i[count sum average maximum minimum].each do |func|
-          define_method(func) { AST::Aggregate.new(self, func) }
-        end
+        import_methods AST::Arithmetics
+        import_methods AST::Aggregations
 
         def as(alias_name)
           AST::As.new(self, alias_name)
@@ -27,23 +25,161 @@ module ActiveRecord
     end
 
     class BlockContext
+      # The model is only consulted to learn which adapter the query is being
+      # built for, which is what decides how a scalar function is spelled.
+      def initialize(model)
+        @model = model
+      end
+
       AGGREGATE_FUNCTIONS = {
-        count: :count, sum: :sum, avg: :average, min: :minimum, max: :maximum,
+        sum: :sum, avg: :average, min: :minimum, max: :maximum,
       }.freeze
 
       AGGREGATE_FUNCTIONS.each do |name, arel_func|
         define_method(name) {|column| AST::Aggregate.new(column, arel_func) }
       end
 
-      SCALAR_FUNCTIONS = %i[upper lower length trim coalesce abs round].freeze
+      def count(column, distinct: false)
+        AST::Aggregate.new(column, :count, distinct: distinct)
+      end
+
+      # Scalar functions, defined as real methods so that a typo is a
+      # NoMethodError and a name Kernel also answers to (format, hash, test)
+      # cannot quietly mean something else.
+      #
+      # The value lists the adapters that differ: a string is what the
+      # function is called there, nil says the adapter has no equivalent.  An
+      # adapter that is not listed spells it like the method.  The families
+      # are what the entries key on, so trilogy reads the mysql column.
+      #
+      # Availability was checked by calling each one; the SQLite figures
+      # assume the math functions its build usually enables.
+      SCALAR_FUNCTIONS = {
+        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
+        # rand would otherwise get Ruby's and never reach the database.
+        rand: {sqlite: 'RANDOM', postgresql: 'RANDOM'},
+        # Two different functions share this name: printf formatting here, and
+        # on MySQL the one that puts separators in a number, which reads a
+        # printf template as the number zero rather than complaining.  The
+        # name keeps the one meaning; fn(:format, ...) reaches MySQL's.
+        format: {mysql: nil},
+      }.freeze
 
-      SCALAR_FUNCTIONS.each do |name|
-        define_method(name) {|*args| AST::Function.new(name.to_s.upcase, args) }
+      ADAPTER_FAMILIES = {
+        'sqlite3' => :sqlite,
+        'postgresql' => :postgresql,
+        'postgis' => :postgresql,
+        'mysql2' => :mysql,
+        'trilogy' => :mysql,
+      }.freeze
+
+      SCALAR_FUNCTIONS.each_key do |name|
+        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
+      # emitted as written, so a case-sensitive one can be spelled exactly,
+      # and for that reason it has to be a plain name, optionally qualified by
+      # a schema; anything else is refused rather than written into the SQL.
+      def fn(name, *args)
+        AST::Function.new(
+          AST.check_name(name, AST::FUNCTION_NAME, "function name").to_s, args)
       end
 
       def exists?(relation)
         AST::Exists.new(relation)
       end
+
+      private
+
+      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,
+                "#{name} has no equivalent on #{@model.connection_db_config.adapter}")
+      end
+
+      # An adapter nobody has classified keeps the standard spellings, and is
+      # left to say for itself what it cannot do.
+      def adapter_family
+        @adapter_family ||=
+          ADAPTER_FAMILIES[@model.connection_db_config.adapter] || :unknown
+      end
     end
 
     module QueryMethods
@@ -93,19 +229,39 @@ module ActiveRecord
         end
       end
 
-      def joins(*args, &block)
+      # 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)
+      def from(value, subquery_name = nil, as: nil)
+        unless value.is_a?(Symbol)
+          if as
+            raise ArgumentError, "as: needs the table named as a symbol"
+          end
+          return super(value, subquery_name)
+        end
+        arel_table = Arel::Table.new(value)
+        arel_table = arel_table.alias(as) if as
+        super(arel_table, subquery_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)
         if block
-          super(build_join_node(args.first, Arel::Nodes::InnerJoin, &block))
+          super(build_join_node(args.first, Arel::Nodes::InnerJoin, as, &block))
         else
-          super
+          reject_join_alias(as)
+          super(*args, &block)
         end
       end
 
-      def left_outer_joins(*args, &block)
+      def left_outer_joins(*args, as: nil, &block)
         if block
-          joins(build_join_node(args.first, Arel::Nodes::OuterJoin, &block))
+          joins(build_join_node(args.first, Arel::Nodes::OuterJoin, as, &block))
         else
-          super
+          reject_join_alias(as)
+          super(*args, &block)
         end
       end
 
@@ -113,7 +269,7 @@ module ActiveRecord
 
       def evaluate_block(&block)
         refined_block = block.refined(ActiveRecord::Refined::BlockSyntax)
-        BlockContext.new.instance_exec(&refined_block)
+        BlockContext.new(klass).instance_exec(&refined_block)
       end
 
       def to_arel_field(node)
@@ -124,12 +280,16 @@ module ActiveRecord
         end
       end
 
-      def build_join_node(target_table, join_class, &block)
+      def reject_join_alias(alias_name)
+        return unless alias_name
+        raise ArgumentError, "as: needs a block to write the ON clause with"
+      end
+
+      def build_join_node(target_table, join_class, alias_name, &block)
         ast = evaluate_block(&block)
-        join_class.new(
-          Arel::Table.new(target_table),
-          Arel::Nodes::On.new(ast.to_arel(table))
-        )
+        arel_table = Arel::Table.new(target_table)
+        arel_table = arel_table.alias(alias_name) if alias_name
+        join_class.new(arel_table, Arel::Nodes::On.new(ast.to_arel(table)))
       end
     end
   end

data/lib/activerecord-refined/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Refined
-    VERSION = '0.3.3'
+    VERSION = '0.5.0'
   end
 end