s.steuer/SchnittstellenanpassungRDSivas
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: s.steuer/SchnittstellenanpassungRDSivas:f678b2ac2f26fbf779d6e6e09a36e69dac5dc61f
Branches Tags
s.steuer/SchnittstellenanpassungRDSivas:main
..
compare: s.steuer/SchnittstellenanpassungRDSivas:4ba04756293f623cf905b6a6d1f468b5d981fc64
Branches Tags
s.steuer/SchnittstellenanpassungRDSivas:main

2 Commits
f678b2ac2f .. 4ba0475629

Author SHA1 Message Date
s.steuer 4ba0475629 Logik an die geänderten Tabellen (siehe Commit d745436) angepasst. Beim Update der TOS-Regeln und -Bedingungen wird zudem in VAR_TEIL_BEDINGUNG_2 und STKL_REGEL nur noch die Positionsnummer aktualisiert, aber nicht mehr die Bedingung oder Regel selbst. Das ist nicht nötig, weil ja eine Verschiebung erfolgt, also abgesehen von einer etwaigen Anpassung der Positionsnummer keine Änderungen erfolgen 2025-08-15 18:49:54 +02:00
s.steuer d745436431 Es wurde bisher nicht berücksichtigt, dass es die Verbindung zwischen den Tabellen COMP und VAR_TEIL_BEDINGUNG_2, bzw. STKL_REGEL nicht über eine Spalte COMP_ID, sondern über 2 Spalten 'UEBTEILENR' und 'POSNR' erfolgt. Die Daten der Tabellen wurden daran angepasst. Zudem wurden die Spaltenname von ID und PARENT in COMP korrigiert -> lauten in Wirklichkeit 'ROWID' und 'UEBTEILENR' 2025-08-15 18:46:14 +02:00
2 changed files with 324 additions and 277 deletions
Expand all files Collapse all files
data/in/sivas_replika.sql
+68 -85
View File
@@ -1,14 +1,7 @@
BEGIN TRANSACTION; BEGIN TRANSACTION;
CREATE TABLE IF NOT EXISTS "Beispiele" (
"ID" INTEGER NOT NULL,
"Parent_ID" TEXT NOT NULL,
"Beispielnr" INTEGER,
PRIMARY KEY("ID" AUTOINCREMENT),
CONSTRAINT "FK_Parent_ID" FOREIGN KEY("Parent_ID") REFERENCES "COMP"("PARENT")
);
CREATE TABLE IF NOT EXISTS "COMP" ( CREATE TABLE IF NOT EXISTS "COMP" (
"ID" INTEGER NOT NULL, "ROWID" INTEGER NOT NULL,
"PARENT" TEXT NOT NULL, "UEBTEILENR" TEXT NOT NULL,
"POSNR" INTEGER NOT NULL, "POSNR" INTEGER NOT NULL,
"KOMPTEILENR" TEXT NOT NULL, "KOMPTEILENR" TEXT NOT NULL,
"DISPO_AKTIV_JN" TEXT, "DISPO_AKTIV_JN" TEXT,
@@ -17,7 +10,7 @@ CREATE TABLE IF NOT EXISTS "COMP" (
"LAENGE" REAL, "LAENGE" REAL,
"ZUSCHNITT" TEXT, "ZUSCHNITT" TEXT,
"RUESTCODE" TEXT, "RUESTCODE" TEXT,
PRIMARY KEY("ID" AUTOINCREMENT) PRIMARY KEY("ROWID" AUTOINCREMENT)
); );
CREATE TABLE IF NOT EXISTS "PARTS" ( CREATE TABLE IF NOT EXISTS "PARTS" (
"TEILENR" INTEGER, "TEILENR" INTEGER,
@@ -47,34 +40,24 @@ CREATE TABLE IF NOT EXISTS "PARTS" (
"STATUS" TEXT "STATUS" TEXT
); );
CREATE TABLE IF NOT EXISTS "STKL_REGEL" ( CREATE TABLE IF NOT EXISTS "STKL_REGEL" (
"ID" INTEGER NOT NULL, "ROWID" INTEGER NOT NULL,
"COMP_ID" INTEGER, "UEBTEILENR" INTEGER,
"REGEL" INTEGER NOT NULL, "POSNR" INTEGER,
PRIMARY KEY("ID" AUTOINCREMENT), "LFD_NR" INTEGER NOT NULL,
CONSTRAINT "FK_COMP_ID" FOREIGN KEY("COMP_ID") REFERENCES "COMP"("ID") PRIMARY KEY("ROWID" AUTOINCREMENT),
CONSTRAINT "FK_COMP_POSNR" FOREIGN KEY("POSNR") REFERENCES "COMP"("POSNR"),
CONSTRAINT "FK_COMP_UEBTEILENR" FOREIGN KEY("UEBTEILENR") REFERENCES "COMP"("UEBTEILENR")
); );
CREATE TABLE IF NOT EXISTS "VAR_TEIL_BEDINGUNG_2" ( CREATE TABLE IF NOT EXISTS "VAR_TEIL_BEDINGUNG_2" (
"ID" INTEGER NOT NULL, "ROWID" INTEGER NOT NULL,
"COMP_ID" INTEGER NOT NULL, "UEBTEILENR" TEXT NOT NULL,
"BEDINGUNG" INTEGER NOT NULL, "POSNR" INTEGER NOT NULL,
PRIMARY KEY("ID" AUTOINCREMENT), "UEB_LEISTEN_NR" INTEGER NOT NULL,
CONSTRAINT "FK_COMP_ID" FOREIGN KEY("COMP_ID") REFERENCES "COMP"("ID") PRIMARY KEY("ROWID" AUTOINCREMENT),
CONSTRAINT "FK_COMP_POSNR" FOREIGN KEY("POSNR") REFERENCES "COMP"("POSNR"),
CONSTRAINT "FK_COMP_UEBTEILENR" FOREIGN KEY("UEBTEILENR") REFERENCES "COMP"("UEBTEILENR")
); );
INSERT INTO "Beispiele" ("ID","Parent_ID","Beispielnr") VALUES (1,'000000369',1), INSERT INTO "COMP" ("ROWID","UEBTEILENR","POSNR","KOMPTEILENR","DISPO_AKTIV_JN","MENGE","ABW_ANZAHL","LAENGE","ZUSCHNITT","RUESTCODE") VALUES (1,'000000380',10,'821096001','J',0.22,1,200.0,'20','HZS'),
(2,'000000370',2),
(3,'000000371',3),
(4,'000000372',4),
(5,'000000373',5),
(6,'000000374',6),
(7,'000000375',7),
(8,'000000376',8),
(9,'000000377',9),
(10,'000000378',10),
(11,'000000379',11),
(12,'000000380',12),
(13,'000000381',13),
(14,'000000382',14);
INSERT INTO "COMP" ("ID","PARENT","POSNR","KOMPTEILENR","DISPO_AKTIV_JN","MENGE","ABW_ANZAHL","LAENGE","ZUSCHNITT","RUESTCODE") VALUES (1,'000000380',10,'821096001','J',0.22,1,200.0,'20','HZS'),
(2,'000000380',20,'829416035','J',1.0,NULL,NULL,NULL,'SRC'), (2,'000000380',20,'829416035','J',1.0,NULL,NULL,NULL,'SRC'),
(3,'000000380',30,'200000168','J',1.0,NULL,NULL,NULL,'SRC'), (3,'000000380',30,'200000168','J',1.0,NULL,NULL,NULL,'SRC'),
(4,'000000380',40,'821096001','J',0.11,1,100.0,'10','HZS'), (4,'000000380',40,'821096001','J',0.11,1,100.0,'10','HZS'),
@@ -154,54 +137,54 @@ INSERT INTO "PARTS" ("TEILENR","BEZ","BEZ2","KZKAUF","MENGENC","ABW_ANZAHL_JN","
(829516051,'GLEITPROFIL - STAHLBANDFÜHRUNG FÜR ILS 2100',NULL,'K','M','J','J','3003','10','20','A',NULL,NULL,'110309',NULL,'Murtfeldt "S" 1000','Masterbatch (Grundfarbe)','FALSCH','J','HZS','EX','0','Eigenbau','B.MÜLLER','5'), (829516051,'GLEITPROFIL - STAHLBANDFÜHRUNG FÜR ILS 2100',NULL,'K','M','J','J','3003','10','20','A',NULL,NULL,'110309',NULL,'Murtfeldt "S" 1000','Masterbatch (Grundfarbe)','FALSCH','J','HZS','EX','0','Eigenbau','B.MÜLLER','5'),
(829526000,'STRUKTUR-PROFIL',NULL,'K','M','J','J','6','10','20','A',NULL,NULL,'120214',NULL,'EN AW-6063-T66','eloxieren','FALSCH','N','HZS','SN','0','Eigenbau','S.STEUER','5'), (829526000,'STRUKTUR-PROFIL',NULL,'K','M','J','J','6','10','20','A',NULL,NULL,'120214',NULL,'EN AW-6063-T66','eloxieren','FALSCH','N','HZS','SN','0','Eigenbau','S.STEUER','5'),
(829526517,'WEICHENPLATTE R-G - ILS II',NULL,'K','Stck','N','J','6','10','20','B',NULL,NULL,NULL,NULL,'1.0038 (S235JR)','verzinken','FALSCH','N','SRC','LW','0','Eigenbau','B.MÜLLER','5'); (829526517,'WEICHENPLATTE R-G - ILS II',NULL,'K','Stck','N','J','6','10','20','B',NULL,NULL,NULL,NULL,'1.0038 (S235JR)','verzinken','FALSCH','N','SRC','LW','0','Eigenbau','B.MÜLLER','5');
INSERT INTO "VAR_TEIL_BEDINGUNG_2" ("ID","COMP_ID","BEDINGUNG") VALUES (1,6,418), INSERT INTO "VAR_TEIL_BEDINGUNG_2" ("ROWID","UEBTEILENR","POSNR","UEB_LEISTEN_NR") VALUES (1,'000000369',10,418),
(2,8,420), (2,'000000369',30,420),
(3,35,419), (3,'000000370',10,419),
(4,10,419), (4,'000000371',10,419),
(5,12,420), (5,'000000371',30,420),
(6,14,418), (6,'000000372',10,418),
(7,15,419), (7,'000000372',20,419),
(8,16,420), (8,'000000372',30,420),
(9,18,417), (9,'000000373',10,417),
(10,19,418), (10,'000000373',20,418),
(11,21,417), (11,'000000374',10,417),
(12,22,418), (12,'000000374',20,418),
(13,24,419), (13,'000000374',40,419),
(14,25,417), (14,'000000375',10,417),
(15,26,418), (15,'000000375',20,418),
(16,28,419), (16,'000000375',40,419),
(17,29,417), (17,'000000376',10,417),
(18,34,419), (18,'000000378',10,419),
(19,37,418), (19,'000000379',20,418),
(20,39,419), (20,'000000379',40,419),
(21,1,417), (21,'000000380',10,417),
(22,2,418), (22,'000000380',20,418),
(23,4,419), (23,'000000380',40,419),
(24,5,420), (24,'000000380',50,420),
(25,40,7), (25,'000000381',10,7),
(26,41,7), (26,'000000381',20,7),
(27,42,2), (27,'000000381',30,2),
(28,43,7), (28,'000000381',40,7),
(29,44,3), (29,'000000381',50,3),
(30,45,11), (30,'000000381',60,11),
(31,46,11), (31,'000000381',70,11),
(32,47,3), (32,'000000381',80,3),
(33,48,1), (33,'000000382',10,1),
(34,49,5), (34,'000000382',20,5),
(35,50,2), (35,'000000382',30,2),
(36,51,6), (36,'000000382',40,6),
(37,52,3), (37,'000000382',50,3),
(38,53,4), (38,'000000382',60,4),
(39,54,4), (39,'000000382',70,4),
(40,55,4), (40,'000000382',80,4),
(41,56,6), (41,'000000382',90,6),
(42,57,1), (42,'000000382',100,1),
(43,58,3), (43,'000000382',110,3),
(44,59,7), (44,'000000382',120,7),
(45,60,7), (45,'000000382',130,7),
(46,61,8), (46,'000000382',140,8),
(47,62,7), (47,'000000382',150,7),
(48,63,10), (48,'000000382',160,10),
(49,64,11), (49,'000000382',170,11),
(50,65,11); (50,'000000382',180,11);
COMMIT; COMMIT;
lib/process_bom.py
+256 -192
View File
@@ -232,32 +232,36 @@ class RD_COMP:
def get_verbose_data(self) -> list[dict[str]]: def get_verbose_data(self) -> list[dict[str]]:
res = self.db.con.execute(""" res = self.db.con.execute("""
SELECT C.*, R.REGEL, B.BEDINGUNG SELECT C.*, R.LFD_NR, B.UEB_LEISTEN_NR
FROM COMP C FROM COMP C
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
ON C.ID = B.COMP_ID ON C.UEBTEILENR = B.UEBTEILENR
AND C.POSNR = B.POSNR
LEFT JOIN STKL_REGEL R LEFT JOIN STKL_REGEL R
ON C.ID = R.COMP_ID ON C.UEBTEILENR = R.UEBTEILENR
AND C.POSNR = R.POSNR
WHERE C.PARENT = :parent_code WHERE C.UEBTEILENR = :parent_code
ORDER BY C.POSNR ORDER BY C.POSNR
""", {"parent_code": self.parent_code}).fetchall() """, {"parent_code": self.parent_code}).fetchall()
return res return res
def get_compact_data(self) -> list[dict[str]]: def get_compact_data(self) -> list[dict[str]]:
res = self.db.con.execute(""" res = self.db.con.execute("""
SELECT C.POSNR, C.KOMPTEILENR, C.ABW_ANZAHL, C.MENGE, C.LAENGE, C.ZUSCHNITT, R.REGEL, B.Bedingung SELECT C.POSNR, C.KOMPTEILENR, C.ABW_ANZAHL, C.MENGE, C.LAENGE, C.ZUSCHNITT, R.LFD_NR, B.UEB_LEISTEN_NR
FROM COMP C FROM COMP C
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
ON C.ID = B.COMP_ID ON C.UEBTEILENR = B.UEBTEILENR
AND C.POSNR = B.POSNR
LEFT JOIN STKL_REGEL R LEFT JOIN STKL_REGEL R
ON C.ID = R.COMP_ID ON C.UEBTEILENR = R.UEBTEILENR
AND C.POSNR = R.POSNR
WHERE C.PARENT = :parent_code WHERE C.UEBTEILENR = :parent_code
ORDER BY C.POSNR ORDER BY C.POSNR
""", {"parent_code": self.parent_code}).fetchall() """, {"parent_code": self.parent_code}).fetchall()
return res return res
@@ -290,26 +294,26 @@ class BOMProcessing:
def _get_codes_case_12_or_13(self) -> None: def _get_codes_case_12_or_13(self) -> None:
""" """
Ermittelt alle, die unter Fall 1.2 oder Fall 1.3 fallen. Ermittelt alle Teilenummern, die unter Fall 1.2 oder Fall 1.3 fallen.
Es wird dafür geprüft, welche Teilenummern NICHT unter Fall 1.1 fallen. Es wird dafür geprüft, welche Teilenummern NICHT unter Fall 1.1 fallen.
Wieso wird nicht geprüft, welche Teilenummern in Fall 1.1 liegen? Wieso wird nicht geprüft, welche Teilenummern in Fall 1.1 liegen?
- Weil die SQL-Abfrage dann deutlich komplexer wird. - Weil die SQL-Abfrage dann komplexer wird.
Die Prüfung läuft so ab: Die Prüfung läuft so ab:
1. Teilenr-Längen-Kombinationen aus der alten und neuen Stückliste mit UNION ALL zusammenfügen 1. Teilenr-Längen-Kombinationen aus der alten und neuen Stückliste mit UNION ALL verschmelzen
2. Mit COUNT ermitteln, wie oft jede Teilenummer-Längen-Kombination in der zusammengefügten Stückliste auftritt 2. Mit COUNT ermitteln, wie oft jede Teilenummer-Längen-Kombination in der verschmolzenen Stückliste auftritt
3. Die Teilenummern in die temporäre Tabelle TMP_CODES_CASE_12_OR_13 schreiben, deren Teilenr-Längen-Kombination 1x vorkommen 3. Die Teilenummern in die temporäre Tabelle TMP_CODES_CASE_12_OR_13 schreiben, sobald 1x eine Teilenr-Längen-Kombination auftritt, die nur 1x vorkommt
=> Diese Teilenummern unterliegen entweder Fall 1.2 oder Fall 1.3, aber definitiv nicht Fall 1.1, weil eine Zuordnung zu => Diese Teilenummern unterliegen entweder Fall 1.2 oder Fall 1.3, aber definitiv nicht Fall 1.1, weil eine Zuordnung zu Fall 1.1 nur dann möglich ist,
Fall 1.1 nur dann möglich ist, wenn alle Teilenr-Längen-Kombinationen exakt 2x auftreten! wenn alle Teilenr-Längen-Kombinationen einer Teilenummer exakt 2x auftreten!
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_CODES_CASE_12_OR_13") self.db.con.execute("DROP TABLE IF EXISTS TMP_CODES_CASE_12_OR_13")
self.db.con.execute("CREATE TABLE TMP_CODES_CASE_12_OR_13 (KOMPTEILENR TEXT NOT NULL, PRIMARY KEY (KOMPTEILENR))") self.db.con.execute("CREATE TABLE TMP_CODES_CASE_12_OR_13 (KOMPTEILENR TEXT NOT NULL)")
self.db.con.execute(""" self.db.con.execute("""
WITH combined_bom AS ( WITH combined_bom AS (
SELECT C.KOMPTEILENR, COALESCE(C.LAENGE, 0) AS LAENGE SELECT C.KOMPTEILENR, COALESCE(C.LAENGE, 0) AS LAENGE
FROM COMP C FROM COMP C
WHERE C.PARENT = :parent_code WHERE C.UEBTEILENR = :parent_code
UNION ALL UNION ALL
@@ -334,24 +338,24 @@ class BOMProcessing:
Fall 1.3 umfasst alle Positionen, die entweder in der neuen Stückliste dazugekommen sind (Fall 1.31) oder deren Fall 1.3 umfasst alle Positionen, die entweder in der neuen Stückliste dazugekommen sind (Fall 1.31) oder deren
Teilenr-Längen-Kombination in beiden Stücklisten vorliegen (Fall 1.32). Teilenr-Längen-Kombination in beiden Stücklisten vorliegen (Fall 1.32).
Wenn Positionen bereits unter Fall 1.1 oder Fall 1.2 fallen, dann werden sie nicht Fall 1.32 zugeordnet, selbst wenn Wenn Positionen bereits unter Fall 1.1 oder Fall 1.2 fallen, dann werden sie NICHT Fall 1.32 zugeordnet, selbst wenn
sie Fall 1.32 auf diese Positionen zutreffen würde (Vorrangsprinzip). Fall 1.32 auf diese Positionen zutreffen würde.
Die Prüfung läuft so ab: Die Prüfung läuft so ab:
1. Teilenr-Posnr-Kombinationen aus der alten und neuen Stückliste mit UNION ALL zusammenfügen, sofern sich die Teilenummern in der 1. Alle Teilenr-Posnr-Kombinationen aus der alten und neuen Stückliste mit UNION ALL verschmelzen, sofern sich die Teilenummern in der
Liste an Teilenummern befindet, die unter Fall 1.2 oder Fall 1.3 fallen (siehe Methode _get_codes_case_12_or_13()) Liste an Teilenummern befindet, die unter Fall 1.2 oder Fall 1.3 fallen (siehe Methode _get_codes_case_12_or_13())
2. Mit COUNT ermitteln, wie oft jede Teilenr-Posnr-Kombination in der zusammengefügten Stückliste auftritt 2. Mit COUNT ermitteln, wie oft jede Teilenr-Posnr-Kombination in der zusammengefügten Stückliste auftritt
3. Die Teilenummern ausgeben, deren Teilenr-Posnr-Kombination nur 1x vorkommen in die temporäre Tabelle TMP_CODES_CASE_13 schreiben 3. Die Teilenummern, deren Teilenr-Posnr-Kombination nur 1x auftritt, in die temporäre Tabelle TMP_CODES_CASE_13 schreiben
=> Diese Teilenummern unterliegen definitv Fall 1.3, weil in Fall 1.2 alle Teilenr-Posnr-Kombinationen exakt 2x auftreten müssen! => Diese Teilenummern unterliegen definitv Fall 1.3, weil in Fall 1.2 alle Teilenr-Posnr-Kombinationen einer Teilenummer exakt 2x auftreten müssen!
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_CODES_CASE_13") self.db.con.execute("DROP TABLE IF EXISTS TMP_CODES_CASE_13")
self.db.con.execute("CREATE TABLE TMP_CODES_CASE_13 (KOMPTEILENR TEXT NOT NULL, PRIMARY KEY(KOMPTEILENR))") self.db.con.execute("CREATE TABLE TMP_CODES_CASE_13 (KOMPTEILENR TEXT NOT NULL)")
self.db.con.execute(""" self.db.con.execute("""
WITH combined_bom AS ( WITH combined_bom AS (
SELECT KOMPTEILENR, POSNR SELECT KOMPTEILENR, POSNR
FROM COMP FROM COMP
WHERE PARENT = :parent_code WHERE UEBTEILENR = :parent_code
AND KOMPTEILENR IN (SELECT * FROM TMP_CODES_CASE_12_OR_13) AND KOMPTEILENR IN (SELECT * FROM TMP_CODES_CASE_12_OR_13)
UNION ALL UNION ALL
@@ -378,31 +382,36 @@ class BOMProcessing:
Deren Ermittlung funktioniert so: Deren Ermittlung funktioniert so:
1. Teilenummern herausfiltern, die NICHT in der Tabelle TMP_CODES_CASE_12_OR_13 vorliegen 1. Teilenummern herausfiltern, die NICHT in der Tabelle TMP_CODES_CASE_12_OR_13 vorliegen
2. Zu den gefundenen Teilenummern: 2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_11 schreiben:
- Parent-Teilenr - Teilenr des Parents
- Posnr. laut neuer Stückliste - Positionsnummer laut alter Stückliste
- ID laut alter Stückliste - Positionsnummer laut neuer Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_11 schreiben.
Hinweis: Hinweis:
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen - Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können Stückliste herstellen zu können
- Die Teilenummer des Parents wird zusamment mit der Positionsnummer laut alter Stückliste dafür benötigt, um in den Tabellen STKL_REGEL und
VAR_TEIL_BEDINGUNG_2 die Zeilen zu ermitteln, die aktualisiert werden müssen
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_11") self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_11")
self.db.con.execute("""CREATE TABLE TMP_POSNRS_CASE_11 (COMP_ID INTEGER NOT NULL,
PARENT TEXT NOT NULL,
POSNR INTEGER NOT NULL,
PRIMARY KEY(POSNR))""")
self.db.con.execute("""
INSERT INTO TMP_POSNRS_CASE_11 (COMP_ID, PARENT, POSNR)
SELECT C.ID AS COMP_ID, C.PARENT, RD.Positionsnummer AS POSNR self.db.con.execute("""
CREATE TABLE TMP_POSNRS_CASE_11 (UEBTEILENR TEXT NOT NULL,
POS_ALT INTEGER NOT NULL,
POS_NEU INTEGER NOT NULL)
""")
self.db.con.execute("""
INSERT INTO TMP_POSNRS_CASE_11 (UEBTEILENR, POS_ALT, POS_NEU)
SELECT C.UEBTEILENR, C.POSNR AS POS_ALT, RD.Positionsnummer AS POS_NEU
FROM RD_COMP RD FROM RD_COMP RD
LEFT JOIN TMP_CODES_CASE_12_OR_13 TMP LEFT JOIN TMP_CODES_CASE_12_OR_13 TMP
ON RD.ChildCode = TMP.KOMPTEILENR ON RD.ChildCode = TMP.KOMPTEILENR
LEFT JOIN COMP C LEFT JOIN COMP C
ON RD.ParentCode = C.PARENT ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR AND RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0) AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
@@ -416,69 +425,68 @@ class BOMProcessing:
Deren Ermittlung funktioniert so: Deren Ermittlung funktioniert so:
1. Teilenummern herausfiltern, die in der Tabelle TMP_CODES_CASE_12_OR_13, aber NICHT in Tabelle TMP_CODES_CASE_13 existieren 1. Teilenummern herausfiltern, die in der Tabelle TMP_CODES_CASE_12_OR_13, aber NICHT in Tabelle TMP_CODES_CASE_13 existieren
2. Zu den gefundenen Teilenummern: 2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_12 schreiben:
- Parent-Teilenr - Teilenr des Parents
- Posnr. laut neuer Stückliste - Positionsnummer laut alter Stückliste
- ID laut alter Stückliste - Positionsnummer laut neuer Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_12 schreiben.
Hinweis: Hinweis:
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen - Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können Stückliste herstellen zu können
- Die Teilenummer des Parents wird zusamment mit der Positionsnummer laut alter Stückliste dafür benötigt, um in den Tabellen STKL_REGEL und
VAR_TEIL_BEDINGUNG_2 die Zeilen zu ermitteln, die aktualisiert werden müssen
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_12") self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_12")
self.db.con.execute(""" self.db.con.execute("""
CREATE TABLE TMP_POSNRS_CASE_12 (COMP_ID INTEGER NOT NULL, CREATE TABLE TMP_POSNRS_CASE_12 (UEBTEILENR TEXT NOT NULL,
PARENT TEXT NOT NULL, POS_ALT INTEGER NOT NULL,
POSNR INTEGER NOT NULL, POS_NEU INTEGER NOT NULL)
PRIMARY KEY(POSNR))
""") """)
self.db.con.execute(""" self.db.con.execute("""
INSERT INTO TMP_POSNRS_CASE_12 (COMP_ID, PARENT, POSNR) INSERT INTO TMP_POSNRS_CASE_12 (UEBTEILENR, POS_ALT, POS_NEU)
SELECT C.ID AS COMP_ID, C.PARENT, RD.Positionsnummer AS POSNR SELECT C.UEBTEILENR, C.POSNR AS POS_ALT, RD.Positionsnummer AS POS_NEU
FROM RD_COMP RD FROM RD_COMP RD
LEFT JOIN TMP_CODES_CASE_13 TMP LEFT JOIN TMP_CODES_CASE_13 TMP
ON RD.ChildCode = TMP.KOMPTEILENR ON RD.ChildCode = TMP.KOMPTEILENR
LEFT JOIN COMP C LEFT JOIN COMP C
ON RD.ParentCode = C.PARENT ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR AND RD.ChildCode = C.KOMPTEILENR
AND RD.Positionsnummer = C.POSNR AND RD.Positionsnummer = C.POSNR
WHERE RD.ParentCode = :parent_code WHERE RD.ParentCode = :parent_code
AND TMP.KOMPTEILENR IS NULL AND TMP.KOMPTEILENR IS NULL
AND RD.Positionsnummer NOT IN (SELECT POSNR FROM TMP_POSNRS_CASE_11); AND RD.Positionsnummer NOT IN (SELECT POS_NEU FROM TMP_POSNRS_CASE_11)
""", {"parent_code": self.parent_code}) """, {"parent_code": self.parent_code})
def _get_case_131_positions(self): def _get_case_131_positions(self):
""" """
Fall 1.31 - Positionsnummern holen, die neu angelegt werden müssen. Fall 1.31 - Positionsnummern ermitteln, die neu angelegt werden müssen.
Deren Ermittlung funktioniert so: Deren Ermittlung funktioniert so:
1. Teilenummern herausfiltern, deren Teilenr-Längen-Kombination nur in der neuen Stückliste existieren und die zudem in der Tabelle 1. Alle Positionsnummern herausfiltern, auf die folgende Kriterien zutreffen:
TMP_CODES_CASE_13 vorliegen. - Teilenr-Längen-Kombination der Position existiert nur in der neuen Stückliste existiert
- Teilenummer der Position ist in der Tabelle TMP_CODES_CASE_13 enthalten
Hinweis: Hinweis:
Es reicht nicht aus, lediglich zu prüfen, ob die Teilenr-Längen-Kombination nur in der neuen Stücklist vorliegt Es reicht nicht aus, lediglich zu prüfen, ob die Teilenr-Längen-Kombination nur in der neuen Stückliste vorliegt
Grund: Grund:
Positionsnummern die unter Fall 1.2 fallen, dürfen in der neuen Stückliste eine andere Teilenr-Längen-Kombination Positionsnummern die unter Fall 1.2 fallen, dürfen in der neuen Stückliste eine andere Teilenr-Längen-Kombination
als in der alten Stückliste aufweisen, d.h. die Teilenr-Längen-Kombi laut neuer Stückliste liegt auch nur dort vor. Trotzdem als in der alten Stückliste aufweisen, d.h. die Teilenr-Längen-Kombi laut neuer Stückliste liegt auch nur dort vor. Trotzdem
werden diese Positionsnummern nicht neu angelegt, sondern von der alten in die neuen Stückliste verschoben! werden diese Positionsnummern nicht neu angelegt, sondern von der alten in die neuen Stückliste verschoben!
2. Zu den gefundenen Teilenummern: 2. Alle gefundenen Positionen in die temporäre Tabelle TMP_POSNRS_CASE_131 schreiben (mehr Informationen werden nicht benötigt)
- Parent-Teilenr """
- Posnr. laut neuer Stückliste
- ID laut alter Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_131 schreiben.
Hinweis:
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können
"""
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_131") self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_131")
self.db.con.execute("CREATE TABLE TMP_POSNRS_CASE_131 (POSNR INTEGER NOT NULL, PRIMARY KEY(POSNR))")
self.db.con.execute("CREATE TABLE TMP_POSNRS_CASE_131 (POSNR INTEGER NOT NULL)")
self.db.con.execute(""" self.db.con.execute("""
INSERT INTO TMP_POSNRS_CASE_131 INSERT INTO TMP_POSNRS_CASE_131
@@ -486,13 +494,13 @@ class BOMProcessing:
FROM RD_COMP RD FROM RD_COMP RD
LEFT JOIN COMP C LEFT JOIN COMP C
ON RD.ParentCode = C.PARENT ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR AND RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0) AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
WHERE RD.ParentCode = :parent_code WHERE RD.ParentCode = :parent_code
AND RD.ChildCode IN (SELECT * FROM TMP_CODES_CASE_13) AND RD.ChildCode IN (SELECT KOMPTEILENR FROM TMP_CODES_CASE_13)
AND C.KOMPTEILENR IS NULL; AND C.KOMPTEILENR IS NULL
""", {"parent_code": self.parent_code}) """, {"parent_code": self.parent_code})
def _get_case_132_positions(self) -> None: def _get_case_132_positions(self) -> None:
@@ -500,63 +508,76 @@ class BOMProcessing:
Fall 1.32 - Positionsnummern holen, die von der alten in die neue Stückliste verschoben werden Fall 1.32 - Positionsnummern holen, die von der alten in die neue Stückliste verschoben werden
Deren Ermittlung funktioniert so: Deren Ermittlung funktioniert so:
1. Teilenummern herausfiltern, deren Teilenr-Längen-Kombination in beiden Stückliste existieren und die zudem in der Tabelle 1. Alle Positionsnummern herausfiltern, auf die folgende Kriterien zutreffen:
TMP_CODES_CASE_13 vorliegen. Lediglich zu prüfen, ob die Teilenr-Längen-Kombination nur in der neuen Stückliste vorliegt reicht nicht aus! - Teilenr-Längen-Kombination existiert in beiden Stücklisten
- Teilenummer der Position ist in der Tabelle TMP_CODES_CASE_13 enthalten
Hinweis:
Es reicht nicht aus, lediglich zu prüfen, ob die Teilenr-Längen-Kombination in beiden Stücklisten vorliegt
Grund: Grund:
Positionsnummern die Fall 1.1 zugeordnet werden können oder Positionsnummern, die unter Fall 1.2 fallen und deren Länge dabei in beiden Positionsnummern die Fall 1.1 zugeordnet werden können oder Positionsnummern, die unter Fall 1.2 fallen und deren Länge dabei in beiden
Stücklisten gleich bleibt würden grundlegend ebenfalls unter Fall 1.32 fallen und somit identifiziert werden. Stücklisten gleich bleibt würden grundlegend ebenfalls unter Fall 1.32 fallen und somit identifiziert werden.
Es gilt jedoch das Vorrangsprinzip, d.h. die Zuordnung zu Fall 1.1 oder Fall 1.2 erfolgt (sofern möglich) immer vor der Zuordnung Es gilt jedoch das Prioritätsprinzip, d.h. die Zuordnung zu Fall 1.1 oder Fall 1.2 erfolgt (sofern möglich) immer vor der Zuordnung
zu Fall 1.32! zu Fall 1.32!
2. Zu den gefundenen Teilenummern: 2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_132 schreiben:
- Parent-Teilenr - Teilenr des Parents
- Posnr. laut neuer Stückliste - Positionsnummer laut alter Stückliste
- ID laut alter Stückliste - Positionsnummer laut neuer Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_132 schreiben.
Hinweis: Hinweis:
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen - Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können Stückliste herstellen zu können
- Die Teilenummer des Parents wird zusamment mit der Positionsnummer laut alter Stückliste dafür benötigt, um in den Tabellen STKL_REGEL und
VAR_TEIL_BEDINGUNG_2 die Zeilen zu ermitteln, die aktualisiert werden müssen
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_132") self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_132")
self.db.con.execute("""
CREATE TABLE TMP_POSNRS_CASE_132 (COMP_ID INTEGER NOT NULL,
PARENT TEXT NOT NULL,
POSNR INTEGER NOT NULL,
PRIMARY KEY(POSNR))""")
self.db.con.execute("""
INSERT INTO TMP_POSNRS_CASE_132 (COMP_ID, PARENT, POSNR)
SELECT C.ID AS COMP_ID, C.PARENT, RD.Positionsnummer AS POSNR self.db.con.execute("""
CREATE TABLE TMP_POSNRS_CASE_132 (UEBTEILENR TEXT NOT NULL,
POS_ALT INTEGER NOT NULL,
POS_NEU INTEGER NOT NULL)
""")
self.db.con.execute("""
INSERT INTO TMP_POSNRS_CASE_132 (UEBTEILENR, POS_ALT, POS_NEU)
SELECT C.UEBTEILENR, C.POSNR AS POS_ALT, RD.Positionsnummer AS POS_NEU
FROM RD_COMP RD FROM RD_COMP RD
INNER JOIN COMP C INNER JOIN COMP C
ON RD.ParentCode = C.PARENT ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR AND RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0) AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
WHERE RD.ParentCode = :parent_code WHERE RD.ParentCode = :parent_code
AND RD.ChildCode IN (SELECT * FROM TMP_CODES_CASE_13) AND RD.ChildCode IN (SELECT KOMPTEILENR FROM TMP_CODES_CASE_13)
""", {"parent_code": self.parent_code}) """, {"parent_code": self.parent_code})
def delete(self): def _get_ids_to_delete(self) -> None:
""" """
Entfernt die Positionsnummern aus der alten Stückliste, die nicht mehr in der neuen Stückliste vorliegen. Ermittelt alle Positionsnummern, die entfernt werden sollen
Hinweis: Hinweis:
Bei der Ermittlung der zu löschenden Datensätze dürfen die Positionsnummern, die verschoben werden NICHT berücksichtigt werden. Bei der Ermittlung dürfen die Positionsnummern, die verschoben werden NICHT berücksichtigt werden. Die alte Lösch-Logik:
Die alte Lösch-Logik: "Die Teile die in der neuen Stückliste nicht drin sind, werden rausgelöscht" nur noch eingeschränkt anwendbar! "Die Teile die in der neuen Stückliste nicht drin sind, werden rausgelöscht"
ist daher nur noch eingeschränkt anwendbar!
Grund: Grund:
Das liegt vor allem an Fall 1.2, denn per Definition darf in diesem Fall die Länge in der neuen Stückliste abweichen, solange alle Das liegt vor allem an Fall 1.2, denn per Definition darf in diesem Fall die Länge in der neuen Stückliste abweichen, solange alle
Teilenr-Posnr-Kombinationen in beiden Stücklisten identsich sind, siehe hierzu z.B. Pos. 3 in Beispiel 3 unter doc/Beispiele.pdf: Teilenr-Posnr-Kombinationen in beiden Stücklisten identsich sind, siehe hierzu z.B. Pos. 3 in Beispiel 3 unter doc/Beispiele.pdf:
Dort liegt die Länge 200 aus der alten Stückliste nicht mehr in der neuen Stückliste vor. Pos. 3 würde also laut alter Logik gelöscht werden. Dort liegt die Länge 200 aus der alten Stückliste nicht mehr in der neuen Stückliste vor. Pos. 3 würde also laut alter Logik gelöscht werden.
Da diese Positionsnummer aber unter Fall 1.2 fällt, wird sie in die neue Stückliste verschoben, d.h. sie darf nicht gelöscht werden! Da diese Positionsnummer aber unter Fall 1.2 fällt, wird sie in die neue Stückliste verschoben, darf also nicht gelöscht werden!
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_IDS_TO_DELETE") self.db.con.execute("DROP TABLE IF EXISTS TMP_IDS_TO_DELETE")
self.db.con.execute("CREATE TABLE TMP_IDS_TO_DELETE (ID INTEGER NOT NULL, PRIMARY KEY(ID))")
self.db.con.execute("""CREATE TABLE TMP_IDS_TO_DELETE (COMP_ROWID INTEGER NOT NULL,
VAR_TEIL_BED_2_ROWID INTEGER,
STKL_REGEL_ROWID INTEGER)
""")
self.db.con.execute(""" self.db.con.execute("""
WITH COMBINED_UPDATE_DATA AS ( WITH COMBINED_UPDATE_DATA AS (
SELECT * FROM TMP_POSNRS_CASE_11 SELECT * FROM TMP_POSNRS_CASE_11
@@ -565,45 +586,55 @@ class BOMProcessing:
UNION UNION
SELECT * FROM TMP_POSNRS_CASE_132 SELECT * FROM TMP_POSNRS_CASE_132
) )
INSERT INTO TMP_IDS_TO_DELETE INSERT INTO TMP_IDS_TO_DELETE (COMP_ROWID, VAR_TEIL_BED_2_ROWID, STKL_REGEL_ROWID)
SELECT C.ID SELECT C.ROWID AS COMP_ROWID, B.ROWID AS VAR_TEIL_BED_2_ROWID, R.ROWID AS STKL_REGEL_ROWID
FROM COMP C FROM COMP C
LEFT JOIN COMBINED_UPDATE_DATA CUD LEFT JOIN COMBINED_UPDATE_DATA CUD
ON C.ID = CUD.COMP_ID ON C.UEBTEILENR = CUD.UEBTEILENR
AND C.POSNR = CUD.POS_ALT
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
ON C.UEBTEILENR = B.UEBTEILENR
AND C.POSNR = B.POSNR
LEFT JOIN STKL_REGEL R
ON C.UEBTEILENR = R.UEBTEILENR
AND C.POSNR = R.POSNR
WHERE C.PARENT = :parent_code WHERE C.UEBTEILENR = :parent_code
AND CUD.COMP_ID IS NULL AND CUD.UEBTEILENR IS NULL
""", {"parent_code": self.parent_code}) """, {"parent_code": self.parent_code})
# Entfernung der Stücklistenpositionen aus COMP def _get_update_data(self):
self.db.con.execute("DELETE FROM COMP WHERE ID IN (SELECT ID FROM TMP_IDS_TO_DELETE)")
# Entfernung der TOS-Bedingungen aus VAR_TEIL_BEDINGUNG_2
self.db.con.execute("DELETE FROM VAR_TEIL_BEDINGUNG_2 WHERE COMP_ID IN (SELECT ID FROM TMP_IDS_TO_DELETE)")
# Entfernung der TOS-Regeln aus STKL_REGEL
self.db.con.execute("DELETE FROM STKL_REGEL WHERE COMP_ID IN (SELECT ID FROM TMP_IDS_TO_DELETE)")
def update(self):
""" """
Aktualisiert die Positionsnummern, die von der alten in die neue Stückliste verschoben werden sollen. Ermittlung der neuen Stücklisteninformationen, mit denen die bestehenden Datzensätze überschrieben werden
Dies umfasst alle Positionsnummern, die unter die Fälle 1.1, 1.2 und 1.32 fallen. Sie wurden in den Methoden Die neuen Informationen werden für alle Positionsnummern bestimmt, die unter die Fälle 1.1, 1.2 und 1.32 fallen,
_get_case_11_positions, _get_case_12_positions & _get_case_132_positions ermittelt und in die temporären also die, die sich in den Tabellen TMP_POSNRS_CASE_11, TMP_POSNRS_CASE_12 & TMP_POSNRS_CASE_132 befinden.
Tabellen TMP_POSNRS_CASE_11, TMP_POSNRS_CASE_12, TMP_POSNRS_CASE_132 geschrieben.
Jetzt passiert folgendes: Hinweis:
1. Die Positionen aus den 3 Tabellen werden zu einer temporären Tabelle, ALL_POSNRS_TO_UPDATE kombiniert. Es werden in diesem Zuge auch die zugehörigen Zeilen-ID's zu den Positionsnummern in den Tabellen VAR_TEIL_BEDINGUNG_2 und STKL_REGEL ermittelt,
2. Zu allen Positionen aus in dieser kombinierten, temporären Tabelle werden dann die neuen Stücklisteninformationen aus COMP, da in diesen Tabellen ebenfalls die Positionsnummern aktualisiert werden müssen, sofern welche vorliegen. Die Regeln und Bedingungen selbst
bzw. RD_COMP bestimmt und in eine weitere, temporäre, aber persistente Tabelle TMP_UPDATE_DATA geschrieben. bleiben unverändert, da sie nur verschoben werden.
3. Durchführen der Updates in den Tabellen COMP (für die Stücklisteninformationen), VAR_TEIL_BEDINGUNG_2 (für die TOS-Bedingungen)
und STKL_REGEL für die TOS-Regeln
""" """
self.db.con.execute("DROP TABLE IF EXISTS TMP_UPDATE_DATA") self.db.con.execute("DROP TABLE IF EXISTS TMP_UPDATE_DATA")
self.db.con.execute("CREATE TABLE TMP_UPDATE_DATA (ID, POSNR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE, BEDINGUNG, REGEL)")
# Neue Stücklisteninformationen ermitteln self.db.con.execute("""
CREATE TABLE TMP_UPDATE_DATA (COMP_ROWID INTEGER NOT NULL,
VAR_TEIL_BED_2_ROWID INTEGER,
STKL_REGEL_ROWID INTEGER,
POS_ALT INTEGER NOT NULL,
POS_NEU INTEGER NOT NULL,
ABW_ANZAHL INTEGER,
MENGE REAL,
LAENGE REAL,
ZUSCHNITT REAL,
DISPO_AKTIV_JN TEXT,
RUESTCODE TEXT)
""")
self.db.con.execute(""" self.db.con.execute("""
WITH ALL_POSNRS_TO_UPDATE AS ( WITH ALL_POSNRS_TO_UPDATE AS (
SELECT * FROM TMP_POSNRS_CASE_11 SELECT * FROM TMP_POSNRS_CASE_11
@@ -612,54 +643,87 @@ class BOMProcessing:
UNION UNION
SELECT * FROM TMP_POSNRS_CASE_132 SELECT * FROM TMP_POSNRS_CASE_132
) )
INSERT INTO TMP_UPDATE_DATA (ID, POSNR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE, BEDINGUNG, REGEL) INSERT INTO TMP_UPDATE_DATA (COMP_ROWID,
VAR_TEIL_BED_2_ROWID,
STKL_REGEL_ROWID,
POS_ALT,
POS_NEU,
ABW_ANZAHL,
MENGE,
LAENGE,
ZUSCHNITT,
DISPO_AKTIV_JN,
RUESTCODE)
SELECT C.ID, SELECT C.ROWID AS COMP_ROWID,
RD.Positionsnummer AS POSNR, B.ROWID AS VAR_TEIL_BED_2_ROWID,
R.ROWID AS STKL_REGEL_ROWID,
P.POS_ALT,
RD.Positionsnummer AS POS_NEU,
-- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV -- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV
CASE CASE
WHEN RD.Uebergabelaenge = 0 THEN NULL WHEN RD.Uebergabelaenge = 0 THEN NULL
ELSE RD.Menge ELSE RD.Menge
END AS ABW_ANZAHL, END AS ABW_ANZAHL,
-- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV -- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV
CASE CASE
WHEN RD.Uebergabelaenge = 0 THEN RD.Menge WHEN RD.Uebergabelaenge = 0 THEN RD.Menge
ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT, 0)) / 1000 ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT, 0)) / 1000
END AS MENGE, END AS MENGE,
-- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV -- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV
CASE CASE
WHEN RD.Uebergabelaenge = 0 THEN NULL WHEN RD.Uebergabelaenge = 0 THEN NULL
ELSE RD.Uebergabelaenge ELSE RD.Uebergabelaenge
END AS LAENGE, END AS LAENGE,
C.ZUSCHNITT, C.ZUSCHNITT,
C.DISPO_AKTIV_JN, C.DISPO_AKTIV_JN,
C.RUESTCODE, C.RUESTCODE
B.BEDINGUNG,
R.REGEL
FROM ALL_POSNRS_TO_UPDATE CUD FROM ALL_POSNRS_TO_UPDATE P
INNER JOIN COMP C INNER JOIN COMP C
ON CUD.COMP_ID = C.ID ON P.UEBTEILENR = C.UEBTEILENR
AND P.POS_ALT = C.POSNR
INNER JOIN RD_COMP RD INNER JOIN RD_COMP RD
ON CUD.PARENT = RD.ParentCode ON P.UEBTEILENR = RD.ParentCode
AND CUD.POSNR = RD.Positionsnummer AND P.POS_NEU = RD.Positionsnummer
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
ON CUD.COMP_ID = B.COMP_ID ON P.UEBTEILENR = B.UEBTEILENR
AND P.POS_ALT = B.POSNR
LEFT JOIN STKL_REGEL R LEFT JOIN STKL_REGEL R
ON CUD.COMP_ID = R.COMP_ID ON P.UEBTEILENR = R.UEBTEILENR
AND P.POS_ALT = R.POSNR
""") """)
def delete(self):
"""
- Entfernt die Positionsnummern aus COMP, die nicht mehr in der neuen Stückliste vorliegen
- Entfernt die TOS-Regeln und -Bedingungen der Positionsnummern aus VAR_TEIL_BEDINGUNG_2 und STKL_REGEL
"""
# Stücklistenpositionen entfernen
self.db.con.execute("DELETE FROM COMP WHERE ROWID IN (SELECT COMP_ROWID FROM TMP_IDS_TO_DELETE)")
# TOS-Bedingungen entfernen
self.db.con.execute("DELETE FROM VAR_TEIL_BEDINGUNG_2 WHERE ROWID IN (SELECT VAR_TEIL_BED_2_ROWID FROM TMP_IDS_TO_DELETE)")
# TOS-Regeln entfernen
self.db.con.execute("DELETE FROM STKL_REGEL WHERE ROWID IN (SELECT STKL_REGEL_ROWID FROM TMP_IDS_TO_DELETE)")
def update(self):
"""
Aktualisiert die Positionsnummern, deren Spaltenanpassungen und TOS-Regeln / -Bedingungen von der alten in die neue Stückliste übernommen werden sollen.
"""
# Stücklisteninformationen updaten # Stücklisteninformationen updaten
self.db.con.execute(""" self.db.con.execute("""
UPDATE COMP UPDATE COMP
SET POSNR = UD.POSNR, SET
POSNR = UD.POS_NEU,
ABW_ANZAHL = UD.ABW_ANZAHL, ABW_ANZAHL = UD.ABW_ANZAHL,
MENGE = UD.MENGE, MENGE = UD.MENGE,
LAENGE = UD.LAENGE, LAENGE = UD.LAENGE,
@@ -667,79 +731,78 @@ class BOMProcessing:
DISPO_AKTIV_JN = UD.DISPO_AKTIV_JN, DISPO_AKTIV_JN = UD.DISPO_AKTIV_JN,
RUESTCODE = UD.RUESTCODE RUESTCODE = UD.RUESTCODE
FROM TMP_UPDATE_DATA UD FROM TMP_UPDATE_DATA UD
WHERE COMP.ID = UD.ID WHERE ROWID = UD.COMP_ROWID
""") """)
# TOS-Bedingungen updaten # TOS-Bedingungen updaten
self.db.con.execute(""" self.db.con.execute("""
UPDATE VAR_TEIL_BEDINGUNG_2 UPDATE VAR_TEIL_BEDINGUNG_2
SET BEDINGUNG = UD.BEDINGUNG SET POSNR = UD.POS_NEU
FROM TMP_UPDATE_DATA UD FROM TMP_UPDATE_DATA UD
WHERE COMP_ID = UD.ID WHERE ROWID = UD.VAR_TEIL_BED_2_ROWID
""") """)
# TOS-Regeln updaten # TOS-Regeln updaten
self.db.con.execute(""" self.db.con.execute("""
UPDATE STKL_REGEL UPDATE STKL_REGEL
SET REGEL = UD.REGEL SET POSNR = UD.POS_NEU
FROM TMP_UPDATE_DATA UD FROM TMP_UPDATE_DATA UD
WHERE COMP_ID = UD.ID WHERE ROWID = UD.STKL_REGEL_ROWID
""") """)
def insert(self): def insert(self):
""" """
Neuanlage aller Positionen, die nur in der neuen Stückliste vorliegen. Neuanlage aller Positionen, die nur in der neuen Stückliste vorliegen (das sind die aus der Tabelle TMP_POSNRS_CASE_131)
Die Positionsnummern wurde bereits in der Methode _get_codes_case_131 ermittelt und in die temporäre Tabelle
TMP_POSNRS_CASE_131 geschrieben.
Hinweise: Hinweise:
- Neue Positionen werden immer ohne TOS-Regeln oder -Bedingungen angelegt, d.h. es erfolgen keine INSERT-Statements - Neue Positionen werden immer ohne TOS-Regeln oder -Bedingungen angelegt, d.h. es erfolgen keine INSERT-Statements
in den Tabellen VAR_TEIL_BEDINGUNG_2 oder STKL_REGEL! in den Tabellen VAR_TEIL_BEDINGUNG_2 oder STKL_REGEL!
- Zur Verdeutlichung, welche Werte z.B. in der Spalte Ruestcode oder Dispoaktiv nach der Neuanlage vorliegen, werden - Zur Verdeutlichung, welche Werte z.B. in der Spalte Ruestcode oder Dispoaktiv nach der Neuanlage vorliegen, werden
die Defaultwerte aus der PARTS-Tabelle geholt. Ob ein solcher INSERT auch in SIVAS erforderlich ist, war zum Zeitpunkt die Defaultwerte aus der PARTS-Tabelle geholt. Ob ein solcher INSERT auch in SIVAS erforderlich ist, war zum Zeitpunkt
der Erstellung nicht klar. der Erstellung dieses Scripts nicht klar.
""" """
self.db.con.execute(""" self.db.con.execute("""
INSERT INTO COMP (PARENT, POSNR, KOMPTEILENR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE) INSERT INTO COMP (UEBTEILENR, POSNR, KOMPTEILENR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE)
SELECT RD.ParentCode AS PARENT, SELECT RD.ParentCode AS UEBTEILENR,
RD.Positionsnummer AS POSNR, RD.Positionsnummer AS POSNR,
RD.ChildCode AS KOMPTEILENR, RD.ChildCode AS KOMPTEILENR,
-- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV -- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV
CASE CASE
WHEN RD.Uebergabelaenge = 0 THEN NULL WHEN RD.Uebergabelaenge = 0 THEN NULL
ELSE RD.Menge ELSE RD.Menge
END AS ABW_ANZAHL, END AS ABW_ANZAHL,
-- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV -- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV
CASE CASE
WHEN RD.Uebergabelaenge = 0 THEN RD.Menge WHEN RD.Uebergabelaenge = 0 THEN RD.Menge
ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT,0)) / 1000 ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT, 0)) / 1000
END AS MENGE, END AS MENGE,
-- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV -- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV
CASE CASE
WHEN RD.Uebergabelaenge = 0 THEN NULL WHEN RD.Uebergabelaenge = 0 THEN NULL
ELSE RD.Uebergabelaenge ELSE RD.Uebergabelaenge
END AS LAENGE, END AS LAENGE,
NULL AS ZUSCHNITT,
P.DISPO_AKTIV_JN, NULL AS ZUSCHNITT,
P.RUESTCODE P.DISPO_AKTIV_JN,
P.RUESTCODE
FROM RD_COMP RD FROM RD_COMP RD
LEFT JOIN COMP C LEFT JOIN COMP C
ON RD.ChildCode = C.KOMPTEILENR ON RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0) AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
AND RD.ParentCode = C.PARENT AND RD.ParentCode = C.UEBTEILENR
LEFT JOIN PARTS P LEFT JOIN PARTS P
ON RD.ChildCode = P.TEILENR ON RD.ChildCode = P.TEILENR
WHERE C.KOMPTEILENR IS NULL WHERE C.KOMPTEILENR IS NULL
AND RD.ParentCode = :parent_code AND RD.ParentCode = :parent_code
AND RD.Positionsnummer IN (SELECT * FROM TMP_POSNRS_CASE_131) AND RD.Positionsnummer IN (SELECT POSNR FROM TMP_POSNRS_CASE_131)
""", {"parent_code": self.parent_code}) """, {"parent_code": self.parent_code})
def drop_tmp_tables(self): def drop_tmp_tables(self):
@@ -752,7 +815,6 @@ class BOMProcessing:
self.db.con.execute("DROP TABLE TMP_IDS_TO_DELETE") self.db.con.execute("DROP TABLE TMP_IDS_TO_DELETE")
self.db.con.execute("DROP TABLE TMP_UPDATE_DATA") self.db.con.execute("DROP TABLE TMP_UPDATE_DATA")
def write_new_bom(self) -> None: def write_new_bom(self) -> None:
self._get_codes_case_12_or_13() self._get_codes_case_12_or_13()
self._get_codes_case_13() self._get_codes_case_13()
@@ -760,6 +822,8 @@ class BOMProcessing:
self._get_case_12_positions() self._get_case_12_positions()
self._get_case_131_positions() self._get_case_131_positions()
self._get_case_132_positions() self._get_case_132_positions()
self._get_ids_to_delete()
self._get_update_data()
self.delete() self.delete()
self.insert() self.insert()
self.update() self.update()