veritas-sql-generator 0.0.3 → 0.0.4

data/lib/veritas/sql/generator/function/aggregate.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      module Function
+
+        # Generates an SQL statement for an aggregate function
+        module Aggregate
+          include Function
+
+          COUNT              = 'COUNT'.freeze
+          SUM                = 'SUM'.freeze
+          MINIMUM            = 'MIN'.freeze
+          MAXIMUM            = 'MAX'.freeze
+          MEAN               = 'AVG'.freeze
+          VARIANCE           = 'VAR_POP'.freeze
+          STANDARD_DEVIATION = 'STDDEV_POP'.freeze
+
+          # Visit a count aggregate function
+          #
+          # @param [Veritas::Aggregate::Count] count
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_count(count)
+            unary_prefix_operation_sql(COUNT, count)
+          end
+
+          # Visit a sum aggregate function
+          #
+          # @param [Veritas::Aggregate::Sum] sum
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_sum(sum)
+            aggregate_function_sql(SUM, sum)
+          end
+
+          # Visit a minimum aggregate function
+          #
+          # @param [Veritas::Aggregate::Minimum] minimum
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_minimum(minimum)
+            # TODO: wrap this in a coalesce operation once the default can be made sane
+            unary_prefix_operation_sql(MINIMUM, minimum)
+          end
+
+          # Visit a maximum aggregate function
+          #
+          # @param [Veritas::Aggregate::Maximum] maximum
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_maximum(maximum)
+            # TODO: wrap this in a coalesce operation once the default can be made sane
+            unary_prefix_operation_sql(MAXIMUM, maximum)
+          end
+
+          # Visit a mean aggregate function
+          #
+          # @param [Veritas::Aggregate::Mean] mean
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_mean(mean)
+            unary_prefix_operation_sql(MEAN, mean)
+          end
+
+          # Visit a variance aggregate function
+          #
+          # @param [Veritas::Aggregate::Variance] variance
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_variance(variance)
+            unary_prefix_operation_sql(VARIANCE, variance)
+          end
+
+          # Visit a standard deviation aggregate function
+          #
+          # @param [Veritas::Aggregate::StandardDeviation] standard_deviation
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_aggregate_standard_deviation(standard_deviation)
+            unary_prefix_operation_sql(STANDARD_DEVIATION, standard_deviation)
+          end
+
+        private
+
+          # Return the SQL
+          #
+          # @param [#to_s] operation
+          #
+          # @param [Veritas::Aggregate] aggregate
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def aggregate_function_sql(operation, aggregate)
+            default_when_null(
+              unary_prefix_operation_sql(operation, aggregate),
+              aggregate.finalize(aggregate.default)
+            )
+          end
+
+          # Specify a default value when SQL expression evaluates to NULL
+          #
+          # @param [#to_s] sql
+          #
+          # @param [Visitable] default
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def default_when_null(sql, default)
+            "COALESCE (#{sql}, #{dispatch(default)})"
+          end
+
+        end # module Aggregate
+      end # module Function
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/function/connective.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      module Function
+
+        # Generates an SQL statement for a connective
+        module Connective
+          include Function
+
+          AND = 'AND'.freeze
+          OR  = 'OR'.freeze
+          NOT = 'NOT'.freeze
+
+          # Visit an Conjunction connective
+          #
+          # @param [Function::Connective::Conjunction] conjunction
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_connective_conjunction(conjunction)
+            Generator.parenthesize!(binary_infix_operation_sql(AND, conjunction))
+          end
+
+          # Visit an Disjunction connective
+          #
+          # @param [Function::Connective::Disjunction] disjunction
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_connective_disjunction(disjunction)
+            Generator.parenthesize!(binary_infix_operation_sql(OR, disjunction))
+          end
+
+          # Visit an Negation connective
+          #
+          # @param [Function::Connective::Negation] negation
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_connective_negation(negation)
+            unary_prefix_operation_sql(NOT, negation)
+          end
+
+        end # module Connective
+      end # module Function
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/function/numeric.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      module Function
+
+        # Generates an SQL statement for a numeric function
+        module Numeric
+          include Function
+
+          ABSOLUTE    = 'ABS'.freeze
+          ADD         = '+'.freeze
+          SUBTRACT    = '-'.freeze
+          MULTIPLY    = '*'.freeze
+          DIVIDE      = '/'.freeze
+          POWER       = 'POWER'.freeze
+          MOD         = 'MOD'.freeze
+          SQUARE_ROOT = 'SQRT'.freeze
+
+          # Visit an Absolute function
+          #
+          # @param [Function::Numeric::Absolute] absolute
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_absolute(absolute)
+            unary_prefix_operation_sql(ABSOLUTE, absolute)
+          end
+
+          # Visit an Addition function
+          #
+          # @param [Function::Numeric::Addition] addition
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_addition(addition)
+            Generator.parenthesize!(binary_infix_operation_sql(ADD, addition))
+          end
+
+          # Visit a Division function
+          #
+          # @param [Function::Numeric::Division] division
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_division(division)
+            Generator.parenthesize!(binary_infix_operation_sql(DIVIDE, division))
+          end
+
+          # Visit a Exponentiation function
+          #
+          # @param [Function::Numeric::Exponentiation] exponentiation
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_exponentiation(exponentiation)
+            binary_prefix_operation_sql(POWER, exponentiation)
+          end
+
+          # Visit a Modulo function
+          #
+          # @param [Function::Numeric::Modulo] modulo
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_modulo(modulo)
+            binary_prefix_operation_sql(MOD, modulo)
+          end
+
+          # Visit a Multiplication function
+          #
+          # @param [Function::Numeric::Multiplication] multiplication
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_multiplication(multiplication)
+            Generator.parenthesize!(binary_infix_operation_sql(MULTIPLY, multiplication))
+          end
+
+          # Visit a Square Root function
+          #
+          # @param [Function::Numeric::SquareRoot] square_root
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_square_root(square_root)
+            unary_prefix_operation_sql(SQUARE_ROOT, square_root)
+          end
+
+          # Visit an Addition function
+          #
+          # @param [Function::Numeric::Addition] subtraction
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_subtraction(subtraction)
+            Generator.parenthesize!(binary_infix_operation_sql(SUBTRACT, subtraction))
+          end
+
+          # Visit an Unary Minus function
+          #
+          # @param [Function::Numeric::UnaryMinus] unary_minus
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_unary_minus(unary_minus)
+            unary_prefix_operation_sql(SUBTRACT, unary_minus)
+          end
+
+          # Visit an Unary Plus function
+          #
+          # @param [Function::Numeric::UnaryPlus] unary_plus
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_numeric_unary_plus(unary_plus)
+            unary_prefix_operation_sql(ADD, unary_plus)
+          end
+
+        end # module Numeric
+      end # module Function
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/function/predicate.rb

