Refactor - Make it easier to configure new functions and operators

Add the type information and the implementations of operators and functions closer together so they can keep in sync.

For operators that accept multiple types and numbers of input arguments, I've chosen to share an implementation for the different input. This makes looking up operators slightly easier as you don't need to know input types to find the operator.

Currently all operators and functions have a single return type that isn't dependent on their inputs. This isn't true for all functions (e.g COALESCE).

Author: zetter

lib/rgsql.rb

@@ -1,4 +1,5 @@
 require 'rgsql/nodes'
+require 'rgsql/callable'
 require 'rgsql/tokenizer'
 require 'rgsql/server'
 require 'rgsql/parser'

lib/rgsql/callable.rb

@@ -0,0 +1,49 @@
+module RgSql
+  Callable = Data.define(:name, :input_types, :output_type, :body)
+
+  class Callable
+    include Nodes
+
+    OPERATORS = [
+      new('+', [[Int, Int]], Int,        ->(op1, op2)       { Int.new(op1.value + op2.value) }),
+      new('-', [[Int, Int], [Int]], Int, ->(op1, op2 = nil) { Int.new(op2 ? op1.value - op2.value : -op1.value) }),
+      new('*', [[Int, Int]], Int,        ->(op1, op2)       { Int.new(op1.value * op2.value) }),
+      new('/', [[Int, Int]], Int,        ->(op1, op2)       { Int.new(op1.value / op2.value) }),
+
+      new('NOT', [[Bool]], Bool,       ->(op)       { Bool.new(!op.value) }),
+      new('AND', [[Bool, Bool]], Bool, ->(op1, op2) { Bool.new(op1.value && op2.value) }),
+      new('OR',  [[Bool, Bool]], Bool, ->(op1, op2) { Bool.new(op1.value || op2.value) }),
+
+      new('<',  [[Bool, Bool], [Int, Int]], Bool, ->(op1, op2) { Bool.new(op1.to_i < op2.to_i) }),
+      new('>',  [[Bool, Bool], [Int, Int]], Bool, ->(op1, op2) { Bool.new(op1.to_i > op2.to_i) }),
+      new('>=', [[Bool, Bool], [Int, Int]], Bool, ->(op1, op2) { Bool.new(op1.to_i >= op2.to_i) }),
+      new('<=', [[Bool, Bool], [Int, Int]], Bool, ->(op1, op2) { Bool.new(op1.to_i <= op2.to_i) }),
+
+      new('=',  [[Bool, Bool], [Int, Int]], Bool, ->(op1, op2) { Bool.new(op1.value == op2.value) }),
+      new('<>', [[Bool, Bool], [Int, Int]], Bool, ->(op1, op2) { Bool.new(op1.value != op2.value) })
+    ].freeze
+
+    FUNCTIONS = [
+      new('ABS', [[Int]],      Int, ->(arg)        { Int.new(arg.value.abs) }),
+      new('MOD', [[Int, Int]], Int, ->(arg1, arg2) { Int.new(arg1.value % arg2.value) })
+    ].freeze
+
+    def self.find_operator(name)
+      operator = OPERATORS.find { |callable| callable.name == name }
+      operator || raise(ValidationError, "Cannot find operator #{name}")
+    end
+
+    def self.find_function(name)
+      function = FUNCTIONS.find { |callable| callable.name == name }
+      function || raise(ValidationError, "Cannot find function #{name}")
+    end
+
+    def call(inputs)
+      body.call(*inputs)
+    end
+
+    def accepts_types?(types)
+      input_types.include?(types)
+    end
+  end
+end

lib/rgsql/expression.rb

@@ -6,9 +6,9 @@ class << self
       def type(expression, table)
         case expression
         when Operator
-          type_operator(expression.operator, type_list(expression.operands, table))
+          type_operator(expression, type_list(expression.operands, table))
         when Function
-          type_function(expression.name, type_list(expression.arguments, table))
+          type_function(expression, type_list(expression.arguments, table))
         when Int, Bool
           expression.class
         when Reference
@@ -19,9 +19,11 @@ def type(expression, table)
       def evaluate(expression, row = [], table = nil)
         case expression
         when Operator
-          evaluate_operator(expression.operator, evaluate_list(expression.operands, row, table))
+          operands = evaluate_list(expression.operands, row, table)
+          Callable.find_operator(expression.operator).call(operands)
         when Function
-          evaluate_function(expression.name, evaluate_list(expression.arguments, row, table))
+          arguments = evaluate_list(expression.arguments, row, table)
+          Callable.find_function(expression.name).call(arguments)
         when Reference
           table.get_reference(row, expression.name)
         when Int, Bool
