axiom-sql-generator 0.1.0

data/lib/axiom/sql/generator/identifier.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Axiom
+  module SQL
+    module Generator
+
+      # Generates an SQL statement for an identifier
+      module Identifier
+
+        QUOTE         = '"'.freeze
+        ESCAPED_QUOTE = '""'.freeze
+
+        # Quote the identifier
+        #
+        # @param [#to_s] identifier
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_identifier(identifier)
+          escaped = identifier.to_s.gsub(QUOTE, ESCAPED_QUOTE)
+          escaped.insert(0, QUOTE) << QUOTE
+        end
+
+      end # module Identifier
+    end # module Generator
+  end # module SQL
+end # module Axiom

data/lib/axiom/sql/generator/literal.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module Axiom
+  module SQL
+    module Generator
+
+      # Generates an SQL statement for a literal
+      module Literal
+
+        TRUE          = 'TRUE'.freeze
+        FALSE         = 'FALSE'.freeze
+        NULL          = 'NULL'.freeze
+        QUOTE         = "'".freeze
+        ESCAPED_QUOTE = "''".freeze
+        SEPARATOR     = ', '.freeze
+        TIME_SCALE    = 9
+
+        # Returns an unfrozen object
+        #
+        # Some objects, like Date, DateTime and Time memoize values
+        # when serialized to a String, so when they are frozen this will
+        # dup them and then return the unfrozen copy.
+        #
+        # @param [Object] object
+        #
+        # @return [Object]
+        #   non-frozen object
+        #
+        # @api private
+        def self.dup_frozen(object)
+          object.frozen? ? object.dup : object
+        end
+
+        # Visit an Enumerable
+        #
+        # @param [Enumerable] enumerable
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_enumerable(enumerable)
+          Generator.parenthesize!(
+            enumerable.map { |entry| dispatch entry }.join(SEPARATOR)
+          )
+        end
+
+        # Visit a String
+        #
+        # @note The string must be UTF-8 encoded
+        #
+        # @param [String] string
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_string(string)
+          escaped = string.gsub(QUOTE, ESCAPED_QUOTE)
+          escaped.insert(0, QUOTE) << QUOTE
+        end
+
+        # Visit a Numeric
+        #
+        # @param [Numeric] numeric
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_numeric(numeric)
+          numeric.to_s
+        end
+
+        # Visit a Class
+        #
+        # @param [Class] klass
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_class(klass)
+          name = klass.name.to_s
+          name.empty? ? NULL : visit_string(name)
+        end
+
+        # Visit a Date and return in ISO 8601 date format
+        #
+        # @param [Date] date
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_date(date)
+          dispatch date.iso8601
+        end
+
+        # Visit a DateTime and return in ISO 8601 date-time format
+        #
+        # Converts the DateTime to UTC format.
+        #
+        # @param [DateTime] date_time
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_date_time(date_time)
+          dispatch date_time.new_offset.iso8601(TIME_SCALE)
+        end
+
+        # Visit a Time
+        #
+        # Converts the Time to UTC format.
+        #
+        # @param [Time] time
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_time(time)
+          dispatch Literal.dup_frozen(time).utc.iso8601(TIME_SCALE)
+        end
+
+        # Visit a true value
+        #
+        # @param [true] _true
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_true_class(_true)
+          TRUE
+        end
+
+        # Visit a false value
+        #
+        # @param [false] _false
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_false_class(_false)
+          FALSE
+        end
+
+        # Visit a nil value
+        #
+        # @param [nil] _nil
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def visit_nil_class(_nil)
+          NULL
+        end
+
+      end # module Literal
+    end # module Generator
+  end # module SQL
+end # module Axiom

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

