jupyter-duckdb 1.2.0.6__tar.gz → 1.2.7__tar.gz

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.0.6
+Version: 1.2.7
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/src/duckdb_kernel/parser/RAParser.py

@@ -19,10 +19,14 @@ class RAParser:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
         # binary operators
-        for operator in RA_BINARY_OPERATORS:
+        for operator_symbols in RA_BINARY_SYMBOLS:
             # iterate tokens and match symbol
             for i in range(1, len(tokens) + 1):
-                if tokens[-i].lower() in operator.symbols():
+                lower_token = tokens[-i].lower()
+
+                if lower_token in operator_symbols:
+                    operator = operator_symbols[lower_token]
+
                     # raise error if left or right operand missing
                     if i == 1:
                         raise RAParserError(f'right operand missing after {tokens[-i]}', depth)

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/src/duckdb_kernel/parser/elements/__init__.py

@@ -9,7 +9,7 @@ from .RAOperator import RAOperator
 from .RABinaryOperator import RABinaryOperator
 from .RAUnaryOperator import RAUnaryOperator
 from .RAOperand import RAOperand
-from .binary import RA_BINARY_OPERATORS
+from .binary import RA_BINARY_OPERATORS, RA_BINARY_SYMBOLS
 from .unary import RA_UNARY_OPERATORS
 
 from .DCOperand import DCOperand

jupyter_duckdb-1.2.7/src/duckdb_kernel/parser/elements/binary/FullOuterJoin.py

@@ -0,0 +1,30 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+from ...util.RenamableColumnList import RenamableColumnList
+
+
+class FullOuterJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(10199), 'fjoin', 'ojoin'
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subqueries
+        lq, lcols = self.left.to_sql(tables)
+        rq, rcols = self.right.to_sql(tables)
+
+        # find matching columns
+        join_cols, all_cols = lcols.intersect(rcols)
+
+        replacements = {c1: c2 for c1, c2 in join_cols}
+        select_cols = [
+            f'COALESCE({c.current_name}, {replacements.get(c).current_name})' if c in replacements else c.current_name
+            for c in all_cols]
+        select_clause = ', '.join(select_cols)
+
+        on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
+
+        # create sql
+        return f'SELECT {select_clause} FROM ({lq}) {self._name()} FULL OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

jupyter_duckdb-1.2.7/src/duckdb_kernel/parser/elements/binary/LeftOuterJoin.py

@@ -0,0 +1,24 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+from ...util.RenamableColumnList import RenamableColumnList
+
+
+class LeftOuterJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(10197), 'ljoin'
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subqueries
+        lq, lcols = self.left.to_sql(tables)
+        rq, rcols = self.right.to_sql(tables)
+
+        # find matching columns
+        join_cols, all_cols = lcols.intersect(rcols)
+
+        on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
+
+        # create sql
+        return f'SELECT {all_cols.list} FROM ({lq}) {self._name()} LEFT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

jupyter_duckdb-1.2.7/src/duckdb_kernel/parser/elements/binary/RightOuterJoin.py

@@ -0,0 +1,24 @@
+from typing import Tuple, Dict
+
+from duckdb_kernel.db import Table
+from ..RABinaryOperator import RABinaryOperator
+from ...util.RenamableColumnList import RenamableColumnList
+
+
+class RightOuterJoin(RABinaryOperator):
+    @staticmethod
+    def symbols() -> Tuple[str, ...]:
+        return chr(10198), 'rjoin'
+
+    def to_sql(self, tables: Dict[str, Table]) -> Tuple[str, RenamableColumnList]:
+        # execute subqueries
+        lq, lcols = self.left.to_sql(tables)
+        rq, rcols = self.right.to_sql(tables)
+
+        # find matching columns
+        join_cols, all_cols = lcols.intersect(rcols, prefer_right=True)
+
+        on_clause = ' AND '.join(f'{l.current_name} = {r.current_name}' for l, r in join_cols)
+
+        # create sql
+        return f'SELECT {all_cols.list} FROM ({lq}) {self._name()} RIGHT OUTER JOIN ({rq}) {self._name()} ON {on_clause}', all_cols

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/src/duckdb_kernel/parser/elements/binary/__init__.py

