diff --git a/database/database_table.py b/database/database_table.py
index e36727700029a1b3711a17a6e85ef6f58722fbe4..8483a8526ef43d31f2237b2a6d2f28a364801703 100644
--- a/database/database_table.py
+++ b/database/database_table.py
@@ -203,11 +203,13 @@ class DatabaseTable(Table):
             bind = self.metadata.bind
 
         pks = get_primary_keys(self)
-        primary_keys = (ttable.columns.get(pk.name) for pk in pks)
 
-        new_pk = PrimaryKeyConstraint(*primary_keys)
-        query = AddConstraint(new_pk)
-        bind.execute(query)
+        if len(pks) > 0:
+            primary_keys = (ttable.columns.get(pk.name) for pk in pks)
+
+            new_pk = PrimaryKeyConstraint(*primary_keys)
+            query = AddConstraint(new_pk)
+            bind.execute(query)
 
     def populate_temporary(self, ttable, in_file, header, year, delimiters=[';', '\\n', '"'],
                            null='', offset=2, bind=None):
@@ -790,7 +792,7 @@ class DatabaseTable(Table):
 
         if target is not None and str(self) + '.' + target in recursion_list:
             # This is a circular reference. Don't be like that.
-            print(target)
+            print(target, self)
             raise CircularReferenceError(target)
 
         # Query for the column, header of csv or var name if empty
@@ -815,7 +817,10 @@ class DatabaseTable(Table):
         referred_tables = []
 
         case = case.strip("~")      # doesn't need "~" anymore
-        for substr in case.split():
+        str_list = re.findall(r'("[\w]"|[\w.]+)', case)
+        # str_list = case.split()
+        for substr in str_list:
+            # print('ss', substr)
             if '.' in substr:        # We have a var from another table
                 table = substr.split('.')[0]
                 table = gen_data_table(table, self.metadata)
@@ -825,12 +830,17 @@ class DatabaseTable(Table):
                 var_name = substr
 
             # If it is a var, will need to be evaluated as it's a dependency.
-            if table._protocol.target_from_dbcolumn(var_name) is not None:
+            if table._protocol and table._protocol.target_from_dbcolumn(var_name) is not None:
                 # Prevents lowering level if var is an aggregation.
-                print("VAR", var_name)
                 level = max(level + table._derivative_recursion(var_name, year, recursion_list)['level'], level)
-                if table is not self and table not in referred_tables:
-                    referred_tables.append(table)
+            else:
+                var_target = self._get_variable_target(var_name.strip('"'), year)
+                if var_target is not None:
+                    var_db = self._protocol.dbcolumn_from_target(var_target)[0]
+                    case = case.replace(var_name, var_db)
+
+            if table is not self and table not in referred_tables:
+                referred_tables.append(table)
 
         self._derivatives[target] = {'query': case, 'dbcolumn': dbcolumn, 'level': level, 'tables': referred_tables}
         return self._derivatives[target]
@@ -880,11 +890,12 @@ class DatabaseTable(Table):
 
     def _apply_denormalization(self, ttable, year, column, denorm_query, referred_tables, bind):
         query = update(ttable)
+        print(ttable.name)
 
         query = query.values(**{column: text(denorm_query)})
+        print('qc', query, column)
 
         for ref_table in referred_tables:
-            ref_table = gen_data_table(ref_table, self.metadata)
             ref_table.map_from_database(bind)
             try:
                 fk_tuples = [(ttable.columns.get(fk_column.name), fkey)