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;
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" (
"ID" INTEGER NOT NULL,
"PARENT" TEXT NOT NULL,
"ROWID" INTEGER NOT NULL,
"UEBTEILENR" TEXT NOT NULL,
"POSNR" INTEGER NOT NULL,
"KOMPTEILENR" TEXT NOT NULL,
"DISPO_AKTIV_JN" TEXT,
@@ -17,7 +10,7 @@ CREATE TABLE IF NOT EXISTS "COMP" (
"LAENGE" REAL,
"ZUSCHNITT" TEXT,
"RUESTCODE" TEXT,
PRIMARY KEY("ID" AUTOINCREMENT)
PRIMARY KEY("ROWID" AUTOINCREMENT)
);
CREATE TABLE IF NOT EXISTS "PARTS" (
"TEILENR" INTEGER,
@@ -47,34 +40,24 @@ CREATE TABLE IF NOT EXISTS "PARTS" (
"STATUS" TEXT
);
CREATE TABLE IF NOT EXISTS "STKL_REGEL" (
"ID" INTEGER NOT NULL,
"COMP_ID" INTEGER,
"REGEL" INTEGER NOT NULL,
PRIMARY KEY("ID" AUTOINCREMENT),
CONSTRAINT "FK_COMP_ID" FOREIGN KEY("COMP_ID") REFERENCES "COMP"("ID")
"ROWID" INTEGER NOT NULL,
"UEBTEILENR" INTEGER,
"POSNR" INTEGER,
"LFD_NR" INTEGER NOT NULL,
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" (
"ID" INTEGER NOT NULL,
"COMP_ID" INTEGER NOT NULL,
"BEDINGUNG" INTEGER NOT NULL,
PRIMARY KEY("ID" AUTOINCREMENT),
CONSTRAINT "FK_COMP_ID" FOREIGN KEY("COMP_ID") REFERENCES "COMP"("ID")
"ROWID" INTEGER NOT NULL,
"UEBTEILENR" TEXT NOT NULL,
"POSNR" INTEGER NOT NULL,
"UEB_LEISTEN_NR" INTEGER NOT NULL,
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),
(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'),
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,'000000380',20,'829416035','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'),
@@ -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'),
(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');
INSERT INTO "VAR_TEIL_BEDINGUNG_2" ("ID","COMP_ID","BEDINGUNG") VALUES (1,6,418),
(2,8,420),
(3,35,419),
(4,10,419),
(5,12,420),
(6,14,418),
(7,15,419),
(8,16,420),
(9,18,417),
(10,19,418),
(11,21,417),
(12,22,418),
(13,24,419),
(14,25,417),
(15,26,418),
(16,28,419),
(17,29,417),
(18,34,419),
(19,37,418),
(20,39,419),
(21,1,417),
(22,2,418),
(23,4,419),
(24,5,420),
(25,40,7),
(26,41,7),
(27,42,2),
(28,43,7),
(29,44,3),
(30,45,11),
(31,46,11),
(32,47,3),
(33,48,1),
(34,49,5),
(35,50,2),
(36,51,6),
(37,52,3),
(38,53,4),
(39,54,4),
(40,55,4),
(41,56,6),
(42,57,1),
(43,58,3),
(44,59,7),
(45,60,7),
(46,61,8),
(47,62,7),
(48,63,10),
(49,64,11),
(50,65,11);
INSERT INTO "VAR_TEIL_BEDINGUNG_2" ("ROWID","UEBTEILENR","POSNR","UEB_LEISTEN_NR") VALUES (1,'000000369',10,418),
(2,'000000369',30,420),
(3,'000000370',10,419),
(4,'000000371',10,419),
(5,'000000371',30,420),
(6,'000000372',10,418),
(7,'000000372',20,419),
(8,'000000372',30,420),
(9,'000000373',10,417),
(10,'000000373',20,418),
(11,'000000374',10,417),
(12,'000000374',20,418),
(13,'000000374',40,419),
(14,'000000375',10,417),
(15,'000000375',20,418),
(16,'000000375',40,419),
(17,'000000376',10,417),
(18,'000000378',10,419),
(19,'000000379',20,418),
(20,'000000379',40,419),
(21,'000000380',10,417),
(22,'000000380',20,418),
(23,'000000380',40,419),
(24,'000000380',50,420),
(25,'000000381',10,7),
(26,'000000381',20,7),
(27,'000000381',30,2),
(28,'000000381',40,7),
(29,'000000381',50,3),
(30,'000000381',60,11),
(31,'000000381',70,11),
(32,'000000381',80,3),
(33,'000000382',10,1),
(34,'000000382',20,5),
(35,'000000382',30,2),
(36,'000000382',40,6),
(37,'000000382',50,3),
(38,'000000382',60,4),
(39,'000000382',70,4),
(40,'000000382',80,4),
(41,'000000382',90,6),
(42,'000000382',100,1),
(43,'000000382',110,3),
(44,'000000382',120,7),
(45,'000000382',130,7),
(46,'000000382',140,8),
(47,'000000382',150,7),
(48,'000000382',160,10),
(49,'000000382',170,11),
(50,'000000382',180,11);
COMMIT;
lib/process_bom.py
+214 -150
View File
@@ -232,32 +232,36 @@ class RD_COMP:
def get_verbose_data(self) -> list[dict[str]]:
res = self.db.con.execute("""
SELECT C.*, R.REGEL, B.BEDINGUNG
SELECT C.*, R.LFD_NR, B.UEB_LEISTEN_NR
FROM COMP C
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
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
""", {"parent_code": self.parent_code}).fetchall()
return res
def get_compact_data(self) -> list[dict[str]]:
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
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
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
""", {"parent_code": self.parent_code}).fetchall()
return res
@@ -290,26 +294,26 @@ class BOMProcessing:
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.
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:
1. Teilenr-Längen-Kombinationen aus der alten und neuen Stückliste mit UNION ALL zusammenfügen
2. Mit COUNT ermitteln, wie oft jede Teilenummer-Längen-Kombination in der zusammengefügten 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
=> 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, wenn alle Teilenr-Längen-Kombinationen exakt 2x auftreten!
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 verschmolzenen Stückliste auftritt
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 Fall 1.1 nur dann möglich ist,
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("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("""
WITH combined_bom AS (
SELECT C.KOMPTEILENR, COALESCE(C.LAENGE, 0) AS LAENGE
FROM COMP C
WHERE C.PARENT = :parent_code
WHERE C.UEBTEILENR = :parent_code
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
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
sie Fall 1.32 auf diese Positionen zutreffen würde (Vorrangsprinzip).
Wenn Positionen bereits unter Fall 1.1 oder Fall 1.2 fallen, dann werden sie NICHT Fall 1.32 zugeordnet, selbst wenn
Fall 1.32 auf diese Positionen zutreffen würde.
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())
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
=> Diese Teilenummern unterliegen definitv Fall 1.3, weil in Fall 1.2 alle Teilenr-Posnr-Kombinationen exakt 2x auftreten müssen!
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 einer Teilenummer exakt 2x auftreten müssen!
"""
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("""
WITH combined_bom AS (
SELECT KOMPTEILENR, POSNR
FROM COMP
WHERE PARENT = :parent_code
WHERE UEBTEILENR = :parent_code
AND KOMPTEILENR IN (SELECT * FROM TMP_CODES_CASE_12_OR_13)
UNION ALL
@@ -378,31 +382,36 @@ class BOMProcessing:
Deren Ermittlung funktioniert so:
1. Teilenummern herausfiltern, die NICHT in der Tabelle TMP_CODES_CASE_12_OR_13 vorliegen
2. Zu den gefundenen Teilenummern:
- Parent-Teilenr
- Posnr. laut neuer Stückliste
- ID laut alter Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_11 schreiben.
2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_11 schreiben:
- Teilenr des Parents
- Positionsnummer laut alter Stückliste
- Positionsnummer laut neuer Stückliste
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
- Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
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("""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
LEFT JOIN TMP_CODES_CASE_12_OR_13 TMP
ON RD.ChildCode = TMP.KOMPTEILENR
LEFT JOIN COMP C
ON RD.ParentCode = C.PARENT
ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
@@ -416,69 +425,68 @@ class BOMProcessing:
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
2. Zu den gefundenen Teilenummern:
- Parent-Teilenr
- Posnr. laut neuer Stückliste
- ID laut alter Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_12 schreiben.
2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_12 schreiben:
- Teilenr des Parents
- Positionsnummer laut alter Stückliste
- Positionsnummer laut neuer Stückliste
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
- Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
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("""
CREATE TABLE TMP_POSNRS_CASE_12 (COMP_ID INTEGER NOT NULL,
PARENT TEXT NOT NULL,
POSNR INTEGER NOT NULL,
PRIMARY KEY(POSNR))
CREATE TABLE TMP_POSNRS_CASE_12 (UEBTEILENR TEXT NOT NULL,
POS_ALT INTEGER NOT NULL,
POS_NEU INTEGER NOT NULL)
""")
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
LEFT JOIN TMP_CODES_CASE_13 TMP
ON RD.ChildCode = TMP.KOMPTEILENR
LEFT JOIN COMP C
ON RD.ParentCode = C.PARENT
ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR
AND RD.Positionsnummer = C.POSNR
WHERE RD.ParentCode = :parent_code
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})
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:
1. Teilenummern herausfiltern, deren Teilenr-Längen-Kombination nur in der neuen Stückliste existieren und die zudem in der Tabelle
TMP_CODES_CASE_13 vorliegen.
1. Alle Positionsnummern herausfiltern, auf die folgende Kriterien zutreffen:
- 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:
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:
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
werden diese Positionsnummern nicht neu angelegt, sondern von der alten in die neuen Stückliste verschoben!
2. Zu den gefundenen Teilenummern:
- 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
2. Alle gefundenen Positionen in die temporäre Tabelle TMP_POSNRS_CASE_131 schreiben (mehr Informationen werden nicht benötigt)
"""
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("""
INSERT INTO TMP_POSNRS_CASE_131
@@ -486,13 +494,13 @@ class BOMProcessing:
FROM RD_COMP RD
LEFT JOIN COMP C
ON RD.ParentCode = C.PARENT
ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
WHERE RD.ParentCode = :parent_code
AND RD.ChildCode IN (SELECT * FROM TMP_CODES_CASE_13)
AND C.KOMPTEILENR IS NULL;
AND RD.ChildCode IN (SELECT KOMPTEILENR FROM TMP_CODES_CASE_13)
AND C.KOMPTEILENR IS NULL
""", {"parent_code": self.parent_code})
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
Deren Ermittlung funktioniert so:
1. Teilenummern herausfiltern, deren Teilenr-Längen-Kombination in beiden Stückliste existieren und die zudem in der Tabelle
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!
1. Alle Positionsnummern herausfiltern, auf die folgende Kriterien zutreffen:
- 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:
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.
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!
2. Zu den gefundenen Teilenummern:
- Parent-Teilenr
- Posnr. laut neuer Stückliste
- ID laut alter Stückliste
in die temporäre Tabelle TMP_POSNRS_CASE_132 schreiben.
2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_132 schreiben:
- Teilenr des Parents
- Positionsnummer laut alter Stückliste
- Positionsnummer laut neuer Stückliste
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
- Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
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("""
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
INNER JOIN COMP C
ON RD.ParentCode = C.PARENT
ON RD.ParentCode = C.UEBTEILENR
AND RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
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})
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:
Bei der Ermittlung der zu löschenden Datensätze dürfen die Positionsnummern, die verschoben werden NICHT berücksichtigt werden.
Die alte Lösch-Logik: "Die Teile die in der neuen Stückliste nicht drin sind, werden rausgelöscht" nur noch eingeschränkt anwendbar!
Bei der Ermittlung dürfen die Positionsnummern, die verschoben werden NICHT berücksichtigt werden. Die alte Lösch-Logik:
"Die Teile die in der neuen Stückliste nicht drin sind, werden rausgelöscht"
ist daher nur noch eingeschränkt anwendbar!
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
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.
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("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("""
WITH COMBINED_UPDATE_DATA AS (
SELECT * FROM TMP_POSNRS_CASE_11
@@ -565,45 +586,55 @@ class BOMProcessing:
UNION
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
LEFT JOIN COMBINED_UPDATE_DATA CUD
ON C.ID = CUD.COMP_ID
ON C.UEBTEILENR = CUD.UEBTEILENR
AND C.POSNR = CUD.POS_ALT
WHERE C.PARENT = :parent_code
AND CUD.COMP_ID IS NULL
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.UEBTEILENR = :parent_code
AND CUD.UEBTEILENR IS NULL
""", {"parent_code": self.parent_code})
# Entfernung der Stücklistenpositionen aus COMP
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):
def _get_update_data(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
_get_case_11_positions, _get_case_12_positions & _get_case_132_positions ermittelt und in die temporären
Tabellen TMP_POSNRS_CASE_11, TMP_POSNRS_CASE_12, TMP_POSNRS_CASE_132 geschrieben.
Die neuen Informationen werden für alle Positionsnummern bestimmt, die unter die Fälle 1.1, 1.2 und 1.32 fallen,
also die, die sich in den Tabellen TMP_POSNRS_CASE_11, TMP_POSNRS_CASE_12 & TMP_POSNRS_CASE_132 befinden.
Jetzt passiert folgendes:
1. Die Positionen aus den 3 Tabellen werden zu einer temporären Tabelle, ALL_POSNRS_TO_UPDATE kombiniert.
2. Zu allen Positionen aus in dieser kombinierten, temporären Tabelle werden dann die neuen Stücklisteninformationen aus COMP,
bzw. RD_COMP bestimmt und in eine weitere, temporäre, aber persistente Tabelle TMP_UPDATE_DATA geschrieben.
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
Hinweis:
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,
da in diesen Tabellen ebenfalls die Positionsnummern aktualisiert werden müssen, sofern welche vorliegen. Die Regeln und Bedingungen selbst
bleiben unverändert, da sie nur verschoben werden.
"""
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("""
WITH ALL_POSNRS_TO_UPDATE AS (
SELECT * FROM TMP_POSNRS_CASE_11
@@ -612,10 +643,23 @@ class BOMProcessing:
UNION
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,
RD.Positionsnummer AS POSNR,
SELECT C.ROWID AS COMP_ROWID,
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
CASE
@@ -637,29 +681,49 @@ class BOMProcessing:
C.ZUSCHNITT,
C.DISPO_AKTIV_JN,
C.RUESTCODE,
B.BEDINGUNG,
R.REGEL
C.RUESTCODE
FROM ALL_POSNRS_TO_UPDATE CUD
FROM ALL_POSNRS_TO_UPDATE P
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
ON CUD.PARENT = RD.ParentCode
AND CUD.POSNR = RD.Positionsnummer
ON P.UEBTEILENR = RD.ParentCode
AND P.POS_NEU = RD.Positionsnummer
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
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
self.db.con.execute("""
UPDATE COMP
SET POSNR = UD.POSNR,
SET
POSNR = UD.POS_NEU,
ABW_ANZAHL = UD.ABW_ANZAHL,
MENGE = UD.MENGE,
LAENGE = UD.LAENGE,
@@ -667,42 +731,40 @@ class BOMProcessing:
DISPO_AKTIV_JN = UD.DISPO_AKTIV_JN,
RUESTCODE = UD.RUESTCODE
FROM TMP_UPDATE_DATA UD
WHERE COMP.ID = UD.ID
WHERE ROWID = UD.COMP_ROWID
""")
# TOS-Bedingungen updaten
self.db.con.execute("""
UPDATE VAR_TEIL_BEDINGUNG_2
SET BEDINGUNG = UD.BEDINGUNG
SET POSNR = UD.POS_NEU
FROM TMP_UPDATE_DATA UD
WHERE COMP_ID = UD.ID
WHERE ROWID = UD.VAR_TEIL_BED_2_ROWID
""")
# TOS-Regeln updaten
self.db.con.execute("""
UPDATE STKL_REGEL
SET REGEL = UD.REGEL
SET POSNR = UD.POS_NEU
FROM TMP_UPDATE_DATA UD
WHERE COMP_ID = UD.ID
WHERE ROWID = UD.STKL_REGEL_ROWID
""")
def insert(self):
"""
Neuanlage aller Positionen, die nur in der neuen Stückliste vorliegen.
Die Positionsnummern wurde bereits in der Methode _get_codes_case_131 ermittelt und in die temporäre Tabelle
TMP_POSNRS_CASE_131 geschrieben.
Neuanlage aller Positionen, die nur in der neuen Stückliste vorliegen (das sind die aus der Tabelle TMP_POSNRS_CASE_131)
Hinweise:
- 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!
- 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
der Erstellung nicht klar.
der Erstellung dieses Scripts nicht klar.
"""
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.ChildCode AS KOMPTEILENR,
@@ -723,6 +785,7 @@ class BOMProcessing:
WHEN RD.Uebergabelaenge = 0 THEN NULL
ELSE RD.Uebergabelaenge
END AS LAENGE,
NULL AS ZUSCHNITT,
P.DISPO_AKTIV_JN,
P.RUESTCODE
@@ -732,14 +795,14 @@ class BOMProcessing:
LEFT JOIN COMP C
ON RD.ChildCode = C.KOMPTEILENR
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
AND RD.ParentCode = C.PARENT
AND RD.ParentCode = C.UEBTEILENR
LEFT JOIN PARTS P
ON RD.ChildCode = P.TEILENR
WHERE C.KOMPTEILENR IS NULL
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})
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_UPDATE_DATA")
def write_new_bom(self) -> None:
self._get_codes_case_12_or_13()
self._get_codes_case_13()
@@ -760,6 +822,8 @@ class BOMProcessing:
self._get_case_12_positions()
self._get_case_131_positions()
self._get_case_132_positions()
self._get_ids_to_delete()
self._get_update_data()
self.delete()
self.insert()
self.update()