Added options hash to Node#to_sql methods.

Author: wvanbergen

lib/sql_tree/node.rb

@@ -20,7 +20,7 @@ def initialize(attributes = {}) # :nodoc:
 
     # Pretty prints this instance for inspection
     def inspect
-      "#{self.class.name}[#{self.to_sql}]"
+      "#{self.class.name}[#{self.to_sql(options)}]"
     end
 
     # Quotes a variable name so that it can be safely used within

lib/sql_tree/node/delete_query.rb

@@ -18,9 +18,9 @@ def initialize(table, where = nil)
     end
 
     # Generates an SQL DELETE query from this node.
-    def to_sql
-      sql = "DELETE FROM #{table.to_sql}"
-      sql << " WHERE #{where.to_sql}" if self.where
+    def to_sql(options = {})
+      sql = "DELETE FROM #{table.to_sql(options)}"
+      sql << " WHERE #{where.to_sql(options)}" if self.where
       sql
     end
 

lib/sql_tree/node/expression.rb

@@ -72,8 +72,8 @@ class PrefixOperator  < SQLTree::Node::Expression
       attr_accessor :rhs
 
       # Generates an SQL fragment for this prefix operator expression.
-      def to_sql
-        "#{operator.upcase} #{rhs.to_sql}"
+      def to_sql(options = {})
+        "#{operator.upcase} #{rhs.to_sql(options)}"
       end
 
       def ==(other) # :nodoc:
@@ -123,8 +123,8 @@ def ==(other) # :nodoc:
       end
 
       # Generates an SQL fragment for this postfix operator expression.
-      def to_sql
-        "#{lhs.to_sql} #{operator}"
+      def to_sql(options = {})
+        "#{lhs.to_sql(options)} #{operator}"
       end
 
       # Parses a postfix operator expression. This method is not yet implemented.
@@ -175,8 +175,8 @@ class BinaryOperator  < SQLTree::Node::Expression
       attr_accessor :rhs
 
       # Generates an SQL fragment for this exression.
-      def to_sql
-        "(#{lhs.to_sql} #{operator} #{rhs.to_sql})"
+      def to_sql(options = {})
+        "(#{lhs.to_sql(options)} #{operator} #{rhs.to_sql(options)})"
       end
 
       def ==(other) # :nodoc:
@@ -282,8 +282,8 @@ def initialize(*items)
       end
 
       # Generates an SQL fragment for this list.
-      def to_sql
-        "(#{items.map {|i| i.to_sql}.join(', ')})"
+      def to_sql(options = {})
+        "(#{items.map {|i| i.to_sql(options)}.join(', ')})"
       end
 
       def ==(other) # :nodoc:
@@ -336,8 +336,8 @@ class FunctionCall  < SQLTree::Node::Expression
       attr_accessor :argument_list
 
       # Generates an SQL fragment for this function call.
-      def to_sql
-        "#{function}(" + argument_list.items.map { |e| e.to_sql }.join(', ') + ")"
+      def to_sql(options = {})
+        "#{function}(" + argument_list.items.map { |e| e.to_sql(options) }.join(', ') + ")"
       end
 
       def ==(other) # :nodoc:
@@ -383,7 +383,7 @@ def initialize(value) # :nodoc:
       #
       # @return [String] A correctly quoted value that can be used safely
       # within an SQL query
-      def to_sql
+      def to_sql(options = {})
         case value
         when nil            then 'NULL'
         when String         then quote_str(@value)
@@ -434,7 +434,7 @@ def initialize(name) # :nodoc:
       #
       # @return [String] A correctly quoted variable that can be safely 
       # used in SQL queries
-      def to_sql
+      def to_sql(options = {})
         quote_var(@name)
       end
 
@@ -481,7 +481,7 @@ def initialize(name, table = nil)
 
       # Generates a correctly quoted reference to the field, which can
       # be incorporated safely into an SQL query.
-      def to_sql
+      def to_sql(options = {})
         @table.nil? ? quote_var(@name) : quote_var(@table) + '.' + quote_var(@name)
       end
 

lib/sql_tree/node/insert_query.rb

@@ -8,10 +8,10 @@ def initialize(table, fields = nil, values = [])
       @table, @fields, @values  = table, fields, values
     end
 
-    def to_sql
-      sql = "INSERT INTO #{table.to_sql} "
-      sql << '(' + fields.map { |f| f.to_sql }.join(', ') + ') ' if fields
-      sql << 'VALUES (' + values.map { |v| v.to_sql }.join(', ') + ')'
+    def to_sql(options = {})
+      sql = "INSERT INTO #{table.to_sql(options)} "
+      sql << '(' + fields.map { |f| f.to_sql(options) }.join(', ') + ') ' if fields
+      sql << 'VALUES (' + values.map { |v| v.to_sql(options) }.join(', ') + ')'
       sql
     end
 

lib/sql_tree/node/join.rb

