Das deutsche Python-Forum

lose = 210
/* Habe Zahlen von 1 -999 */
TA04 = 1
/* Habe Zahlen von 0 -3 */

mycursor = my_db.cursor() /* keine Problem */
query="SELECT * from daw WHERE daw1 = "+str(TA04)+" and daw3 = "+str(lose)+"" /* gefunden im Internet */
#mycursor.execute("SELECT * FROM daw WHERE daw1 = %s", (lose,)) /* eine alte Abfrage */
myresult = mycursor.fetchall() /* keine Problem */
for row in myresult: /* keine Problem */
ivsb19 == row[2] /* keine Problem */
ivsb21 == row[4] /* keine Problem */

hinter "lose" verbirgen sich Zahlen von 1 - 999
hinter "TA04" verbirgen sich Zahlen von 0-3
Meine Tabelle dazu:
#############################################################################
CREATE TABLE `daw` (
`id` int(255) UNSIGNED NOT NULL COMMENT 'ID',
`daw1` varchar(1) NOT NULL COMMENT 'TA04',
`daw2` varchar(100) NOT NULL COMMENT 'Titel zu TA04',
`daw3` varchar(3) NOT NULL COMMENT 'lose',
`daw4` varchar(255) NOT NULL COMMENT 'Titel zu lose'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci ROW_FORMAT=COMPACT;
#############################################################################
Habe einfach mal was erstellt für Testzwecke, da ich derzeit kein Zugriff auf Original DB habe.
Wie zu sehen kan ich 4 mal 999 Einträge verwalten.
Zu jeder Zahl (0-4) 999 Stück
Gesammt 3996 Einträge
Ich bekomme 2 Daten, TA04 und lose. Mit diese 2 Daten möchte ich nun eine bestimmte Zeile auslesen
Meine Zeile mit # bei ABfrage habe ich aktiv im Einsatz allerdings mit anderer Tabelle.
Die Zeile mit "query" ist was ich gefunden habe, eine Abfragen mit 2 Werte aus einer Tabelle.
Die "query" Zeile soll ersetzt werden mit funtionierender # Abfrage, wo bei # im dan nicht benötigt wird.
Nach einigen gescheiterten Versuche wollte ich Euch mal fragen wie ich die Abfrage gestallen muß, damit ich mit Werten eine Teile aus einer Tabelle abfragen kann ?

@linvris: Es wäre sinnvoll Code in einen Code-Block zu setzen im Beitrag, damit die Einrückung erhalten bleibt. Und wenn Du Python-Code hast, sollten da keine Kommentare rein die keine Python-Kommentare sind, sondern die Syntax von einer anderen Programmiersprache verwenden.

Dann hast Du ein echt fürchterliches Problem mit Namen. Tabellenspalten die einfach durchnummeriert sind und im Kommentar beschreiben was die jeweilige Spaltenwerte bedeuten. Wobei da so etwas wie ID für die Spalte ID überflüssig ist, und `TA04` auch nicht wirklich verrät was das ist.

Im Programm dann `ivsb19` und `ivsb21` sind auch ganz fürchterlich schlechte Namen.

Überflüssig und sinnfrei sind auch die ganzen `my` vor den Namen. Ja klar sind das Deine, wem sollen die sonst gehören?

Das zusammenstückeln von Zeichenketten und Werten mittels ``+`` und `str()` ist eher BASIC als Python. Dafür gibt es die `format()`-Methode auf Zeichenketten und f-Zeichenkettenliterale. Aaaaber das macht man nicht bei SQL. Das ist im besten Fall unperformant und im schlechteren Fall gefährlich. Im Internet gefunden? Ja da findet man oft auch Mist, den jemand da abgekippt hat.

Werte lässt man von der Datenbankbibliothek an die Datenbank übermitteln. Das ist sicher, und eventuell bastelt die Client-API da auch gar keine Zeichenetten zusammen, sondern überträgt SQL mit Platzhaltern und Daten getrennt an den Server, der damit beispielsweise die Möglichkeit hat Anfragen zu cachen.

Wie man das richtig macht, sieht man doch in der auskommentierten alten Anfrage.

Man sollte auch explizit angeben welche Werte man haben will und nicht einfach ein ``SELECT *``. Dann ist man sicher gegenüber Änderungen am Datenbankschema, solange die Spalten erhalten bleiben, die man abfragt. Falls davon Spalten wegfallen, bekommt man eine deutliche Fehlermeldung *was* da nicht mehr da ist. Und man muss auch nicht immer die kompletten Datensätze abfragen wenn man gar nicht alle Werte benötigt. Und in der Schleife kann man dann auch die Werte an sinnvolle Namen binden, statt später über magische Indexzahlen darauf zuzugreifen.

Der Cursor sollte nach Verwendung sauber geschlossen werden. Da bietet sich ``with`` und `contextlib.closing()` an. Das gilt im übrigen auch für die Datenbankverbindung.

Der würde dann also so aussehen: Statt irgendwo im Internet zu suchen, solltest Du einfach mal in der Dokumentation nachlesen was `cursor.execute()` an Argumenten erwartet, was die bedeuten, und wie man dort SQL-Anfrage mit Platzhaltern und Werte zusammenbringt. Soweit ich mich erinnere wird das in der MySQL-Dokumentation mit Beispielen erklärt.

Was beim Datenbankentwurf auch komisch ist, sind die VARCHAR für *Zahlen*. Warum das? Und die Displaybreite für INT von 255 für Zahlen die maximal 11 Zeichen lang sein können, macht auch nicht so wirklich Sinn. Den Wert würde ich gar nicht setzen. Oder wofür brauchst Du den?

Habe doch gesagt das ich zum Test was erstellt habe, auf eigendliche DB kan ich derzeit nich zugreifen.
Ich fange meist an mit allen Positionen ( * ) und verkleinere dann später.
Wenn ich es unter PHP machen würde dann hätte ich es schon fertig, aber das würde mehr Arbeit bedeuten,
und nicht so schnell ausführbar in meinen Augen,.
Ich bin davon ausgegangen wenn ich Abfragen unter PHP habe sind sie in etwa gleich auch mit anderen Sprachen.
Die Eigendliche Tabelle kenne ich noch nicht den Inhalt genau. Ich habe mal gesucht nach Bezeichnungen wie charn varchar und co. aber nichts nennenswertes gefunden auf deutsch.
char bzw varchar sind für mich halt Zeichen, daher nam och das. Wenn Du den Wert auf lose oder TA04 beziehst dazu muß ich sagen das diese Werte über eine Eingabe bekomme und nicht fix sind wie im Beispiel dafür gab ich an Zaheln von 0-3 und 1-999 würde ich bekommen.

Es ist nunmal relevant welchen Typ Deine Daten haben, ob es Strings sind, oder Zahlen.
Wo hast Du jetzt konkret ein Problem? Was hast Du versucht? Was passiert? Welchen Fehler bekommst Du?

@linvris: Ich meinte die 255 Zeichen Breite für die ID die bei dem Typ maximal 11 Zeichen haben kann. Das ``INT(255)``. Das macht nicht wirklich Sinn. Warum hast Du da 255 gewählt, beziehungsweise überhaupt eine Zahl?

Was CHAR, VARCHAR & Co angeht: es wird schwierig etwas mit relationalen Datenbanken zu machen wenn man die Grundlagen wie beispielsweise die Datentypen nicht kennt. Bei SQL hat man sicher eine bessere Chance auch brauchbare deutschsprachige Literatur zu finden, weil sich das Thema nicht so schnell weiterentwickelt wie vieles andere im technischen Bereich, aber letztlich wird man nicht um die Dokumentation der verwendeten Systeme herum kommen und die ist auch bei MySQL erst einmal auf englisch aktuell. Und dann sollte es kein Problem sein das alte Beispiel um einen Wert zu erweitern. Wenn man denn verstanden hat, was das alte Beispiel macht, also warum das so aussieht wie es aussieht.

Hallo,

das macht doch alles nur semi-viel Sinn...

Wenn ich es unter PHP machen würde dann hätte ich es schon fertig, aber das würde mehr Arbeit bedeuten,
und nicht so schnell ausführbar in meinen Augen,.

Wenn du in PHP fertig wärst, dann kann es doch a) nicht mehr Arbeit sein, weil in Python bist du nicht fertig und b) warum nimmst du kein PHP, wenn da das kannst? Bzgl. Performance: im gezeigten Code ist ziemlich sicher die Datenbank der geschwindigkeitsbestimmende Faktor, d.h. die Programmiersprache spielt (fast) keine Rolle.

