veritas-sql-generator 0.0.3

data/lib/veritas/sql/generator/relation.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+
+      # Abstract base class for SQL generation from a relation
+      class Relation < Visitor
+        extend Identifier
+        include Attribute
+
+        EMPTY_STRING = ''.freeze
+        SEPARATOR    = ', '.freeze
+        ALL_COLUMNS  = '*'.freeze
+
+        # Return the alias name
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        attr_reader :name
+
+        # Factory method to instantiate the generator for the relation
+        #
+        # @param [Veritas::Relation]
+        #
+        # @return [Generator::Relation]
+        #
+        # @api private
+        def self.visit(relation)
+          klass = case relation
+            when Veritas::Relation::Operation::Set    then self::Set
+            when Veritas::Relation::Operation::Binary then self::Binary
+            when Veritas::Relation::Operation::Unary  then self::Unary
+            when Veritas::BaseRelation                then self::Base
+            else
+              raise InvalidRelationError, "#{relation.class} is not a visitable relation"
+          end
+          klass.new.visit(relation)
+        end
+
+        # Return the subquery for the relation and identifier
+        #
+        # @param [#to_subquery] relation
+        #
+        # @param [#to_s] identifier
+        #   optional identifier, defaults to relation.name
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def self.subquery(relation, identifier = relation.name)
+          "(#{relation.to_subquery}) AS #{visit_identifier(identifier)}"
+        end
+
+        # Initialize a Generator
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize
+          @sql = EMPTY_STRING
+        end
+
+        # Visit an object and generate SQL from each node
+        #
+        # @example
+        #   generator.visit(visitable)
+        #
+        # @param [Visitable] visitable
+        #   A visitable object
+        #
+        # @return [self]
+        #
+        # @raise [Visitor::UnknownObject]
+        #   raised when the visitable object has no handler
+        #
+        # @api public
+        def visit(visitable)
+          @sql = dispatch(visitable).to_s.freeze
+          freeze
+        end
+
+        # Returns the current SQL string
+        #
+        # @example
+        #   sql = generator.to_sql
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_sql
+          @sql
+        end
+
+        # Test if a visitable object has been visited
+        #
+        # @example
+        #   visitor.visited?  # true or false
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def visited?
+          !@name.nil?
+        end
+
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/relation/base.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      class Relation
+
+        # Generates an SQL statement for a base relation
+        class Base < Unary; end
+
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/relation/binary.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      class Relation
+
+        # Generates an SQL statement for a Binary relation
+        class Binary < Relation
+
+          JOIN       = 'NATURAL JOIN'.freeze
+          PRODUCT    = 'CROSS JOIN'.freeze
+          LEFT_NAME  = 'left'.freeze
+          RIGHT_NAME = 'right'.freeze
+
+          # Return the subquery for the generator and identifier
+          #
+          # @param [#to_subquery] generator
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def self.subquery(generator, *)
+            generator.kind_of?(Base) ? generator.to_subquery : super
+          end
+
+          # Visit an Join
+          #
+          # @param [Algebra::Join] join
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_join(join)
+            set_operation(JOIN)
+            set_columns(join)
+            set_operands(join)
+            set_name
+            self
+          end
+
+          # Visit an Product
+          #
+          # @param [Algebra::Product] product
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_product(product)
+            set_operation(PRODUCT)
+            set_columns(product)
+            set_operands(product)
+            set_name
+            self
+          end
+
+          # Return the SQL for the binary relation
+          #
+          # @example
+          #   sql = binary_relation.to_s
+          #
+          # @return [#to_s]
+          #
+          # @api public
+          def to_s
+            generate_sql(@columns)
+          end
+
+          # Return the SQL suitable for an subquery
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def to_subquery
+            generate_sql(ALL_COLUMNS)
+          end
+
+        private
+
+          # Generate the SQL using the supplied columns
+          #
+          # @param [String] columns
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def generate_sql(columns)
+            return EMPTY_STRING unless visited?
+            "SELECT #{columns} FROM #{left_subquery} #{@operation} #{right_subquery}"
+          end
+
+          # Return the left subquery
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def left_subquery
+            self.class.subquery(@left, LEFT_NAME)
+          end
+
+          # Return the right subquery
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def right_subquery
+            self.class.subquery(@right, RIGHT_NAME)
+          end
+
+          # Set the operation
+          #
+          # @param [#to_s] operation
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def set_operation(operation)
+            @operation = operation
+          end
+
+          # Set the columns from the relation
+          #
+          # @param [Relation::Operation::Binary] relation
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def set_columns(relation)
+            @columns = columns_for(relation)
+          end
+
+          # Set the operands from the relation
+          #
+          # @param [Relation::Operation::Binary] relation
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def set_operands(relation)
+            util   = self.class
+            @left  = util.visit(relation.left)
+            @right = util.visit(relation.right)
+          end
+
+          # Set the name using the operands' name
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def set_name
+            @name = [ @left.name, @right.name ].uniq.join(UNDERSCORE).freeze
+          end
+
+          # Return a list of columns in a header
+          #
+          # @param [Veritas::Relation] relation
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def columns_for(relation)
+            relation.header.map { |attribute| dispatch(attribute) }.join(SEPARATOR)
+          end
+
+          # Generates an SQL statement for base relation binary operands
+          class Base < Relation::Base
+
+          private
+
+            # Generate the SQL for this base relation
+            #
+            # @return [#to_s]
+            #
+            # @api private
+            def generate_sql(*)
+              visited? ? @from : EMPTY_STRING
+            end
+
+          end # class Base
+        end # class Binary
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/relation/set.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      class Relation
+
+        # Generates an SQL statement for a set relation
+        class Set < Binary
+
+          DIFFERENCE   = 'EXCEPT'.freeze
+          INTERSECTION = 'INTERSECT'.freeze
+          UNION        = 'UNION'.freeze
+
+          # Visit a Union
+          #
+          # @param [Algebra::Union] union
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_union(union)
+            set_operation(UNION)
+            set_operands(union)
+            set_name
+            self
+          end
+
+          # Visit an Intersection
+          #
+          # @param [Algebra::Intersection] intersection
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_intersection(intersection)
+            set_operation(INTERSECTION)
+            set_operands(intersection)
+            set_name
+            self
+          end
+
+          # Visit an Difference
+          #
+          # @param [Algebra::Difference] difference
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_difference(difference)
+            set_operation(DIFFERENCE)
+            set_operands(difference)
+            set_name
+            self
+          end
+
+          # Return the SQL for the set relation
+          #
+          # @example
+          #   sql = set_relation.to_s
+          #
+          # @return [#to_s]
+          #
+          # @api public
+          def to_s
+            generate_sql(:to_s)
+          end
+
+          # Return the SQL suitable for an subquery
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def to_subquery
+            generate_sql(:to_subquery)
+          end
+
+        private
+
+          # Generate the SQL using the supplied method
+          #
+          # @param [Symbol] method
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def generate_sql(method)
+            return EMPTY_STRING unless visited?
+            "(#{@left.send(method)}) #{@operation} (#{@right.send(method)})"
+          end
+
+          # Generates an SQL statement for base relation set operands
+          class Base < Relation::Base; end
+
+        end # class Set
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Veritas

