arel_extensions 1.1.8 → 1.1.9

data/lib/arel_extensions/visitors/to_sql.rb

@@ -1,6 +1,6 @@
 module ArelExtensions
   module Visitors
-	Arel::Visitors::ToSql.class_eval do
+  Arel::Visitors::ToSql.class_eval do
 
       # Math Functions
       def visit_ArelExtensions_Nodes_Abs o, collector
@@ -52,14 +52,14 @@ module ArelExtensions
         collector << ")"
         collector
       end
-      
+  
       def visit_ArelExtensions_Nodes_Log10 o, collector
         collector << "LOG10("
         collector = visit o.left, collector
         collector << ")"
         collector
       end
-      
+  
       def visit_ArelExtensions_Nodes_Power o, collector
         collector << "POW("
         o.expressions.each_with_index { |arg, i|
@@ -73,7 +73,7 @@ module ArelExtensions
       # String functions
       def visit_ArelExtensions_Nodes_Concat o, collector
         collector << "CONCAT("
-	    o.expressions.each_with_index { |arg, i|
+      o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
         }
@@ -134,7 +134,7 @@ module ArelExtensions
         collector << ")"
         collector
       end
-      
+  
       def visit_ArelExtensions_Nodes_Repeat o, collector
         collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
@@ -205,7 +205,6 @@ module ArelExtensions
         collector
       end
 
-
       def visit_ArelExtensions_Nodes_Rtrim o, collector
         collector << "RTRIM("
         o.expressions.each_with_index { |arg, i|
@@ -217,7 +216,7 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Blank o, collector
-		#visit o.left.coalesce('').trim.length.eq(0), collector
+    #visit o.left.coalesce('').trim.length.eq(0), collector
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.left, collector
         collector << Arel::Visitors::ToSql::COMMA
@@ -228,7 +227,7 @@ module ArelExtensions
 
 
       def visit_ArelExtensions_Nodes_NotBlank o, collector
-		#visit o.left.coalesce('').trim.length.gt(0), collector
+    #visit o.left.coalesce('').trim.length.gt(0), collector
         collector << 'LENGTH(TRIM(COALESCE('
         collector = visit o.left, collector
         collector << Arel::Visitors::ToSql::COMMA
@@ -257,33 +256,33 @@ module ArelExtensions
         collector
       end
 
-  	  #comparators
+      #comparators
 
-	  def visit_ArelExtensions_Nodes_Cast o, collector
+      def visit_ArelExtensions_Nodes_Cast o, collector
         collector << "CAST("
         collector = visit o.left, collector
         collector << " AS "
-		case o.as_attr
-		when :string
-			as_attr = Arel::Nodes::SqlLiteral.new('char')
-		when :number 
-			as_attr = Arel::Nodes::SqlLiteral.new('int')
-		when :decimal, :float 
-			as_attr = Arel::Nodes::SqlLiteral.new('float')
-		when :datetime 
-			as_attr = Arel::Nodes::SqlLiteral.new('datetime')
-		when :time
-			as_attr = Arel::Nodes::SqlLiteral.new('time')
-		when :binary			
-			as_attr = Arel::Nodes::SqlLiteral.new('binary')		
-		else
-			as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
-		end
+        case o.as_attr
+        when :string
+          as_attr = Arel::Nodes::SqlLiteral.new('char')
+        when :number  
+          as_attr = Arel::Nodes::SqlLiteral.new('int')
+        when :decimal, :float  
+          as_attr = Arel::Nodes::SqlLiteral.new('float')
+        when :datetime  
+          as_attr = Arel::Nodes::SqlLiteral.new('datetime')
+        when :time
+          as_attr = Arel::Nodes::SqlLiteral.new('time')
+        when :binary  
+          as_attr = Arel::Nodes::SqlLiteral.new('binary')  
+        else
+          as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
+        end
         collector = visit as_attr, collector
         collector << ")"
         collector
-	  end
-      
+      end
+
       def visit_ArelExtensions_Nodes_Coalesce o, collector
         collector << "COALESCE("
         o.expressions.each_with_index { |arg, i|
@@ -294,19 +293,19 @@ module ArelExtensions
         collector
       end
 
-  	  def visit_ArelExtensions_Nodes_DateDiff o, collector
+      def visit_ArelExtensions_Nodes_DateDiff o, collector
         collector << if o.left_node_type == :ruby_time || o.left_node_type == :datetime || o.left_node_type == :time
                       'TIMEDIFF('
                     else
                       'DATEDIFF('
                     end
-  	    collector = visit o.left, collector
-  	    collector << Arel::Visitors::ToSql::COMMA
-  	    collector = visit o.right, collector
-  	    collector << ")"
-  	    collector
-  	  end
- 
+        collector = visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        collector = visit o.right, collector
+        collector << ")"
+        collector
+      end
+  
       def visit_ArelExtensions_Nodes_DateSub o, collector
         collector << "DATE_SUB("
         collector = visit o.left, collector
@@ -372,20 +371,20 @@ module ArelExtensions
         collector << ")"
         collector
       end
-      
-	  def visit_ArelExtensions_Nodes_IsNotNull o, collector
-        collector << "NOT ISNULL("
-        collector = visit o.left, collector
-        collector << ")"
-        collector
-	  end
+
+      def visit_ArelExtensions_Nodes_IsNotNull o, collector
+          collector << "NOT ISNULL("
+          collector = visit o.left, collector
+          collector << ")"
+          collector
+      end
 
       def visit_ArelExtensions_Nodes_Then o, collector
         collector << "CASE WHEN ("
         collector = visit o.left, collector
         collector << ") THEN "
         collector = visit o.right, collector
-        if o.expressions[2]          
+        if o.expressions[2]  
           collector << " ELSE "
           collector = visit o.expressions[2], collector
         end
@@ -403,140 +402,209 @@ module ArelExtensions
         collector
       end
 
-    if Arel::VERSION.to_i < 7
-      def visit_ArelExtensions_InsertManager_BulkValues o, collector
-        collector << 'VALUES '
-        row_nb = o.left.length
-        o.left.each_with_index do |row, idx|
-          collector << '('
-          v = Arel::Nodes::Values.new(row, o.cols)
-          len = v.expressions.length - 1
-          v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
-              case value
-              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
-                collector = visit value, collector
-              else
-                collector << quote(value, attr && column_for(attr)).to_s
-              end
-              collector << Arel::Visitors::ToSql::COMMA unless i == len
-          }
-          collector << (idx == row_nb-1 ? ')' : '), ')
+      if Arel::VERSION.to_i < 7
+        def visit_ArelExtensions_InsertManager_BulkValues o, collector
+          collector << 'VALUES '
+          row_nb = o.left.length
+          o.left.each_with_index do |row, idx|
+            collector << '('
+            v = Arel::Nodes::Values.new(row, o.cols)
+            len = v.expressions.length - 1
+            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+                case value
+                when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                  collector = visit value, collector
+                else
+                  collector << quote(value, attr && column_for(attr)).to_s
+                end
+                collector << Arel::Visitors::ToSql::COMMA unless i == len
+            }
+            collector << (idx == row_nb-1 ? ')' : '), ')
+          end
+          collector
+        end
+      else
+        def visit_ArelExtensions_InsertManager_BulkValues o, collector
+          collector << 'VALUES '
+          row_nb = o.left.length
+          o.left.each_with_index do |row, idx|
+            collector << '('
+            v = Arel::Nodes::Values.new(row, o.cols)
+            len = v.expressions.length - 1
+            v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+                case value
+                when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                  collector = visit value, collector
+                else
+                  collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
+                end
+                collector << Arel::Visitors::ToSql::COMMA unless i == len
+            }
+            collector << (idx == row_nb-1 ? ')' : '), ')
+          end
+          collector
         end
