diff --git a/coursebuilder/__main__.py b/coursebuilder/__main__.py
index 65b2393..beedcb5 100644
--- a/coursebuilder/__main__.py
+++ b/coursebuilder/__main__.py
@@ -58,24 +58,12 @@ class CourseBuilder:
 
                     meta = yaml.load(fm,Loader=yaml.Loader)
 
-                    table_items = schema.process(meta=meta,fields=actual_fields,lang=args.lang) if query == None else schema.to_list_of_dict(meta=meta,fields=actual_fields,lang=args.lang)
+                    table_items = schema.process(meta=meta,fields=actual_fields,lang=args.lang) if query == None else schema.process_raw(meta=meta,fields=actual_fields,lang=args.lang)
 
                     if args.legacy:
                         MarkdownGenerator.generate_table_legacy(table_items=table_items,add_pagebreak=args.pagebreak,title_template=args.title,first_colwidth=args.leftcol)
                     elif query:
-
                         query.run(table_items)
-
-                        # for i in table_items:
-                            # print(i)
-
-                        q = schema.to_list_of_tuple(meta=meta,fields=actual_fields,lang=args.lang)
-
-                        for i in q:
-                            print(i)
-                        
-                        # MarkdownGenerator.generate_table(table_items=q,add_pagebreak=args.pagebreak,title_template=args.title,first_colwidth=args.leftcol)
-
                     else:
                         MarkdownGenerator.generate_table(table_items=table_items,add_pagebreak=args.pagebreak,title_template=args.title,first_colwidth=args.leftcol)
 
diff --git a/coursebuilder/query.py b/coursebuilder/query.py
index 835fe36..fab883b 100644
--- a/coursebuilder/query.py
+++ b/coursebuilder/query.py
@@ -1,6 +1,4 @@
 
-import pandas as pd
-
 class Query:
 
     def __init__(self,query) -> None:
@@ -8,9 +6,8 @@ class Query:
 
     def run(self,table_items):
         # print(table_items)
-        # for item in table_items:
-            # pass
-            # print(item)
-            # print(eval(self.__query,locals()))
+        for row in table_items:
+            print(row)
+            # print(eval(self.__query,{row:row}))
         pass
 
diff --git a/coursebuilder/schema.py b/coursebuilder/schema.py
index ee730c0..ee4f058 100644
--- a/coursebuilder/schema.py
+++ b/coursebuilder/schema.py
@@ -92,7 +92,7 @@ class Schema:
         return [k,', '.join(parts)]
 
 
-    def process(self,meta,fields,lang):
+    def process(self,meta,fields = [],lang = 'de'):
 
         table_items = []
 
@@ -113,44 +113,52 @@ class Schema:
         # maybe return tableitems as np.Dataframe?
         return table_items
     
-    def get_value(self,meta,field,lang):
-        """treats receiving the value like a variant, 
-           return values are language specific"""
-        match self.__schema[field]['type']: 
-            case 'str': return meta[field][lang] if self.is_translatable(field) else meta[field]['value']
-            case 'enum' | 'int' | 'num' | 'multikey' : return meta[field]['value']
-            case 'multinum': return meta[field]['value'] if hasattr(meta[field]['value'],'__iter__') else (meta[field]['value'],) # force list!
+    def get_str(self,meta,field,lang='de'):
+        if self.is_translatable(field):
+            return meta[field][lang]
+        else:
+            if not 'value' in meta[field]:
+                raise AssertionError(field,'incomplete')
+            return meta[field]['value']
+
+    def get_enum(self,meta,field,lang):
+        vv = meta[field]['value']
+        return self.__schema[field]['values'][vv][lang]
     
