arel 0.2.1 → 0.3.0

data/History.txt

@@ -1,3 +1,11 @@
+== 0.3.0 / 2010-02-05
+
+* Enhancements
+
+  * Introduced "SQL compilers" for query generation.
+  * Added support for Oracle (Raimonds Simanovskis) and IBM/DB (Praveen Devarao).
+  * Improvements to give better support to ActiveRecord.
+
 == 0.2.1 / 2010-02-05
 
 * Enhancements

data/README.markdown

@@ -4,8 +4,6 @@ Arel is a Relational Algebra for Ruby. It 1) simplifies the generation complex o
 
 ## Status ##
 
-Arel is alpha software, BEWARE. Nevertheless, at this point, many (most?) SELECT queries can be composed, including very very complicated ones. Writes are only experimental for now.
-
 For the moment, Arel uses ActiveRecord's connection adapters to connect to the various engines, connection pooling, perform quoting, and do type conversion. On the horizon is the use of DataObjects instead.
 
 The long term goal, following both LINQ and DataMapper, is to have Arel adapt to engines beyond RDBMS, including XML, IMAP, YAML, etc.

data/Rakefile

@@ -20,13 +20,13 @@ else
   end
 
   namespace :spec do
-    for adapter in %w[mysql sqlite3 postgresql]
+    for adapter in %w[mysql sqlite3 postgresql oracle]
       desc "Run specs with the #{adapter} database adapter"
       Spec::Rake::SpecTask.new(adapter) do |t|
         t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
         t.libs << "#{File.dirname(__FILE__)}/vendor/rails/activerecord/lib"
         t.libs << "#{File.dirname(__FILE__)}/spec"
-        t.warning = true
+        # t.warning = true
         t.spec_files =
           ["spec/connections/#{adapter}_connection.rb"] +
           ["spec/schemas/#{adapter}_schema.rb"] +

data/arel.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{arel}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bryan Helmkamp", "Nick Kallen", "Emilio Tagua"]
-  s.date = %q{2010-02-05}
+  s.date = %q{2010-03-10}
   s.description = %q{Arel is a Relational Algebra for Ruby. It 1) simplifies the generation complex
 of SQL queries and it 2) adapts to various RDBMS systems. It is intended to be
 a framework framework; that is, you can build your own ORM with it, focusing on
@@ -69,6 +69,11 @@ and query generation.}
     "lib/arel/engines/memory/relations/writes.rb",
     "lib/arel/engines/sql.rb",
     "lib/arel/engines/sql/christener.rb",
+    "lib/arel/engines/sql/compilers/ibm_db_compiler.rb",
+    "lib/arel/engines/sql/compilers/mysql_compiler.rb",
+    "lib/arel/engines/sql/compilers/oracle_compiler.rb",
+    "lib/arel/engines/sql/compilers/postgresql_compiler.rb",
+    "lib/arel/engines/sql/compilers/sqlite_compiler.rb",
     "lib/arel/engines/sql/core_extensions.rb",
     "lib/arel/engines/sql/core_extensions/array.rb",
     "lib/arel/engines/sql/core_extensions/nil_class.rb",
@@ -79,6 +84,7 @@ and query generation.}
     "lib/arel/engines/sql/predicates.rb",
     "lib/arel/engines/sql/primitives.rb",
     "lib/arel/engines/sql/relations.rb",
+    "lib/arel/engines/sql/relations/compiler.rb",
     "lib/arel/engines/sql/relations/operations/alias.rb",
     "lib/arel/engines/sql/relations/operations/join.rb",
     "lib/arel/engines/sql/relations/relation.rb",
@@ -146,6 +152,7 @@ and query generation.}
     "spec/arel/engines/sql/unit/relations/update_spec.rb",
     "spec/arel/engines/sql/unit/relations/where_spec.rb",
     "spec/connections/mysql_connection.rb",
+    "spec/connections/oracle_connection.rb",
     "spec/connections/postgresql_connection.rb",
     "spec/connections/sqlite3_connection.rb",
     "spec/doubles/hash.rb",
@@ -153,6 +160,7 @@ and query generation.}
     "spec/matchers/disambiguate_attributes.rb",
     "spec/matchers/hash_the_same_as.rb",
     "spec/schemas/mysql_schema.rb",
+    "spec/schemas/oracle_schema.rb",
     "spec/schemas/postgresql_schema.rb",
     "spec/schemas/sqlite3_schema.rb",
     "spec/spec.opts",