@@ -0,0 +1,266 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      module Function
+
+        # Generates an SQL statement for a predicate function
+        module Predicate
+          include Function
+
+          EQUAL_TO                 = '='.freeze
+          EQUAL_TO_NULL            = 'IS'.freeze
+          NOT_EQUAL_TO             = '<>'.freeze
+          NOT_EQUAL_TO_NULL        = 'IS NOT'.freeze
+          GREATER_THAN             = '>'.freeze
+          GREATER_THAN_OR_EQUAL_TO = '>='.freeze
+          LESS_THAN                = '<'.freeze
+          LESS_THAN_OR_EQUAL_TO    = '<='.freeze
+          IN                       = 'IN'.freeze
+          NOT_IN                   = 'NOT IN'.freeze
+          BETWEEN                  = 'BETWEEN'.freeze
+          NOT_BETWEEN              = 'NOT BETWEEN'.freeze
+          EMPTY_ARRAY              = [].freeze
+
+          # Visit an Equality predicate
+          #
+          # @param [Function::Predicate::Equality] equality
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_equality(equality)
+            binary_infix_operation_sql(equality.right.nil? ? EQUAL_TO_NULL : EQUAL_TO, equality)
+          end
+
+          # Visit an Inequality predicate
+          #
+          # @param [Function::Predicate::Inequality] inequality
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_inequality(inequality)
+            expressions = inequality_expressions(inequality)
+            expressions.one? ? expressions.first : Generator.parenthesize!(expressions.join(' OR '))
+          end
+
+          # Visit an GreaterThan predicate
+          #
+          # @param [Function::Predicate::GreaterThan] greater_than
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_greater_than(greater_than)
+            binary_infix_operation_sql(GREATER_THAN, greater_than)
+          end
+
+          # Visit an GreaterThanOrEqualTo predicate
+          #
+          # @param [Function::Predicate::GreaterThanOrEqualTo] greater_than_or_equal_to
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_greater_than_or_equal_to(greater_than_or_equal_to)
+            binary_infix_operation_sql(GREATER_THAN_OR_EQUAL_TO, greater_than_or_equal_to)
+          end
+
+          # Visit an LessThan predicate
+          #
+          # @param [Function::Predicate::LessThan] less_than
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_less_than(less_than)
+            binary_infix_operation_sql(LESS_THAN, less_than)
+          end
+
+          # Visit an LessThanOrEqualTo predicate
+          #
+          # @param [Function::Predicate::LessThanOrEqualTo] less_than_or_equal_to
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_less_than_or_equal_to(less_than_or_equal_to)
+            binary_infix_operation_sql(LESS_THAN_OR_EQUAL_TO, less_than_or_equal_to)
+          end
+
+          # Visit an Inclusion predicate
+          #
+          # @param [Function::Predicate::Inclusion] inclusion
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_inclusion(inclusion)
+            case inclusion.right
+              when Range       then range_inclusion_sql(inclusion)
+              when EMPTY_ARRAY then FALSE
+              else
+                binary_infix_operation_sql(IN, inclusion)
+            end
+          end
+
+          # Visit an Exclusion predicate
+          #
+          # @param [Function::Predicate::Exclusion] exclusion
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def visit_veritas_function_predicate_exclusion(exclusion)
+            case exclusion.right
+              when Range       then range_exclusion_sql(exclusion)
+              when EMPTY_ARRAY then TRUE
+              else
+                binary_infix_operation_sql(NOT_IN, exclusion)
+            end
+          end
+
+        private
+
+          # Return the SQL for an Inclusion using a Range
+          #
+          # @param [Function::Predicate::Inclusion] predicate
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def range_inclusion_sql(inclusion)
+            if inclusion.right.exclude_end?
+              exclusive_range_inclusion_sql(inclusion)
+            else
+              inclusive_range_sql(BETWEEN, inclusion)
+            end
+          end
+
+          # Return the SQL for an Exclusion using a Range
+          #
+          # @param [Function::Predicate::Exclusion] exclusion
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def range_exclusion_sql(exclusion)
+            if exclusion.right.exclude_end?
+              exclusive_range_exclusion_sql(exclusion)
+            else
+              inclusive_range_sql(NOT_BETWEEN, exclusion)
+            end
+          end
+
+          # Return the SQL for an Inclusion using an exclusive Range
+          #
+          # @param [Function::Predicate::Inclusion] inclusion
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def exclusive_range_inclusion_sql(inclusion)
+            left  = new_from_enumerable_predicate(Veritas::Function::Predicate::GreaterThanOrEqualTo, inclusion, :first)
+            right = new_from_enumerable_predicate(Veritas::Function::Predicate::LessThan,             inclusion, :last)
+            dispatch left.and(right)
+          end
+
+          # Return the SQL for an Exclusion using an exclusive Range
+          #
+          # @param [Function::Predicate::Exclusion] exclusion
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def exclusive_range_exclusion_sql(exclusion)
+            left  = new_from_enumerable_predicate(Veritas::Function::Predicate::LessThan,             exclusion, :first)
+            right = new_from_enumerable_predicate(Veritas::Function::Predicate::GreaterThanOrEqualTo, exclusion, :last)
+            dispatch left.or(right)
+          end
+
+          # Instantiate a new Predicate object from an Enumerable Predicate
+          #
+          # @param [Class<Function::Predicate>] klass
+          #   the type of predicate to create
+          # @param [Function::Predicate::Enumerable] predicate
+          #   the enumerable predicate
+          # @param [Symbol] method
+          #   the method to call on the right operand of the predicate
+          # @return [Function::Predicate]
+          #
+          # @api private
+          def new_from_enumerable_predicate(klass, predicate, method)
+            klass.new(predicate.left, predicate.right.send(method))
+          end
+
+          # Return the expressions for an inequality
+          #
+          # @param [Function::Predicate::Inequality] inequality
+          #
+          # @return [Array<#to_s>]
+          #
+          # @api private
+          def inequality_expressions(inequality)
+            expressions = [
+              inequality_sql(inequality),
+              optional_is_null_sql(inequality.left),
+              optional_is_null_sql(inequality.right),
+            ]
+            expressions.compact!
+            expressions
+          end
+
+          # Return the SQL for an inequality predicate
+          #
+          # @param [Function::Predicate::Inequality] inequality
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def inequality_sql(inequality)
+            binary_infix_operation_sql(inequality.right.nil? ? NOT_EQUAL_TO_NULL : NOT_EQUAL_TO, inequality)
+          end
+
+          # Return the SQL for an operation using an inclusive Range
+          #
+          # @param [#to_s] operator
+          #
+          # @param [Function::Predicate::Enumerable] predicate
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def inclusive_range_sql(operator, predicate)
+            right = predicate.right
+            "#{dispatch(predicate.left)} #{operator} #{dispatch(right.first)} AND #{dispatch(right.last)}"
+          end
+
+          # Return SQL for an Equality with a nil value for optional attributes
+          #
+          # @param [Attribute] attribute
+          #
+          # @return [#to_sql, nil]
+          #
+          # @api private
+          def optional_is_null_sql(attribute)
+            dispatch(attribute.eq(nil)) if optional?(attribute)
+          end
+
+          # Test if the object is not required
+          #
+          # @param [Object] operand
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def optional?(operand)
+            operand.respond_to?(:required?) && !operand.required?
+          end
+
+        end # module Predicate
+      end # module Function
+    end # module Generator
+  end # module SQL
+end # module Veritas