typed_dag 1.0.1 → 2.0.0

data/lib/typed_dag/version.rb

@@ -1,3 +1,3 @@
 module TypedDag
-  VERSION = '1.0.1'
+  VERSION = '2.0.0'
 end

data/spec/support/helpers.rb

@@ -30,9 +30,18 @@ module TypedDag
           [r.from.text,
            r.to.text,
            r.hierarchy,
-           r.invalidate]
+           r.invalidate,
+           r.count]
         end
       end
+
+      def mysql_db?
+        ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+      end
+
+      def harmonize_string(string)
+        string.squish.gsub('( ', '(').gsub(' )', ')')
+      end
     end
   end
 end

data/spec/test_app/config/database.yml

@@ -5,12 +5,10 @@
 #   gem 'sqlite3'
 #
 default: &default
-  #adapter: postgresql
-  adapter: mysql2
+  adapter: postgresql
   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
   database: typed_dag_test
   timeout: 5000
-  username: root
 
 development:
   <<: *default

data/spec/test_app/db/migrate/20170831093433_create_nodes_and_endges.rb

@@ -10,11 +10,10 @@ class CreateNodesAndEndges < ActiveRecord::Migration[5.1]
 
       t.column :hierarchy, :integer, null: false, default: 0
       t.column :invalidate, :integer, null: false, default: 0
-      t.column :mention, :integer, null: false, default: 0
 
-      t.index :hierarchy
-      t.index :invalidate
-      t.index :mention
+      t.column :count, :integer, null: false, default: 1
+
+      t.index %i(ancestor_id descendant_id hierarchy invalidate), unique: true, name: 'unique_constraint'
     end
 
     add_foreign_key :relations, :messages, column: :ancestor_id

data/spec/test_app/db/schema.rb

@@ -12,21 +12,22 @@
 
 ActiveRecord::Schema.define(version: 20170831093433) do
 
-  create_table "messages", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8" do |t|
+  # These are extensions that must be enabled in order to support this database
+  enable_extension "plpgsql"
+
+  create_table "messages", force: :cascade do |t|
     t.string "text"
   end
 
-  create_table "relations", force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8" do |t|
+  create_table "relations", force: :cascade do |t|
     t.bigint "ancestor_id", null: false
     t.bigint "descendant_id", null: false
     t.integer "hierarchy", default: 0, null: false
     t.integer "invalidate", default: 0, null: false
-    t.integer "mention", default: 0, null: false
+    t.integer "count", default: 0, null: false
+    t.index ["ancestor_id", "descendant_id", "hierarchy", "invalidate"], name: "unique_constraint", unique: true
     t.index ["ancestor_id"], name: "index_relations_on_ancestor_id"
     t.index ["descendant_id"], name: "index_relations_on_descendant_id"
-    t.index ["hierarchy"], name: "index_relations_on_hierarchy"
-    t.index ["invalidate"], name: "index_relations_on_invalidate"
-    t.index ["mention"], name: "index_relations_on_mention"
   end
 
   add_foreign_key "relations", "messages", column: "ancestor_id"

data/spec/typed_dag/edge_spec.rb

@@ -347,15 +347,15 @@ RSpec.describe 'Edge' do
           it 'expects the transitive relations to be updated' do
             attribute_array = to_attribute_array Relation.non_reflexive
             expect(attribute_array)
-              .to match_array([['A', 'B', 0, 1],
-                               ['A', 'C', 1, 1],
-                               ['A', 'D', 1, 2],
-                               ['A', 'E', 2, 1],
-                               ['B', 'C', 1, 0],
-                               ['B', 'D', 1, 1],
-                               ['B', 'E', 2, 0],
-                               ['C', 'D', 0, 1],
-                               ['C', 'E', 1, 0]])
+              .to match_array([['A', 'B', 0, 1, 1],
+                               ['A', 'C', 1, 1, 1],
+                               ['A', 'D', 1, 2, 1],
+                               ['A', 'E', 2, 1, 1],
+                               ['B', 'C', 1, 0, 1],
+                               ['B', 'D', 1, 1, 1],
+                               ['B', 'E', 2, 0, 1],
+                               ['C', 'D', 0, 1, 1],
+                               ['C', 'E', 1, 0, 1]])
           end
         end
       end