@@ -161,7 +169,7 @@ and query generation.}
   s.homepage = %q{http://github.com/brynary/arel}
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{arel}
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Arel is a relational algebra engine for Ruby}
   s.test_files = [
     "spec/arel/algebra/unit/predicates/binary_spec.rb",
@@ -221,6 +229,7 @@ and query generation.}
     "spec/arel/engines/sql/unit/relations/update_spec.rb",
     "spec/arel/engines/sql/unit/relations/where_spec.rb",
     "spec/connections/mysql_connection.rb",
+    "spec/connections/oracle_connection.rb",
     "spec/connections/postgresql_connection.rb",
     "spec/connections/sqlite3_connection.rb",
     "spec/doubles/hash.rb",
@@ -228,6 +237,7 @@ and query generation.}
     "spec/matchers/disambiguate_attributes.rb",
     "spec/matchers/hash_the_same_as.rb",
     "spec/schemas/mysql_schema.rb",
+    "spec/schemas/oracle_schema.rb",
     "spec/schemas/postgresql_schema.rb",
     "spec/schemas/sqlite3_schema.rb",
     "spec/spec_helper.rb"

data/lib/arel.rb

@@ -7,5 +7,5 @@ module Arel
   require 'arel/engines'
   autoload :Session, 'arel/session'
 
-  VERSION = "0.2.1"
-end
+  VERSION = "0.3.0"
+end

data/lib/arel/algebra/relations/relation.rb

@@ -84,7 +84,8 @@ module Arel
 
     module AttributeAccessable
       def [](index)
-        case index
+        @cached_attributes ||= {}
+        @cached_attributes[index] ||= case index
         when Symbol, String
           find_attribute_matching_name(index)
         when Attribute, Expression
@@ -96,7 +97,7 @@ module Arel
       end
 
       def find_attribute_matching_name(name)
-        attributes.detect { |a| a.named?(name) }
+        attributes.detect { |a| a.named?(name) } || Attribute.new(self, name)
       end
 
       def find_attribute_matching_attribute(attribute)

data/lib/arel/engines/sql/compilers/ibm_db_compiler.rb

@@ -0,0 +1,62 @@
+# +-----------------------------------------------------------------------+
+# |                                                                       |
+# | Copyright (c) 2010 IBM Corporation                                    |
+# |                                                                       |
+# | Permission is hereby granted, free of charge, to any person obtaining |
+# | a copy of this software and associated documentation files (the       |
+# | "Software"), to deal in the Software without restriction, including   |
+# | without limitation the rights to use, copy, modify, merge, publish,   |
+# | distribute, sublicense, and/or sell copies of the Software, and to    |
+# | permit persons to whom the Software is furnished to do so, subject to |
+# | the following conditions:                                             |
+# |                                                                       |
+# | The above copyright notice and this permission notice shall be        |
+# | included in all copies or substantial portions of the Software.       |
+# |                                                                       |
+# | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       |
+# | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    |
+# | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.|
+# | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR      |
+# | ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION           |
+# | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
+# | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.       |
+# |                                                                       |
+# +-----------------------------------------------------------------------+
+
+#
+#  Author: Praveen Devarao <praveendrl@in.ibm.com>
+#
+
+module Arel
+  module SqlCompiler
+    class IBM_DBCompiler < GenericCompiler
+
+      def select_sql
+        query = build_query \
+          "SELECT     #{select_clauses.join(', ')}",
+          "FROM       #{from_clauses}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses.join(" AND ")}"    unless wheres.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
+          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      )
+          engine.add_limit_offset!(query,{:limit=>taken,:offset=>skipped}) unless taken.blank?
+          query << "#{locked}" unless locked.blank?
+          query
+      end
+
+      def limited_update_conditions(conditions, taken)
+        quoted_primary_key = engine.quote_table_name(primary_key)
+        update_conditions = "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions} " #Note: - ')' not added, limit segment is to be appended
+        engine.add_limit_offset!(update_conditions,{:limit=>taken,:offset=>nil})
+        update_conditions << ")" # Close the sql segment
+        update_conditions
+      end
+
+      def add_limit_on_delete(taken)
+        raise "IBM_DB does not support limit on deletion" # Limiting the number of rows to be deleted is not supported by IBM_DB
+      end
+
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/mysql_compiler.rb

@@ -0,0 +1,11 @@
+module Arel
+  module SqlCompiler
+    class MySQLCompiler < GenericCompiler
+      def limited_update_conditions(conditions, taken)
+        conditions << " LIMIT #{taken}"
+        conditions
+      end
+    end
+  end
+end
+

