Added indexes to SQLite3 Database

* There are several queries that use ORDER BY statements. In order
  to let them work properly, indexes must be created

Author: Ezetowers

MLC/GUI/Experiment/ExperimentWindow.py

@@ -471,6 +471,7 @@ def on_draw_as_tree_button_clicked(self):
                                                   experiment_name=self._experiment_name,
                                                   gen_data=gen_data,
                                                   current_gen=self._current_gen)
+        tree_window.setAttribute(Qt.WA_DeleteOnClose)
         tree_window.show()
 
     def on_board_config_button_clicked(self):

MLC/GUI/mlc_gui.py

@@ -21,8 +21,6 @@
 
 import os
 import sys
-# reload(sys)
-# sys.setdefaultencoding("utf-8")
 
 mlc_gui_dir = os.path.dirname(os.path.abspath(__file__))
 root_dir = os.path.join(*[mlc_gui_dir, "..", ".."])

MLC/api/Experiment.py

@@ -79,13 +79,13 @@ def reload_configuration(self):
         """
         Load again the experiment configuration, reading the config file from disk
         """
-        self._configuration = ConfigParser.ConfigParser()
+        self._configuration = configparser.ConfigParser()
         self._configuration.read(self._config_file)
         Config.get_instance().read(self._config_file)
         return Config.to_dictionary(self._configuration)
 
     def set_configuration(self, new_configuration):
-        self._configuration = Config.from_dictionary(new_configuration, config_type=ConfigParser.ConfigParser)
+        self._configuration = Config.from_dictionary(new_configuration, config_type=configparser.ConfigParser)
         self._configuration.write(open(self._config_file, "wt"))
 
         # Reload the configuration

MLC/db/sqlite/sql_statements.py

@@ -19,11 +19,18 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>
 
+
 def stmt_create_table_individuals():
-    return ''' CREATE TABLE individual(indiv_id INTEGER PRIMARY KEY,
-                                       value text,
-                                       formal text,
-                                       complexity INTEGER)'''
+    return '''
+    CREATE TABLE individual(indiv_id INTEGER PRIMARY KEY,
+                            value text,
+                            formal text,
+                            complexity INTEGER)'''
+
+
+def stmt_create_table_index_individuals():
+    return '''
+    CREATE INDEX index_indiv_id ON individual(indiv_id)'''
 
 
 def stmt_create_table_population():
@@ -38,6 +45,16 @@ def stmt_create_table_population():
                             FOREIGN KEY(indiv_id) REFERENCES individual(indiv_id))'''
 
 
+def stmt_create_id_index_on_population():
+    return '''
+    CREATE INDEX index_pop_id ON population(id)'''
+
+
+def stmt_create_indiv_id_index_on_population():
+    return '''
+    CREATE INDEX index_pop_indiv_id ON population(indiv_id)'''
+
+
 def stmt_delete_generation(generation):
     return """DELETE FROM population
               WHERE gen = %s""" % (generation,)
@@ -47,10 +64,12 @@ def stmt_delete_from_generations(from_generation):
     return """DELETE FROM population
               WHERE gen >= %s""" % (from_generation,)
 
+
 def stmt_delete_to_generations(to_generation):
     return """DELETE FROM population
               WHERE gen <= %s""" % (to_generation,)
 
+
 def stmt_delete_unused_individuals():
     return '''DELETE FROM individual
               WHERE indiv_id NOT IN (SELECT DISTINCT indiv_id FROM population)'''
@@ -72,19 +91,19 @@ def stmt_get_generations():
 
 def stmt_insert_individual_in_population(generation, indiv_id, cost, evaluation_time, gen_method, parents):
     return '''INSERT INTO population (gen, cost, evaluation_time, gen_method, parents, indiv_id)
-              VALUES (%s, "%s", %s, %s, "%s", %s)''' % (generation,
-                                                        cost,
-                                                        evaluation_time,
-                                                        gen_method,
-                                                        parents,
-                                                        indiv_id)
+              VALUES ( % s, "%s", % s, % s, "%s", % s)''' % (generation,
+                                                             cost,
+                                                             evaluation_time,
+                                                             gen_method,
+                                                             parents,
+                                                             indiv_id)
 
 
 def stmt_get_individuals_from_population(generation):
-    return '''SELECT indiv_id, cost, evaluation_time, gen_method, parents, ID
+    return '''SELECT indiv_id, cost, evaluation_time, gen_method, parents, id
               FROM population
               WHERE gen = %s
-              ORDER BY ID''' % generation
+              ORDER BY id''' % generation
 
 
 class SQLSaveFormal:
@@ -102,10 +121,10 @@ def from_sql(indiv_formal_column):
 
 
 def stmt_insert_individual(individual_id, individual):
-    return '''INSERT INTO individual VALUES (%s, "%s", "%s", %s)''' % (individual_id,
-                                                                       individual.get_value(),
-                                                                       SQLSaveFormal.to_sql(individual.get_formal()),
-                                                                       individual.get_complexity())
+    return '''INSERT INTO individual VALUES ( % s, "%s", "%s", % s)''' % (individual_id,
+                                                                          individual.get_value(),
+                                                                          SQLSaveFormal.to_sql(individual.get_formal()),
+                                                                          individual.get_complexity())
 
 
 def stmt_get_all_individuals():
@@ -140,16 +159,19 @@ def stmt_update_cost(individual_id, cost, evaluation_time, generation):
                                                      individual_id,
                                                      generation)
 """
-The individual with the least cost in the last population 
+The individual with the least cost in the last population
 is considered to be the best individual
 """
+
+
 def stmt_get_individual_with_min_cost_in_last_pop():
