Cascading Delete Implementation

datajoint/relation.py

@@ -1,4 +1,5 @@
 from collections.abc import Mapping
+from collections import defaultdict
 import numpy as np
 import logging
 import abc
@@ -82,10 +83,16 @@ def children(self):
 
     @property
     def references(self):
+        """
+        :return: list of tables that this tables refers to
+        """
         return self.connection.erm.references[self.full_table_name]
 
     @property
     def referenced(self):
+        """
+        :return: list of tables for which this table is referenced by
+        """
         return self.connection.erm.referenced[self.full_table_name]
 
     @property
@@ -187,22 +194,35 @@ def delete(self):
         User is prompted for confirmation if config['safemode']
         """
         relations = self.descendants
-        if self.restrictions and len(relations)>1:
-            raise NotImplementedError('Restricted cascading deletes are not yet implemented')
-        do_delete = True
+        #if self.restrictions and len(relations)>1:
+        #    raise NotImplementedError('Restricted cascading deletes are not yet implemented')
+        restrict_by_me = defaultdict(lambda: False)
+        rel_by_name = {r.full_table_name:r for r in relations}
+        for r in relations:
+            for ref in r.references:
+                restrict_by_me[ref] = True
+
+        if self.restrictions is not None:
+            restrict_by_me[self.full_table_name] = True
+            rel_by_name[self.full_table_name]._restrict(self.restrictions)
+
+        for r in relations:
+            for dep in (r.children + r.references):
+                rel_by_name[dep]._restrict(r.project() if restrict_by_me[r.full_table_name] else r.restrictions)
+
         if config['safemode']:
-            do_delete = False
+            do_delete = False # indicate if there is anything to delete
             print('The contents of the following tables are about to be deleted:')
             for relation in relations:
                 count = len(relation)
                 if count:
                     do_delete = True
                     print(relation.full_table_name, '(%d tuples)' % count)
-            do_delete = do_delete and user_choice("Proceed?", default='no') == 'yes'
-        if do_delete:
-            with self.connection.transaction:
-                while relations:
-                    relations.pop().delete_quick()
+            if not do_delete or user_choice("Proceed?", default='no') != 'yes':
+                return
+        with self.connection.transaction:
+            while relations:
+                relations.pop().delete_quick()
 
     def drop_quick(self):
         """

datajoint/relational_operand.py

@@ -113,7 +113,10 @@ def _restrict(self, restriction):
         if restriction is not None:
             if self._restrictions is None:
                 self._restrictions = []
-            self._restrictions.append(restriction)
+            if isinstance(restriction, list):
+                self._restrictions.extend(restriction)
+            else:
+                self._restrictions.append(restriction)
         return self
 
     def __iand__(self, restriction):
@@ -414,12 +417,14 @@ def __init__(self, arg, group=None, *attributes, **renamed_attributes):
             self._arg = Subquery(arg)
         else:
             self._group = None
-            if arg.heading.computed:
-                self._arg = Subquery(arg)
-            else:
-                # project without subquery
+            if arg.heading.computed or\
+                    (isinstance(arg.restrictions, RelationalOperand) and \
+                    all(attr in self._attributes for attr in arg.restrictions.heading.names)) :
+                # can simply the expression because all restrictions attrs are projected out anyway!
                 self._arg = arg
                 self._restrictions = self._arg.restrictions
+            else:
+                self._arg = Subquery(arg)
 
     @property
     def connection(self):

tests/schema.py

@@ -61,6 +61,7 @@ def _make_tuples(self, key):
         """
         from datetime import date, timedelta
         users = User().fetch()['username']
+        random.seed('Amazing Seed')
         for experiment_id in range(self.fake_experiments_per_subject):
             self.insert1(
                 dict(key,
@@ -82,6 +83,7 @@ def _make_tuples(self, key):
         """
         populate with random data (pretend reading from raw files)
         """
+        random.seed('Amazing Seed')
         for trial_id in range(10):
             self.insert1(
                 dict(key,
@@ -103,6 +105,7 @@ def _make_tuples(self, key):
         """
         populate with random data
         """
+        random.seed('Amazing seed')
         row = dict(key,
                    sampling_frequency=6000,
                    duration=np.minimum(2, random.expovariate(1)))
@@ -124,6 +127,7 @@ def fill(self, key, number_samples):
         """
         populate random trace of specified length
         """
+        random.seed('Amazing seed')
         for channel in range(2):
             self.insert1(
                 dict(key,