jupyter-duckdb 1.2.0.3__tar.gz → 1.2.0.5__tar.gz

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jupyter-duckdb
-Version: 1.2.0.3
+Version: 1.2.0.5
 Summary: a basic wrapper kernel for DuckDB
 Home-page: https://github.com/erictroebs/jupyter-duckdb
 Author: Eric Tröbs
@@ -32,10 +32,6 @@ This is a simple DuckDB wrapper kernel which accepts SQL as input, executes it
 using a previously loaded DuckDB instance and formats the output as a table.
 There are some magic commands that make teaching easier with this kernel.
 
-## Quick Start
-
-[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/git/https%3A%2F%2Fdbgit.prakinf.tu-ilmenau.de%2Fertr8623%2Fjupyter-duckdb.git/master)
-
 ## Table of Contents
 
 - [Setup](#setup)
@@ -85,6 +81,12 @@ Execute the following command to pull and run a prepared image.
 docker run -p 8888:8888 troebs/jupyter-duckdb
 ```
 
+There is also a second image. It contains an additional instance of PostgreSQL:
+
+```bash
+docker run -p 8888:8888 troebs/jupyter-duckdb:postgresql
+```
+
 This image can also be used with JupyterHub and the
 [DockerSpawner / SwarmSpawner](https://github.com/jupyterhub/dockerspawner)
 and probably with the
@@ -138,6 +140,13 @@ Please note that `:memory:` is also a valid file path for DuckDB. The data is
 then stored exclusively in the main memory. In combination with `CREATE`
 and `OF` this makes it possible to work on a temporary copy in memory.
 
+Although the name suggests otherwise, the kernel can also be used with other
+databases:
+- **SQLite** is automatically used as a fallback if the DuckDB dependency is
+  missing.
+- To connect to a **PostgreSQL** instance, you need to specify a database URI
+  starting with `(postgresql|postgres|pgsql|psql|pg)://`.
+
 ### Schema Diagrams
 
 The magic command `SCHEMA` can be used to create a simple schema diagram of the
@@ -153,6 +162,10 @@ representation requires more space, but can improve readability.
 %SCHEMA TD
 ```
 
+The optional argument `ONLY`, followed by one or more table names separated by a
+comma, can be used to display only the named tables and all those connected with
+a foreign key.
+
 Graphviz (`dot` in PATH) is required to render schema diagrams.
 
 ### Number of Rows
@@ -234,6 +247,11 @@ UNION
 SELECT 1, 'Name 1'
 ```
 
+By default, failed tests will display an explanation, but the notebook will
+continue to run. Set the `DUCKDB_TESTS_RAISE_EXCEPTION` environment variable to
+`true` to raise an exception when a test fails. This can be useful for automated
+testing in CI environments.
+
 Disclaimer: The integrated testing is work-in-progress and thus subject to
 potentially incompatible changes and enhancements.
 
@@ -244,7 +262,7 @@ magic command `RA` activates the relational algebra mode for a single cell:
 
 ```
 %RA
-π a, b (σ c = 1 (R))
+π [a, b] (σ [c = 1] (R))
 ```
 
 The supported operations are:
@@ -259,6 +277,9 @@ The supported operations are:
 - Cross Product `×`
 - Division `÷`
 
+The optional flag `ANALYZE` can be used to add an execution diagram to the
+output.
+
 The Dockerfile also installs the Jupyter Lab plugin
 [jupyter-ra-extension](https://pypi.org/project/jupyter-ra-extension/). It adds
 the symbols mentioned above and some other supported symbols to the toolbar for
@@ -273,3 +294,13 @@ magic command `DC` activates the domain calculus mode for a single cell:
 %DC
 { a, b | R(a, b, c) ∧ c = 1 }
 ```
+
+### Automated Parser Selection
+
+`%ALL_RA` or `%ALL_DC` enables the corresponding parser for all subsequently
+executed cells.
+
+If the magic command `%AUTO_PARSER` is added to a cell, a parser is
+automatically selected. If `%GUESS_PARSER` is executed, the parser is
+automatically selected for all subsequent cells.
+

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/README.md

@@ -4,10 +4,6 @@ This is a simple DuckDB wrapper kernel which accepts SQL as input, executes it
 using a previously loaded DuckDB instance and formats the output as a table.
 There are some magic commands that make teaching easier with this kernel.
 
-## Quick Start
-
-[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/git/https%3A%2F%2Fdbgit.prakinf.tu-ilmenau.de%2Fertr8623%2Fjupyter-duckdb.git/master)
-
 ## Table of Contents
 
 - [Setup](#setup)
@@ -57,6 +53,12 @@ Execute the following command to pull and run a prepared image.
 docker run -p 8888:8888 troebs/jupyter-duckdb
 ```
 
+There is also a second image. It contains an additional instance of PostgreSQL:
+
+```bash
+docker run -p 8888:8888 troebs/jupyter-duckdb:postgresql
+```
+
 This image can also be used with JupyterHub and the
 [DockerSpawner / SwarmSpawner](https://github.com/jupyterhub/dockerspawner)
 and probably with the
@@ -110,6 +112,13 @@ Please note that `:memory:` is also a valid file path for DuckDB. The data is
 then stored exclusively in the main memory. In combination with `CREATE`
 and `OF` this makes it possible to work on a temporary copy in memory.
 
+Although the name suggests otherwise, the kernel can also be used with other
+databases:
+- **SQLite** is automatically used as a fallback if the DuckDB dependency is
+  missing.
+- To connect to a **PostgreSQL** instance, you need to specify a database URI
+  starting with `(postgresql|postgres|pgsql|psql|pg)://`.
+
 ### Schema Diagrams
 
 The magic command `SCHEMA` can be used to create a simple schema diagram of the
@@ -125,6 +134,10 @@ representation requires more space, but can improve readability.
 %SCHEMA TD
 ```
 
+The optional argument `ONLY`, followed by one or more table names separated by a
+comma, can be used to display only the named tables and all those connected with
+a foreign key.
+
 Graphviz (`dot` in PATH) is required to render schema diagrams.
 
 ### Number of Rows
@@ -206,6 +219,11 @@ UNION
 SELECT 1, 'Name 1'
 ```
 
+By default, failed tests will display an explanation, but the notebook will
+continue to run. Set the `DUCKDB_TESTS_RAISE_EXCEPTION` environment variable to
+`true` to raise an exception when a test fails. This can be useful for automated
+testing in CI environments.
+
 Disclaimer: The integrated testing is work-in-progress and thus subject to
 potentially incompatible changes and enhancements.
 
@@ -216,7 +234,7 @@ magic command `RA` activates the relational algebra mode for a single cell:
 
 ```
 %RA
-π a, b (σ c = 1 (R))
+π [a, b] (σ [c = 1] (R))
 ```
 
 The supported operations are:
@@ -231,6 +249,9 @@ The supported operations are:
 - Cross Product `×`
 - Division `÷`
 
+The optional flag `ANALYZE` can be used to add an execution diagram to the
+output.
+
 The Dockerfile also installs the Jupyter Lab plugin
 [jupyter-ra-extension](https://pypi.org/project/jupyter-ra-extension/). It adds
 the symbols mentioned above and some other supported symbols to the toolbar for
@@ -245,3 +266,13 @@ magic command `DC` activates the domain calculus mode for a single cell:
 %DC
 { a, b | R(a, b, c) ∧ c = 1 }
 ```
+
+### Automated Parser Selection
+
+`%ALL_RA` or `%ALL_DC` enables the corresponding parser for all subsequently
+executed cells.
+
+If the magic command `%AUTO_PARSER` is added to a cell, a parser is
+automatically selected. If `%GUESS_PARSER` is executed, the parser is
+automatically selected for all subsequent cells.
+

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/kernel.py

@@ -12,8 +12,9 @@ from ipykernel.kernelbase import Kernel
 from .db import Connection, DatabaseError, Table
 from .db.error import *
 from .magics import *
-from .parser import RAParser, DCParser
+from .parser import RAParser, DCParser, ParserError
 from .util.ResultSetComparator import ResultSetComparator
+from .util.TestError import TestError
 from .util.formatting import row_count, rows_table, wrap_image
 from .visualization import *
 
@@ -45,8 +46,12 @@ class DuckDBKernel(Kernel):
             MagicCommand('query_max_rows').arg('count').on(self._query_max_rows_magic),
             MagicCommand('schema').flag('td').opt('only').on(self._schema_magic),
             MagicCommand('store').arg('file').flag('noheader').result(True).on(self._store_magic),
-            MagicCommand('ra').flag('analyze').code(True).on(self._ra_magic),
-            MagicCommand('dc').code(True).on(self._dc_magic)
+            MagicCommand('ra').disable('dc', 'auto_parser').flag('analyze').code(True).on(self._ra_magic),
+            MagicCommand('all_ra').arg('value', '1').on(self._all_ra_magic),
+            MagicCommand('dc').disable('ra', 'auto_parser').code(True).on(self._dc_magic),
+            MagicCommand('all_dc').arg('value', '1').on(self._all_dc_magic),
+            MagicCommand('auto_parser').disable('ra', 'dc').code(True).on(self._auto_parser_magic),
+            MagicCommand('guess_parser').arg('value', '1').on(self._guess_parser_magic),
         )
 
         # create placeholders for database and tests
@@ -139,6 +144,7 @@ class DuckDBKernel(Kernel):
             return False
 
     def _execute_stmt(self, query: str, silent: bool,
+                      column_name_mapping: Dict[str, str],
                       max_rows: Optional[int]) -> Tuple[Optional[List[str]], Optional[List[List]]]:
         if self._db is None:
             raise AssertionError('load a database first')
@@ -168,7 +174,8 @@ class DuckDBKernel(Kernel):
         else:
             if columns is not None:
                 # table header
-                table_header = ''.join(f'<th>{c}</th>' for c in columns)
+                mapped_columns = (column_name_mapping.get(c, c) for c in columns)
+                table_header = ''.join(f'<th>{c}</th>' for c in mapped_columns)
 
                 # table data
                 if max_rows is not None and len(rows) > max_rows:
@@ -302,12 +309,23 @@ class DuckDBKernel(Kernel):
         result_columns = [col.rsplit('.', 1)[-1] for col in result_columns]
 
         # extract data for test
-        data = self._tests[name]
+        test_data = self._tests[name]
 
+        # execute test
+        try:
+            self._execute_test(test_data, result_columns, result)
+            self.print_data(wrap_image(True))
+        except TestError as e:
+            self.print_data(wrap_image(False, e.message))
+            if os.environ.get('DUCKDB_TESTS_RAISE_EXCEPTION', 'false').lower() in ('true', '1'):
+                raise e
+
+    @staticmethod
+    def _execute_test(test_data: Dict, result_columns: List[str], result: List[List]):
         # check columns if required
-        if isinstance(data['equals'], dict):
+        if isinstance(test_data['equals'], dict):
             # get column order
-            data_columns = list(data['equals'].keys())
+            data_columns = list(test_data['equals'].keys())
             column_order = []
 
             for dc in data_columns:
@@ -318,39 +336,37 @@ class DuckDBKernel(Kernel):
                         found += 1
 
                 if found == 0:
-                    return self.print_data(wrap_image(False, f'attribute {dc} missing'))
+                    raise TestError(f'attribute {dc} missing')
                 if found >= 2:
-                    return self.print_data(wrap_image(False, f'ambiguous attribute {dc}'))
+                    raise TestError(f'ambiguous attribute {dc}')
 
             # abort if columns from result are unnecessary
             for i, rc in enumerate(result_columns):
                 if i not in column_order:
-                    return self.print_data(wrap_image(False, f'unnecessary attribute {rc}'))
+                    raise TestError(f'unnecessary attribute {rc}')
 
             # reorder columns and transform to list of lists
             sorted_columns = [x for _, x in sorted(zip(column_order, data_columns))]
             rows = []
 
-            for row in zip(*(data['equals'][col] for col in sorted_columns)):
+            for row in zip(*(test_data['equals'][col] for col in sorted_columns)):
                 rows.append(row)
 
         else:
-            rows = data['equals']
+            rows = test_data['equals']
 
         # ordered test
-        if data['ordered']:
+        if test_data['ordered']:
             # calculate diff
             rsc = ResultSetComparator(result, rows)
 
             missing = len(rsc.ordered_right_only)
             if missing > 0:
-                return self.print_data(wrap_image(False, f'{row_count(missing)} missing'))
+                raise TestError(f'{row_count(missing)} missing')
 
             missing = len(rsc.ordered_left_only)
             if missing > 0:
-                return self.print_data(wrap_image(False, f'{row_count(missing)} more than required'))
-
-            return self.print_data(wrap_image(True))
+                raise TestError(f'{row_count(missing)} more than required')
 
         # unordered test
         else:
@@ -362,13 +378,11 @@ class DuckDBKernel(Kernel):
 
             # print result
             if below > 0 and above > 0:
-                self.print_data(wrap_image(False, f'{row_count(below)} missing, {row_count(above)} unnecessary'))
+                raise TestError(f'{row_count(below)} missing, {row_count(above)} unnecessary')
             elif below > 0:
-                self.print_data(wrap_image(False, f'{row_count(below)} missing'))
+                raise TestError(f'{row_count(below)} missing')
             elif above > 0:
-                self.print_data(wrap_image(False, f'{row_count(above)} unnecessary'))
-            else:
-                self.print_data(wrap_image(True))
+                raise TestError(f'{row_count(above)} unnecessary')
 
     def _all_magic(self, silent: bool):
         return {
@@ -486,6 +500,15 @@ class DuckDBKernel(Kernel):
             'generated_code': sql
         }
 
+    def _all_ra_magic(self, silent: bool, value: str):
+        if value.lower() in ('1', 'on', 'true'):
+            self._magics['ra'].default(True)
+            self._magics['dc'].default(False)
+
+            self.print('All further cells are interpreted as %RA.\n')
+        else:
+            self._magics['ra'].default(False)
+
     def _dc_magic(self, silent: bool, code: str):
         if self._db is None:
             raise AssertionError('load a database first')
@@ -503,12 +526,42 @@ class DuckDBKernel(Kernel):
         root_node = DCParser.parse_query(code)
 
         # generate sql
-        sql = root_node.to_sql(tables)
+        sql, cnm = root_node.to_sql_with_renamed_columns(tables)
 
         return {
-            'generated_code': sql
+            'generated_code': sql,
+            'column_name_mapping': cnm
         }
 
+    def _all_dc_magic(self, silent: bool, value: str):
+        if value.lower() in ('1', 'on', 'true'):
+            self._magics['dc'].default(True)
+            self._magics['ra'].default(False)
+
+            self.print('All further cells are interpreted as %DC.\n')
+        else:
+            self._magics['dc'].default(False)
+
+    def _guess_parser_magic(self, silent: bool, value: str):
+        if value.lower() in ('1', 'on', 'true'):
+            self._magics['auto_parser'].default(True)
+            self.print('The correct parser is guessed for each subsequently executed cell.\n')
+        else:
+            self._magics['auto_parser'].default(False)
+
+    def _auto_parser_magic(self, silent: bool, code: str):
+        try:
+            return self._ra_magic(silent, code, analyze=False)
+        except ParserError as e:
+            if e.depth > 0:
+                raise e
+
+        try:
+            return self._dc_magic(silent, code)
+        except ParserError as e:
+            if e.depth > 0:
+                raise e
+
     # jupyter related functions
     def do_execute(self, code: str, silent: bool,
                    store_history: bool = True, user_expressions: dict = None, allow_stdin: bool = False,
@@ -530,6 +583,10 @@ class DuckDBKernel(Kernel):
                 clean_code = execution_args['generated_code']
                 del execution_args['generated_code']
 
+            # set default column name mapping if none provided
+            if 'column_name_mapping' not in execution_args:
+                execution_args['column_name_mapping'] = {}
+
             # execute statement if needed
             if clean_code.strip():
                 cols, rows = self._execute_stmt(clean_code, silent, **execution_args)

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/magics/MagicCommand.py

@@ -1,27 +1,28 @@
-from typing import Any, List, Tuple, Callable, Dict
+from typing import Any, List, Tuple, Callable, Dict, Set
 
 
 class MagicCommand:
-    _ARG = '''([^ ]+?|'.+?'|".+?")'''
+    _ARG = '''([^ ]+?|'.+?'|".+?")?'''
 
     def __init__(self, *names: str):
-        self._names: Tuple[str] = names
+        self._names: Tuple[str, ...] = names
 
-        self._arguments: List[Tuple[str, str]] = []
+        self._arguments: List[Tuple[str, Any, str]] = []
         self._flags: List[Tuple[str, str]] = []
         self._optionals: List[Tuple[str, Any, str]] = []
-
+        self._disables: Set[str] = set()
         self._code: bool = False
         self._result: bool = False
+        self._default: bool = False
 
         self._on: List[Callable] = []
 
     @property
-    def names(self) -> Tuple[str]:
+    def names(self) -> Tuple[str, ...]:
         return self._names
 
     @property
-    def args(self) -> List[Tuple[str, str]]:
+    def args(self) -> List[Tuple[str, Any, str]]:
         return self._arguments
 
     @property
@@ -32,6 +33,10 @@ class MagicCommand:
     def optionals(self) -> List[Tuple[str, Any, str]]:
         return self._optionals
 
+    @property
+    def disables(self) -> Set[str]:
+        return self._disables
+
     @property
     def requires_code(self) -> bool:
         return self._code
@@ -40,8 +45,17 @@ class MagicCommand:
     def requires_query_result(self) -> bool:
         return self._result
 
-    def arg(self, name: str, description: str = None) -> 'MagicCommand':
-        self._arguments.append((name, description))
+    @property
+    def is_default(self) -> bool:
+        return self._default
+
+    def arg(self, name: str, default_value: Any = None, description: str = None) -> 'MagicCommand':
+        if len(self._arguments) > 0:
+            ln, ldv, _ = self._arguments[-1]
+            if ldv is not None and default_value is None:
+                raise ValueError(f'argument {name} without default value registered after argument {ln} with default value {ldv}')
+
+        self._arguments.append((name, default_value, description))
         return self
 
     def opt(self, name: str, default_value: Any = None, description: str = None) -> 'MagicCommand':
@@ -52,6 +66,12 @@ class MagicCommand:
         self._flags.append((name, description))
         return self
 
+    def disable(self, *name: str) -> 'MagicCommand':
+        for n in name:
+            self._disables.add(n)
+
+        return self
+
     def code(self, code: bool) -> 'MagicCommand':
         self._code = code
         return self
@@ -60,10 +80,14 @@ class MagicCommand:
         self._result = result
         return self
 
-    def on(self, fun: Callable):
+    def on(self, fun: Callable) -> 'MagicCommand':
         self._on.append(fun)
         return self
 
+    def default(self, default: bool) -> 'MagicCommand':
+        self._default = default
+        return self
+
     @property
     def parameters(self) -> str:
         args = ' +'.join([self._ARG] * len(self._arguments))

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/magics/MagicCommandCallback.py

@@ -1,20 +1,31 @@
 from typing import Optional, List
 
 from . import MagicCommand
+from .StringWrapper import StringWrapper
 
 
 class MagicCommandCallback:
-    def __init__(self, mc: MagicCommand, silent: bool, code: str, *args, **kwargs):
+    def __init__(self, mc: MagicCommand, silent: bool, code: StringWrapper, *args, **kwargs):
         self._mc: MagicCommand = mc
         self._silent: bool = silent
-        self._code: str = code
+        self._code: StringWrapper = code
         self._args = args
         self._kwargs = kwargs
 
+    @property
+    def magic(self) -> MagicCommand:
+        return self._mc
+
     def __call__(self, columns: Optional[List[str]] = None, rows: Optional[List[List]] = None):
         if self._mc.requires_code:
-            return self._mc(self._silent, self._code, *self._args, **self._kwargs)
+            result = self._mc(self._silent, self._code.value, *self._args, **self._kwargs)
+            if 'generated_code' in result:
+                self._code.value = result['generated_code']
+
+            return result
+
         if self._mc.requires_query_result:
             return self._mc(self._silent, columns, rows, *self._args, **self._kwargs)
+
         else:
             return self._mc(self._silent, *self._args, **self._kwargs)

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/magics/MagicCommandHandler.py

@@ -1,7 +1,8 @@
 import re
-from typing import Dict, Tuple, List
+from typing import Dict, Tuple, List, Optional
 
 from . import MagicCommand, MagicCommandException, MagicCommandCallback
+from .StringWrapper import StringWrapper
 
 
 class MagicCommandHandler:
@@ -14,10 +15,23 @@ class MagicCommandHandler:
                 key = key.lower()
                 self._magics[key] = cmd
 
+    def __getitem__(self, key: str) -> MagicCommand:
+        return self._magics[key.lower()]
+
     def __call__(self, silent: bool, code: str) -> Tuple[str, List[MagicCommandCallback], List[MagicCommandCallback]]:
-        pre_query_callbacks = []
-        post_query_callbacks = []
+        code_wrapper = StringWrapper()
+        enabled_callbacks: List[MagicCommandCallback] = []
+
+        # enable commands with default==True
+        for magic in self._magics.values():
+            if magic.is_default:
+                flags = {name: False for name, _ in magic.flags}
+                optionals = {name: default for name, default, _ in magic.optionals}
+                callback = MagicCommandCallback(magic, silent, code_wrapper, **flags, **optionals)
 
+                enabled_callbacks.append(callback)
+
+        # search for magic commands in code
         while True:
             # ensure code starts with '%' or '%%' but not with '%%%'
             match = re.match(r'^%{1,2}([^% ]+?)([ \t]*$| .+?$)', code, re.MULTILINE | re.IGNORECASE)
@@ -45,7 +59,11 @@ class MagicCommandHandler:
                 raise MagicCommandException(f'could not parse parameters for command "{command}"')
 
             # extract args
-            args = [g for g, _ in zip(match.groups(), magic.args)]
+            args = [group if group is not None else default
+                    for group, (_, default, _) in zip(match.groups(), magic.args)]
+
+            if any(arg is None for arg in args):
+                raise MagicCommandException(f'could not parse parameters for command "{command}"')
 
             i = len(args) + 1
 
@@ -73,12 +91,35 @@ class MagicCommandHandler:
                     optionals[name.lower()] = value
 
             # add to callbacks
-            callback = MagicCommandCallback(magic, silent, code, *args, **flags, **optionals)
+            callback = MagicCommandCallback(magic, silent, code_wrapper, *args, **flags, **optionals)
+            enabled_callbacks.append(callback)
+
+        # disable overwritten callbacks
+        callbacks = []
+        blacklist = set()
+
+        for callback in reversed(enabled_callbacks):
+            for name in callback.magic.names:
+                if name in blacklist:
+                    break
+            else:
+                callbacks.append(callback)
+
+                for name in callback.magic.names:
+                    blacklist.add(name)
+                for disable in callback.magic.disables:
+                    blacklist.add(disable)
+
+        # prepare callback lists
+        pre_query_callbacks = []
+        post_query_callbacks = []
 
-            if not magic.requires_query_result:
+        for callback in reversed(callbacks):
+            if not callback.magic.requires_query_result:
                 pre_query_callbacks.append(callback)
             else:
                 post_query_callbacks.append(callback)
 
         # return callbacks
+        code_wrapper.value = code
         return code, pre_query_callbacks, post_query_callbacks

jupyter_duckdb-1.2.0.5/src/duckdb_kernel/magics/StringWrapper.py

@@ -0,0 +1,3 @@
+class StringWrapper:
+    def __init__(self, value: str = None):
+        self.value: str = value

{jupyter_duckdb-1.2.0.3 → jupyter_duckdb-1.2.0.5}/src/duckdb_kernel/parser/DCParser.py

@@ -1,3 +1,4 @@
+from .ParserError import DCParserError
 from .elements import *
 from .tokenizer import *
 
@@ -18,17 +19,17 @@ class DCParser:
                 )
 
         # raise exception if query is not in the correct format
-        raise AssertionError('The expression shall be of the format "{ x1, ..., xn | f(x1, ..., xn) }".')
+        raise DCParserError('The expression shall be of the format "{ x1, ..., xn | f(x1, ..., xn) }".', 0)
 
     @staticmethod
-    def parse_projection(*tokens: Token) -> LogicOperand:
+    def parse_projection(*tokens: Token, depth: int = 0) -> LogicOperand:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
         return LogicOperand(*tokens)
 
     @staticmethod
-    def parse_condition(*tokens: Token) -> LogicElement:
+    def parse_condition(*tokens: Token, depth: int = 0) -> LogicElement:
         if len(tokens) == 1:
             tokens = tuple(Tokenizer.tokenize(tokens[0]))
 
@@ -40,8 +41,8 @@ class DCParser:
                     # return the operator
                     # with left part of tokens and right part of tokens
                     return operator(
-                        DCParser.parse_condition(*tokens[:-i]),
-                        DCParser.parse_condition(*tokens[-i + 1:])
+                        DCParser.parse_condition(*tokens[:-i], depth=depth + 1),
+                        DCParser.parse_condition(*tokens[-i + 1:], depth=depth + 1)
                     )
 
         # not
@@ -56,10 +57,12 @@ class DCParser:
         elif len(tokens) == 2:
             return DCOperand(
                 tokens[0],
-                tuple(Tokenizer.tokenize(tokens[1]))
+                tuple(Tokenizer.tokenize(tokens[1])),
+                depth=depth + 1
             )
         else:
             return DCOperand(
                 tokens[0],
-                tokens[1:]
+                tokens[1:],
+                depth=depth + 1
             )