+      end
+
+      def visit_ArelExtensions_Nodes_Union o, collector
+        collector = visit o.left, collector
+        collector << " UNION "
+        collector = visit o.right, collector
         collector
       end
-    else
-      def visit_ArelExtensions_InsertManager_BulkValues o, collector
-        collector << 'VALUES '
-        row_nb = o.left.length
-        o.left.each_with_index do |row, idx|
-          collector << '('
-          v = Arel::Nodes::Values.new(row, o.cols)
-          len = v.expressions.length - 1
-          v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
-              case value
-              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
-                collector = visit value, collector
-              else
-                collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
-              end
-              collector << Arel::Visitors::ToSql::COMMA unless i == len
+  
+      def visit_ArelExtensions_Nodes_UnionAll o, collector
+        collector = visit o.left, collector
+        collector << " UNION ALL "
+        collector = visit o.right, collector
+        collector
+      end
+  
+      def visit_ArelExtensions_Nodes_As o, collector
+        if o.left.is_a?(ArelExtensions::Nodes::Union) || o.left.is_a?(ArelExtensions::Nodes::UnionAll)
+          collector << "("
+          collector = visit o.left, collector
+          collector << ") "
+          visit o.right, collector
+        else
+          collector = visit o.left, collector
+          collector << " AS "
+          visit o.right, collector
+        end
+      end
+  
+      def visit_ArelExtensions_Nodes_Case o, collector
+        collector << "CASE "
+        if o.case
+          visit o.case, collector
+          collector << " "
+        end
+        o.conditions.each do |condition|
+          visit condition, collector
+          collector << " "
+        end
+        if o.default
+          visit o.default, collector
+          collector << " "
+        end
+        collector << "END"
+      end
+
+      def visit_ArelExtensions_Nodes_Case_When o, collector
+        collector << "WHEN "
+        visit Arel::Nodes.build_quoted(o.left), collector
+        collector << " THEN "
+        visit Arel::Nodes.build_quoted(o.right), collector
+      end
+
+      def visit_ArelExtensions_Nodes_Case_Else o, collector
+        collector << "ELSE "
+        visit Arel::Nodes.build_quoted(o.expr), collector
+      end
+
+      def visit_ArelExtensions_Nodes_FormattedNumber o, collector  
+        visit o.left, collector
+      end
+  
+      remove_method(:visit_Arel_Nodes_LessThan) rescue nil  
+      def visit_Arel_Nodes_LessThan o, collector
+        collector = visit o.left, collector
+        collector << " < "
+        visit o.right, collector
+      end
+  
+      def visit_ArelExtensions_Nodes_Std o, collector  
+        collector << "STD("
+        visit o.left, collector
+        collector << ")"
+        collector
+      end
+  
+      def visit_ArelExtensions_Nodes_Variance o, collector  
+        collector << "VARIANCE("
+        visit o.left, collector
+        collector << ")"
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
+        collector << "LEVENSHTEIN_DISTANCE("
+        collector = visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        collector = visit o.right, collector
+        collector << ')'
+        collector
+      end
+
+      alias_method :old_visit_Arel_Nodes_And, :visit_Arel_Nodes_And
+      def visit_Arel_Nodes_And o, collector
+        if o.children.length == 2
+          old_visit_Arel_Nodes_And o, collector
+        else
+          o.children.each_with_index { |arg, i|
+            if i == 0
+              collector << '('
+            else
+              collector << ') AND ('
+            end
+            collector = visit arg, collector
           }
