flounder 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d324609dd93210feb39bb7b46739c46cfbc0662f
-  data.tar.gz: cb52c14ff194b1222eaed3b22b0ad938dc7a1914
+  metadata.gz: ea885fee238d20c64364425cad9315b36a857c5a
+  data.tar.gz: 213baa1bff13a230263f742537667474e54fecee
 SHA512:
-  metadata.gz: 64af342ed59b17cd4912168f60fe61f46fae2e1da4e9077095736b96c917953098a700851c7c877f263d0ddddfc9ddb3a4d683b90313d7d106d778461a7478c8
-  data.tar.gz: 234cfb876a6f5119807075fcceac54ec63b819af7b733d97964252e43385851af2052ff25928167f376a67383c0dae1e376e5aca60588791fde5ad4cc667e73e
+  metadata.gz: 05ecfc437a608a3e87369501f7ab3ffba0373e731752bdaa1fd4d89d7736e6479c33eea3e3ae589e6ae9ba7fb12f699e9100b3d88c763efecbda93e0c1368ae1
+  data.tar.gz: 82059189fb7904376ca5d03bd9ceca30fe77e47f67ab61280c49f66b4f9764ac3b34b1710c6f5791f9e66c4d2df64dd2b456309a12ceba636247880714de6409

data/HISTORY

@@ -1,3 +1,8 @@
+# 0.11
+
+  + #anchor now only affects the interpretation of #on, doesn't modify return 
+    value. 
+  + #hoist is the opposite of #anchor - it reverts to the original entity. 
 
 # 0.10
   + Datamapper interop is improved (also in #order_by)

data/flounder.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name     = "flounder"
-  s.version  = '0.10.0'
+  s.version  = '0.11.0'
   s.summary  = "Flounder is a way to write SQL simply in Ruby. It deals with everything BUT object relational mapping. "
   s.email    = "kaspar.schiess@technologyastronauts.ch"
   s.homepage = "https://bitbucket.org/technologyastronauts/oss_flounder"

data/lib/flounder/query/select.rb

@@ -14,6 +14,9 @@ module Flounder::Query
       @projection_prefixes = Hash.new
       @default_projection = []
 
+      # by default, joins are made to the entity that you start the query with
+      @join_entity = entity
+
       add_fields_to_default from_entity
 
       manager.from from_entity.table
@@ -30,6 +33,8 @@ module Flounder::Query
     # prefix during this query. 
     attr_reader :projection_prefixes
 
+    attr_reader :join_entity, :last_join
+
     def _join join_node, entity
       entity = convert_to_entity(entity)
 
@@ -67,11 +72,17 @@ module Flounder::Query
 
     def on join_conditions
       manager.on(
-        *join_conditions.map { |(k, v)| transform_tuple(entity, k, join_field(v)) })
+        *join_conditions.map { |(k, v)| transform_tuple(
+          join_entity, k, join_field(v)) })
       self
     end
+
     def anchor
-      @entity = @last_join
+      @join_entity = last_join
+      self
+    end
+    def hoist
+      @join_entity = entity
       self
     end
 

data/qed/flounder.sql

@@ -30,11 +30,12 @@ DROP TABLE IF EXISTS "comments" CASCADE;
 CREATE TABLE "comments" (
   "id" serial PRIMARY KEY, 
   "post_id" int NOT NULL REFERENCES posts("id"),
-  "text" text NOT NULL
+  "text" text NOT NULL, 
+  "author_id" int not null REFERENCES users("id")
 );
 
 BEGIN; 
-INSERT INTO "comments" (post_id, text) VALUES (1, 'A silly comment.'); 
+INSERT INTO "comments" (post_id, text, author_id) VALUES (1, 'A silly comment.', 1); 
 COMMIT; 
 
 -- import using

data/qed/index.md

@@ -72,56 +72,6 @@ By default, symbols are interpreted as field names in the entity that you start
     assert generates_sql("SELECT [fields] FROM \"users\"  WHERE \"posts\".\"id\" = 1")
 ~~~
 