@@ -2,6 +2,9 @@ from .Cross import Cross
 from .Difference import Difference
 from .Intersection import Intersection
 from .Join import Join
+from .LeftOuterJoin import LeftOuterJoin
+from .RightOuterJoin import RightOuterJoin
+from .FullOuterJoin import FullOuterJoin
 from .Union import Union
 
 from .Add import Add
@@ -30,12 +33,22 @@ LOGIC_BINARY_OPERATORS = sorted([
 ], key=lambda x: x.order, reverse=True)
 
 RA_BINARY_OPERATORS = [
-    Difference,
-    Union,
-    Intersection,
-    Join,
-    Cross,
-    Division
+    [Difference],
+    [Union],
+    [Intersection],
+    [Join],
+    [LeftOuterJoin, RightOuterJoin, FullOuterJoin],
+    [Cross],
+    [Division]
+]
+
+RA_BINARY_SYMBOLS = [
+    {
+        symbol: operator
+        for operator in level
+        for symbol in operator.symbols()
+    }
+    for level in RA_BINARY_OPERATORS
 ]
 
 DC_SET = ConditionalSet

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/src/duckdb_kernel/parser/util/RenamableColumnList.py

@@ -73,18 +73,26 @@ class RenamableColumnList(list[RenamableColumn]):
 
         return RenamableColumnList(cols.values())
 
-    def intersect(self, other: 'RenamableColumnList') \
+    def intersect(self, other: 'RenamableColumnList', prefer_right: bool = False) \
             -> Tuple[List[Tuple[RenamableColumn, RenamableColumn]], 'RenamableColumnList']:
         self_cols: Dict[str, RenamableColumn] = {col.name: col for col in self}
         other_cols: Dict[str, RenamableColumn] = {col.name: col for col in other}
 
+        replacements: Dict[RenamableColumn, RenamableColumn] = {}
         intersection: List[Tuple[RenamableColumn, RenamableColumn]] = []
+
         for name in tuple(self_cols.keys()):
             if name in other_cols:
+                if prefer_right:
+                    replacements[self_cols[name]] = other_cols[name]
+
                 intersection.append((self_cols[name], other_cols[name]))
                 del other_cols[name]
 
         # if len(intersection) == 0:
         #     raise AssertionError('no common attributes found for join')
 
-        return intersection, RenamableColumnList(self_cols.values(), other_cols.values())
+        return intersection, RenamableColumnList(
+            (replacements.get(x, x) for x in self_cols.values()),
+            other_cols.values()
+        )

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/src/jupyter_duckdb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.0.6
+Version: 1.2.7
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/src/jupyter_duckdb.egg-info/SOURCES.txt

@@ -50,15 +50,18 @@ src/duckdb_kernel/parser/elements/binary/Difference.py
 src/duckdb_kernel/parser/elements/binary/Divide.py
 src/duckdb_kernel/parser/elements/binary/Division.py
 src/duckdb_kernel/parser/elements/binary/Equal.py
+src/duckdb_kernel/parser/elements/binary/FullOuterJoin.py
 src/duckdb_kernel/parser/elements/binary/GreaterThan.py
 src/duckdb_kernel/parser/elements/binary/GreaterThanEqual.py
 src/duckdb_kernel/parser/elements/binary/Intersection.py
 src/duckdb_kernel/parser/elements/binary/Join.py
+src/duckdb_kernel/parser/elements/binary/LeftOuterJoin.py
 src/duckdb_kernel/parser/elements/binary/LessThan.py
 src/duckdb_kernel/parser/elements/binary/LessThanEqual.py
 src/duckdb_kernel/parser/elements/binary/Minus.py
 src/duckdb_kernel/parser/elements/binary/Multiply.py
 src/duckdb_kernel/parser/elements/binary/Or.py