data/lib/arel/engines/sql/compilers/oracle_compiler.rb

@@ -0,0 +1,95 @@
+module Arel
+  module SqlCompiler
+    class OracleCompiler < GenericCompiler
+
+      def select_sql
+        where_clauses_array = where_clauses
+        if limit_or_offset = !taken.blank? || !skipped.blank?
+          # if need to select first records without ORDER BY and GROUP BY
+          # then can use simple ROWNUM in WHERE clause
+          if skipped.blank? && groupings.blank? && orders.blank?
+            where_clauses_array << "ROWNUM <= #{taken}" if !taken.blank? && skipped.blank? && groupings.blank? && orders.blank?
+            limit_or_offset = false
+          end
+        end
+
+        # when limit or offset subquery is used then cannot use FOR UPDATE directly
+        # and need to construct separate subquery for primary key
+        if use_subquery_for_lock = limit_or_offset && !locked.blank?
+          quoted_primary_key = engine.quote_column_name(primary_key)
+        end
+        select_attributes_string = use_subquery_for_lock ? quoted_primary_key : select_clauses.join(', ')
+
+        # OracleEnhanced adapter workaround when ORDER BY is used with columns not
+        # present in DISTINCT columns list
+        order_clauses_array = if select_attributes_string =~ /DISTINCT.*FIRST_VALUE/ && !orders.blank?
+          order = order_clauses.join(', ').split(',').map { |s| s.strip }.reject(&:blank?)
+          order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{'DESC' if s =~ /\bdesc$/i}" }
+        else
+          order_clauses
+        end
+
+        query = build_query \
+          "SELECT     #{select_attributes_string}",
+          "FROM       #{from_clauses}",
+          (joins(self)                                   unless joins(self).blank? ),
+          ("WHERE     #{where_clauses_array.join(" AND ")}"    unless where_clauses_array.blank?      ),
+          ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
+          ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
+          ("ORDER BY  #{order_clauses_array.join(', ')}" unless order_clauses_array.blank? )
+
+        # Use existing method from oracle_enhanced adapter to implement limit and offset using subqueries
+        engine.add_limit_offset!(query, :limit => taken, :offset => skipped) if limit_or_offset
+
+        if use_subquery_for_lock
+          build_query \
+            "SELECT     #{select_clauses.join(', ')}",
+            "FROM       #{from_clauses}",
+            "WHERE      #{quoted_primary_key} IN (#{query})",
+            "#{locked}"
+        elsif !locked.blank?
+          build_query query, "#{locked}"
+        else
+          query
+        end
+      end
+
+      def delete_sql
+        where_clauses_array = wheres.collect(&:to_sql)
+        where_clauses_array << "ROWNUM <= #{taken}" unless taken.blank?
+        build_query \
+          "DELETE",
+          "FROM #{table_sql}",
+          ("WHERE #{where_clauses_array.join(' AND ')}" unless where_clauses_array.blank? )
+      end
+
+    protected
+
+      def build_update_conditions_sql
+        conditions = ""
+        where_clauses_array = wheres.collect(&:to_sql)
+        # if need to select first records without ORDER BY
+        # then can use simple ROWNUM in WHERE clause
+        if !taken.blank? && orders.blank?
+          where_clauses_array << "ROWNUM <= #{taken}"
+        end
+        conditions << " WHERE #{where_clauses_array.join(' AND ')}" unless where_clauses_array.blank?
+        unless taken.blank?
+          conditions = limited_update_conditions(conditions, taken)
+        end
+        conditions
+      end
+
+      def limited_update_conditions(conditions, taken)
+        # need to add ORDER BY only if just taken ones should be updated
+        conditions << " ORDER BY #{order_clauses.join(', ')}" unless orders.blank?
+        quoted_primary_key = engine.quote_column_name(primary_key)
+        subquery = "SELECT #{quoted_primary_key} FROM #{engine.connection.quote_table_name table.name} #{conditions}"
+        # Use existing method from oracle_enhanced adapter to get taken records when ORDER BY is used
+        engine.add_limit_offset!(subquery, :limit => taken) unless orders.blank?
+        "WHERE #{quoted_primary_key} IN (#{subquery})"
+      end
+
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/postgresql_compiler.rb