@@ -415,15 +415,15 @@ RSpec.describe 'Edge' do
           it 'expects the transitive relations to be updated' do
             attribute_array = to_attribute_array Relation.non_reflexive
             expect(attribute_array)
-              .to match_array([['F', 'B', 0, 1],
-                               ['F', 'C', 0, 2],
-                               ['F', 'D', 0, 3],
-                               ['F', 'E', 1, 2],
-                               ['B', 'C', 0, 1],
-                               ['B', 'D', 0, 2],
-                               ['B', 'E', 1, 1],
-                               ['C', 'D', 0, 1],
-                               ['C', 'E', 1, 0]])
+              .to match_array([['F', 'B', 0, 1, 1],
+                               ['F', 'C', 0, 2, 1],
+                               ['F', 'D', 0, 3, 1],
+                               ['F', 'E', 1, 2, 1],
+                               ['B', 'C', 0, 1, 1],
+                               ['B', 'D', 0, 2, 1],
+                               ['B', 'E', 1, 1, 1],
+                               ['C', 'D', 0, 1, 1],
+                               ['C', 'E', 1, 0, 1]])
           end
         end
       end
@@ -483,15 +483,15 @@ RSpec.describe 'Edge' do
           it 'expects the transitive relations to be updated' do
             attribute_array = to_attribute_array Relation.non_reflexive
             expect(attribute_array)
-              .to match_array([['A', 'B', 0, 1],
-                               ['A', 'C', 0, 2],
-                               ['A', 'F', 0, 3],
-                               ['A', 'E', 1, 2],
-                               ['B', 'C', 0, 1],
-                               ['B', 'F', 0, 2],
-                               ['B', 'E', 1, 1],
-                               ['C', 'F', 0, 1],
-                               ['C', 'E', 1, 0]])
+              .to match_array([['A', 'B', 0, 1, 1],
+                               ['A', 'C', 0, 2, 1],
+                               ['A', 'F', 0, 3, 1],
+                               ['A', 'E', 1, 2, 1],
+                               ['B', 'C', 0, 1, 1],
+                               ['B', 'F', 0, 2, 1],
+                               ['B', 'E', 1, 1, 1],
+                               ['C', 'F', 0, 1, 1],
+                               ['C', 'E', 1, 0, 1]])
           end
         end
       end
@@ -551,12 +551,12 @@ RSpec.describe 'Edge' do
           it 'expects the transitive relations to be updated' do
             attribute_array = to_attribute_array Relation.non_reflexive
             expect(attribute_array)
-              .to match_array([['A', 'B', 0, 1],
-                               ['F', 'C', 0, 1],
-                               ['C', 'D', 0, 1],
-                               ['C', 'E', 1, 0],
-                               ['F', 'D', 0, 2],
-                               ['F', 'E', 1, 1]])
+              .to match_array([['A', 'B', 0, 1, 1],
+                               ['F', 'C', 0, 1, 1],
+                               ['C', 'D', 0, 1, 1],
+                               ['C', 'E', 1, 0, 1],
+                               ['F', 'D', 0, 2, 1],
+                               ['F', 'E', 1, 1, 1]])
           end
         end
       end

data/spec/typed_dag/node_spec.rb

@@ -1953,6 +1953,7 @@ RSpec.describe TypedDag::Node, 'included in Message' do
     end
 
     describe '#rebuild_dag!' do
+
       description = <<-'WITH'
 
         DAG (messed up transitive closures):
@@ -1998,44 +1999,32 @@ RSpec.describe TypedDag::Node, 'included in Message' do
           Message.rebuild_dag!
         end
 
