diff --git a/BlackDynamite/runselector.py b/BlackDynamite/runselector.py
index 33ad981..33ee5ae 100755
--- a/BlackDynamite/runselector.py
+++ b/BlackDynamite/runselector.py
@@ -1,87 +1,62 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # -*- py-which-shell: "python"; -*-
 
 __all__ = ["RunSelector"]
 
 import copy
 import run
 import job
 import selector
 import constraints as BDcons
 ################################################################
 
 
 class RunSelector(selector.Selector):
     """
     """
 
     def selectRuns(self, constraints,
                    sort_by=None, quiet=False):
 
         run_list = self.select([run.Run, job.Job],
                                constraints=['runs.job_id = jobs.id',
                                             constraints],
                                sort_by=sort_by)
 
         if quiet is False:
             if not run_list:
                 print ("no runs found")
             print("Selected runs are: " + str([r[0].id for r in run_list]))
             print("Selected jobs are: " + str([r[0]["job_id"]
                                                for r in run_list]))
 
         # run_list = self.buildJoinedList(myjob, myrun, curs)
         return run_list
 
     def buildJoinedList(self, job_object, run_object, curs):
         coljob_info = self.base.getColumnProperties(job_object)
         colrun_info = self.base.getColumnProperties(run_object)
 
         run_list = []
         for entries in curs:
             jobj = copy.deepcopy(job_object)
             robj = copy.deepcopy(run_object)
             ncoljob = len(coljob_info)
             ncolrun = len(colrun_info)
             for i in range(0, ncoljob):
                 col_name = coljob_info[i][0]
                 jobj[col_name] = entries[i]
             jobj.id = jobj["id"]
 
             for i in range(0, ncolrun):
                 col_name = colrun_info[i][0]
                 robj[col_name] = entries[i+ncoljob]
             robj.id = robj["id"]
 
             run_list.append([robj, jobj])
 
         return run_list
 
-    def getObjectList(self, order="id"):
-        self.prepare()
-        request = "SELECT * FROM {0}.{1} ORDER BY ".format(
-            self.base.schema, self.table_name) + order
-
-        curs = self.base.performRequest(request)
-        return self.buildList(curs)
-
-    def getMatchedObjectList(self, order_condition=""):
-        condition, params = self.makeMatchingCondition()
-
-        request = self.makeSelectRequest()
-        # print (condition)
-        # print (order_condition)
-        if (condition):
-            request += "WHERE " + condition
-        if (order_condition):
-            request += order_condition
-
-        # print (request)
-        # print (params)
-
-        curs = self.base.performRequest(request, params)
-        return self.buildList(curs)
-
     def __init__(self, base):
         selector.Selector.__init__(self, base)
diff --git a/BlackDynamite/selector.py b/BlackDynamite/selector.py
index 17e1c3b..2a6ab08 100644
--- a/BlackDynamite/selector.py
+++ b/BlackDynamite/selector.py
@@ -1,74 +1,84 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # -*- py-which-shell: "python"; -*-
 ################################################################
 import copy
 import constraints as BDcons
 ################################################################
 
 
 class Selector(object):
 
     def __init__(self, base):
         self.base = base
 
-    def buildList(self, curs, sqlobj):
+    def buildList(self, curs, sqlobjs):
 
-        if isinstance(sqlobj, type):
-            sqlobj = sqlobj(self.base)
+        if not isinstance(sqlobjs, list):
+            sqlobjs = [sqlobjs]
 
-        col_info = self.base.getColumnProperties(sqlobj)
-        list_objects = []
+        col_infos = []
+
+        for sqlobj in sqlobjs:
+            if isinstance(sqlobj, type):
+                sqlobj = sqlobj(self.base)
 
+            col_infos.append(self.base.getColumnProperties(sqlobj))
+
+        list_objects = []
         for entries in curs:
-            obj = copy.deepcopy(sqlobj)
+            objs = []
+            for index, sqlobj in enumerate(sqlobjs):
 
-            for i in range(0, len(col_info)):
-                col_name = col_info[i][0]
-                obj[col_name] = entries[i]
+                obj = copy.deepcopy(sqlobj)
+                col_info = col_infos[index]
+                for i in range(0, col_info):
+                    col_name = col_info[i][0]
+                    obj[col_name] = entries[i]
 
-            list_objects.append(obj)
+                objs.append(objs)
+            list_objects.append(objs)
 
         # print len(list_objects)
         return list_objects
 
     def select(self, _types, constraints=None, sort_by=None):
 
         const = BDcons.BDconstraints(self.base, constraints)
         condition, params = const.getMatchingCondition()
 
 ################################################################
 #review
 #if not isinstance(sort_by, list) and sort_by is not None):
 #            sort_by = [sort_by]
 #
 #            order_condition = ""
 #        if (sort_by is not None):
 #            order_condition = " ORDER BY ("
 #            for cond in sort_by:
 #                order_condition += cond + ","
 #            order_condition = order_condition[:len(order_condition)-1] + ")"
 ################################################################
 
         if not isinstance(_types, list):
             _types = [_types]
 
         selected_tables = ['{0}.{1}'.format(self.base.schema, t.table_name)
                            for t in _types]
         selected_tables = ','.join(selected_tables)
 
         request = "SELECT * FROM {0}".format(selected_tables)
 
         if condition:
             request += " WHERE " + condition
 
         if sort_by:
             request += " ORDER BY " + sort_by
 
         # print(request)
         # print(params)
         curs = self.base.performRequest(request, params)
 
         obj_list = self.buildList(curs, _types)
 
         return obj_list