@@ -33,54 +35,22 @@ def evaluate(expression, row = [], table = nil)
 
       private
 
-      def type_operator(operator, operand_types)
-        case operator
-        when '+', '-', '*', '/'
-          if operand_types.all? { |type| type == Int }
-            Int
-          else
-            raise ValidationError, "Invalid types for operator #{operator}: #{operand_types}"
-          end
-        when 'NOT'
-          if operand_types == [Bool]
-            Bool
-          else
-            raise ValidationError, "Invalid types for operator #{operator}: #{operand_types}"
-          end
-        when 'AND', 'OR'
-          if operand_types == [Bool, Bool]
-            Bool
-          else
-            raise ValidationError, "Invalid types for operator #{operator}: #{operand_types}"
-          end
-        when '<', '>', '>=', '<=', '=', '<>'
-          if [[Int, Int], [Bool, Bool]].include?(operand_types)
-            Bool
-          else
-            raise ValidationError, "Invalid types for operator #{operator}: #{operand_types}"
-          end
-        else
-          raise "unknown operator #{operator}"
+      def type_operator(expression, operand_types)
+        operator = Callable.find_operator(expression.operator)
+        unless operator.accepts_types?(operand_types)
+          raise(ValidationError, "Operator #{expression.operator} does not accept types #{operand_types}")
         end
+
+        operator.output_type
       end
 
-      def type_function(name, argument_types)
-        case name
-        when 'ABS'
-          if argument_types == [Int]
-            Int
-          else
-            raise ValidationError, "Invalid types for function #{name}: #{argument_types}"
-          end
-        when 'MOD'
-          if argument_types == [Int, Int]
-            Int
-          else
-            raise ValidationError, "Invalid types for function #{name}: #{argument_types}"
-          end
-        else
-          raise ValidationError, "unknown function #{name}"
+      def type_function(expression, argument_types)
+        function = Callable.find_function(expression.name)
+        unless function.accepts_types?(argument_types)
+          raise(ValidationError, "Function #{expression.name} does not accept types #{argument_types}")
         end
+
+        function.output_type
       end
 
       def evaluate_list(expressions, row, table)
@@ -90,71 +60,6 @@ def evaluate_list(expressions, row, table)
       def type_list(expressions, table)
         expressions.map { |expression| type(expression, table) }
       end
-
-      def evaluate_function(name, arguments)
-        arg1 = arguments[0]
-        arg2 = arguments[1]
-
-        case name
-        when 'ABS'
-          Int.new(arg1.value.abs)
-        when 'MOD'
-          Int.new(arg1.value % arg2.value)
-        else
-          raise "unknown function #{name}"
-        end
-      end
-
-      def evaluate_operator(operator, operands)
-        op1 = operands[0]
-        op2 = operands[1]
-
-        case operator
-        when '+'
-          Int.new(op1.value + op2.value)
-        when '-'
-          if operands.length == 1
-            Int.new(-op1.value)
-          else
-            Int.new(op1.value - op2.value)
-          end
-        when '*'
-          Int.new(op1.value * op2.value)
-        when '/'
-          Int.new(op1.value / op2.value)
-        when 'NOT'
-          Bool.new(!op1.value)
-        when 'AND'
-          Bool.new(op1.value && op2.value)
-        when 'OR'
-          Bool.new(op1.value || op2.value)
-        when '<'
-          Bool.new(to_integer(op1) < to_integer(op2))
-        when '>'
-          Bool.new(to_integer(op1) > to_integer(op2))
-        when '>='
-          Bool.new(to_integer(op1) >= to_integer(op2))
-        when '<='
-          Bool.new(to_integer(op1) <= to_integer(op2))
-        when '='
-          Bool.new(op1.value == op2.value)
-        when '<>'
-          Bool.new(op1.value != op2.value)
-        else
-          raise "unknown operator #{operator}"
-        end
-      end
-
-      def to_integer(argument)
-        case argument
-        when Int
-          argument.value
-        when Bool
-          argument.value ? 1 : 0
-        else
-          raise "unexpected argument type #{argument.class}"
-        end
-      end
     end
   end
 end

lib/rgsql/nodes.rb

@@ -1,7 +1,16 @@
 module RgSql
   module Nodes
-    Int = Data.define(:value)
-    Bool = Data.define(:value)
+    Int = Data.define(:value) do
+      def to_i
+        value
+      end
+    end
+
+    Bool = Data.define(:value) do
+      def to_i
+        value ? 1 : 0
+      end
+    end
 
     Select = Data.define(:select_list, :table)
     SelectListItem = Data.define(:name, :expression)