@@ -0,0 +1,240 @@
+# encoding: utf-8
+
+module Axiom
+  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
+        STAR         = '*'.freeze
+        EMPTY_HASH   = {}.freeze
+
+        # Return the alias name
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        attr_reader :name
+
+        # Factory method to instantiate the generator for the relation
+        #
+        # @param [Axiom::Relation] relation
+        #
+        # @return [Generator::Relation]
+        #
+        # @api private
+        def self.visit(relation)
+          klass = case relation
+          when Axiom::Relation::Operation::Insertion then self::Insertion
+          when Axiom::Relation::Operation::Set       then self::Set
+          when Axiom::Relation::Operation::Binary    then self::Binary
+          when Axiom::Relation::Operation::Unary     then self::Unary
+          when Axiom::Relation::Base                 then self::Base
+          when Axiom::Relation::Materialized         then self::Materialized
+          else
+            raise InvalidRelationError, "#{relation.class} is not a visitable relation"
+          end
+          klass.new.visit(relation)
+        end
+
+        # Initialize a Generator
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize
+          @sql        = EMPTY_STRING
+          @extensions = {}
+        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
+
+        # Return the SQL for the unary relation
+        #
+        # @example
+        #   sql = unary_relation.to_s
+        #
+        # @return [#to_s]
+        #
+        # @api public
+        def to_s
+          return EMPTY_STRING unless visited?
+          generate_sql(query_columns)
+        end
+
+        # Return the SQL suitable for an subquery
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def to_subquery
+          return EMPTY_STRING unless visited?
+          Generator.parenthesize!(generate_sql(subquery_columns))
+        end
+
+        # Test if a visitable object has been visited
+        #
+        # @example
+        #   visitor.visited?  # true or false
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def visited?
+          instance_variable_defined?(:@name)
+        end
+
+      private
+
+        # Return the columns to use in a query
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def query_columns
+          explicit_columns
+        end
+
+        # Return the columns to use in a subquery
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def subquery_columns
+          implicit_columns
+        end
+
+        # Return the implicit columns for the select list
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def implicit_columns
+          sql = [ STAR, column_list_for(@extensions) ]
+          sql.reject! { |fragment| fragment.empty? }
+          sql.join(SEPARATOR)
+        end
+
+        # Return the explicit columns for the select list
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def explicit_columns
+          @distinct.to_s + column_list_for(@extensions.merge(@columns || EMPTY_HASH))
+        end
+
+        # Return the list of columns
+        #
+        # @param [#map] columns
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def column_list_for(columns)
+          sql = columns.values_at(*@header)
+          sql.compact!
+          sql.join(SEPARATOR)
+        end
+
+        # Return a list of columns in a header
+        #
+        # @param [Axiom::Relation] relation
+        #
+        # @param [#[]] aliases
+        #   optional aliases for the columns
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def columns_for(relation, aliases = EMPTY_HASH)
+          columns = {}
+          relation.header.each do |attribute|
+            columns[aliases.fetch(attribute, attribute)] = column_for(attribute, aliases)
+          end
+          columns
+        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)
+          if aliases.key?(attribute)
+            alias_for(attribute, aliases[attribute])
+          else
+            dispatch(attribute)
+          end
+        end
+
+        # Return the column alias for an attribute
+        #
+        # @param [#to_s] attribute
+        #
+        # @param [Attribute, nil] alias_attribute
+        #   attribute to use for the alias
+        #
+        # @return [#to_s]
+        #
+        # @api private
+        def alias_for(attribute, alias_attribute)
+          "#{dispatch(attribute)} AS #{dispatch(alias_attribute)}"
+        end
+
+        # Add extensions for extension and summarize queries
+        #
+        # @param [#each] extensions
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def add_extensions(extensions)
+          extensions.each do |attribute, function|
+            @extensions[attribute] = alias_for(function, attribute)
+          end
+        end
+
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Axiom

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

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Axiom
+  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 Axiom

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

@@ -0,0 +1,136 @@
+# encoding: utf-8
+
+module Axiom
+  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
+
+          # Visit an Join
+          #
+          # @param [Algebra::Join] join
+          #
+          # @return [self]
+          #
+          # @api private
+          def visit_axiom_algebra_join(join)
+            @header = join.header
+            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_axiom_algebra_product(product)
+            @header = product.header
+            set_operation(PRODUCT)
+            set_columns(product)
+            set_operands(product)
+            set_name
+            self
+          end
+
+        private
+
+          # Generate the SQL using the supplied columns
+          #
+          # @param [String] columns
+          #
+          # @return [#to_s]
+          #
+          # @api private
+          def generate_sql(columns)
+            "SELECT #{columns} FROM #{@left.to_subquery} AS #{visit_identifier(LEFT_NAME)} #{@operation} #{@right.to_subquery} AS #{visit_identifier(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
+
+          # Generates an SQL statement for base relation binary operands
+          class Base < Relation::Base
+
+            # Return the SQL suitable for an subquery
+            #
+            # Does not parenthesize the query
+            #
+            # @return [#to_s]
+            #
+            # @api private
+            def to_subquery
+              return EMPTY_STRING unless visited?
+              generate_sql
+            end
+
+          private
+
+            # Generate the SQL for this base relation
+            #
+            # @return [#to_s]
+            #
+            # @api private
+            def generate_sql(*)
+              @from
+            end
+
+          end # class Base
+        end # class Binary
+      end # class Relation
+    end # module Generator
+  end # module SQL
+end # module Axiom