-        it '#descendants_of_depth(1) for A is H' do
-          expect(a.descendants_of_depth(1))
-            .to match_array([h])
-        end
-
-        it '#all_invalidates_of_depth(1) for A is B, C, D' do
-          expect(a.all_invalidates_of_depth(1))
-            .to match_array([b, c, d])
-        end
-
-        it '#descendants_of_depth(2) for A is H' do
-          expect(a.descendants_of_depth(2))
-            .to match_array([i])
-        end
-
-        it '#all_invalidates_of_depth(2) for A is C, E, F' do
-          expect(a.all_invalidates_of_depth(2))
-            .to match_array([c, e, f])
-        end
-
-        it '#descendants_of_depth(3) for A is G' do
-          expect(a.descendants_of_depth(3))
-            .to match_array([g])
-        end
-
-        it '#all_invalidates_of_depth(3) for A is G and F' do
-          expect(a.all_invalidates_of_depth(3))
-            .to match_array([g, f])
-        end
-
-        it '#descendants_of_depth(4) for A is empty' do
-          expect(a.descendants_of_depth(4))
-            .to be_empty
-        end
-
-        it '#all_invalidates_of_depth(4) for A is G' do
-          expect(a.all_invalidates_of_depth(4))
-            .to match_array([g])
+        it 'rebuilds the closure for A correctly' do
+          attribute_array = to_attribute_array a.relations_to
+          expect(attribute_array)
+            .to match_array([['A', 'A', 0, 0, 1],
+                             ['A', 'B', 0, 1, 1],
+                             ['A', 'C', 0, 1, 1],
+                             ['A', 'C', 0, 2, 2],
+                             ['A', 'D', 0, 1, 1],
+                             ['A', 'E', 0, 2, 1],
+                             ['A', 'F', 0, 2, 1],
+                             ['A', 'F', 0, 3, 3],
+                             ['A', 'G', 0, 3, 1],
+                             ['A', 'G', 0, 4, 3],
+                             ['A', 'G', 3, 0, 1],
+                             ['A', 'H', 1, 0, 1],
+                             ['A', 'I', 2, 0, 1]])
+        end
+
+        it 'rebuilds the closure for B correctly' do
+          attribute_array = to_attribute_array b.relations_to
+          expect(attribute_array)
+            .to match_array([['B', 'B', 0, 0, 1],
+                             ['B', 'C', 0, 1, 1],
+                             ['B', 'E', 0, 1, 1],
+                             ['B', 'F', 0, 2, 2],
+                             ['B', 'G', 0, 3, 2]])
         end
 
         it 'rebuilds all reflexive relations' do
@@ -2096,32 +2085,36 @@ RSpec.describe TypedDag::Node, 'included in Message' do
       description = <<-'WITH'
 
         DAG (invalid) before:
-        --+A
-       |  + \
-       i i   h
-       |/     +
-       C+--h---B
+         C+-h--B
+         |+    +
+         | \   |
+         h  i  h
+         |   \ |
+         +    \|
+         D--h-+A
       WITH
 
       context description do
         let!(:a) { Message.create text: 'A' }
         let!(:b) { Message.create text: 'B', parent: a }
         let!(:c) { Message.create text: 'C', parent: b }
-        let!(:invalid_relation) do
+        let!(:d) { Message.create text: 'D', parent: c }
+        let!(:invalid_relation1) do
           Relation