data/lib/veritas/sql/generator/relation/unary.rb

@@ -0,0 +1,326 @@
+# encoding: utf-8
+
+module Veritas
+  module SQL
+    module Generator
+      class Relation
+
+        # Generates an SQL statement for a unary relation
+        class Unary < Relation
+          extend Aliasable
+          include Direction, Literal, Logic
+
+          inheritable_alias(:visit_veritas_relation_operation_reverse => :visit_veritas_relation_operation_order)
+
+          DISTINCT     = 'DISTINCT '.freeze
+          COLLAPSIBLE  = {
+            Algebra::Projection                   => Set[ Algebra::Projection, Algebra::Restriction,                                                                                                                                                                        ].freeze,
+            Algebra::Restriction                  => Set[ Algebra::Projection,                       Veritas::Relation::Operation::Order, Veritas::Relation::Operation::Reverse,                                                                                            ].freeze,
+            Veritas::Relation::Operation::Order   => Set[ Algebra::Projection, Algebra::Restriction, Veritas::Relation::Operation::Order, Veritas::Relation::Operation::Reverse,                                                                            Algebra::Rename ].freeze,
+            Veritas::Relation::Operation::Reverse => Set[ Algebra::Projection, Algebra::Restriction, Veritas::Relation::Operation::Order, Veritas::Relation::Operation::Reverse,                                                                            Algebra::Rename ].freeze,
+            Veritas::Relation::Operation::Offset  => Set[ Algebra::Projection, Algebra::Restriction, Veritas::Relation::Operation::Order, Veritas::Relation::Operation::Reverse,                                                                            Algebra::Rename ].freeze,
+            Veritas::Relation::Operation::Limit   => Set[ Algebra::Projection, Algebra::Restriction, Veritas::Relation::Operation::Order, Veritas::Relation::Operation::Reverse, Veritas::Relation::Operation::Offset,                                      Algebra::Rename ].freeze,
+            Algebra::Rename                       => Set[ Algebra::Projection, Algebra::Restriction, Veritas::Relation::Operation::Order, Veritas::Relation::Operation::Reverse, Veritas::Relation::Operation::Offset, Veritas::Relation::Operation::Limit                  ].freeze,
+          }.freeze
+
+          # Initialize a Unary relation SQL generator
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def initialize
+            super
+            @scope = ::Set.new
+          end
+
+          # Visit a Base Relation
+          #
+          # @param [BaseRelation] base_relation
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_base_relation(base_relation)
+            @name    = base_relation.name
+            @from    = visit_identifier(@name)
+            @columns = columns_for(base_relation)
+            self
+          end
+
+          # Visit a Projection
+          #
+          # @param [Algebra::Projection] projection
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_projection(projection)
+            @from     = subquery_for(projection)
+            @distinct = DISTINCT
+            @columns  = columns_for(projection)
+            scope_query(projection)
+            self
+          end
+
+          # Visit a Rename
+          #
+          # @param [Algebra::Rename] rename
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_rename(rename)
+            @from    = subquery_for(rename)
+            @columns = columns_for(rename.operand, rename.aliases.to_hash)
+            scope_query(rename)
+            self
+          end
+
+          # Visit a Restriction
+          #
+          # @param [Algebra::Restriction] restriction
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_algebra_restriction(restriction)
+            @from      = subquery_for(restriction)
+            @where     = dispatch(restriction.predicate)
+            @columns ||= columns_for(restriction)
+            scope_query(restriction)
+            self
+          end
+
+          # Visit an Order
+          #
+          # @param [Relation::Operation::Order] order
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_relation_operation_order(order)
+            @from      = subquery_for(order)
+            @order     = order_for(order.directions)
+            @columns ||= columns_for(order)
+            scope_query(order)
+            self
+          end
+
+          # Visit a Limit
+          #
+          # @param [Relation::Operation::Limit] limit
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_relation_operation_limit(limit)
+            @from      = subquery_for(limit)
+            @limit     = limit.limit
+            @columns ||= columns_for(limit)
+            scope_query(limit)
+            self
+          end
+
+          # Visit an Offset
+          #
+          # @param [Relation::Operation::Offset] offset
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_veritas_relation_operation_offset(offset)
+            @from      = subquery_for(offset)
+            @offset    = offset.offset
+            @columns ||= columns_for(offset)
+            scope_query(offset)
+            self
+          end
+
+          # Return the SQL for the unary relation
+          #
+          # @example
+          #   sql = unary_relation.to_s
+          #
+          # @return [#to_s]
+          #
+          # @api public
+          def to_s
+            generate_sql(@columns)
+          end
+
+          # Return the SQL suitable for an subquery
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def to_subquery
+            generate_sql(all_columns? ? ALL_COLUMNS : @columns)
+          end
+
+        private
+
+          # Generate the SQL using the supplied columns
+          #
+          # @param [String] columns
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def generate_sql(columns)
+            return EMPTY_STRING unless visited?
+            sql = "SELECT #{@distinct}#{columns} FROM #{@from}"
+            sql << " WHERE #{@where}"    if @where
+            sql << " ORDER BY #{@order}" if @order
+            sql << " LIMIT #{@limit}"    if @limit
+            sql << " OFFSET #{@offset}"  if @offset
+            sql
+          end
+
+          # Return a list of columns in a header
+          #
+          # @param [Veritas::Relation] relation
+          #
+          # @param [#[]] aliases
+          #   optional aliases for the columns
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def columns_for(relation, aliases = {})
+            relation.header.map { |attribute| column_for(attribute, aliases) }.join(SEPARATOR)
+          end
+
+          # Return the column for an attribute
+          #
+          # @param [Attribute] attribute
+          #
+          # @param [#[]] aliases
+          #   aliases for the columns
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def column_for(attribute, aliases)
+            column = dispatch(attribute)
+            if aliases.key?(attribute)
+              alias_for(column, aliases[attribute])
+            else
+              column
+            end
+          end
+
+          # Return the column alias for an attribute
+          #
+          # @param [#to_s] column
+          #
+          # @param [Attribute, nil] alias_attribute
+          #   attribute to use for the alias
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def alias_for(column, alias_attribute)
+            "#{column} AS #{visit_identifier(alias_attribute.name)}"
+          end
+
+          # Return a list of columns for ordering
+          #
+          # @param [DirectionSet] directions
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def order_for(directions)
+            directions.map { |direction| dispatch(direction) }.join(SEPARATOR)
+          end
+
+          # Return an expression that can be used for the FROM
+          #
+          # @param [Relation] relation
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def subquery_for(relation)
+            operand  = relation.operand
+            subquery = dispatch(operand)
+            if collapse_subquery_for?(relation)
+              @from
+            else
+              aliased_subquery(subquery)
+            end
+          end
+
+          # Add the operand to the current scope
+          #
+          # @param [Relation] operand
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def scope_query(operand)
+            @scope << operand.class
+          end
+
+          # Test if the query should use "*" and not specify columns explicitly
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def all_columns?
+            !@scope.include?(Algebra::Projection) && !@scope.include?(Algebra::Rename)
+          end
+
+          # Test if the relation should be collapsed
+          #
+          # @param [Relation] relation
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def collapse_subquery_for?(relation)
+            @scope.subset?(COLLAPSIBLE.fetch(relation.class))
+          end
+
+          # Returns an aliased subquery
+          #
+          # @param [#to_s] subquery
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def aliased_subquery(subquery)
+            self.class.subquery(subquery)
+          ensure
+            reset_query_state
+          end
+
+          # Visit a Binary Relation
+          #
+          # @param [Relation::Operation::Binary] set
+          #
+          # @return [Relation::Binary]
+          #
+          # @api private
+          def visit_veritas_relation_operation_binary(binary)
+            generator = self.class.visit(binary)
+            @name     = generator.name
+            @from     = aliased_subquery(generator)
+            generator
+          end
+
+          # Reset the query state
+          #
+          # @return [undefined]
+          #
+          # @api private
+          def reset_query_state
+            @scope.clear
+            @distinct = @columns = @where = @order = @limit = @offset = nil
+          end
+
+        end # class Unary
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Veritas