-          collector << (idx == row_nb-1 ? ')' : '), ')
+          collector << ')'
+          collector
+        end
+      end
+
+      def visit_ArelExtensions_Nodes_Or o, collector
+        collector << '('
+        o.children.each_with_index { |arg, i|
+          if i == 0
+            collector << '('
+          else
+            collector << ') OR ('
+          end
+          collector = visit arg, collector
+        }
+        collector << '))'
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_Json o,collector
+        case o.hash
+        when Array
+          res = Arel::Nodes.build_quoted('[')
+          o.hash.each.with_index do |v,i|
+            if i != 0
+              res += ', '
+            end
+            if (v.is_a?(Arel::Attributes::Attribute) && o.type_of_attribute(v) == :string) || (v.return_type == :string)
+              res = res + '"' + v + '"'
+            else
+              res += v
+            end
+          end
+          res += ']'
+          collector = visit res, collector
+        when Hash
+          res = Arel::Nodes.build_quoted('{')
+          o.hash.each.with_index do |(k,v),i|
+            if i != 0
+              res += ', '
+            end
+            res += Arel::Nodes.build_quoted('"')+k + '": '
+            if (v.is_a?(Arel::Attributes::Attribute) && o.type_of_attribute(v) == :string) || (v.try(:return_type) == :string) # TODO : remove the try
+              res = res + '"' + v + '"'
+            else
+              res += v
+            end
+          end
+          res += '}'
+          collector = visit res, collector
+        else
+          collector = visit o.hash, collector
         end
         collector
       end
