Use a class to build to sql queries

This greatly reduced the amount of duplicate code in the DataBaseHandlers
Not sure how secure this is SQL injections. Need to check that and maybe
put in some guards. Using double underscores for now and only provide a
getter. But then again why bother with an SQL injection as
you can just as easily modify the Python code, and we still have the old
Containers to fallback to if the Database gets corrupted.

Contributes to CURA-6096

cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py

@@ -1,49 +1,22 @@
+from UM.Settings.SQLQueryFactory import SQLQueryFactory
 from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController
 from UM.Settings.InstanceContainer import InstanceContainer
 
 
 class IntentDatabaseHandler(DatabaseMetadataContainerController):
+    """The Database handler for Intent containers"""
+
     def __init__(self) -> None:
-        super().__init__(
+        super().__init__(SQLQueryFactory(table = "intents",
-            insert_query = """  INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version)
+                                         fields = {
-                                VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)""",
+                                             "id": "text",
-            update_query="""UPDATE intents
+                                             "name": "text",
-                            SET name = ?,
+                                             "quality_type": "text",
-                                quality_type = ?,
+                                             "intent_category": "text",
-                                intent_category = ?,
+                                             "variant": "text",
-                                variant = ?,
+                                             "definition": "text",
-                                definition = ?,
+                                             "material": "text",
-                                material = ?,
+                                             "version": "text",
-                                version = ?,
+                                             "setting_version": "text"
-                                setting_version = ?
+                                         }))
-                            WHERE id = ?
+        self.container_type = InstanceContainer
-                        """,
-            select_query = "SELECT * FROM intents WHERE id = ?",
-            delete_query = "DELETE FROM intents WHERE id = ?",
-            table_query="""CREATE TABLE intents
-               (
-                   id text,
-                   name text,
-                   quality_type text,
-                   intent_category text,
-                   variant text,
-                   definition text,
-                   material text,
-                   version text,
-                   setting_version text
-               );
-               CREATE UNIQUE INDEX idx_intents_id on intents (id);"""
-        )
-
-    def _convertMetadataToUpdateBatch(self, metadata):
-        return self._convertMetadataToInsertBatch(metadata)[1:]
-
-    def _convertRawDataToMetadata(self, data):
-        return {"id": data[0], "name": data[1], "quality_type": data[2], "intent_category": data[3], "variant": data[4], "definition": data[5], "container_type": InstanceContainer, "material": data[6], "version": data[7], "setting_version": data[8], "type": "intent"}
-
-    def _convertMetadataToInsertBatch(self, metadata):
-        return metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata[
-            "variant"], metadata["definition"], metadata["material"], metadata["version"], metadata["setting_version"]
-
-
-

cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py

@@ -1,59 +1,29 @@
+from typing import Generator
+
+from UM.Settings.SQLQueryFactory import SQLQueryFactory, metadata_type
 from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController
 from UM.Settings.InstanceContainer import InstanceContainer
 
 
 class QualityDatabaseHandler(DatabaseMetadataContainerController):
-    def __init__(self) -> None:
+    """The Database handler for Quality containers"""
-        super().__init__(
-            insert_query = """  INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition, version, setting_version) 
-                                VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)""",
-            update_query = """  UPDATE qualities
-                                SET name = ?,
-                                    quality_type = ?,
-                                    material = ?,
-                                    variant = ?,
-                                    global_quality = ?,
-                                    definition = ?,
-                                    version = ?,
-                                    setting_version = ?
-                                WHERE id = ?
-                            """,
-            select_query = "SELECT * FROM qualities WHERE id = ?",
-            delete_query = "DELETE FROM qualities WHERE id = ?",
-            table_query = """CREATE TABLE qualities
-                (
-                    id text,
-                    name text,
-                    quality_type text,
-                    material text,
-                    variant text,
-                    global_quality bool,
-                    definition text,
-                    version text,
-                    setting_version text
-                );
-                CREATE UNIQUE INDEX idx_qualities_id on qualities (id);"""
-        )
-
-    def _convertMetadataToUpdateBatch(self, metadata):
-        return self._convertMetadataToInsertBatch(metadata)[1:]
-
-    def _convertRawDataToMetadata(self, data):
-        return {"id": data[0], "name": data[1], "quality_type": data[2], "material": data[3], "variant": data[4],
-                "global_quality": data[5], "definition": data[6], "container_type": InstanceContainer,
-                "version": data[7], "setting_version": data[8], "type": "quality"}
-
-    def _convertMetadataToInsertBatch(self, metadata):
-        global_quality = False
-        if "global_quality" in metadata:
-            global_quality = metadata["global_quality"]
-        material = ""
-        if "material" in metadata:
-            material = metadata["material"]
-        variant = ""
-        if "variant" in metadata:
-            variant = metadata["variant"]
-
-        return metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"], metadata["version"], metadata["setting_version"]
 
+    def __init__(self):
+        super().__init__(SQLQueryFactory(table = "qualities",
+                                         fields = {
+                                             "id": "text",
+                                             "name": "text",
+                                             "quality_type": "text",
+                                             "material": "text",
+                                             "variant": "text",
+                                             "global_quality": "bool",
+                                             "definition": "text",
+                                             "version": "text",
+                                             "setting_version": "text"
+                                         }))
+        self.container_type = InstanceContainer
 
+    def groomMetadata(self, metadata: metadata_type) -> metadata_type:
+        if "global_quality" not in metadata:
+            metadata["global_quality"] = "False"
+        return super().groomMetadata(metadata)

cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py

@@ -1,40 +1,19 @@
+from UM.Settings.SQLQueryFactory import SQLQueryFactory
 from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController
 from UM.Settings.InstanceContainer import InstanceContainer
 
 
 class VariantDatabaseHandler(DatabaseMetadataContainerController):
-    def __init__(self) -> None:
+    """The Database handler for Variant containers"""
-        super().__init__(
-            insert_query = """INSERT INTO variants (id, name, hardware_type, definition, version, setting_version) 
-                             VALUES (?, ?, ?, ?, ?, ?)""",
-            update_query = """  UPDATE variants
-                                SET name = ?,
-                                    hardware_type = ?,
-                                    definition = ?,
-                                    version = ?,
-                                    setting_version = ?
-                                WHERE id = ?
-                           """,
-            select_query = "SELECT * FROM variants WHERE id = ?",
-            delete_query = "DELETE FROM variants WHERE id = ?",
-            table_query = """CREATE TABLE variants
-                (
-                    id text,
-                    name text,
-                    hardware_type text,
-                    definition text,
-                    version text,
-                    setting_version text
-                );
-                CREATE UNIQUE INDEX idx_variants_id on variants (id);"""
-        )
 
-    def _convertMetadataToUpdateBatch(self, metadata):
+    def __init__(self):
-        return self._convertMetadataToInsertBatch(metadata)[1:]
+        super().__init__(SQLQueryFactory(table = "variants",
-
+                                         fields = {
-    def _convertRawDataToMetadata(self, data):
+                                             "id": "text",
-        return {"id": data[0], "name": data[1], "hardware_type": data[2], "definition": data[3], "container_type": InstanceContainer, "version": data[4], "setting_version": data[5], "type": "variant"}
+                                             "name": "text",
-
+                                             "hardware_type": "text",
-    def _convertMetadataToInsertBatch(self, metadata):
+                                             "definition": "text",
-        return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"], metadata["version"], \
+                                             "version": "text",
-               metadata["setting_version"]
+                                             "setting_version": "text"
+                                         }))
+        self.container_type = InstanceContainer