+src/duckdb_kernel/parser/elements/binary/RightOuterJoin.py
 src/duckdb_kernel/parser/elements/binary/Unequal.py
 src/duckdb_kernel/parser/elements/binary/Union.py
 src/duckdb_kernel/parser/elements/binary/__init__.py

{jupyter_duckdb-1.2.0.6 → jupyter_duckdb-1.2.7}/test/test_ra.py

@@ -32,9 +32,9 @@ def test_case_insensitivity():
             ]
 
     for query in (
-        'π [ Username ] ( Users )',
-        'π [ username ] ( Users )',
-        'π [ userName ] ( Users )'
+            'π [ Username ] ( Users )',
+            'π [ username ] ( Users )',
+            'π [ userName ] ( Users )'
     ):
         root = RAParser.parse_query(query)
 
@@ -47,9 +47,9 @@ def test_case_insensitivity():
             ]
 
     for query in (
-        'π [ Id, Username ] ( Users )',
-        'π [ id, username ] ( Users )',
-        'π [ iD, userName ] ( Users )'
+            'π [ Id, Username ] ( Users )',
+            'π [ id, username ] ( Users )',
+            'π [ iD, userName ] ( Users )'
     ):
         root = RAParser.parse_query(query)
 
@@ -160,6 +160,64 @@ def test_binary_operator_join():
             ]
 
 
+def test_binary_operator_ljoin():
+    for query in (
+            r'Users ⟕ BannedUsers',
+            r'Users ljoin BannedUsers'
+    ):
+        root = RAParser.parse_query(query)
+
+        assert isinstance(root, BinaryOperators.LeftOuterJoin)
+        assert isinstance(root.left, RAOperand) and root.left.name == 'Users'
+        assert isinstance(root.right, RAOperand) and root.right.name == 'BannedUsers'
+
+        with Connection() as con:
+            assert con.execute_ra(root) == [
+                (1, 'Alice', None),
+                (2, 'Bob', 'Bob'),
+                (3, 'Charlie', None),
+            ]
+
+
+def test_binary_operator_rjoin():
+    for query in (
+            r'Users ⟖ BannedUsers',
+            r'Users rjoin BannedUsers'
+    ):
+        root = RAParser.parse_query(query)
+
+        assert isinstance(root, BinaryOperators.RightOuterJoin)
+        assert isinstance(root.left, RAOperand) and root.left.name == 'Users'
+        assert isinstance(root.right, RAOperand) and root.right.name == 'BannedUsers'
+
+        with Connection() as con:
+            assert con.execute_ra(root) == [
+                (2, 'Bob', 'Bob'),
+                (4, None, 'David')
+            ]
+
+
+def test_binary_operator_fjoin():
+    for query in (
+            r'Users ⟗ BannedUsers',
+            r'Users fjoin BannedUsers',
+            r'Users ojoin BannedUsers'
+    ):
+        root = RAParser.parse_query(query)
+
+        assert isinstance(root, BinaryOperators.FullOuterJoin)
+        assert isinstance(root.left, RAOperand) and root.left.name == 'Users'
+        assert isinstance(root.right, RAOperand) and root.right.name == 'BannedUsers'
+
+        with Connection() as con:
+            assert con.execute_ra(root) == [
+                (1, 'Alice', None),
+                (2, 'Bob', 'Bob'),
+                (3, 'Charlie', None),
+                (4, None, 'David')
+            ]
+
+
 def test_binary_operator_union():
     for query in (
             r'Users ∪ BannedUsers',
@@ -313,6 +371,178 @@ def test_unary_operator_selection():
             ]
 
 
