arel 5.0.1.20140414130214 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86a3156add2973e4e2cd8b3a852e82c26c073601
-  data.tar.gz: 06fc106d1ef5fdc41de327a78a8e0b467096202b
+  metadata.gz: dc3719172683caa3fb2bd15ce6ef3ed477a8b2ef
+  data.tar.gz: 74b4f1d7d44871db56c62907ed1c4ba51040bf6e
 SHA512:
-  metadata.gz: ba39500686768a6865b688ce693dd6bc69e2e7ea1a7acb52ab0ad1f0d00fefb85b537f4c5405e865abe67016c166f06503ded328c3b79c2a34156c8ed75e6293
-  data.tar.gz: 1d916874f785a6fc85a2df91633edbc4b607612c876160e6fce14d03ebc17694fd87be197b793ec44f89a68a9815dba07161717333fb15575e36419efae16508
+  metadata.gz: bedb8b1701ee99fca067c4a52f92d096648d25d67d4809408ede3eeb40298b3fc83a9fdccf1f4195c32f871ee430eba29f11dedd19b12032639a8b03bc7ec54c
+  data.tar.gz: 97a3b3155db8b0c57ca4616598d45d8aad7592c56a6882e0e7f5369eeac221802cae5cd60b4d72a92d755eb13be4b39aedc9ea967e1c6faac28953a3414d1f39

data/History.txt

@@ -1,9 +1,49 @@
-== 5.0.1 / 2014-04-14
+=== 9.0.0 / 2017-11-14
 
- * Bug Fixes
+* Enhancements
+  * `InsertManager#insert` is now chainable
+  * Support multiple inserts
 
-  * Fix `SqlLiteral` YAML serialization
-  * PostgreSQL bugfix for invalid SQL in subqueries
+=== 8.0.0 / 2017-02-21
+
+* Enhancements
+
+  * Remove deprecated type casting support in Arel
+  * Frozen all string literals in Arel
+
+=== 7.1.1 / 2016-07-27
+
+* Bug Fixes
+
+  * Fix warning in `Casted#hash`
+
+=== 7.1.0 / 2016-07-19
+
+* Enhancements
+
+  * Support Ruby 2.4 unified Integer class
+  * Implement `CASE` conditional expression
+  * Support for Bitwise Operations as `InfixOperations`
+
+=== 7.0.0 / 2015-12-17
+
+* Enhancements
+
+  * Remove deprecated method `Table#primary_key`
+  * Remove engine from the constructor arguments `Arel::Table`
+  * Deprecate automatic type casting within Arel
+
+=== 6.0.0 / 2014-11-25
+
+* Enhancements
+
+  * Remove deprecated `Arel::Expression`
+  * Remove deprecated `Arel::SqlLiteral`
+  * Remove deprecated `SelectManager#joins`
+  * Remove deprecated `SelectManager#to_a`
+  * Remove deprecated `Arel::Sql::Engine`
+  * Remove deprecated `Arel::InnerJoin` constant
+  * Remove deprecated `Arel::OuterJoin` constant
 
 == 5.0.0 / 2013-12-04
 

data/MIT-LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2007-2010 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
+Copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -18,3 +18,4 @@ 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.
+

data/README.md

