square-arel 2.0.9.20110222133018

data/lib/arel/visitors/mssql.rb

@@ -0,0 +1,16 @@
+module Arel
+  module Visitors
+    class MSSQL < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_Limit o
+        ""
+      end
+
+      def visit_Arel_Nodes_Top o
+        "TOP #{visit o.expr}"
+      end
+
+    end
+  end
+end

data/lib/arel/visitors/mysql.rb

@@ -0,0 +1,34 @@
+module Arel
+  module Visitors
+    class MySQL < Arel::Visitors::ToSql
+      private
+      def visit_Arel_Nodes_Lock o
+        visit o.expr
+      end
+
+      ###
+      # :'(
+      # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
+      def visit_Arel_Nodes_SelectStatement o
+        o.limit = Arel::Nodes::Limit.new(18446744073709551615) if o.offset && !o.limit
+        super
+      end
+
+      def visit_Arel_Nodes_SelectCore o
+        o.froms ||= Arel.sql('DUAL')
+        super
+      end
+
+      def visit_Arel_Nodes_UpdateStatement o
+        [
+          "UPDATE #{visit o.relation}",
+          ("SET #{o.values.map { |value| visit value }.join ', '}" unless o.values.empty?),
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND '}" unless o.wheres.empty?),
+          ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
+          (visit(o.limit) if o.limit),
+        ].compact.join ' '
+      end
+
+    end
+  end
+end

data/lib/arel/visitors/oracle.rb

@@ -0,0 +1,116 @@
+module Arel
+  module Visitors
+    class Oracle < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_SelectStatement o
+        o = order_hacks(o)
+
+        # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
+        # then can use simple ROWNUM in WHERE clause
+        if o.limit && o.orders.empty? && !o.offset && o.cores.first.projections.first !~ /^DISTINCT /
+          o.cores.last.wheres.push Nodes::LessThanOrEqual.new(
+            Nodes::SqlLiteral.new('ROWNUM'), o.limit.expr
+          )
+          return super
+        end
+
+        if o.limit && o.offset
+          o        = o.dup
+          limit    = o.limit.expr.to_i
+          offset   = o.offset
+          o.offset = nil
+          sql = super(o)
+          return <<-eosql
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (#{sql}) raw_sql_
+                WHERE rownum <= #{offset.value.to_i + limit}
+              )
+              WHERE #{visit offset}
+          eosql
+        end
+
+        if o.limit
+          o       = o.dup
+          limit   = o.limit.expr
+          return "SELECT * FROM (#{super(o)}) WHERE ROWNUM <= #{visit limit}"
+        end
+
+        if o.offset
+          o        = o.dup
+          offset   = o.offset
+          o.offset = nil
+          sql = super(o)
+          return <<-eosql
+              SELECT * FROM (
+                SELECT raw_sql_.*, rownum raw_rnum_
+                FROM (#{sql}) raw_sql_
+              )
+              WHERE #{visit offset}
+          eosql
+        end
+
+        super
+      end
+
+      def visit_Arel_Nodes_Limit o
+      end
+
+      def visit_Arel_Nodes_Offset o
+        "raw_rnum_ > #{visit o.value}"
+      end
+
+      def visit_Arel_Nodes_Except o
+        "( #{visit o.left} MINUS #{visit o.right} )"
+      end
+
+      ###
+      # Hacks for the order clauses specific to Oracle
+      def order_hacks o
+        return o if o.orders.empty?
+        return o unless o.cores.any? do |core|
+          core.projections.any? do |projection|
+            /DISTINCT.*FIRST_VALUE/ === projection
+          end
+        end
+        # Previous version with join and split broke ORDER BY clause
+        # if it contained functions with several arguments (separated by ',').
+        #
+        # orders   = o.orders.map { |x| visit x }.join(', ').split(',')
+        orders   = o.orders.map do |x|
+          string = visit x
+          if string.include?(',')
+            split_order_string(string)
+          else
+            string
+          end
+        end.flatten
+        o.orders = []
+        orders.each_with_index do |order, i|
+          o.orders <<
+            Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i === order}")
+        end
+        o
+      end
+
+      # Split string by commas but count opening and closing brackets
+      # and ignore commas inside brackets.
+      def split_order_string(string)
+        array = []
+        i = 0
+        string.split(',').each do |part|
+          if array[i]
+            array[i] << ',' << part
+          else
+            # to ensure that array[i] will be String and not Arel::Nodes::SqlLiteral
+            array[i] = '' << part
+          end
+          i += 1 if array[i].count('(') == array[i].count(')')
+        end
+        array
+      end
+
+    end
+  end
+end