-    def to_list_of_dict(self,meta,fields,lang):
-        # list comprehension for rows
-        return [{'field' : field,   # field name
-                  'lang' : lang,    # language shortcode
-                  'type' : self.__schema[field]['type'], # datatype
-                  'label' : self.process_label(field,lang), # label
-                  'value' : self.get_value(meta,field,lang), # actual value
-                  'template' : self.__schema[field]['template'][lang] if 'template' in self.__schema[field] else None,
-                  # getting crazy with nested dict comprehension
-                  'enum_values' : { k:v[lang] for (k,v) in self.__schema[field]['values'].items()} if 'enum' in self.__schema[field]['type'] else None,
-                  'key_values' : { k:v[lang] for (k,v) in self.__schema[field]['keys'].items()} if 'multikey' in self.__schema[field]['type'] else None,
-                  'spec' : meta[field]['spec'][lang] if 'spec' in meta[field] else None
+    def get_num(self,meta,field,lang):
+        return meta[field]['value']
+
+        # if self.needs_spec(field):
+
+        #     t = string.Template(self.get_template(field=field,lang=lang))
+
+        #     spec = meta[field]['spec'][lang]
+
+        #     return [self.process_label(field,lang),t.substitute({'value': enum_val,'spec': spec})]
+        # else:
+        #     return [self.process_label(field,lang),enum_val]
+        
+
+
+    def get_value(self,meta,field,lang):
+        match self.__schema[field]['type']: 
+            case 'str': return self.get_str(meta,field,lang)
+            case 'enum': return self.get_enum(meta,field,lang)
+            case 'int' | 'num' : return self.get_num(meta,field,lang)
+            case 'multinum' : return meta[field]['value']
+    
+    
+    def process_raw(self,meta,fields,lang):
+
+        items = [{'field' : field, 
+                  'lang' : lang,
+                  'type' : self.__schema[field]['type'], 
+                  'label' : self.process_label(field,lang),
+                  'value' : self.get_value(meta,field,lang)
+                  
                   }
                   for field in fields]
-    
-    def to_list_of_tuple(self,meta,fields,lang):
-        # generate a list of tuples with key and value (text)
-        list = []
-        for r in self.to_list_of_dict(meta,fields,lang):
-            match r['type']:
-                case 'str' : 
-                    list.append( (r['label'],r['value']) )
-                case 'int' | 'num' : 
-                    list.append( ( r['label'], r['template'].format(value=r['value'],spec=r['spec']) if r['template'] else r['value']) )
-                case 'enum' : 
-                    list.append( ( r['label'], r['template'].format(value=r['enum_values'][r['value']],spec=r['spec']) 
-                                  if r['template'] else r['enum_values'][r['value']] ) )
-                case 'multikey' : 
-                    list.append( ( r['label'], ', '.join( [r['template'].format(key=r['key_values'][k],value=v) for k,v in r['value'].items()] ) ) )
-                case 'multinum' :
-                    list.append( (r['label'], ', '.join( r['template'].format(value=v) for v in r['value'])) )
 
-        return list
\ No newline at end of file
+
+        # maybe return tableitems as np.Dataframe?
+        return items
\ No newline at end of file
diff --git a/test/Makefile b/test/Makefile
index f662980..c806cc2 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -33,6 +33,6 @@ debug:
 	#  | pandoc ${target_flags} -V lang:de -o ${target_de}
 
 debug-query:
-	python ${coursebuilder} -s schema.yaml -m mod.cg.yaml mod.interactsys.yaml -q "item['field'] == 'kind' and item['value'] == 'elective'"
+	python ${coursebuilder} -s schema.yaml -m mod.cg.yaml mod.interactsys.yaml -q "kind == compulsory"
 
 .PHONY: clean
\ No newline at end of file
diff --git a/test/schema.yaml b/test/schema.yaml
index 94c7820..fde6931 100644
--- a/test/schema.yaml
+++ b/test/schema.yaml
@@ -114,8 +114,8 @@ form-of-instruction:
         }
     }
     template: 
-        de: "{key} ({value}SWS)"
-        en: "{key} ({value}SWS)"
+        de: "${key} (${value}SWS)"
+        en: "${key} (${value}SWS)"
 
 #
 # Voraussetzungen für die Teilnahme
@@ -181,15 +181,14 @@ workload:
 # credits/ECTS
 #
 credits:
-    type: num
-    unit: ECTS
+    type: num 
     label: { 
         en: "credits and weight of mark",
         de: "Kreditpunkte und Gewichtung der Note in der Gesamtnote"
     }
     template: 
-        de: "{value}CP, Gewichtung: {value}CP von 120CP "
-        en: "{value}CP, weight: {value} / 120 "    
+        de: "${value}CP, Gewichtung: ${value}CP von 120CP "
+        en: "${value}CP, weight: ${value} / 120 "    
     
 
 #
@@ -217,8 +216,8 @@ form-of-exam:
     }
     spec: true
     template:
-        de: "{value} ({spec})" 
-        en: "{value} ({spec})"
+        de: "${value} (${spec})" 
+        en: "${value} (${spec})"
 
 
 #
@@ -263,8 +262,8 @@ duration:
         de: Dauer
         en: duration
     template: 
-        de: "{value} Semester"
-        en: "{value} term(s)"
+        de: "$value Semester"
+        en: "$value term(s)"
 
 #
 # Art der Veranstaltung