implement joining

BrianHicks · May 4, 2021 · d6930d5 · d6930d5
1 parent c3e84a4
commit d6930d5
Show file tree

Hide file tree

Showing 2 changed files with 46 additions and 1 deletion.
diff --git a/src/Datalog.elm b/src/Datalog.elm
@@ -1,6 +1,7 @@
 module Datalog exposing (Atom, Rule, Term, atom, rule, ruleToPlan, string, var)
 
 import Database exposing (Constant)
+import Dict
 
 
 type Problem
@@ -28,7 +29,33 @@ ruleToPlan (Rule (Atom _ headTerms) bodyAtoms) =
                     Ok (atomToPlan only)
 
                 first :: rest ->
-                    Debug.todo "combine more than one atom"
+                    List.foldl
+                        (\nextAtom ( rightNames, rightPlan ) ->
+                            let
+                                ( leftNames, leftPlan ) =
+                                    atomToPlan nextAtom
+
+                                fields =
+                                    Dict.merge
+                                        (\_ _ soFar -> soFar)
+                                        (\_ left right soFar -> ( left, right ) :: soFar)
+                                        (\_ _ soFar -> soFar)
+                                        (Dict.fromList (List.indexedMap (\i field -> ( field, i )) leftNames))
+                                        (Dict.fromList (List.indexedMap (\i field -> ( field, i )) rightNames))
+                                        []
+                            in
+                            ( leftNames ++ rightNames
+                            , Database.Join
+                                { left = leftPlan
+                                , leftFields = List.map Tuple.first fields
+                                , right = rightPlan
+                                , rightFields = List.map Tuple.second fields
+                                }
+                            )
+                        )
+                        (atomToPlan first)
+                        rest
+                        |> Ok
     in
     planned
         |> Result.map

diff --git a/tests/DatalogTests.elm b/tests/DatalogTests.elm
@@ -26,5 +26,23 @@ datalogTests =
                                 |> Database.Project [ 0 ]
                                 |> Ok
                             )
+            , test "sharing a variable between two atoms results in a join" <|
+                \_ ->
+                    rule
+                        (atom "reachable" [ var "a", var "c" ])
+                        [ atom "link" [ var "a", var "b" ]
+                        , atom "reachable" [ var "b", var "c" ]
+                        ]
+                        |> ruleToPlan
+                        |> Expect.equal
+                            (Database.Join
+                                { left = Database.Read "reachable"
+                                , leftFields = [ 0 ]
+                                , right = Database.Read "link"
+                                , rightFields = [ 1 ]
+                                }
+                                |> Database.Project [ 2, 1 ]
+                                |> Ok
+                            )
             ]
         ]