@@ -0,0 +1,295 @@
+# Arel
+
+* http://github.com/rails/arel
+* [API Documentation](http://www.rubydoc.info/github/rails/arel)
+
+## DESCRIPTION
+
+Arel Really Exasperates Logicians
+
+Arel is a SQL AST manager for Ruby. It
+
+1. simplifies the generation of complex SQL queries, and
+2. adapts to various RDBMSes.
+
+It is intended to be a framework framework; that is, you can build your own ORM
+with it, focusing on innovative object and collection modeling as opposed to
+database compatibility and query generation.
+
+## Status
+
+For the moment, Arel uses Active Record's connection adapters to connect to the various engines and perform connection pooling, quoting, and type conversion.
+
+## A Gentle Introduction
+
+Generating a query with Arel is simple. For example, in order to produce
+
+```sql
+SELECT * FROM users
+```
+
+you construct a table relation and convert it to SQL:
+
+```ruby
+users = Arel::Table.new(:users)
+query = users.project(Arel.sql('*'))
+query.to_sql
+```
+
+### More Sophisticated Queries
+
+Here is a whirlwind tour through the most common SQL operators. These will probably cover 80% of all interaction with the database.
+
+First is the 'restriction' operator, `where`:
+
+```ruby
+users.where(users[:name].eq('amy'))
+# => SELECT * FROM users WHERE users.name = 'amy'
+```
+
+What would, in SQL, be part of the `SELECT` clause is called in Arel a `projection`:
+
+```ruby
+users.project(users[:id])
+# => SELECT users.id FROM users
+```
+
+Comparison operators `=`, `!=`, `<`, `>`, `<=`, `>=`, `IN`:
+
+```ruby
+users.where(users[:age].eq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" = 10
+
+users.where(users[:age].not_eq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" != 10
+
+users.where(users[:age].lt(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" < 10
+
+users.where(users[:age].gt(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" > 10
+
+users.where(users[:age].lteq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" <= 10
+
+users.where(users[:age].gteq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" >= 10
+
+users.where(users[:age].in([20, 16, 17])).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" IN (20, 16, 17)
+```
+
+Bitwise operators `&`, `|`, `^`, `<<`, `>>`:
+
+```ruby
+users.where((users[:bitmap] & 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" & 16) > 0
+
+users.where((users[:bitmap] | 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" | 16) > 0
+
+users.where((users[:bitmap] ^ 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" ^ 16) > 0
+
+users.where((users[:bitmap] << 1).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" << 1) > 0
+
+users.where((users[:bitmap] >> 1).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" >> 1) > 0
+
+users.where((~ users[:bitmap]).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users" WHERE  ~ "users"."bitmap" > 0
+```
+
+Joins resemble SQL strongly:
+
+```ruby
+users.join(photos).on(users[:id].eq(photos[:user_id]))
+# => SELECT * FROM users INNER JOIN photos ON users.id = photos.user_id
+```
+
+Left joins:
+
+```ruby
+users.join(photos, Arel::Nodes::OuterJoin).on(users[:id].eq(photos[:user_id]))
+# => SELECT FROM users LEFT OUTER JOIN photos ON users.id = photos.user_id
+```
+
+What are called `LIMIT` and `OFFSET` in SQL are called `take` and `skip` in Arel:
+
+```ruby
+users.take(5) # => SELECT * FROM users LIMIT 5
+users.skip(4) # => SELECT * FROM users OFFSET 4
+```
+
+`GROUP BY` is called `group`:
+
+```ruby
+users.project(users[:name]).group(users[:name])
+# => SELECT users.name FROM users GROUP BY users.name
+```
+
+The best property of Arel is its "composability," or closure under all operations. For example, to restrict AND project, just "chain" the method invocations:
+
+```ruby
+users                                 \
+  .where(users[:name].eq('amy'))      \
+  .project(users[:id])                \
+# => SELECT users.id FROM users WHERE users.name = 'amy'
+```
+
+All operators are chainable in this way, and they are chainable any number of times, in any order.
+
+```ruby
+users.where(users[:name].eq('bob')).where(users[:age].lt(25))
+```
+
+The `OR` operator works like this:
+
+```ruby
+users.where(users[:name].eq('bob').or(users[:age].lt(25)))
+```
+
+The `AND` operator behaves similarly. Here is an example of the `DISTINCT` operator:
+
+```ruby
+posts = Arel::Table.new(:posts)
+posts.project(posts[:title])
+posts.distinct
+posts.to_sql # => 'SELECT DISTINCT "posts"."title" FROM "posts"'
+```
+
+Aggregate functions `AVG`, `SUM`, `COUNT`, `MIN`, `MAX`, `HAVING`:
+
+```ruby
+photos.group(photos[:user_id]).having(photos[:id].count.gt(5))
+# => SELECT FROM photos GROUP BY photos.user_id HAVING COUNT(photos.id) > 5
+
+users.project(users[:age].sum)
+# => SELECT SUM(users.age) FROM users
+
+users.project(users[:age].average)
+# => SELECT AVG(users.age) FROM users
+
+users.project(users[:age].maximum)
+# => SELECT MAX(users.age) FROM users
+
+users.project(users[:age].minimum)
+# => SELECT MIN(users.age) FROM users
+
+users.project(users[:age].count)
+# => SELECT COUNT(users.age) FROM users
+```
+
+Aliasing Aggregate Functions:
+
+```ruby
+users.project(users[:age].average.as("mean_age"))
+# => SELECT AVG(users.age) AS mean_age FROM users
+```
+
+### The Advanced Features
+
+The examples above are fairly simple and other libraries match or come close to matching the expressiveness of Arel (e.g. `Sequel` in Ruby).
+
+#### Inline math operations
+
+Suppose we have a table `products` with prices in different currencies. And we have a table `currency_rates`, of constantly changing currency rates. In Arel:
+
+```ruby
+products = Arel::Table.new(:products)
+# Attributes: [:id, :name, :price, :currency_id]
+
+currency_rates = Arel::Table.new(:currency_rates)
+# Attributes: [:from_id, :to_id, :date, :rate]
+```
+
+Now, to order products by price in user preferred currency simply call:
+
+```ruby
+products.
+  join(:currency_rates).on(products[:currency_id].eq(currency_rates[:from_id])).
+  where(currency_rates[:to_id].eq(user_preferred_currency), currency_rates[:date].eq(Date.today)).
+  order(products[:price] * currency_rates[:rate])
+```
+
+#### Complex Joins
+
+##### Alias
+Where Arel really shines is in its ability to handle complex joins and aggregations. As a first example, let's consider an "adjacency list", a tree represented in a table. Suppose we have a table `comments`, representing a threaded discussion:
+
+```ruby
+comments = Arel::Table.new(:comments)
+```
+
+And this table has the following attributes:
+
+```ruby
+# [:id, :body, :parent_id]
+```
+
+The `parent_id` column is a foreign key from the `comments` table to itself.
+Joining a table to itself requires aliasing in SQL. This aliasing can be handled from Arel as below:
+
+```ruby
+replies = comments.alias
+comments_with_replies = \
+  comments.join(replies).on(replies[:parent_id].eq(comments[:id])).where(comments[:id].eq(1))
+# => SELECT * FROM comments INNER JOIN comments AS comments_2
+#    WHERE comments_2.parent_id = comments.id AND comments.id = 1
+```
+
+This will return the reply for the first comment.
+
+##### CTE
+[Common Table Expressions (CTE)](https://en.wikipedia.org/wiki/Common_table_expressions#Common_table_expression) support via:
+
+Create a `CTE`
+
+```ruby
+cte_table = Arel::Table.new(:cte_table)
+composed_cte = Arel::Nodes::As.new(cte_table, photos.where(photos[:created_at].gt(Date.current)))
+```
+
+Use the created `CTE`:
+
+```ruby
+users.
+  join(cte_table).on(users[:id].eq(cte_table[:user_id])).
+  project(users[:id], cte_table[:click].sum).
+  with(composed_cte)
+
+# => WITH cte_table AS (SELECT FROM photos  WHERE photos.created_at > '2014-05-02')
+#    SELECT users.id, SUM(cte_table.click)
+#    FROM users INNER JOIN cte_table ON users.id = cte_table.user_id
+```
+
+#### Write SQL strings
+When your query is too complex for `Arel`, you can use `Arel::SqlLiteral`:
+
+```ruby
+photo_clicks = Arel::Nodes::SqlLiteral.new(<<-SQL
+    CASE WHEN condition1 THEN calculation1
+    WHEN condition2 THEN calculation2
+    WHEN condition3 THEN calculation3
+    ELSE default_calculation END
+SQL
+)
+
+photos.project(photo_clicks.as("photo_clicks"))
+# => SELECT CASE WHEN condition1 THEN calculation1
+#    WHEN condition2 THEN calculation2
+#    WHEN condition3 THEN calculation3
+#    ELSE default_calculation END
+#    FROM "photos"
+```
+
+## Contributing to Arel
+
+Arel is the work of many contributors. You're encouraged to submit pull requests, propose
+features and discuss issues.
+
+See [CONTRIBUTING](CONTRIBUTING.md).
+
+## License
+Arel is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/arel/alias_predication.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module AliasPredication
     def as other

data/lib/arel/attributes/attribute.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Attributes
     class Attribute < Struct.new :relation, :name
@@ -12,6 +13,14 @@ module Arel
       def lower
         relation.lower self
       end
+
+      def type_cast_for_database(value)
+        relation.type_cast_for_database(name, value)
+      end
+
+      def able_to_type_cast?
+        relation.able_to_type_cast?
+      end
     end
 
     class String    < Attribute; end

data/lib/arel/attributes.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'arel/attributes/attribute'
 
 module Arel

data/lib/arel/collectors/bind.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel
+  module Collectors
+    class Bind
+      def initialize
+        @binds = []
+      end
+
+      def << str
+        self
+      end
+
+      def add_bind bind
+        @binds << bind
+        self
+      end
+
+      def value
+        @binds
+      end
+    end
+  end
+end

data/lib/arel/collectors/composite.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arel
+  module Collectors
+    class Composite
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def << str
+        left << str
+        right << str
+        self
+      end
+
+      def add_bind bind, &block
+        left.add_bind bind, &block
+        right.add_bind bind, &block
+        self
+      end
+
+      def value
+        [left.value, right.value]
+      end
+
+      protected
+
+      attr_reader :left, :right
+    end
+  end
+end

data/lib/arel/collectors/plain_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Arel
+  module Collectors
+    class PlainString
+      def initialize
+        @str = ''.dup
+      end
+
+      def value
+        @str
+      end
+
+      def << str
+        @str << str
+        self
+      end
+    end
+  end
+end

data/lib/arel/collectors/sql_string.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'arel/collectors/plain_string'
+
+module Arel
+  module Collectors
+    class SQLString < PlainString
+      def initialize(*)
+        super
+        @bind_index = 1
+      end
+
+      def add_bind bind
+        self << yield(@bind_index)
+        @bind_index += 1
+        self
+      end
+
+      def compile bvs
+        value
+      end
+    end
+  end
+end

data/lib/arel/collectors/substitute_binds.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Arel
+  module Collectors
+    class SubstituteBinds
+      def initialize(quoter, delegate_collector)
+        @quoter = quoter
+        @delegate = delegate_collector
+      end
+
+      def << str
+        delegate << str
+        self
+      end
+
+      def add_bind bind
+        self << quoter.quote(bind)
+      end
+
+      def value
+        delegate.value
+      end
+
+      protected
+
+      attr_reader :quoter, :delegate
+    end
+  end
+end

data/lib/arel/compatibility/wheres.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Compatibility # :nodoc:
     class Wheres # :nodoc:

data/lib/arel/crud.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 module Arel
   ###
   # FIXME hopefully we can remove this
   module Crud
     def compile_update values, pk
-      um = UpdateManager.new @engine
+      um = UpdateManager.new
 
       if Nodes::SqlLiteral === values
         relation = @ctx.from
@@ -26,11 +27,12 @@ module Arel
     end
 
     def create_insert
-      InsertManager.new @engine
+      InsertManager.new
     end
 
     def compile_delete
-      dm = DeleteManager.new @engine
+      dm = DeleteManager.new
+      dm.take @ast.limit.expr if @ast.limit
       dm.wheres = @ctx.wheres
       dm.from @ctx.froms
       dm

data/lib/arel/delete_manager.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 module Arel
   class DeleteManager < Arel::TreeManager
-    def initialize engine
+    def initialize
       super
       @ast = Nodes::DeleteStatement.new
       @ctx = @ast
@@ -11,6 +12,11 @@ module Arel
       self
     end
 
+    def take limit
+      @ast.limit = Nodes::Limit.new(Nodes.build_quoted(limit)) if limit
+      self
+    end
+
     def wheres= list
       @ast.wheres = list
     end

data/lib/arel/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Arel
+  class ArelError < StandardError
+  end
+
+  class EmptyJoinError < ArelError
+  end
+end

data/lib/arel/expressions.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   module Expressions
     def count distinct = false
@@ -5,23 +6,24 @@ module Arel
     end
 
     def sum
-      Nodes::Sum.new [self], Nodes::SqlLiteral.new('sum_id')
+      Nodes::Sum.new [self]
     end
 
     def maximum
-      Nodes::Max.new [self], Nodes::SqlLiteral.new('max_id')
+      Nodes::Max.new [self]
     end
 
     def minimum
-      Nodes::Min.new [self], Nodes::SqlLiteral.new('min_id')
+      Nodes::Min.new [self]
     end
 
     def average
-      Nodes::Avg.new [self], Nodes::SqlLiteral.new('avg_id')
+      Nodes::Avg.new [self]
     end
 
     def extract field
       Nodes::Extract.new [self], field
     end
+
   end
 end

data/lib/arel/factory_methods.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Arel
   ###
   # Methods for creating various nodes
@@ -37,7 +38,7 @@ module Arel
     ###
     # Create a LOWER() function
     def lower column
-      Nodes::NamedFunction.new 'LOWER', [column]
+      Nodes::NamedFunction.new 'LOWER', [Nodes.build_quoted(column)]
     end
   end
 end

data/lib/arel/insert_manager.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 module Arel
   class InsertManager < Arel::TreeManager
-    def initialize engine
+    def initialize
       super
       @ast = Nodes::InsertStatement.new
     end
@@ -13,11 +14,15 @@ module Arel
     def columns; @ast.columns end
     def values= val; @ast.values = val; end
 
+    def select select
+      @ast.select = select
+    end
+
     def insert fields
       return if fields.empty?
 
       if String === fields
-        @ast.values = SqlLiteral.new(fields)
+        @ast.values = Nodes::SqlLiteral.new(fields)
       else
         @ast.relation ||= fields.first.first.relation
 
@@ -29,10 +34,15 @@ module Arel
         end
         @ast.values = create_values values, @ast.columns
       end
+      self
     end
 
     def create_values values, columns
       Nodes::Values.new values, columns
     end
+
+    def create_values_list(rows)
+      Nodes::ValuesList.new(rows)
+    end
   end
 end