data/lib/arel/visitors/order_clauses.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Visitors
+    class OrderClauses < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_SelectStatement o
+        o.orders.map { |x| visit x }
+      end
+    end
+  end
+end

data/lib/arel/visitors/postgresql.rb

@@ -0,0 +1,58 @@
+module Arel
+  module Visitors
+    class PostgreSQL < Arel::Visitors::ToSql
+      private
+      def visit_Arel_Nodes_Lock o
+        visit o.expr
+      end
+
+      def visit_Arel_Nodes_SelectStatement o
+        if !o.orders.empty? && using_distinct_on?(o)
+          subquery        = o.dup
+          subquery.orders = []
+          subquery.limit  = nil
+          subquery.offset = nil
+
+          sql = super(subquery)
+          [
+            "SELECT * FROM (#{sql}) AS id_list",
+            "ORDER BY #{aliased_orders(o.orders).join(', ')}",
+            (visit(o.limit) if o.limit),
+            (visit(o.offset) if o.offset),
+          ].compact.join ' '
+        else
+          super
+        end
+      end
+
+      def visit_Arel_Nodes_Matches o
+        "#{visit o.left} ILIKE #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_DoesNotMatch o
+        "#{visit o.left} NOT ILIKE #{visit o.right}"
+      end
+
+      def using_distinct_on?(o)
+        o.cores.any? do |core|
+          core.projections.any? do |projection|
+            /DISTINCT ON/ === projection
+          end
+        end
+      end
+
+      def aliased_orders orders
+        #orders = o.orders.map { |x| visit x }.join(', ').split(',')
+        list = []
+        orders.each_with_index do |o,i|
+          list <<
+            [
+              "id_list.alias_#{i}",
+              (o.index(/desc/i) && 'DESC')
+            ].compact.join(' ')
+        end
+        list
+      end
+    end
+  end
+end

data/lib/arel/visitors/sqlite.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Visitors
+    class SQLite < Arel::Visitors::ToSql
+      private
+      def visit_Arel_Nodes_SelectStatement o
+        o.limit = Arel::Nodes::Limit.new(-1) if o.offset && !o.limit
+        super
+      end
+    end
+  end
+end

data/lib/arel/visitors/to_sql.rb

