SQLite Befehl bauen?

[berndoa]

Hallo,
ich habe eine Datenbank mit einer Tabelle, die wie folgt gebaut wurde:

CREATE TABLE Tuples (
    Sixtuple   STRING  NOT NULL,
    SixtupleId INTEGER NOT NULL,
    Triple     STRING  NOT NULL,
    TripleId   INTEGER NOT NULL,
    PRIMARY KEY (
        SixtupleID,
        TripleID
    )
);

Die 2 wirklich relevanten Spalten sind SixtupleId und TripleId, die anderen Beiden sind nur zu Kontrollzwecken da und sind im Prinzip überflüssig.


Nun will ich im Rahmen eines Java Programms, das über den jdbc server blabla an der Datenbank rumwerkelt, 2 Sachen machen:
Sache ist, die SixtupleIds sind einfach Zahlen von 0-ca. 13Millionen.
Nun will ich Folgendes:
Vorgegeben vom Java Programm sei eine bestimmte Zahl Z.
Es ist sicher (vor Abarbeiten nachfolgender Schritte) dass diverse zeilen vorkommen, in denen diese Zahl als TripleId vorkommt.
Nun soll
1. die Datenbank dahingehend durchsucht werden ob es für jede mögliche SixtupleId (wie gesagt, Zahlen 0-13 Millionen) eine Zeile gibt, in der ein TripleId ungleich Z vorkommt.
Kurzum, ob für jede SixtupleId mindestens ein Paar (SixtupleId,TripleId) vorkommt, wo die TripelId nicht Z ist.

2.Falls obiges mit true beantwortet wurde, dann sollen alle Zeilen entfernt werden in denen TripleId=Z ist.
Diesen Befehl kriege ich vermutlich recht easy hin.

Nur das 1. bin ich mir unsicher wie ich das recht effizient hinkriege.

Oder müsste ich da in guter alter Java Manier eine For schleife über die Zahlen 0-13Mille machen, mittels (wenn i die for schleifen Variable ist)

SELECT *
FROM Tupels
WHERE SixtupleID=i AND TripleId!=Z

jeweils ResultSet generieren, irgendwie gucken ob die Alle nicht-leer sind
und so das bestimmen?

Mein Problem ist halt dass mein Datensatz aus ca. 260 Milliraden Zeilen besteht.
Da wäre eine möglichst effiziente Variante recht gut, gerade auch weil ich dieses Vorgehen für viele Zahlen Z durchführen werde (maximal 18000 solcher Zahlen Z, um genau zu sein)

 

[yfons123]

wenn du gute indizes setzt und sinnvolle sql befehle absetzt dann soll es nicht an der performance hapern
weil du dann der db nichts dämliches aufbrumst und über die indizes kann die db gezielt suchen und dann geht das ganz flott

ein select * tut da schon im herzen weh

 

[mihe7]

1. die Datenbank dahingehend durchsucht werden ob es für jede mögliche SixtupleId (wie gesagt, Zahlen 0-13 Millionen) eine Zeile gibt, in der ein TripleId ungleich Z vorkommt.
Kurzum, ob für jede SixtupleId mindestens ein Paar (SixtupleId,TripleId) vorkommt, wo die TripelId nicht Z ist.

2.Falls obiges mit true beantwortet wurde, dann sollen alle Zeilen entfernt werden in denen TripleId=Z ist.

Wenn ich Dich richtig verstehe, möchtest Du alle Zeilen löschen, für die es eine Zeile mit gleicher SixtupleId und einer bestimmten TripleId Z gibt, wenn sich die TripleIds unterscheiden.

DELETE FROM Tuples toDelete 
 INNER JOIN Tuples other ON toDelete.SixtupleId = other.SixtupleId AND toDelete.TripleId <> other.TripleId 
      WHERE other.TripleId = ?

Bei solchen Abfragen empfielt es sich immer, den Ausführungsplan im Auge zu behalten (EXPLAIN), dabei sollten die Indizes möglichst effizient zum Einsatz kommen und je nach DBMS kann es auch sein, dass Du mit einer anderen Formulierung (z. B. mit NOT IN oder NOT EXISTS) einen besseren Plan erhältst.

 

