From 3f80fcb5e5aa8c5c64b67c835febaf83fc7e0550 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Thu, 19 Aug 2021 15:20:20 +0200 Subject: [PATCH 01/17] Add first stub for profile database CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index 295d843fd7..aa9b23f4d4 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -44,6 +44,32 @@ class CuraContainerRegistry(ContainerRegistry): # is added, we check to see if an extruder stack needs to be added. self.containerAdded.connect(self._onContainerAdded) + @override(ContainerRegistry) + def _createDatabaseFile(self, db_path: str) -> None: + connection = super()._createDatabaseFile(db_path) + cursor = connection.cursor() + cursor.execute(""" + CREATE TABLE qualities( + id text, + name text, + quality_type text, + material text, + variant text, + global_quality bool, + definition text + ); + CREATE UNIQUE INDEX idx_qualities_id on qualities (id); + + CREATE TABLE variants( + id text, + name text, + hardware_type text, + definition text + ); + CREATE UNIQUE INDEX idx_variants_id on variants (id); + """) + return connection + @override(ContainerRegistry) def addContainer(self, container: ContainerInterface) -> bool: """Overridden from ContainerRegistry From 48ab21ac68e4f3345b55361b9833dc7d06614e0e Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Fri, 20 Aug 2021 10:17:57 +0200 Subject: [PATCH 02/17] Add functions to get & add variants & qualities from DB CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 40 ++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index aa9b23f4d4..38070a16b7 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -44,6 +44,46 @@ class CuraContainerRegistry(ContainerRegistry): # is added, we check to see if an extruder stack needs to be added. self.containerAdded.connect(self._onContainerAdded) + self._add_to_database_handlers["variant"] = self._addVariantToDatabase + self._add_to_database_handlers["quality"] = self._addQualityToDatabase + + self._get_from_database_handlers["variant"] = self._getVariantFromDatabase + self._get_from_database_handlers["quality"] = self._getQualityFromDatabase + + def _getQualityFromDatabase(self, container_id): + connection = self._getDatabaseConnection() + result = connection.cursor().execute("SELECT * FROM qualities where id = ?", (container_id,)) + data = result.fetchone() + return {"id": data[0], "name": data[1], "quality_type": data[2], "material": data[3], "variant": data[4], "global_quality": data[5], "definition": data[6]} + + def _getVariantFromDatabase(self, container_id): + connection = self._getDatabaseConnection() + result = connection.cursor().execute("SELECT * FROM variants where id = ?", (container_id,)) + data = result.fetchone() + return {"id": data[0], "name": data[1], "hardware_type": data[2], "definition": data[3] } + + def _addVariantToDatabase(self, metadata) -> None: + connection = self._getDatabaseConnection() + connection.cursor().execute( + "INSERT INTO variants (id, name, hardware_type, definition) VALUES (?, ?, ? ,?)", + (metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"])) + + def _addQualityToDatabase(self, metadata) -> None: + connection = self._getDatabaseConnection() + 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"] + + connection.cursor().execute( + "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition) VALUES (?, ?, ? ,?, ?, ?, ?)", + (metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"])) + @override(ContainerRegistry) def _createDatabaseFile(self, db_path: str) -> None: connection = super()._createDatabaseFile(db_path) From 5311c949f0969187d8a10e40ddbf04bff7fb5920 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Fri, 20 Aug 2021 11:05:37 +0200 Subject: [PATCH 03/17] Add variants to the database CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 36 +++++++++++++++++++++++--- 1 file changed, 33 insertions(+), 3 deletions(-) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index 38070a16b7..a47a45c705 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -46,6 +46,7 @@ class CuraContainerRegistry(ContainerRegistry): self._add_to_database_handlers["variant"] = self._addVariantToDatabase self._add_to_database_handlers["quality"] = self._addQualityToDatabase + self._add_to_database_handlers["intent"] = self._addIntentToDatabase self._get_from_database_handlers["variant"] = self._getVariantFromDatabase self._get_from_database_handlers["quality"] = self._getQualityFromDatabase @@ -60,7 +61,14 @@ class CuraContainerRegistry(ContainerRegistry): connection = self._getDatabaseConnection() result = connection.cursor().execute("SELECT * FROM variants where id = ?", (container_id,)) data = result.fetchone() - return {"id": data[0], "name": data[1], "hardware_type": data[2], "definition": data[3] } + return {"id": data[0], "name": data[1], "hardware_type": data[2], "definition": data[3]} + + def _getIntentFromDatabase(self, container_id): + + connection = self._getDatabaseConnection() + result = connection.cursor().execute("SELECT * FROM intents where id = ?", (container_id,)) + data = result.fetchone() + return {"id": data[0], "name": data[1], "quality_type": data[2], "intent_category": data[3], "variant": data[4], "definition": data[5]} def _addVariantToDatabase(self, metadata) -> None: connection = self._getDatabaseConnection() @@ -84,12 +92,22 @@ class CuraContainerRegistry(ContainerRegistry): "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition) VALUES (?, ?, ? ,?, ?, ?, ?)", (metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"])) + def _addIntentToDatabase(self, metadata) -> None: + connection = self._getDatabaseConnection() + + connection.cursor().execute( + "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition) VALUES (?, ?, ? ,?, ?, ?)", + (metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata["variant"], + metadata["definition"])) + + @override(ContainerRegistry) def _createDatabaseFile(self, db_path: str) -> None: connection = super()._createDatabaseFile(db_path) cursor = connection.cursor() cursor.execute(""" - CREATE TABLE qualities( + CREATE TABLE qualities + ( id text, name text, quality_type text, @@ -100,13 +118,25 @@ class CuraContainerRegistry(ContainerRegistry): ); CREATE UNIQUE INDEX idx_qualities_id on qualities (id); - CREATE TABLE variants( + CREATE TABLE variants + ( id text, name text, hardware_type text, definition text ); CREATE UNIQUE INDEX idx_variants_id on variants (id); + + CREATE TABLE intents + ( + id text, + name text, + quality_type text, + intent_category text, + variant text, + definition text + ); + CREATE UNIQUE INDEX idx_intents_id on intents (id); """) return connection From 6f32809a3a12dae25dd35b3570fe1737c6202fff Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Fri, 20 Aug 2021 13:09:40 +0200 Subject: [PATCH 04/17] Prepare the inserts before actually doing them CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 32 ++++++++++++-------------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index a47a45c705..321d2a41b0 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -44,12 +44,17 @@ class CuraContainerRegistry(ContainerRegistry): # is added, we check to see if an extruder stack needs to be added. self.containerAdded.connect(self._onContainerAdded) - self._add_to_database_handlers["variant"] = self._addVariantToDatabase - self._add_to_database_handlers["quality"] = self._addQualityToDatabase - self._add_to_database_handlers["intent"] = self._addIntentToDatabase + self._prepare_for_database_handlers["variant"] = self._prepareVariantForDatabase + self._prepare_for_database_handlers["quality"] = self._prepareQualityForDatabase + self._prepare_for_database_handlers["intent"] = self._prepareIntentForDatabase self._get_from_database_handlers["variant"] = self._getVariantFromDatabase self._get_from_database_handlers["quality"] = self._getQualityFromDatabase + self._get_from_database_handlers["intent"] = self._getIntentFromDatabase + + self._insert_into_database_queries["variant"] = "INSERT INTO variants (id, name, hardware_type, definition) VALUES (?, ?, ? ,?)" + self._insert_into_database_queries["quality"] = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition) VALUES (?, ?, ? ,?, ?, ?, ?)" + self._insert_into_database_queries["intent"] = "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition) VALUES (?, ?, ? ,?, ?, ?)" def _getQualityFromDatabase(self, container_id): connection = self._getDatabaseConnection() @@ -64,20 +69,15 @@ class CuraContainerRegistry(ContainerRegistry): return {"id": data[0], "name": data[1], "hardware_type": data[2], "definition": data[3]} def _getIntentFromDatabase(self, container_id): - connection = self._getDatabaseConnection() result = connection.cursor().execute("SELECT * FROM intents where id = ?", (container_id,)) data = result.fetchone() return {"id": data[0], "name": data[1], "quality_type": data[2], "intent_category": data[3], "variant": data[4], "definition": data[5]} - def _addVariantToDatabase(self, metadata) -> None: - connection = self._getDatabaseConnection() - connection.cursor().execute( - "INSERT INTO variants (id, name, hardware_type, definition) VALUES (?, ?, ? ,?)", - (metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"])) + def _prepareVariantForDatabase(self, metadata): + return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"] - def _addQualityToDatabase(self, metadata) -> None: - connection = self._getDatabaseConnection() + def _prepareQualityForDatabase(self, metadata): global_quality = False if "global_quality" in metadata: global_quality = metadata["global_quality"] @@ -88,17 +88,15 @@ class CuraContainerRegistry(ContainerRegistry): if "variant" in metadata: variant = metadata["variant"] - connection.cursor().execute( - "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition) VALUES (?, ?, ? ,?, ?, ?, ?)", - (metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"])) + return metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"] - def _addIntentToDatabase(self, metadata) -> None: + def _prepareIntentForDatabase(self, metadata) -> None: + return metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata["variant"], metadata["definition"] connection = self._getDatabaseConnection() connection.cursor().execute( "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition) VALUES (?, ?, ? ,?, ?, ?)", - (metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata["variant"], - metadata["definition"])) + ()) @override(ContainerRegistry) From 27f0fe8bb949a1be641ba7fee1f6dc74a61b7023 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Fri, 20 Aug 2021 14:40:55 +0200 Subject: [PATCH 05/17] Ensure that all metadata of profiles is stored CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 31 ++++++++++++++++---------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index 321d2a41b0..fc50b975df 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -52,30 +52,30 @@ class CuraContainerRegistry(ContainerRegistry): self._get_from_database_handlers["quality"] = self._getQualityFromDatabase self._get_from_database_handlers["intent"] = self._getIntentFromDatabase - self._insert_into_database_queries["variant"] = "INSERT INTO variants (id, name, hardware_type, definition) VALUES (?, ?, ? ,?)" - self._insert_into_database_queries["quality"] = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition) VALUES (?, ?, ? ,?, ?, ?, ?)" - self._insert_into_database_queries["intent"] = "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition) VALUES (?, ?, ? ,?, ?, ?)" + self._insert_into_database_queries["variant"] = "INSERT INTO variants (id, name, hardware_type, definition, version, setting_version) VALUES (?, ?, ?, ?, ?, ?)" + self._insert_into_database_queries["quality"] = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)" + self._insert_into_database_queries["intent"] = "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)" def _getQualityFromDatabase(self, container_id): connection = self._getDatabaseConnection() result = connection.cursor().execute("SELECT * FROM qualities where id = ?", (container_id,)) data = result.fetchone() - return {"id": data[0], "name": data[1], "quality_type": data[2], "material": data[3], "variant": data[4], "global_quality": data[5], "definition": data[6]} + 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 _getVariantFromDatabase(self, container_id): connection = self._getDatabaseConnection() result = connection.cursor().execute("SELECT * FROM variants where id = ?", (container_id,)) data = result.fetchone() - return {"id": data[0], "name": data[1], "hardware_type": data[2], "definition": data[3]} + 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"} def _getIntentFromDatabase(self, container_id): connection = self._getDatabaseConnection() result = connection.cursor().execute("SELECT * FROM intents where id = ?", (container_id,)) data = result.fetchone() - return {"id": data[0], "name": data[1], "quality_type": data[2], "intent_category": data[3], "variant": data[4], "definition": data[5]} + 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 _prepareVariantForDatabase(self, metadata): - return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"] + return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"], metadata["version"], metadata["setting_version"] def _prepareQualityForDatabase(self, metadata): global_quality = False @@ -88,10 +88,10 @@ class CuraContainerRegistry(ContainerRegistry): if "variant" in metadata: variant = metadata["variant"] - return metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"] + return metadata["id"], metadata["name"], metadata["quality_type"], material, variant, global_quality, metadata["definition"], metadata["version"], metadata["setting_version"] def _prepareIntentForDatabase(self, metadata) -> None: - return metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata["variant"], metadata["definition"] + return metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata["variant"], metadata["definition"], metadata["material"], metadata["version"], metadata["setting_version"] connection = self._getDatabaseConnection() connection.cursor().execute( @@ -112,7 +112,9 @@ class CuraContainerRegistry(ContainerRegistry): material text, variant text, global_quality bool, - definition text + definition text, + version text, + setting_version text ); CREATE UNIQUE INDEX idx_qualities_id on qualities (id); @@ -121,7 +123,9 @@ class CuraContainerRegistry(ContainerRegistry): id text, name text, hardware_type text, - definition text + definition text, + version text, + setting_version text ); CREATE UNIQUE INDEX idx_variants_id on variants (id); @@ -132,7 +136,10 @@ class CuraContainerRegistry(ContainerRegistry): quality_type text, intent_category text, variant text, - definition text + definition text, + material text, + version text, + setting_version text ); CREATE UNIQUE INDEX idx_intents_id on intents (id); """) From e0e8223c5df223069243a2192e1290e6da14e6bc Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Fri, 20 Aug 2021 15:40:50 +0200 Subject: [PATCH 06/17] Move DB handling into specialised classes This keeps CuraContainerRegistry a lot cleaner, especially when more container types are added Cura-6096 --- cura/Settings/CuraContainerRegistry.py | 107 ++---------------- .../DatabaseHandlers/IntentDatabaseHandler.py | 35 ++++++ .../QualityDatabaseHandler.py | 44 +++++++ .../VariantDatabaseHandler.py | 29 +++++ cura/Settings/DatabaseHandlers/__init__.py | 0 5 files changed, 116 insertions(+), 99 deletions(-) create mode 100644 cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py create mode 100644 cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py create mode 100644 cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py create mode 100644 cura/Settings/DatabaseHandlers/__init__.py diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index fc50b975df..1b880d037d 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -10,6 +10,7 @@ from PyQt5.QtWidgets import QMessageBox from UM.Decorators import override from UM.Settings.ContainerFormatError import ContainerFormatError +from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController from UM.Settings.Interfaces import ContainerInterface from UM.Settings.ContainerRegistry import ContainerRegistry from UM.Settings.ContainerStack import ContainerStack @@ -32,6 +33,10 @@ from cura.Machines.ContainerTree import ContainerTree from cura.ReaderWriters.ProfileReader import NoProfileException, ProfileReader from UM.i18n import i18nCatalog +from .DatabaseHandlers.IntentDatabaseHandler import IntentDatabaseHandler +from .DatabaseHandlers.QualityDatabaseHandler import QualityDatabaseHandler +from .DatabaseHandlers.VariantDatabaseHandler import VariantDatabaseHandler + catalog = i18nCatalog("cura") @@ -44,106 +49,10 @@ class CuraContainerRegistry(ContainerRegistry): # is added, we check to see if an extruder stack needs to be added. self.containerAdded.connect(self._onContainerAdded) - self._prepare_for_database_handlers["variant"] = self._prepareVariantForDatabase - self._prepare_for_database_handlers["quality"] = self._prepareQualityForDatabase - self._prepare_for_database_handlers["intent"] = self._prepareIntentForDatabase + self._database_handlers["variant"] = VariantDatabaseHandler() + self._database_handlers["quality"] = QualityDatabaseHandler() + self._database_handlers["intent"] = IntentDatabaseHandler() - self._get_from_database_handlers["variant"] = self._getVariantFromDatabase - self._get_from_database_handlers["quality"] = self._getQualityFromDatabase - self._get_from_database_handlers["intent"] = self._getIntentFromDatabase - - self._insert_into_database_queries["variant"] = "INSERT INTO variants (id, name, hardware_type, definition, version, setting_version) VALUES (?, ?, ?, ?, ?, ?)" - self._insert_into_database_queries["quality"] = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)" - self._insert_into_database_queries["intent"] = "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)" - - def _getQualityFromDatabase(self, container_id): - connection = self._getDatabaseConnection() - result = connection.cursor().execute("SELECT * FROM qualities where id = ?", (container_id,)) - data = result.fetchone() - 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 _getVariantFromDatabase(self, container_id): - connection = self._getDatabaseConnection() - result = connection.cursor().execute("SELECT * FROM variants where id = ?", (container_id,)) - data = result.fetchone() - 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"} - - def _getIntentFromDatabase(self, container_id): - connection = self._getDatabaseConnection() - result = connection.cursor().execute("SELECT * FROM intents where id = ?", (container_id,)) - data = result.fetchone() - 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 _prepareVariantForDatabase(self, metadata): - return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"], metadata["version"], metadata["setting_version"] - - def _prepareQualityForDatabase(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 _prepareIntentForDatabase(self, metadata) -> None: - return metadata["id"], metadata["name"], metadata["quality_type"], metadata["intent_category"], metadata["variant"], metadata["definition"], metadata["material"], metadata["version"], metadata["setting_version"] - connection = self._getDatabaseConnection() - - connection.cursor().execute( - "INSERT INTO intents (id, name, quality_type, intent_category, variant, definition) VALUES (?, ?, ? ,?, ?, ?)", - ()) - - - @override(ContainerRegistry) - def _createDatabaseFile(self, db_path: str) -> None: - connection = super()._createDatabaseFile(db_path) - cursor = connection.cursor() - cursor.execute(""" - 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); - - 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); - - 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); - """) - return connection @override(ContainerRegistry) def addContainer(self, container: ContainerInterface) -> bool: diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py new file mode 100644 index 0000000000..79a28e7fb8 --- /dev/null +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -0,0 +1,35 @@ +from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController +from UM.Settings.InstanceContainer import InstanceContainer + + +class IntentDatabaseHandler(DatabaseMetadataContainerController): + def __init__(self) -> None: + super().__init__( + insert_query="INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)", + update_query="", + select_query = "SELECT * 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 _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"] + + + diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py new file mode 100644 index 0000000000..fcc21fe5b9 --- /dev/null +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -0,0 +1,44 @@ +from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController +from UM.Settings.InstanceContainer import InstanceContainer + + +class QualityDatabaseHandler(DatabaseMetadataContainerController): + def __init__(self) -> None: + super().__init__( + insert_query = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)", + update_query = "", + select_query = "SELECT * 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 _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"] + + diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py new file mode 100644 index 0000000000..37bf40d25c --- /dev/null +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -0,0 +1,29 @@ +from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController +from UM.Settings.InstanceContainer import InstanceContainer + + +class VariantDatabaseHandler(DatabaseMetadataContainerController): + def __init__(self) -> None: + super().__init__( + insert_query= "INSERT INTO variants (id, name, hardware_type, definition, version, setting_version) VALUES (?, ?, ?, ?, ?, ?)", + update_query= "", + select_query= "SELECT * 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 _convertRawDataToMetadata(self, data): + 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"} + + + def _convertMetadataToInsertBatch(self, metadata): + return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"], metadata["version"], \ + metadata["setting_version"] diff --git a/cura/Settings/DatabaseHandlers/__init__.py b/cura/Settings/DatabaseHandlers/__init__.py new file mode 100644 index 0000000000..e69de29bb2 From 2bef85c6c2357821d4b3f3d64fee5f4b0d54c994 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Tue, 24 Aug 2021 14:45:52 +0200 Subject: [PATCH 07/17] Remove weird whitespace CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 1 - 1 file changed, 1 deletion(-) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index 1b880d037d..7ab488eeba 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -53,7 +53,6 @@ class CuraContainerRegistry(ContainerRegistry): self._database_handlers["quality"] = QualityDatabaseHandler() self._database_handlers["intent"] = IntentDatabaseHandler() - @override(ContainerRegistry) def addContainer(self, container: ContainerInterface) -> bool: """Overridden from ContainerRegistry From 132b863e132340348fb8f479c51ba2d6d6719ec3 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Wed, 25 Aug 2021 13:48:25 +0200 Subject: [PATCH 08/17] Add update queries for variant, intent & qualit DB handlers CURA-6096 --- .../DatabaseHandlers/IntentDatabaseHandler.py | 16 ++++++++++++++-- .../DatabaseHandlers/QualityDatabaseHandler.py | 15 ++++++++++++++- .../DatabaseHandlers/VariantDatabaseHandler.py | 13 +++++++++++-- 3 files changed, 39 insertions(+), 5 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 79a28e7fb8..ffe0191088 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -6,7 +6,17 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__( insert_query="INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)", - update_query="", + update_query="""UPDATE intents + SET name = ?, + quality_type = ?, + intent_category = ?, + variant = ?, + definition = ?, + material = ?, + version = ?, + setting_version = ? + WHERE id = ? + """, select_query = "SELECT * FROM intents where id = ?", table_query="""CREATE TABLE intents ( @@ -23,10 +33,12 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): 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"] diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index fcc21fe5b9..258c63709b 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -6,7 +6,17 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__( insert_query = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)", - update_query = "", + 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 = ?", table_query = """CREATE TABLE qualities ( @@ -23,6 +33,9 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): 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, diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index 37bf40d25c..0670f132e9 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -6,7 +6,14 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__( insert_query= "INSERT INTO variants (id, name, hardware_type, definition, version, setting_version) VALUES (?, ?, ?, ?, ?, ?)", - update_query= "", + update_query="""UPDATE variants + SET name = ?, + hardware_type = ?, + definition = ?, + version = ?, + setting_version = ? + WHERE id = ? + """, select_query= "SELECT * FROM variants where id = ?", table_query="""CREATE TABLE variants ( @@ -20,10 +27,12 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): CREATE UNIQUE INDEX idx_variants_id on variants (id);""" ) + def _convertMetadataToUpdateBatch(self, metadata): + return self._convertMetadataToInsertBatch(metadata)[1:] + def _convertRawDataToMetadata(self, data): 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"} - def _convertMetadataToInsertBatch(self, metadata): return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"], metadata["version"], \ metadata["setting_version"] From 55d6ff0e61763f6bcd7698f908c029843fa84138 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Wed, 25 Aug 2021 13:58:11 +0200 Subject: [PATCH 09/17] Clean up formating of the insert queries CURA-6096 --- .../DatabaseHandlers/IntentDatabaseHandler.py | 3 ++- .../QualityDatabaseHandler.py | 3 ++- .../VariantDatabaseHandler.py | 21 ++++++++++--------- 3 files changed, 15 insertions(+), 12 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index ffe0191088..1a48d652a7 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -5,7 +5,8 @@ from UM.Settings.InstanceContainer import InstanceContainer class IntentDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__( - insert_query="INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)", + insert_query = """ INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) + VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)""", update_query="""UPDATE intents SET name = ?, quality_type = ?, diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index 258c63709b..d0bb987b95 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -5,7 +5,8 @@ from UM.Settings.InstanceContainer import InstanceContainer class QualityDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__( - insert_query = "INSERT INTO qualities (id, name, quality_type, material, variant, global_quality, definition, version, setting_version) VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)", + 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 = ?, diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index 0670f132e9..4673a3d60e 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -5,17 +5,18 @@ from UM.Settings.InstanceContainer import InstanceContainer class VariantDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: 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 = ? - """, + 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 = ?", - table_query="""CREATE TABLE variants + table_query = """CREATE TABLE variants ( id text, name text, From 3191baf5a017d45666403049446f2520f65ca251 Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Fri, 27 Aug 2021 14:36:04 +0200 Subject: [PATCH 10/17] Add delete to handlers CURA-6096 --- cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py | 3 ++- cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 3 ++- cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py | 3 ++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 1a48d652a7..65c966dd9e 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -18,7 +18,8 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): setting_version = ? WHERE id = ? """, - select_query = "SELECT * FROM intents where id = ?", + select_query = "SELECT * FROM intents WHERE id = ?", + delete_query = "DELETE FROM intents WHERE id = ?", table_query="""CREATE TABLE intents ( id text, diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index d0bb987b95..c6e02e3ac3 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -18,7 +18,8 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): setting_version = ? WHERE id = ? """, - select_query = "SELECT * FROM qualities where id = ?", + select_query = "SELECT * FROM qualities WHERE id = ?", + delete_query = "DELETE FROM qualities WHERE id = ?", table_query = """CREATE TABLE qualities ( id text, diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index 4673a3d60e..c2987df675 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -15,7 +15,8 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): setting_version = ? WHERE id = ? """, - select_query= "SELECT * FROM variants where id = ?", + select_query = "SELECT * FROM variants WHERE id = ?", + delete_query = "DELETE FROM variants WHERE id = ?", table_query = """CREATE TABLE variants ( id text, From 7aa08d4acd42a0ade4f4e7a23a87ae777c1456b9 Mon Sep 17 00:00:00 2001 From: jelle Spijker Date: Wed, 1 Sep 2021 13:58:58 +0200 Subject: [PATCH 11/17] 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 --- .../DatabaseHandlers/IntentDatabaseHandler.py | 59 ++++----------- .../QualityDatabaseHandler.py | 74 ++++++------------- .../VariantDatabaseHandler.py | 47 ++++-------- 3 files changed, 51 insertions(+), 129 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 65c966dd9e..17ac715c39 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/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__( - insert_query = """ INSERT INTO intents (id, name, quality_type, intent_category, variant, definition, material, version, setting_version) - VALUES (?, ?, ? ,?, ?, ?, ?, ?, ?)""", - update_query="""UPDATE intents - SET name = ?, - quality_type = ?, - intent_category = ?, - variant = ?, - definition = ?, - material = ?, - version = ?, - setting_version = ? - WHERE id = ? - """, - 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"] - - - + super().__init__(SQLQueryFactory(table = "intents", + fields = { + "id": "text", + "name": "text", + "quality_type": "text", + "intent_category": "text", + "variant": "text", + "definition": "text", + "material": "text", + "version": "text", + "setting_version": "text" + })) + self.container_type = InstanceContainer diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index c6e02e3ac3..286ab19271 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/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: - 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"] + """The Database handler for Quality containers""" + 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) diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index c2987df675..4173243afd 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/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: - 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);""" - ) + """The Database handler for Variant containers""" - def _convertMetadataToUpdateBatch(self, metadata): - return self._convertMetadataToInsertBatch(metadata)[1:] - - def _convertRawDataToMetadata(self, data): - 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"} - - def _convertMetadataToInsertBatch(self, metadata): - return metadata["id"], metadata["name"], metadata["hardware_type"], metadata["definition"], metadata["version"], \ - metadata["setting_version"] + def __init__(self): + super().__init__(SQLQueryFactory(table = "variants", + fields = { + "id": "text", + "name": "text", + "hardware_type": "text", + "definition": "text", + "version": "text", + "setting_version": "text" + })) + self.container_type = InstanceContainer From f80e1ec2790d7fca93ac5e6de0b5a0a1ad62df6d Mon Sep 17 00:00:00 2001 From: jelle Spijker Date: Wed, 1 Sep 2021 18:32:40 +0200 Subject: [PATCH 12/17] Updated documentation Contributes to CURA-6096 --- cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index 286ab19271..43de7cb098 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -24,6 +24,14 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): self.container_type = InstanceContainer def groomMetadata(self, metadata: metadata_type) -> metadata_type: + """ + Ensures that the metadata is in the order of the field keys and has the right size. + if the metadata doesn't contains a key which is stored in the DB it will add it as + an empty string. Key, value pairs that are not stored in the DB are dropped. + If the `global_quality` isn't set it well default to 'False' + + :param metadata: The container metadata + """ if "global_quality" not in metadata: metadata["global_quality"] = "False" return super().groomMetadata(metadata) From 4067d9d607184c7c699cbf5401873a16d348bf10 Mon Sep 17 00:00:00 2001 From: jelle Spijker Date: Thu, 2 Sep 2021 10:17:40 +0200 Subject: [PATCH 13/17] Fixed typing Contributes to CURA-6096 --- cura/Settings/CuraContainerRegistry.py | 1 - cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 2 -- 2 files changed, 3 deletions(-) diff --git a/cura/Settings/CuraContainerRegistry.py b/cura/Settings/CuraContainerRegistry.py index 7ab488eeba..6130019f4d 100644 --- a/cura/Settings/CuraContainerRegistry.py +++ b/cura/Settings/CuraContainerRegistry.py @@ -10,7 +10,6 @@ from PyQt5.QtWidgets import QMessageBox from UM.Decorators import override from UM.Settings.ContainerFormatError import ContainerFormatError -from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController from UM.Settings.Interfaces import ContainerInterface from UM.Settings.ContainerRegistry import ContainerRegistry from UM.Settings.ContainerStack import ContainerStack diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index 43de7cb098..5447c0ed62 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -1,5 +1,3 @@ -from typing import Generator - from UM.Settings.SQLQueryFactory import SQLQueryFactory, metadata_type from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController from UM.Settings.InstanceContainer import InstanceContainer From 571a051041b7c126ca942055961c7714312a967f Mon Sep 17 00:00:00 2001 From: jelle Spijker Date: Thu, 2 Sep 2021 16:55:24 +0200 Subject: [PATCH 14/17] Use SQLQueryFactory for container DB Needed to add a Filter possibility to facilitate that Created a Simple UserString class which can be used as: ```py sql_filter = SQLFilter(f"SELECT {{}} FROM table_name WHERE id = ?") cursor.execute(sql_filter) # Will execute: SELECT * FROM table_name WHERE id = ? cursor.execute(sql_filter["id", "name"]) # Will execute: SELECT id, name FROM table_name WHERE id = ? ``` Contributes to CURA-6096 --- cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py | 3 --- cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 3 --- cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py | 3 --- 3 files changed, 9 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 17ac715c39..1eece06a3c 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -1,6 +1,5 @@ from UM.Settings.SQLQueryFactory import SQLQueryFactory from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController -from UM.Settings.InstanceContainer import InstanceContainer class IntentDatabaseHandler(DatabaseMetadataContainerController): @@ -9,7 +8,6 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__(SQLQueryFactory(table = "intents", fields = { - "id": "text", "name": "text", "quality_type": "text", "intent_category": "text", @@ -19,4 +17,3 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) - self.container_type = InstanceContainer diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index 5447c0ed62..8d666fc22f 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -1,6 +1,5 @@ from UM.Settings.SQLQueryFactory import SQLQueryFactory, metadata_type from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController -from UM.Settings.InstanceContainer import InstanceContainer class QualityDatabaseHandler(DatabaseMetadataContainerController): @@ -9,7 +8,6 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): def __init__(self): super().__init__(SQLQueryFactory(table = "qualities", fields = { - "id": "text", "name": "text", "quality_type": "text", "material": "text", @@ -19,7 +17,6 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) - self.container_type = InstanceContainer def groomMetadata(self, metadata: metadata_type) -> metadata_type: """ diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index 4173243afd..969aef48a9 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -1,6 +1,5 @@ from UM.Settings.SQLQueryFactory import SQLQueryFactory from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController -from UM.Settings.InstanceContainer import InstanceContainer class VariantDatabaseHandler(DatabaseMetadataContainerController): @@ -9,11 +8,9 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): def __init__(self): super().__init__(SQLQueryFactory(table = "variants", fields = { - "id": "text", "name": "text", "hardware_type": "text", "definition": "text", "version": "text", "setting_version": "text" })) - self.container_type = InstanceContainer From adac0af1eca22ddfe1cf01232cdfd5364094899f Mon Sep 17 00:00:00 2001 From: Ghostkeeper Date: Wed, 8 Sep 2021 15:10:32 +0200 Subject: [PATCH 15/17] Revert "Use SQLQueryFactory for container DB" This reverts commit 571a051041b7c126ca942055961c7714312a967f. --- cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py | 3 +++ cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 3 +++ cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py | 3 +++ 3 files changed, 9 insertions(+) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 1eece06a3c..17ac715c39 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -1,5 +1,6 @@ from UM.Settings.SQLQueryFactory import SQLQueryFactory from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController +from UM.Settings.InstanceContainer import InstanceContainer class IntentDatabaseHandler(DatabaseMetadataContainerController): @@ -8,6 +9,7 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): def __init__(self) -> None: super().__init__(SQLQueryFactory(table = "intents", fields = { + "id": "text", "name": "text", "quality_type": "text", "intent_category": "text", @@ -17,3 +19,4 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) + self.container_type = InstanceContainer diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index 8d666fc22f..5447c0ed62 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -1,5 +1,6 @@ from UM.Settings.SQLQueryFactory import SQLQueryFactory, metadata_type from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController +from UM.Settings.InstanceContainer import InstanceContainer class QualityDatabaseHandler(DatabaseMetadataContainerController): @@ -8,6 +9,7 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): def __init__(self): super().__init__(SQLQueryFactory(table = "qualities", fields = { + "id": "text", "name": "text", "quality_type": "text", "material": "text", @@ -17,6 +19,7 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) + self.container_type = InstanceContainer def groomMetadata(self, metadata: metadata_type) -> metadata_type: """ diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index 969aef48a9..4173243afd 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -1,5 +1,6 @@ from UM.Settings.SQLQueryFactory import SQLQueryFactory from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController +from UM.Settings.InstanceContainer import InstanceContainer class VariantDatabaseHandler(DatabaseMetadataContainerController): @@ -8,9 +9,11 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): def __init__(self): super().__init__(SQLQueryFactory(table = "variants", fields = { + "id": "text", "name": "text", "hardware_type": "text", "definition": "text", "version": "text", "setting_version": "text" })) + self.container_type = InstanceContainer From 057ba8cdeb6c2c30a79fbb6b94f8937f708d2715 Mon Sep 17 00:00:00 2001 From: Ghostkeeper Date: Wed, 8 Sep 2021 15:46:25 +0200 Subject: [PATCH 16/17] Fix setting container type of subclasses This mistake caused all of the container types to end up as either None or the actual instance itself, which was causing crashes. Contributes to issue CURA-6096. --- cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py | 2 +- cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 2 +- cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 17ac715c39..33dc176ac8 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -19,4 +19,4 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) - self.container_type = InstanceContainer + self._container_type = InstanceContainer diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index 5447c0ed62..a84f725587 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -19,7 +19,7 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) - self.container_type = InstanceContainer + self._container_type = InstanceContainer def groomMetadata(self, metadata: metadata_type) -> metadata_type: """ diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index 4173243afd..d8029c754f 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -16,4 +16,4 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): "version": "text", "setting_version": "text" })) - self.container_type = InstanceContainer + self._container_type = InstanceContainer From 034f62ea2c113bd39fc29c8619aa482f9c1fe1d8 Mon Sep 17 00:00:00 2001 From: Ghostkeeper Date: Wed, 8 Sep 2021 16:40:22 +0200 Subject: [PATCH 17/17] Match table name with container type The table name is used as the container type in the resulting metadata, so we need to use the container type string as table name correctly, or none of the profiles can be found. Contributes to issue CURA-6096. --- cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py | 5 ++++- cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py | 5 ++++- cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py | 5 ++++- 3 files changed, 12 insertions(+), 3 deletions(-) diff --git a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py index 33dc176ac8..cd6c662591 100644 --- a/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/IntentDatabaseHandler.py @@ -1,3 +1,6 @@ +# Copyright (c) 2021 Ultimaker B.V. +# Cura is released under the terms of the LGPLv3 or higher. + from UM.Settings.SQLQueryFactory import SQLQueryFactory from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController from UM.Settings.InstanceContainer import InstanceContainer @@ -7,7 +10,7 @@ class IntentDatabaseHandler(DatabaseMetadataContainerController): """The Database handler for Intent containers""" def __init__(self) -> None: - super().__init__(SQLQueryFactory(table = "intents", + super().__init__(SQLQueryFactory(table = "intent", fields = { "id": "text", "name": "text", diff --git a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py index a84f725587..477bb56465 100644 --- a/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/QualityDatabaseHandler.py @@ -1,3 +1,6 @@ +# Copyright (c) 2021 Ultimaker B.V. +# Cura is released under the terms of the LGPLv3 or higher. + from UM.Settings.SQLQueryFactory import SQLQueryFactory, metadata_type from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController from UM.Settings.InstanceContainer import InstanceContainer @@ -7,7 +10,7 @@ class QualityDatabaseHandler(DatabaseMetadataContainerController): """The Database handler for Quality containers""" def __init__(self): - super().__init__(SQLQueryFactory(table = "qualities", + super().__init__(SQLQueryFactory(table = "quality", fields = { "id": "text", "name": "text", diff --git a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py index d8029c754f..4b1deae356 100644 --- a/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py +++ b/cura/Settings/DatabaseHandlers/VariantDatabaseHandler.py @@ -1,3 +1,6 @@ +# Copyright (c) 2021 Ultimaker B.V. +# Cura is released under the terms of the LGPLv3 or higher. + from UM.Settings.SQLQueryFactory import SQLQueryFactory from UM.Settings.DatabaseContainerMetadataController import DatabaseMetadataContainerController from UM.Settings.InstanceContainer import InstanceContainer @@ -7,7 +10,7 @@ class VariantDatabaseHandler(DatabaseMetadataContainerController): """The Database handler for Variant containers""" def __init__(self): - super().__init__(SQLQueryFactory(table = "variants", + super().__init__(SQLQueryFactory(table = "variant", fields = { "id": "text", "name": "text",