-            .new(from: c,
-                 to: a,
+            .new(from: a,
+                 to: c,
                  invalidate: 1)
             .save(validate: false)
-
+        end
+        let!(:invalid_relation2) do
           Relation
-            .new(from: c,
+            .new(from: d,
                  to: a,
-                 invalidate: 1)
+                 hierarchy: 1)
             .save(validate: false)
         end
 
-        it 'throws an error if more attepts than specified are made' do
+        it 'throws an error if more attempts than specified are made' do
           expect { Message.rebuild_dag!(1) }
             .to raise_error(TypedDag::RebuildDag::AttemptsExceededError)
         end

data/spec/typed_dag/sql/add_closure_spec.rb

@@ -1,47 +1,113 @@
 require 'spec_helper'
 
 RSpec.describe TypedDag::Sql::AddClosure do
+  include TypedDag::Specs::Helpers
+
   describe '.sql' do
     let(:relation) { Relation.new id: 11, ancestor_id: 4, descendant_id: 6, invalidate: 1 }
 
-    def harmonize_string(string)
-      string.squish.gsub('( ', '(').gsub(' )', ')').gsub(' , ', ', ')
-    end
-
     it 'produces the correct sql' do
-      expected_sql = <<-SQL
-        INSERT INTO
-
-          relations
-
-          (ancestor_id,
-          descendant_id,
-          hierarchy, invalidate)
-        SELECT
-          r1.ancestor_id,
-          r2.descendant_id,
-          CASE
-            WHEN r1.descendant_id = r2.ancestor_id AND (r1.hierarchy > 0 OR r2.hierarchy > 0)
-            THEN r1.hierarchy + r2.hierarchy
-            WHEN r1.descendant_id != r2.ancestor_id
-            THEN r1.hierarchy + r2.hierarchy + 0
-            ELSE 0
-            END AS hierarchy,
-          CASE
-            WHEN r1.descendant_id = r2.ancestor_id AND (r1.invalidate > 0 OR r2.invalidate > 0)
-            THEN r1.invalidate + r2.invalidate
-            WHEN r1.descendant_id != r2.ancestor_id
-            THEN r1.invalidate + r2.invalidate + 1
-            ELSE 0
-            END AS invalidate
-
-        FROM
-          relations r1
-        JOIN
-          relations r2
-        ON
-          (r1.descendant_id = 4 AND r2.ancestor_id = 6 AND NOT (r1.ancestor_id = 4 AND r2.descendant_id = 6))
-      SQL
+      expected_sql = if mysql_db?
+        <<-SQL
+          INSERT INTO
+
+            relations
+
+            (ancestor_id,
+            descendant_id,
+            hierarchy,
+            invalidate,
+            count)
+          SELECT
+            ancestor_id,
+            descendant_id,
+            hierarchy,
+            invalidate,
+            SUM(count) AS count
+          FROM
+            (SELECT
+              r1.ancestor_id,
+              r2.descendant_id,
+              CASE
+                WHEN r1.descendant_id = r2.ancestor_id AND (r1.hierarchy > 0 OR r2.hierarchy > 0)
+                THEN r1.hierarchy + r2.hierarchy
+                WHEN r1.descendant_id != r2.ancestor_id
+                THEN r1.hierarchy + r2.hierarchy + 0
+                ELSE 0
+                END AS hierarchy,
+              CASE
+                WHEN r1.descendant_id = r2.ancestor_id AND (r1.invalidate > 0 OR r2.invalidate > 0)
+                THEN r1.invalidate + r2.invalidate
+                WHEN r1.descendant_id != r2.ancestor_id
+                THEN r1.invalidate + r2.invalidate + 1
+                ELSE 0
+                END AS invalidate,
+              r1.count * r2.count AS count
+            FROM
+              relations r1
+            JOIN
+              relations r2
+            ON
+              (r1.descendant_id = 4 AND r2.ancestor_id = 6 AND NOT (r1.ancestor_id = 4 AND r2.descendant_id = 6))) unique_rows
+          GROUP BY
+            ancestor_id,
+            descendant_id,
+            hierarchy,
+            invalidate
+          ON DUPLICATE KEY
+          UPDATE count = relations.count + VALUES(count)
+        SQL
+      else
+        <<-SQL
+          INSERT INTO
+
+            relations
+
+            (ancestor_id,
+            descendant_id,
+            hierarchy,
+            invalidate,
+            count)
+          SELECT
+            ancestor_id,
+            descendant_id,
+            hierarchy,
+            invalidate,
+            SUM(count) AS count
+          FROM
+            (SELECT
+              r1.ancestor_id,
+              r2.descendant_id,
+              CASE
+                WHEN r1.descendant_id = r2.ancestor_id AND (r1.hierarchy > 0 OR r2.hierarchy > 0)
+                THEN r1.hierarchy + r2.hierarchy
+                WHEN r1.descendant_id != r2.ancestor_id
+                THEN r1.hierarchy + r2.hierarchy + 0
+                ELSE 0
+                END AS hierarchy,
+              CASE
+                WHEN r1.descendant_id = r2.ancestor_id AND (r1.invalidate > 0 OR r2.invalidate > 0)
+                THEN r1.invalidate + r2.invalidate
+                WHEN r1.descendant_id != r2.ancestor_id
+                THEN r1.invalidate + r2.invalidate + 1
+                ELSE 0
+                END AS invalidate,
+              r1.count * r2.count AS count
+            FROM
+              relations r1
+            JOIN
+              relations r2
+            ON
+              (r1.descendant_id = 4 AND r2.ancestor_id = 6 AND NOT (r1.ancestor_id = 4 AND r2.descendant_id = 6))) unique_rows
+          GROUP BY
+            ancestor_id,
+            descendant_id,
+            hierarchy,
+            invalidate
+          ON CONFLICT (ancestor_id, descendant_id, hierarchy, invalidate)
+          DO UPDATE SET count = relations.count + EXCLUDED.count
+        SQL
+      end
 
       expect(harmonize_string(described_class.sql(relation)))
         .to eql harmonize_string(expected_sql)