Ich bin davon ausgegangen wenn ich Abfragen unter PHP habe sind sie in etwa gleich auch mit anderen Sprachen.

SQL ist SQL, richtig. Alles, was zu deinen SQL Statements und zu deinem Datenbankdesign gesagt wurde, ist unabhängig von der Programmiersprache, die die Datenbankabfrage macht.

Die Eigendliche Tabelle kenne ich noch nicht den Inhalt genau.

Na ja, wenn man die Tabelle nicht kennt, kann man halt auch keine sinnvolle Abfrage machen.

Gruß, noisefloor

Erst einmal, muss dein MySQL funktionieren.

In Linux kannst du immer auf localhost mysql-server installieren. Keine Ahnung wie das auf Windows geht.

Wenn mysql von der Kommandozeile geht, dann installiere phpmyadmin.

Wenn du dich in phpmyadmin einloggen kannst, dann, als Erstes, ein Database erschaffen. Dann eine Tabelle mit Zeilen und Spalten wie du willst machen.

Z.B. ich bin in babydb:
Ich empfehle immer die Spalte id in jeder Tabelle zu haben.

Nun, was auch immer du in Python machen willst, probiere deine MySQL query erst in phpmyadmin, bis du sicher bist, dass es funktioniert.

Dann kannst du pythonieren.