+def test_unary_inner_to_outer_evaluation_order():
+    root = RAParser.parse_query(r'π [ Id ] π [ Id, Username ] (Users)')
+    assert isinstance(root, UnaryOperators.Projection) and root.columns == ('Id',)
+    assert isinstance(root.target, UnaryOperators.Projection) and root.target.columns == ('Id', 'Username')
+
+    root = RAParser.parse_query(r'σ [ Id > 2 ] σ [ Id > 1 ] (Users)')
+    assert isinstance(root, UnaryOperators.Selection)
+    assert isinstance(root.condition, BinaryOperators.GreaterThan)
+    assert root.condition.left == ('Id',) and root.condition.right == ('2',)
+    assert isinstance(root.target, UnaryOperators.Selection)
+    assert isinstance(root.target.condition, BinaryOperators.GreaterThan)
+    assert root.target.condition.left == ('Id',) and root.target.condition.right == ('1',)
+
+    root = RAParser.parse_query(r'β [ Id3 ← Id2 ] β [ Id2 ← Id ] (Users)')
+    assert isinstance(root, UnaryOperators.Rename)
+    assert isinstance(root.arrow, BinaryOperators.ArrowLeft)
+    assert root.arrow.left == ('Id3',) and root.arrow.right == ('Id2',)
+    assert isinstance(root.target, UnaryOperators.Rename)
+    assert isinstance(root.target.arrow, BinaryOperators.ArrowLeft)
+    assert root.target.arrow.left == ('Id2',) and root.target.arrow.right == ('Id',)
+
+
+def test_binary_left_to_right_evaluation_order():
+    # difference
+    root = RAParser.parse_query(r'a \ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, BinaryOperators.Difference)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    # union
+    root = RAParser.parse_query(r'a ∪ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, BinaryOperators.Union)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    # intersection
+    root = RAParser.parse_query(r'a ∩ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, BinaryOperators.Intersection)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    # natural join
+    root = RAParser.parse_query(r'a ⋈ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, BinaryOperators.Join)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    # outer join
+    root = RAParser.parse_query(r'a ⟕ b ⟕ c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟖ b ⟖ c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟗ b ⟗ c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    # mixed outer joins
+    root = RAParser.parse_query(r'a ⟕ b ⟖ c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟕ b ⟗ c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟖ b ⟕ c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟖ b ⟗ c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟗ b ⟕ c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+    root = RAParser.parse_query(r'a ⟗ b ⟖ c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+
+    # cross join
+    root = RAParser.parse_query(r'a x b x c')
+    assert isinstance(root, BinaryOperators.Cross)
+    assert isinstance(root.left, BinaryOperators.Cross)
+    assert isinstance(root.left.left, RAOperand)
+    assert root.left.left.name == 'a'
+    assert isinstance(root.left.right, RAOperand)
+    assert root.left.right.name == 'b'
+    assert isinstance(root.right, RAOperand)
+    assert root.right.name == 'c'
+
+
 def test_unary_evaluation_order():
     root = RAParser.parse_query(r'π [ Id2 ] β [ Id2 ← Id ] (Users)')
     assert isinstance(root, UnaryOperators.Projection)
@@ -367,6 +597,30 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Difference)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Join)
 
+    root = RAParser.parse_query(r'a \ b ⟕ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟕ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a \ b ⟖ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟖ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a \ b ⟗ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.FullOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟗ b \ c')
+    assert isinstance(root, BinaryOperators.Difference)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
+
     # difference <-> cross
     root = RAParser.parse_query(r'a \ b x c')
     assert isinstance(root, BinaryOperators.Difference)
@@ -403,6 +657,30 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Union)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Join)
 
+    root = RAParser.parse_query(r'a ∪ b ⟕ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟕ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ∪ b ⟖ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟖ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ∪ b ⟗ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.FullOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟗ b ∪ c')
+    assert isinstance(root, BinaryOperators.Union)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
+
     # union <-> cross
     root = RAParser.parse_query(r'a ∪ b x c')
     assert isinstance(root, BinaryOperators.Union)
@@ -430,6 +708,30 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Intersection)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Join)
 
+    root = RAParser.parse_query(r'a ∩ b ⟕ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟕ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ∩ b ⟖ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟖ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ∩ b ⟗ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.FullOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟗ b ∩ c')
+    assert isinstance(root, BinaryOperators.Intersection)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
+
     # intersection <-> cross
     root = RAParser.parse_query(r'a ∩ b x c')
     assert isinstance(root, BinaryOperators.Intersection)
@@ -457,6 +759,30 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
 