@@ -0,0 +1,331 @@
+require 'bigdecimal'
+require 'date'
+
+module Arel
+  module Visitors
+    class ToSql < Arel::Visitors::Visitor
+      def initialize engine
+        @engine         = engine
+        @connection     = nil
+        @quoted_tables  = {}
+        @quoted_columns = {}
+      end
+
+      def accept object
+        Thread.current[:arel_visitors_to_sql_last_column] = nil
+        @engine.connection_pool.with_connection do |conn|
+          @connection = conn
+          super
+        end
+      end
+
+      private
+      def visit_Arel_Nodes_DeleteStatement o
+        [
+          "DELETE FROM #{visit o.relation}",
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND '}" unless o.wheres.empty?)
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_UpdateStatement o
+        if o.orders.empty? && o.limit.nil?
+          wheres = o.wheres
+        else
+          stmt             = Nodes::SelectStatement.new
+          core             = stmt.cores.first
+          core.froms       = o.relation
+          core.projections = [o.relation.primary_key]
+          stmt.limit       = o.limit
+          stmt.orders      = o.orders
+
+          wheres = [Nodes::In.new(o.relation.primary_key, [stmt])]
+        end
+
+        [
+          "UPDATE #{visit o.relation}",
+          ("SET #{o.values.map { |value| visit value }.join ', '}" unless o.values.empty?),
+          ("WHERE #{wheres.map { |x| visit x }.join ' AND '}" unless wheres.empty?)
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_InsertStatement o
+        [
+          "INSERT INTO #{visit o.relation}",
+
+          ("(#{o.columns.map { |x|
+                quote_column_name x.name
+            }.join ', '})" unless o.columns.empty?),
+
+          (visit o.values if o.values),
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_Exists o
+        "EXISTS (#{visit o.select_stmt})#{
+          o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_Values o
+        "VALUES (#{o.expressions.zip(o.columns).map { |value, column|
+          quote(value, column && column.column)
+        }.join ', '})"
+      end
+
+      def visit_Arel_Nodes_SelectStatement o
+        [
+          o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
+          ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
+          (visit(o.limit) if o.limit),
+          (visit(o.offset) if o.offset),
+          (visit(o.lock) if o.lock),
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_SelectCore o
+        [
+          "SELECT",
+          (visit(o.top) if o.top),
+          "#{o.projections.map { |x| visit x }.join ', '}",
+          ("FROM #{visit o.froms}" if o.froms),
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }" unless o.wheres.empty?),
+          ("GROUP BY #{o.groups.map { |x| visit x }.join ', ' }" unless o.groups.empty?),
+          (visit(o.having) if o.having),
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_Having o
+        "HAVING #{visit o.expr}"
+      end
+
+      def visit_Arel_Nodes_Offset o
+        "OFFSET #{visit o.expr}"
+      end
+
+      def visit_Arel_Nodes_Limit o
+        "LIMIT #{visit o.expr}"
+      end
+
+      # FIXME: this does nothing on most databases, but does on MSSQL
+      def visit_Arel_Nodes_Top o
+        ""
+      end
+
+      # FIXME: this does nothing on SQLLite3, but should do things on other
+      # databases.
+      def visit_Arel_Nodes_Lock o
+      end
+
+      def visit_Arel_Nodes_Grouping o
+        "(#{visit o.expr})"
+      end
+
+      def visit_Arel_Nodes_Ordering o
+        "#{visit o.expr} #{o.descending? ? 'DESC' : 'ASC'}"
+      end
+
+      def visit_Arel_Nodes_Group o
+        visit o.expr
+      end
+
+      def visit_Arel_Nodes_Count o
+        "COUNT(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
+          visit x
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_Sum o
+        "SUM(#{o.expressions.map { |x|
+          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_Max o
+        "MAX(#{o.expressions.map { |x|
+          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_Min o
+        "MIN(#{o.expressions.map { |x|
+          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_Avg o
+        "AVG(#{o.expressions.map { |x|
+          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
+      def visit_Arel_Nodes_TableAlias o
+        "#{visit o.relation} #{quote_table_name o.name}"
+      end
+
+      def visit_Arel_Nodes_Between o
+        "#{visit o.left} BETWEEN #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_GreaterThanOrEqual o
+        "#{visit o.left} >= #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_GreaterThan o
+        "#{visit o.left} > #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_LessThanOrEqual o
+        "#{visit o.left} <= #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_LessThan o
+        "#{visit o.left} < #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_Matches o
+        "#{visit o.left} LIKE #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_DoesNotMatch o
+        "#{visit o.left} NOT LIKE #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_StringJoin o
+        "#{visit o.left} #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_OuterJoin o
+        "#{visit o.left} LEFT OUTER JOIN #{visit o.right} #{visit o.constraint}"
+      end
+
+      def visit_Arel_Nodes_InnerJoin o
+        "#{visit o.left} INNER JOIN #{visit o.right} #{visit o.constraint if o.constraint}"
+      end
+
+      def visit_Arel_Nodes_On o
+        "ON #{visit o.expr}"
+      end
+
+      def visit_Arel_Nodes_Not o
+        "NOT (#{visit o.expr})"
+      end
+
+      def visit_Arel_Nodes_Union o
+        "( #{visit o.left} UNION #{visit o.right} )"
+      end
+
+      def visit_Arel_Nodes_UnionAll o
+        "( #{visit o.left} UNION ALL #{visit o.right} )"
+      end
+
+      def visit_Arel_Nodes_Intersect o
+        "( #{visit o.left} INTERSECT #{visit o.right} )"
+      end
+
+      def visit_Arel_Nodes_Except o
+        "( #{visit o.left} EXCEPT #{visit o.right} )"
+      end
+
+      def visit_Arel_Table o
+        if o.table_alias
+          "#{quote_table_name o.name} #{quote_table_name o.table_alias}"
+        else
+          quote_table_name o.name
+        end
+      end
+
+      def visit_Arel_Nodes_In o
+      "#{visit o.left} IN (#{visit o.right})"
+      end
+
+      def visit_Arel_Nodes_NotIn o
+      "#{visit o.left} NOT IN (#{visit o.right})"
+      end
+
+      def visit_Arel_Nodes_And o
+        "#{visit o.left} AND #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_Or o
+        "#{visit o.left} OR #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_Assignment o
+        right = quote(o.right, o.left.column)
+        "#{visit o.left} = #{right}"
+      end
+
+      def visit_Arel_Nodes_Equality o
+        right = o.right
+
+        if right.nil?
+          "#{visit o.left} IS NULL"
+        else
+          "#{visit o.left} = #{visit right}"
+        end
+      end
+
+      def visit_Arel_Nodes_NotEqual o
+        right = o.right
+
+        if right.nil?
+          "#{visit o.left} IS NOT NULL"
+        else
+          "#{visit o.left} != #{visit right}"
+        end
+      end
+
+      def visit_Arel_Nodes_As o
+        "#{visit o.left} AS #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_UnqualifiedColumn o
+        "#{quote_column_name o.name}"
+      end
+
+      def visit_Arel_Attributes_Attribute o
+        Thread.current[:arel_visitors_to_sql_last_column] = o.column
+        join_name = o.relation.table_alias || o.relation.name
+        "#{quote_table_name join_name}.#{quote_column_name o.name}"
+      end
+      alias :visit_Arel_Attributes_Integer :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Float :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Decimal :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_String :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute
+      alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute
+
+      def visit_Fixnum o; o end
+      alias :visit_Arel_Nodes_SqlLiteral :visit_Fixnum
+      alias :visit_Arel_SqlLiteral :visit_Fixnum # This is deprecated
+      alias :visit_Bignum :visit_Fixnum
+
+      def visit_String o; quote(o, Thread.current[:arel_visitors_to_sql_last_column]) end
+
+      alias :visit_ActiveSupport_Multibyte_Chars :visit_String
+      alias :visit_BigDecimal :visit_String
+      alias :visit_Date :visit_String
+      alias :visit_DateTime :visit_String
+      alias :visit_FalseClass :visit_String
+      alias :visit_Float :visit_String
+      alias :visit_Hash :visit_String
+      alias :visit_Symbol :visit_String
+      alias :visit_Time :visit_String
+      alias :visit_TrueClass :visit_String
+      alias :visit_NilClass :visit_String
+      alias :visit_ActiveSupport_StringInquirer :visit_String
+      alias :visit_Class :visit_String
+
+      def visit_Array o
+        o.empty? ? 'NULL' : o.map { |x| visit x }.join(', ')
+      end
+
+      def quote value, column = nil
+        @connection.quote value, column
+      end
+
+      def quote_table_name name
+        @quoted_tables[name] ||= @connection.quote_table_name(name)
+      end
+
+      def quote_column_name name
+        @quoted_columns[name] ||= @connection.quote_column_name(name)
+      end
+    end
+  end
+end