-# Some JOINs
-
-Here are some non-crazy joins that also work. 
-
-~~~ruby
-  domain[:users].join(domain[:posts]).on(:id => :user_id).
-    assert generates_sql(%Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id"))
-
-  domain[:users].outer_join(domain[:posts]).on(:id => :user_id).
-    assert generates_sql(%Q(SELECT [fields] FROM "users" LEFT OUTER JOIN "posts" ON "users"."id" = "posts"."user_id"))
-~~~
-
-You might want to drop the calls to domain. 
-
-~~~ruby 
-  domain[:users].join(:posts).on(:id => :user_id).
-    assert generates_sql(
-      %Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id"))
-~~~
-
-Joining presents an interesting dilemma. There are two ways of joining things together, given three tables. The sequence A.B.C might mean to join A to B and C; it might also be interpreted to mean to join A to B and B to C. Here's how we solve this. 
-
-~~~ruby
-  domain[:users].
-    join(domain[:posts]).on(:id => :user_id).
-    join(domain[:comments]).on(:id => :post_id).
-      assert generates_sql(%Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id" INNER JOIN "comments" ON "users"."id" = "comments"."post_id"))
-~~~
-
-So just doing `A.B.C` will give you the first of the above possibilities. Here's how to achive the second effect. 
-
-~~~ruby
-  domain[:users].
-    join(domain[:posts]).on(:id => :user_id).anchor.
-    join(domain[:comments]).on(:id => :post_id).
-      assert generates_sql(%Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id" INNER JOIN "comments" ON "posts"."id" = "comments"."post_id"))
-~~~
-
-The call to `#anchor` anchors all further joins at that point. 
-
-# Ordering records
-
-~~~ruby
-  domain[:users].where(id: 2013).order_by(domain[:users][:id]).
-    assert generates_sql(%Q(SELECT [fields] FROM "users"  WHERE "users"."id" = 2013  ORDER BY "users"."id"))
-
-  domain[:users].order_by(:id).
-    assert generates_sql(%Q(SELECT [fields] FROM "users"   ORDER BY "users"."id"))
-~~~
-
 # Selective projection
 
 ~~~ruby

data/qed/joins.md

@@ -11,7 +11,7 @@ Joins are correctly created.
   row.post.id.assert == 1
 ~~~
 
-Joins are … joined using AND.
+Join conditions are joined using `AND`. 
 
 ~~~ruby
   query = domain[:posts].
@@ -19,3 +19,67 @@ Joins are … joined using AND.
 
   query.assert generates_sql(%Q(SELECT [fields] FROM "posts" INNER JOIN "users" ON "posts"."user_id" = "users"."id" AND "posts"."strange_example_id" = "users"."id"))
 ~~~
+
+You might want to drop the calls to domain. 
+
+~~~ruby 
+  domain[:users].join(:posts).on(:id => :user_id).
+    assert generates_sql(
+      %Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id"))
+~~~
+
+
+# Anchoring
+
+Joining presents an interesting dilemma. There are two ways of joining things together, given three tables. The sequence A.B.C might mean to join A to B and C; it might also be interpreted to mean to join A to B and B to C. Here's how we solve this. 
+
+~~~ruby
+  domain[:users].
+    join(domain[:posts]).on(:id => :user_id).
+    join(domain[:comments]).on(:id => :post_id).
+      assert generates_sql(%Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id" INNER JOIN "comments" ON "users"."id" = "comments"."post_id"))
+~~~
+
+So just doing `A.B.C` will give you the first of the above possibilities. Here's how to achive the second effect. 
+
+~~~ruby
+  users.
+    join(:posts).on(:id => :user_id).anchor.
+    join(:comments).on(:id => :post_id).
+      assert generates_sql(%Q(SELECT [fields] FROM "users" INNER JOIN "posts" ON "users"."id" = "posts"."user_id" INNER JOIN "comments" ON "posts"."id" = "comments"."post_id"))
+~~~
+
+During the construction of the query, flounder keeps track of what table joins are relative to. That table also provides field resolution for the left hand side of the `#on` clause: 
+
+    A.join(B).on(:a_field => :b_field).
+      join(C).on(:a_field => :c_field)
+
+By default, A in the above example will always be the entity that you started the query with. To anchor a join on a different entity, you will need to join that entity in and then end the join with a call to `#anchor`: 
+
+    A.join(B).on(:a_field => :b_field).anchor.
+      join(C).on(:b_field => :c_field)
+
+To get rid of the anchor, you will need to call `#hoist`. This will always reset the left side of all further joins to the entity that you started the 
+query with:
+
+    A.join(B).on(:a_field => :b_field).anchor.
+      join(C).on(:b_field => :c_field).hoist.
+      join(D).on(:a_field => :d_field)
+
+Here's a real usage example.
+
+~~~ruby
+  query = users.
+    join(:posts).on(:id => :user_id).anchor.
+    join(:comments).on(:id => :post_id).hoist.
+    join(comments.as(:other_comments, :other_comment)).on(:id => :author_id)
+
+  query.assert generates_sql("SELECT [fields] FROM \"users\" INNER JOIN \"posts\" ON \"users\".\"id\" = \"posts\".\"user_id\" INNER JOIN \"comments\" ON \"posts\".\"id\" = \"comments\".\"post_id\" INNER JOIN \"comments\" \"other_comments\" ON \"users\".\"id\" = \"other_comments\".\"author_id\"")
+~~~
+
+Results should also be correct: 
+
+~~~ruby
+  row = query.first
+  row.other_comment.assert == row.comment
+~~~

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flounder
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Kaspar Schiess
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arel