-    return '''SELECT indiv_id, 
-                     cost 
+    return '''SELECT indiv_id,
+                     cost
                 FROM population 
             ORDER BY gen DESC, 
                      cost ASC 
                LIMIT 1'''
 
+
 def stmt_enable_foreign_key():
     return '''PRAGMA foreign_keys = ON'''

MLC/db/sqlite/sqlite_repository.py

@@ -75,7 +75,10 @@ def __initialize_db(self):
 
         # MLC Population tables
         cursor.execute(stmt_create_table_individuals())
+        cursor.execute(stmt_create_table_index_individuals())
         cursor.execute(stmt_create_table_population())
+        cursor.execute(stmt_create_id_index_on_population())
+        cursor.execute(stmt_create_indiv_id_index_on_population())
 
         # Board configuration tables
         cursor.execute(stmt_create_table_board())
@@ -331,6 +334,7 @@ def __load_individuals(self):
         individuals = {}
         conn = self.__get_db_connection()
         cursor = conn.execute(stmt_get_all_individuals())
+        # data = cursor.fetchall()
 
         for row in cursor:
             new_individual = Individual(str(row[1]), SQLSaveFormal.from_sql(row[2]), row[3])

MLC/individual/Individual.py

@@ -98,8 +98,6 @@ class MutationType:
     _maxdepthfirst = None
 
     def __init__(self, value, formal=None, complexity=None):
-        self._config = Config.get_instance()
-
         # Tree expression initialized using lazing initialization through
         # _tree property. Use self._tree instead of self._lazy_tree to
         # obtain the tree expression.
@@ -114,8 +112,8 @@ def __init__(self, value, formal=None, complexity=None):
             self._complexity = self._tree.complexity()
             self._value = self._tree.get_expanded_tree_as_string()
 
-        self._range = self._config.getint("POPULATION", "range")
-        self._precision = self._config.getint("POPULATION", "precision")
+    def get_config():
+        return Config.get_instance()
 
     @property
     def _tree(self):
@@ -188,9 +186,9 @@ def __crossover_tree(self, other_individual):
 
             :return: (first new tree, second new tree) as strings
         """
-        maxtries = self._config.getint("GP", "maxtries")
-        mutmindepth = self._config.getint("GP", "mutmindepth")
-        maxdepth = self._config.getint("GP", "maxdepth")
+        maxtries = Config.get_instance().getint("GP", "maxtries")
+        mutmindepth = Config.get_instance().getint("GP", "mutmindepth")
+        maxdepth = Config.get_instance().getint("GP", "maxdepth")
 
         correct = False
         count = 0
@@ -218,11 +216,11 @@ def __crossover_tree(self, other_individual):
         return value_1, value_2
 
     def __mutate_tree(self, mutation_type):
-        mutmindepth = self._config.getint("GP", "mutmindepth")
-        maxdepth = self._config.getint("GP", "maxdepth")
-        sensor_spec = self._config.getboolean("POPULATION", "sensor_spec")
-        sensors = self._config.getint("POPULATION", 'sensors')
-        mutation_types = self._config.get_list("GP", 'mutation_types')
+        mutmindepth = Config.get_instance().getint("GP", "mutmindepth")
+        maxdepth = Config.get_instance().getint("GP", "maxdepth")
+        sensor_spec = Config.get_instance().getboolean("POPULATION", "sensor_spec")
+        sensors = Config.get_instance().getint("POPULATION", 'sensors')
+        mutation_types = Config.get_instance().get_list("GP", 'mutation_types')
 
         # equi probability for each mutation type selected.
         if mutation_type == Individual.MutationType.ANY:
@@ -241,11 +239,12 @@ def __mutate_tree(self, mutation_type):
                     else:
                         next_individual_type = 4
 
-                    new_individual_value = Individual.__generate_indiv_regressive_tree(subtree, self._config, next_individual_type)
+                    new_individual_value = Individual.__generate_indiv_regressive_tree(
+                        subtree, Config.get_instance(), next_individual_type)
 
                     if new_individual_value:
                         if sensor_spec:
-                            config_sensor_list = sorted(self._config.get_list('POPULATION', 'sensor_list'))
+                            config_sensor_list = sorted(Config.get_instance().get_list('POPULATION', 'sensor_list'))
                         else:
                             config_sensor_list = range(sensors - 1, -1, -1)
 
@@ -275,11 +274,11 @@ def __mutate_tree(self, mutation_type):
         elif mutation_type == Individual.MutationType.HOIST:
             preevok = False
             counter = 0
-            maxtries = self._config.getint("GP", "maxtries")
+            maxtries = Config.get_instance().getint("GP", "maxtries")
 
             while not preevok and counter < maxtries:
                 counter += 1
-                controls = self._config.getint("POPULATION", "controls")
+                controls = Config.get_instance().getint("POPULATION", "controls")
                 prob_threshold = 1 / float(controls)
 
                 cl = [stree.to_string() for stree in self.get_tree().get_root_node()._nodes]
@@ -336,8 +335,8 @@ def __extract_subtree(self, expression_tree, mindepth, subtreedepthmax, maxdepth
 
     def __reparam_tree(self, tree_expression):
         def leaf_value_generator():
-            leaf_value = (RandomManager.rand() - 0.5) * 2 * self._range
-            return "%0.*f" % (self._precision, leaf_value)
+            leaf_value = (RandomManager.rand() - 0.5) * 2 * Config.get_instance().getint("POPULATION", "range")
+            return "%0.*f" % (Config.get_instance().getint("POPULATION", "precision"), leaf_value)
 
         return self.__change_const_tree(tree_expression, leaf_value_generator)