-    end
 
-		def visit_ArelExtensions_Nodes_Union o, collector
-			collector = visit o.left, collector
-			collector << " UNION "
-			collector = visit o.right, collector
-			collector
-		end
-		
-		def visit_ArelExtensions_Nodes_UnionAll o, collector
-			collector = visit o.left, collector
-			collector << " UNION ALL "
-			collector = visit o.right, collector
-			collector
-		end
-		
-		def visit_ArelExtensions_Nodes_As o, collector
-			if o.left.is_a?(ArelExtensions::Nodes::Union) || o.left.is_a?(ArelExtensions::Nodes::UnionAll)
-				collector << "("
-				collector = visit o.left, collector
-				collector << ") "
-				visit o.right, collector
-			else
-				collector = visit o.left, collector
-				collector << " AS "
-				visit o.right, collector
-			end
-		end
-		
-		def visit_ArelExtensions_Nodes_Case o, collector
-			collector << "CASE "
-			if o.case
-			  visit o.case, collector
-			  collector << " "
-			end
-			o.conditions.each do |condition|
-			  visit condition, collector
-			  collector << " "
-			end
-			if o.default
-			  visit o.default, collector
-			  collector << " "
-			end
-			collector << "END"
-		end
-
-		def visit_ArelExtensions_Nodes_Case_When o, collector
-			collector << "WHEN "
-			visit Arel::Nodes.build_quoted(o.left), collector
-			collector << " THEN "
-			visit Arel::Nodes.build_quoted(o.right), collector
-		end
-
-		def visit_ArelExtensions_Nodes_Case_Else o, collector
-			collector << "ELSE "
-			visit Arel::Nodes.build_quoted(o.expr), collector
-		end
-
-		def visit_ArelExtensions_Nodes_FormattedNumber o, collector		
-			visit o.left, collector
-		end
-		
-		remove_method(:visit_Arel_Nodes_LessThan) rescue nil 
-		def visit_Arel_Nodes_LessThan o, collector
-			collector = visit o.left, collector
-			collector << " < "
-			visit o.right, collector
-		end
-		
-		def visit_ArelExtensions_Nodes_Std o, collector		
-			collector << "STD("
-			visit o.left, collector
-			collector << ")"
-			collector
-		end
-		
-		def visit_ArelExtensions_Nodes_Variance o, collector		
-			collector << "VARIANCE("
-			visit o.left, collector
-			collector << ")"
-			collector
-		end
-
-		def visit_ArelExtensions_Nodes_LevenshteinDistance o, collector
-			collector << "LEVENSHTEIN_DISTANCE("
-			collector = visit o.left, collector
-			collector << Arel::Visitors::ToSql::COMMA
-			collector = visit o.right, collector
-			collector << ')'
-			collector
-		end
-		
-	end
+    end
   end
 end

data/lib/arel_extensions/visitors.rb

@@ -7,45 +7,75 @@ require 'arel_extensions/visitors/sqlite'
 require 'arel_extensions/visitors/mssql'
 
 Arel::Visitors::MSSQL.class_eval do