Und danach kann man das alles auf 'ner Cloud machen in der Gewissheit, das es alles schon auf localhost geht!

@Pedroski55: Keine Ahnung was dieser Beitrag jetzt wem sagen soll.

NOT NULL ist bei PRIMARY KEY überflüssig, denn das ist da schon enthalten. Die Default-Werte machen alle keinen Sinn. Der bei Name sieht so aus als würde man eigentlich das NOT NULL weglassen wollen statt das mit einem speziellen Wert auszudrücken der dann halt doch wieder nicht eindeutig ist, weil tatsächlich jemand so heissen könnte.

VARCHAR für so ein kurzes Feld ist wahrscheinlich nicht wirklich sinnvoll.

Na, dann, sage ich es dir ganz klar:

Erst die MySQL Query in MySQL probieren. Wenn du weißt, dass es dort funktioniert, dann kannst du es via Python probieren.

Aber, ich sehe, du meckerst gerne!

@Pedroski55: Ganz klar: Das macht nicht wirklich Sinn. *Wo* mach die Anfrage eintippt, ob nun im mysqlclient, in phpmyadmin, in adminer, in …, oder Python, ist letztlich egal. Bei literalen SQL-Abfragen ist das doch immer das gleiche SQL was man da eingibt. Das gilt ja genau so umgekehrt: Wenn die Abfrage in Python funktioniert, dann weisst Du, dass sie auch in phpmyadmin funktioniert.

Ich meckere nicht gerne, ich übe konstruktive Kritik. Kannst Du als meckern abtun. Oder versuchen was zu lernen. Liegt ganz bei Dir.

@Pedroski55: dein Post hat halt auch nichts mit der Frage des TE zu tun... der hat ein Problem mit einer SELECT-Abfrage (und schlechtem DB Design), SELECT kommt bei dir gar nicht vor. Sondern nur ein Beispiel für eine suboptimales Tabellendesign, wo nur eine untergewichtige Person hinzugefügt wird.

Gruß, noisefloor