[berndoa]

Wenn ich Dich richtig verstehe, möchtest Du alle Zeilen löschen, für die es eine Zeile mit gleicher SixtupleId und einer bestimmten TripleId Z gibt, wenn sich die TripleIds unterscheiden.

DELETE FROM Tuples toDelete
 INNER JOIN Tuples other ON toDelete.SixtupleId = other.SixtupleId AND toDelete.TripleId <> other.TripleId
      WHERE other.TripleId = ?

Bei solchen Abfragen empfielt es sich immer, den Ausführungsplan im Auge zu behalten (EXPLAIN), dabei sollten die Indizes möglichst effizient zum Einsatz kommen und je nach DBMS kann es auch sein, dass Du mit einer anderen Formulierung (z. B. mit NOT IN oder NOT EXISTS) einen besseren Plan erhältst.

Man stelle sich einen Graph sergestalt vor, dass links eine Menge Knoten ist (das sind die Sixtuples) und rehcts eine Menge Knoten (das sind die Triples).
Jeder Knoten links ist eingangs mit genau 20 Knoten rechts verbunden. (später können es natürlich weniger sein, minimal 1)
Und ich frage mich "Kann ich den ganz bestimmten Knoten XYZ auf der rechten Seite entfernen sodass trotzdem JEDER Knoten links mit mindestens einem Knoten rechts verbunden ist?"
meine Tabelle enthält, gerade in jeder Zeile eine solche Verbindung/Kante.
Und ich will einfahc gucken, wenn man sich so vorstellt, der Knoten XYZ und alle damit einhergehenden Verbindungen wären weg, sind dann trotzdem naoch für jeder Knoten links (aka für jedes Sixtuple) noch verbindungen dahin da?

Kurzum, kann ich alle Zeilen in denen das Tripel XYZ vorkommt, löschen, und es gibt trotzdem noch für jede Sixtuple eine Zeile wo es vorkommt?

Super minimalistisches Beispiel:

Sagen wir es gäbe nur die Sixtuple 1,2,3 und die Tripel 1,2,3.
W#ren nun die verbleibenden Verbindungen
(1,1)
(1,3)
(2,1)
(2,3)
(3,1)
(3,2)
(3,3)

Kann das Tripel 1 entfernt werden?
Ja, denn auch wenn alle Verbindungen weg sind, auf deren rechter Seite ne 1 steht, so haben wir
(1,3)
(2,3)
(3,2)
(3,3)
ir sehen, alle sixtuple 1,2,3 kommen auf der linken seite immer noch mind. einmal vor.

Können wir nun das tripel 3 entfernen?
nein, denn dann hätten wir
(3,2)
und die sixtuple 1 und 2 haben keienrlei zeilen mehr/kommen in keiner zeile mehr vor.

Einen Schritt zurück, von
(1,3)
(2,3)
(3,2)
(3,3)
aus, können wir allerdings durch das Tripel 2 entfernen.
Denn dann haben wir
(1,3)
(2,3)
(3,3)
alle sixtuple 1-3 werden immer noch erreicht.

Wir sind nun auch am Ende.
Denn das einzige noch benutzte tripel 3 kann nicht mehr entfernt werden aus offensichtlichen Gründen.

So in etwa ist bei mir auch der hintergedanke beim vorgehen,
nur dass die sixtupleids von 0-13 millionen gehenund die tripleids nicht zwingend aufsteigende natürliche zahlen sind (konkret habe ich die tripleid einfahc definiert als konkatenation der 3 zahlen und das wieder in int konvetiert. a la 12+23+27=122327)

 

[mihe7]

Naja, dann fragst Du halt nach der Anzahl verschiedener Sixtupl:e, die nach dem Löschen verbleiben würden:

SELECT count(DISTINCT SixtupleId) FROM Tupel WHERE TripleId <> ?