@@ -0,0 +1,42 @@
+module Arel
+  module SqlCompiler
+    class PostgreSQLCompiler < GenericCompiler
+
+      def select_sql
+        if !orders.blank? && using_distinct_on?
+          subquery = build_query \
+            "SELECT #{select_clauses.kind_of?(::Array) ? select_clauses.join("") : select_clauses.to_s}",
+            "FROM #{from_clauses}",
+            (joins(self) unless joins(self).blank? ),
+            ("WHERE #{where_clauses.join(" AND ")}" unless wheres.blank? ),
+            ("GROUP BY #{group_clauses.join(', ')}" unless groupings.blank? ),
+            ("HAVING #{having_clauses.join(', ')}" unless havings.blank? ),
+            ("#{locked}" unless locked.blank? )
+
+          build_query \
+            "SELECT * FROM (#{subquery}) AS id_list",
+            "ORDER BY #{aliased_orders(order_clauses)}",
+            ("LIMIT #{taken}" unless taken.blank? ),
+            ("OFFSET #{skipped}" unless skipped.blank? )
+        else
+          super
+        end
+      end
+
+      def using_distinct_on?
+        select_clauses.any? { |x| x =~ /DISTINCT ON/ }
+      end
+
+      def aliased_orders(orders)
+        # PostgreSQL does not allow arbitrary ordering when using DISTINCT ON, so we work around this
+        # by wrapping the +sql+ string as a sub-select and ordering in that query.
+        order = orders.join(', ').split(/,/).map { |s| s.strip }.reject(&:blank?)
+        order = order.zip((0...order.size).to_a).map { |s,i| "id_list.alias_#{i} #{'DESC' if s =~ /\bdesc$/i}" }.join(', ')
+      end
+
+      def supports_insert_with_returning?
+        engine.postgresql_version >= 80200
+      end
+    end
+  end
+end

data/lib/arel/engines/sql/compilers/sqlite_compiler.rb

@@ -0,0 +1,9 @@
+module Arel
+  module SqlCompiler
+    class SQLiteCompiler < GenericCompiler
+      def locked
+        nil
+      end
+    end
+  end
+end

data/lib/arel/engines/sql/engine.rb

@@ -1,16 +1,23 @@
 module Arel
   module Sql
     class Engine
+
       def initialize(ar = nil)
         @ar = ar
       end
 
       def connection
-        @ar.connection
+        @ar ? @ar.connection : nil
       end
 
       def adapter_name
-        @adapter_name ||= connection.adapter_name
+        @adapter_name ||= case (name = connection.adapter_name)
+        # map OracleEnanced adapter to Oracle
+        when /Oracle/
+          'Oracle'
+        else
+          name
+        end
       end
 
       def method_missing(method, *args, &block)
@@ -19,7 +26,14 @@ module Arel
 
       module CRUD
         def create(relation)
-          connection.insert(relation.to_sql)
+          primary_key_value = if relation.primary_key.blank?
+            nil
+          elsif relation.record.is_a?(Hash)
+            attribute = relation.record.detect { |attr, _| attr.name.to_s == relation.primary_key.to_s }
+            attribute && attribute.last.value
+          end
+
+          connection.insert(relation.to_sql(false), nil, relation.primary_key, primary_key_value)
         end
 
         def read(relation)

data/lib/arel/engines/sql/formatters.rb

@@ -93,7 +93,7 @@ module Arel
 
     class TableReference < Formatter
       def select(select_sql, table)
-        "(#{select_sql}) AS #{quote_table_name(name_for(table))}"
+        "(#{select_sql}) #{quote_table_name(name_for(table))}"
       end
 
       def table(table)
@@ -101,7 +101,7 @@ module Arel
           table.name
         else
           quote_table_name(table.name) +
-            (table.name != name_for(table) ? " AS " + quote_table_name(name_for(table)) : '')
+            (table.name != name_for(table) ? " #{quote_table_name(name_for(table))}" : '')
         end
       end
     end
@@ -112,7 +112,7 @@ module Arel
       end
 
       def range(left, right)
-        "#{left} AND #{right}"
+        "#{scalar(left)} AND #{scalar(right)}"
       end
     end
 

data/lib/arel/engines/sql/relations.rb

@@ -2,6 +2,7 @@ require 'arel/engines/sql/relations/utilities/compound'
 require 'arel/engines/sql/relations/utilities/recursion'
 require 'arel/engines/sql/relations/utilities/externalization'
 require 'arel/engines/sql/relations/utilities/nil'
+require 'arel/engines/sql/relations/compiler'
 require 'arel/engines/sql/relations/relation'
 require 'arel/engines/sql/relations/table'
 require 'arel/engines/sql/relations/operations/join'