@@ -8,10 +8,10 @@ def initialize(values = {})
       values.each { |key, value| self.send(:"#{key}=", value) }
     end
 
-    def to_sql
+    def to_sql(options = {})
       join_sql = join_type ? "#{join_type.to_s.upcase} " : ""
-      join_sql << "JOIN #{table_reference.to_sql} "
-      join_sql << "ON #{join_expression.to_sql}"
+      join_sql << "JOIN #{table_reference.to_sql(options)} "
+      join_sql << "ON #{join_expression.to_sql(options)}"
       join_sql
     end
 

lib/sql_tree/node/ordering.rb

@@ -8,8 +8,8 @@ def initialize(expression, direction = nil)
       @expression, @direction = expression, direction
     end
 
-    def to_sql
-      sql = expression.to_sql
+    def to_sql(options = {})
+      sql = expression.to_sql(options)
       sql << " #{direction.to_s.upcase}" if direction
       sql
     end

lib/sql_tree/node/select_declaration.rb

@@ -4,8 +4,8 @@ class SelectDeclaration < Base
 
     attr_accessor :expression, :variable
 
-    def to_sql
-      sql = @expression.to_sql
+    def to_sql(options = {})
+      sql = @expression.to_sql(options)
       sql << " AS " << quote_var(@variable) if @variable
       return sql
     end
@@ -60,7 +60,7 @@ def ==(other)
       other.class == self.class && other.table == self.table
     end
 
-    def to_sql
+    def to_sql(options = {})
       table ? "#{quote_var(table)}.*" : '*'
     end
   end

lib/sql_tree/node/select_query.rb

@@ -9,15 +9,15 @@ def initialize
       @select   = []
     end
 
-    def to_sql
+    def to_sql(options = {})
       raise "At least one SELECT expression is required" if self.select.empty?
       sql = (self.distinct) ? "SELECT DISTINCT " : "SELECT "
-      sql << select.map { |s| s.to_sql }.join(', ')
-      sql << " FROM "     << from.map { |f| f.to_sql }.join(', ') if from
-      sql << " WHERE "    << where.to_sql if where
-      sql << " GROUP BY " << group_by.map { |g| g.to_sql }.join(', ') if group_by
-      sql << " ORDER BY " << order_by.map { |o| o.to_sql }.join(', ') if order_by
-      sql << " HAVING "   << having.to_sql if having
+      sql << select.map { |s| s.to_sql(options) }.join(', ')
+      sql << " FROM "     << from.map { |f| f.to_sql(options) }.join(', ') if from
+      sql << " WHERE "    << where.to_sql(options) if where
+      sql << " GROUP BY " << group_by.map { |g| g.to_sql(options) }.join(', ') if group_by
+      sql << " ORDER BY " << order_by.map { |o| o.to_sql(options) }.join(', ') if order_by
+      sql << " HAVING "   << having.to_sql(options) if having
       return sql
     end
 

lib/sql_tree/node/source.rb

@@ -16,9 +16,9 @@ def table_alias
       table_reference.table_alias
     end
 
-    def to_sql
-      sql = table_reference.to_sql
-      sql << ' ' << joins.map { |j| j.to_sql }.join(' ') if joins.any?
+    def to_sql(options = {})
+      sql = table_reference.to_sql(options)
+      sql << ' ' << joins.map { |j| j.to_sql(options) }.join(' ') if joins.any?
       return sql
     end
 

lib/sql_tree/node/table_reference.rb

@@ -8,7 +8,7 @@ def initialize(table, table_alias = nil)
       @table, @table_alias = table, table_alias
     end
 
-    def to_sql
+    def to_sql(options = {})
       sql = quote_var(table)
       sql << " AS " << quote_var(table_alias) if table_alias
       return sql

lib/sql_tree/node/update_query.rb

@@ -22,10 +22,10 @@ def initialize(table, updates = [], where = nil)
 
     # Generates the SQL UPDATE query.
     # @return [String] The SQL update query
-    def to_sql
-      sql = "UPDATE #{table.to_sql} SET "
-      sql << updates.map { |u| u.to_sql }.join(', ')
-      sql << " WHERE " << where.to_sql if self.where
+    def to_sql(options = {})
+      sql = "UPDATE #{table.to_sql(options)} SET "
+      sql << updates.map { |u| u.to_sql(options) }.join(', ')
+      sql << " WHERE " << where.to_sql(options) if self.where
       sql
     end
 
@@ -78,8 +78,8 @@ def initialize(field, expression = nil)
       # Generates an SQL fragment for this node.
       # @return [String] An SQL fragment that can be embedded in the SET
       #    clause of on SQL UPDATE query.
-      def to_sql
-        "#{field.to_sql} = #{expression.to_sql}"
+      def to_sql(options = {})
+        "#{field.to_sql(options)} = #{expression.to_sql(options)}"
       end
 
       # Parses an Assignment node from a stream of tokens. Syntax: