C# MYSQL aufruf von SELECT erstellt unendlich viele Zeilen

[Stefan (Gast)]

Hallo,

ich habe ein Problem, dass beim Aufrufen des Befehls in C# in meiner 
MYSQL Datenbank unendlich viele Zeilen erstellt werden und ich verstehe 
nicht warum. Sobald der Code mtGrid_productionData.DataSource = data 
aufruft geht es los. Ich bekomme für jede erstellt Zeile in Debugmodus 
diese Sachen angezeigt am Output. Exception bekomme ich auch nicht somit 
habe ich keine Ahnung was da passiert!

The thread 0x2170 has exited with code 0 (0x0).
The thread 0x4c8 has exited with code 0 (0x0).
The thread 0x14e8 has exited with code 0 (0x0).
The thread 0x23bc has exited with code 0 (0x0).
The thread 0xacc has exited with code 0 (0x0).
The thread 0x1638 has exited with code 0 (0x0).
The thread 0x218c has exited with code 0 (0x0).

private void loadProject()
{
    try
    {
        using (MySqlConnection myConn = new MySqlConnection(stringDB))
        {
            myConn.Open();

            MySqlDataAdapter myAdapter = new MySqlDataAdapter("SELECT comment FROM " + mtxb_projectNumber.Text + " WHERE template LIKE template", myConn);

            DataTable data = new DataTable();
            myAdapter.Fill(data);

            if (data.Rows.Count == 0)
                MessageBox.Show("No production data available!");
            else
            {
                mtGrid_productionData.DataSource = data;
            }
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Message", MessageBoxButtons.OK, MessageBoxIcon.Error);

So wird meine Tabelle dynamisch erstellt:

//Create Tabel fro Data
                        using (MySqlCommand cmd = new MySqlCommand("CREATE TABLE IF NOT EXISTS `" + mtxb_projectNumber.Text + "` (" +
                                    "`id` INT AUTO_INCREMENT," +
                                    "`partnumber` VARCHAR(45)," +
                                    "`partname` VARCHAR(45)," +
                                    "`value` VARCHAR(45)," +
                                    "`mountingTech` VARCHAR(45)," +
                                    "`mfgStep` VARCHAR(45), " +
                                    "`sequence` VARCHAR(45), " +
                                    "`refdes` VARCHAR(45), " +
                                    "`Xmm` VARCHAR(45), " +
                                    "`Ymm` VARCHAR(45), " +
                                    "`side` VARCHAR(45), " +
                                    "`rotate` VARCHAR(45), " +
                                    "`minForce` VARCHAR(45), " +
                                    "`maxForce` VARCHAR(45), " +
                                    "`mfgForce` VARCHAR(45), " +
                                    "`mfgOK` VARCHAR(45), " +
                                    "`comment` LONGTEXT, " +
                                    "`template` VARCHAR(45), " +
                                    "`serialnumber` VARCHAR(45), " +
                                    "`mfgStaffID` VARCHAR(45), " +
                                    "PRIMARY KEY(id));", myConn))
                        {
                            cmd.ExecuteNonQuery();
                            cmd.Dispose();
                        }

Weis jemand was ich falsch mache? Ich bin ziemlich neu beim Datenbanken 
programmieren, daher habe ich vielleicht nur einen Denkfehler irgendwo!

Gruss Stefan

[amr2100 (Gast)]

Hallo,
Ich arbeite zwar nicht mit mysql, sondern mit anderen Datenbanken, aber 
ich denke das Problem liegt an der where Bedingung. Hier wird die Spalte 
template mit sich selbst verglichen. Es sollte dann dort der konkrete 
Suchbegriff stehen.
Zb. Where template like "%suchtext%", wobei % ein Wildcardsymbol ist
Noch besser wäre der Einsatz von Variablen

Gruß Anton

[Nase (Gast)]

Stefan schrieb:
> So wird meine Tabelle dynamisch erstellt:
> //Create Tabel fro Data
>                         using (MySqlCommand cmd = new
> MySqlCommand("CREATE TABLE IF NOT EXISTS `" + mtxb_projectNumber.Text +
> "` (" +
Warum machst du so einen Quatsch?

Ein typisches RDBS hat eher ein Problem mit vielen Tabellen als mit 
großen Tabellen.

[Stefan (Gast)]

@amr2100
es wird nicht mit sich selbst verglichen, sonder nach dem Wert template 
in der Spalte template gesucht.

@Nase
unter einigen Bedingung muss ich leider eine neu Tabelle erstellen, da 
kommen auch sehr viele Daten rein.

[Carl D. (jcw2)]

Stefan schrieb:
> @amr2100
> es wird nicht mit sich selbst verglichen, sonder nach dem Wert template
> in der Spalte template gesucht.

Dann würde ich das 2te "template" auch als Literal schreiben.

[c-hater (Gast)]

Stefan schrieb:

> @amr2100
> es wird nicht mit sich selbst verglichen, sonder nach dem Wert template
> in der Spalte template gesucht.

Ist das bei MySQL wirklich so? Falls ja, wäre es das bescheuertste 
denkbare RDBMS, von dem ich je gehört hätte. Aber das ist ja nix 
wirklich neues...

Jede SQL-DB für Normaldenkende wird jedenfalls diese where-Klausel so 
interpretieren, wie amr2100 geschrieben hat. Trotzdem ist es eine schöne 
Aufgabe zum Vergleich der Query-Optimizer. Nicht jede checkt, dass es 
sich hier um eine redundante Bedingung handelt, die zur Laufzeit der 
Abfrage überhaupt nicht mehr geprüft werden muss. Übrigens: sogar "where 
1=1" behandelt nicht jede RDBMS sinnvoll. Wahrscheinlich haben die 
Entwickler einfach nicht mit der grenzenlosen Idiotie mancher Anwender 
gerechnet...

Was nun das Problem des TO betrifft: Natürlich wird die Abfrage nicht 
"unendlich viele" Zeilen liefern, sondern maximal das "Kreuzprodukt" aus 
den in "mtxb_projectNumber.Text" mit Kommas separiert aufgeführten 
Tabellen.

Das kann allerdings recht groß werden, wenn Dau Dummdödel jede 
verschissene Tabelle in der DB dort aufgelistet hat oder zugelassen hat, 
dass ein Angreifer die Macht dazu hatte. Der kann dann nämlich durchaus 
auch "virtuelle" Tabellen mit einer unendlichen Zahl von Einträgen 
erzeugen.

Ich schätze also mal, dass hier wieder mal ein völlig überforderter 
"WÄBDESIGNER" mit den Realitäten konfrontiert wurde und num wegen seiner 
grenzenlosen Inkompetenz am völlig falschen Ende des Problems 
rumdoktort.

[Nase (Gast)]

Stefan schrieb:
> @amr2100
> es wird nicht mit sich selbst verglichen, sonder nach dem Wert template
> in der Spalte template gesucht.
Das ist aber nicht so. Wenn du nach "template" suchen willst, dann setz 
es in Anführungszeichen oder mach einen Platzhalter für ein prepared 
statement draus. Oder eine Variable.
So jedenfalls vergleichst du die Spalte mit sich selbst.

>
> @Nase
> unter einigen Bedingung muss ich leider eine neu Tabelle erstellen, da
> kommen auch sehr viele Daten rein.
Dann hast du in 99,9% ein Problem mit der Normalisierung deiner Daten.


c-hater schrieb:
> Ich schätze also mal,
Und ich schätze mal, dass hier wieder mal ein völlig inkompetenter 
c-hater in altbekannter Manier von Dingen faselt, von denen er nicht mal 
ansatzweise Ahnung hat.

[Carl D. (jcw2)]

> Ist das bei MySQL wirklich so? Falls ja, wäre es das bescheuertste
> denkbare RDBMS, von dem ich je gehört hätte. Aber das ist ja nix
> wirklich neues...

> Jede SQL-DB für Normaldenkende wird jedenfalls diese where-Klausel so
> interpretieren, wie amr2100 geschrieben hat.

Nein, nur "c-hater"-denkende kommen auf die Idee.
Andere erlauben es 2 Felder einer Zeile zu vergleichen.

Welcher Blödsinn wäre es die Eigenschaft "Literal" von der Position 
innerhalb des Ausdrucks abhängig zu machen.

Zudem ist es völlig egal, denn was zählt ist das Ergebnis und das will 
"c-liebend" erzielt werden.

[Michael U. (amiga)]

Hallo,

 WHERE template LIKE template

vergleicht auch in MySQl template mit template, also die Spalte mit sich 
selbst. Kann man auch gleich WHERE 1 = 1 hinschreiben oder den WHERE 
Teil weglassen...

Gruß aus Berlin
Michael

[Nase (Gast)]

Michael U. schrieb:
> Kann man auch gleich WHERE 1 = 1 hinschreiben oder den WHERE
> Teil weglassen...

Wobei "WHERE 1" in früheren MySQL-Versionen tatsächlich mal für 
Performancegewinn gesorgt hat...

[Carl D. (jcw2)]

Probier's doch einfach mal so:

MySqlDataAdapter myAdapter = new MySqlDataAdapter("SELECT comment FROM " + mtxb_projectNumber.Text + " WHERE template LIKE 'template'", myConn);

SQL erlaubt da freundlicherweise einzelne oder doppelte Hochkommas. Gut 
für die, die C-Strings-Literale so sehr hassen, daß sie "\"" nicht 
interpretieren können.