+    root = RAParser.parse_query(r'a ⟕ b x c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a x b ⟕ c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a ⟖ b x c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a x b ⟖ c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a ⟗ b x c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Cross)
+
+    root = RAParser.parse_query(r'a x b ⟗ c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Cross)
+
     # join <-> division
     root = RAParser.parse_query(r'a ⋈ b ÷ c')
     assert isinstance(root, BinaryOperators.Join)
@@ -466,6 +792,55 @@ def test_binary_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
 
+    root = RAParser.parse_query(r'a ⟕ b ÷ c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ⟕ c')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ⟖ b ÷ c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ⟖ c')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ⟗ b ÷ c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.Division)
+
+    root = RAParser.parse_query(r'a ÷ b ⟗ c')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.Division)
+
+    # natural join <-> outer join
+    root = RAParser.parse_query(r'a ⋈ b ⟕ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟕ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.LeftOuterJoin)
+
+    root = RAParser.parse_query(r'a ⋈ b ⟖ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟖ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.RightOuterJoin)
+
+    root = RAParser.parse_query(r'a ⋈ b ⟗ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, BinaryOperators.FullOuterJoin)
+
+    root = RAParser.parse_query(r'a ⟗ b ⋈ c')
+    assert isinstance(root, BinaryOperators.Join)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, BinaryOperators.FullOuterJoin)
+
     # cross <-> division
     root = RAParser.parse_query(r'a x b ÷ c')
     assert isinstance(root, BinaryOperators.Cross)
@@ -567,6 +942,30 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
 
+    root = RAParser.parse_query(r'a ⟕ π [ Id ] b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'π [ Id ] a ⟕ b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'a ⟖ π [ Id ] b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'π [ Id ] a ⟖ b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'a ⟗ π [ Id ] b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Projection)
+
+    root = RAParser.parse_query(r'π [ Id ] a ⟗ b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Projection)
+
     # join <-> rename
     root = RAParser.parse_query(r'a ⋈ β [ Id2 ← Id ] b')
     assert isinstance(root, BinaryOperators.Join)
@@ -576,6 +975,30 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
 
+    root = RAParser.parse_query(r'a ⟕ β [ Id2 ← Id ] b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⟕ b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⟖ β [ Id2 ← Id ] b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⟖ b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'a ⟗ β [ Id2 ← Id ] b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Rename)
+
+    root = RAParser.parse_query(r'β [ Id2 ← Id ] a ⟗ b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Rename)
+
     # join <-> selection
     root = RAParser.parse_query(r'a ⋈ σ [ Id > 1 ] b')
     assert isinstance(root, BinaryOperators.Join)
@@ -585,6 +1008,30 @@ def test_mixed_evaluation_order():
     assert isinstance(root, BinaryOperators.Join)
     assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
 
+    root = RAParser.parse_query(r'a ⟕ σ [ Id > 1 ] b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'σ [ Id > 1 ] a ⟕ b')
+    assert isinstance(root, BinaryOperators.LeftOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'a ⟖ σ [ Id > 1 ] b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'σ [ Id > 1 ] a ⟖ b')
+    assert isinstance(root, BinaryOperators.RightOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'a ⟗ σ [ Id > 1 ] b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.left, RAOperand) and isinstance(root.right, UnaryOperators.Selection)
+
+    root = RAParser.parse_query(r'σ [ Id > 1 ] a ⟗ b')
+    assert isinstance(root, BinaryOperators.FullOuterJoin)
+    assert isinstance(root.right, RAOperand) and isinstance(root.left, UnaryOperators.Selection)
+
     # cross <-> projection
     root = RAParser.parse_query(r'a x π [ Id ] b')
     assert isinstance(root, BinaryOperators.Cross)
@@ -657,7 +1104,7 @@ def test_special_queries():
             (
               Sigma [ Id > 1 ] Pi [ Username, Id ] (Users)
             ) x (
-              Beta [ Username2 <- Username ] Beta [ Id2 <- Id ] (BannedUsers)
+              Beta [ Username2 <- BannedUsername ] Beta [ Id2 <- Id ] (BannedUsers)
             )
         ''')