-	include ArelExtensions::Visitors::MSSQL
-	
-	alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
-	def visit_Arel_Nodes_SelectStatement o, collector	
-		if !collector.value.blank? && o.limit.blank? && o.offset.blank? 		
-			o = o.dup
-			o.orders = []
-		end
-		old_visit_Arel_Nodes_SelectStatement(o,collector)
-	end	
+  include ArelExtensions::Visitors::MSSQL
+
+  alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+  def visit_Arel_Nodes_As o, collector
+    if o.left.is_a?(Arel::Nodes::Binary)
+      collector << '('
+      collector = visit o.left, collector
+      collector << ')'
+    else
+      collector = visit o.left, collector
+    end
+    collector << " AS ["
+    collector = visit o.right, collector
+    collector << "]"
+    collector
+  end
+
+  alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+  def visit_Arel_Nodes_SelectStatement o, collector
+    if !collector.value.blank? && o.limit.blank? && o.offset.blank?
+      o = o.dup
+      o.orders = []
+    end
+    old_visit_Arel_Nodes_SelectStatement(o,collector)
+  end
 end
 
-begin 
-	require 'arel_sqlserver'
-	if Arel::VERSION.to_i == 6
-		if Arel::Visitors::VISITORS['sqlserver'] && Arel::Visitors::VISITORS['sqlserver'] != Arel::Visitors::MSSQL
-			Arel::Visitors::VISITORS['sqlserver'].class_eval do
+begin
+  require 'arel_sqlserver'
+  if Arel::VERSION.to_i == 6
+    if Arel::Visitors::VISITORS['sqlserver'] && Arel::Visitors::VISITORS['sqlserver'] != Arel::Visitors::MSSQL
+      Arel::Visitors::VISITORS['sqlserver'].class_eval do
         include ArelExtensions::Visitors::MSSQL
 
         alias_method :old_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
-				def visit_Arel_Nodes_SelectStatement o, collector	
-					if !collector.value.blank? && o.limit.blank? && o.offset.blank? 					
-						o = o.dup
-						o.orders = []
-					end
-					old_visit_Arel_Nodes_SelectStatement(o,collector)
-				end
+        def visit_Arel_Nodes_SelectStatement o, collector
+          if !collector.value.blank? && o.limit.blank? && o.offset.blank?
+            o = o.dup
+            o.orders = []
+          end
+          old_visit_Arel_Nodes_SelectStatement(o,collector)
+        end
+
+        alias_method :old_visit_Arel_Nodes_As, :visit_Arel_Nodes_As
+        def visit_Arel_Nodes_As o, collector
+          if o.left.is_a?(Arel::Nodes::Binary)
+            collector << '('
+            collector = visit o.left, collector
+            collector << ')'
+          else
+            collector = visit o.left, collector
+          end
+          collector << " AS ["
+          collector = visit o.right, collector
+          collector << "]"
+          collector
+        end
 
         alias_method :old_primary_Key_From_Table, :primary_Key_From_Table
-				def primary_Key_From_Table t
-					return unless t
-					column_name = @connection.schema_cache.primary_keys(t.name) ||
-					  @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
-					column_name ? t[column_name] : nil
-				end
-			end 
-		end
-	end
-rescue LoadError
+        def primary_Key_From_Table t
+          return unless t
+          column_name = @connection.schema_cache.primary_keys(t.name) ||
+            @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+          column_name ? t[column_name] : nil
+        end
+      end
+    end
+  end
+  rescue LoadError
 rescue => e
-	e
+    e
 end

data/lib/arel_extensions.rb

@@ -65,6 +65,7 @@ require 'arel_extensions/nodes/as'
 require 'arel_extensions/nodes/case'
 require 'arel_extensions/nodes/soundex'
 require 'arel_extensions/nodes/cast'
+require 'arel_extensions/nodes/json'
 
 
 

data/test/visitors/test_oracle.rb

@@ -106,4 +106,4 @@ module ArelExtensions
 
     end
   end
-end
+end