Listen und MySQL

[FJK]

Hi,

ich habe eine Liste in der ich Instanzen drin stehen habe.
Jetzt möchte ich schnellst möglich die Attribute der Instanzen in eine MySQl Datenbank schreiben. Leider habe ich nur eine Möglichkeit gefunden, in der ich jede Instanz aufrufen und jedes Attribut dann einen String Befehl zuweisen muss. Grade das mit der String Konvertierung, es handelt sich ja immerhin um Zahlen, scheint mir sehr ineffizent zu sein.
Gibt es eine bessere Methode?
Vieleicht das ich die Liste per .net direkt an die DB schieben kann?

 

[RudolfG]

Hi FJK,

vielleicht zeigst du uns erstmal die Variante die du gefunden hast (als Quelltext) und vielleicht kann es ja dann auch anders gemacht werden.

Gruß
RudolfG

 

[FJK]

Ich benutze derzeit das hier:

public void InsertRow(string myConnectionString) 
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }
 
    MySqlConnection myConnection = new MySqlConnection(myConnectionString);
    string myInsertQuery = "INSERT INTO Orders (id, customerId, amount) 
                            Values(1001, 23, 30.66)";
    MySqlCommand myCommand = new MySqlCommand(myInsertQuery);
    myCommand.Connection = myConnection;
    myConnection.Open();
    myCommand.ExecuteNonQuery();
    myCommand.Connection.Close();
}

dies habe ich hier gefunden.

Was auch noch intressant zu wissen wäre, ob man die Verbindung für jeden Zugriff beenden und neu aufbauen muss?
Datenbanken scheinen mir nicht sehr Zeitoptimiert zu sein. Schön wäre ja mit Zeigern direkt in der Datenbank zu arbeiten

 

[RudolfG]

Ich benutze derzeit das hier:

public void InsertRow(string myConnectionString) 
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }
 
    MySqlConnection myConnection = new MySqlConnection(myConnectionString);
    string myInsertQuery = "INSERT INTO Orders (id, customerId, amount) 
                            Values(1001, 23, 30.66)";
    MySqlCommand myCommand = new MySqlCommand(myInsertQuery);
    myCommand.Connection = myConnection;
    myConnection.Open();
    myCommand.ExecuteNonQuery();
    myCommand.Connection.Close();
}

dies habe ich hier gefunden.

Ich hätte es wie folgt gemacht:

public void InsertRow(string myConnectionString)
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }

   using (MySqlConnection myConnection = new MySqlConnection(myConnectionString))
   {
      MySqlCommand command = myConnection.CreateCommand();
      command.CommandText = "insert into orders(id, customerid, amaount) values(?id, ?customer_id, ?amount);"
      conn.Open();

      // Das Statement wird auf dem Server schon vorkompiliert
      command.Prepare();
     
      // Hier werden die Parameter hinzufügt
      command.Parameters.AddWithValue("id", 1001);
      command.Parameters.AddWithValue("customer_id", 23);
      command.Parameters.AddWithValue("amount", 30.66);

      // Hier muss der Server nur noch die Parameter mit dem vorkompilierten Statement ergänzen und ausführen i. d. R. ist es schneller (besonders bei komplexen Statements!
      command.ExecuteNonQuery();
   } // Das Objekt wird zerstört und die Verbindung an den Pool zurückgegeben! 
}

Was auch noch intressant zu wissen wäre, ob man die Verbindung für jeden Zugriff beenden und neu aufbauen muss?

Muss man nicht, aber das wird soviel ich weiß dringend empfohlen. Dabei bedient sich der Connector dem Pooling-Verfahren, so dass wenn du die Verbindung aufbaust eine Verbindung aus dem Pool genommen wird.

Datenbanken scheinen mir nicht sehr Zeitoptimiert zu sein. Schön wäre ja mit Zeigern direkt in der Datenbank zu arbeiten

Datenbanken sind eigentlich so ziemlich die langsamste Komponente bei der Softwareentwicklung (die Code ausführung, Dateien selber schreiben, Netzwerkoperationen etc. gehen schneller!) aber trotzdem setzen es alle ein.

Warum? Der Grund liegt hier darin, dass die Daten sehr strukturiert abgelegt sind und über eine standatisierte Sprache (SQL) abgefragt werden können. Außerdem laufen diese seehr stabil. Sicher bieten diese noch viel mehr Vorteile aber wie du schon selber bemerkt hast auch eben einpaar Nachteile. Trotz allem sind die Datenbanken mehr optimiert als man die Suchroutinen selber schreiben könnte, da hier die letzten Performance-Killer rausgekitzelt werden.

Zeiger auf Datenbanken?! (Kommst du aus der C/C++-Welt?) Sowas habe ich noch nie gehört... Da das ein extrem mächtiges aber auch sehr gefährliches Werkzeug währe, würde keiner die Gewährleistung übernehmen können und wollen, das die Datenbank nach deinen eigenen Operationen nicht komplett zerstört währe.

Gruß
RudolfG

 

[FJK]

hi,
danke für eure antworten

Ich hätte es wie folgt gemacht:

public void InsertRow(string myConnectionString)
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }

   using (MySqlConnection myConnection = new MySqlConnection(myConnectionString))
   {
      MySqlCommand command = myConnection.CreateCommand();
      command.CommandText = "insert into orders(id, customerid, amaount) values(?id, ?customer_id, ?amount);"
      conn.Open();

      // Das Statement wird auf dem Server schon vorkompiliert
      command.Prepare();
     
      // Hier werden die Parameter hinzufügt
      command.Parameters.AddWithValue("id", 1001);
      command.Parameters.AddWithValue("customer_id", 23);
      command.Parameters.AddWithValue("amount", 30.66);

      // Hier muss der Server nur noch die Parameter mit dem vorkompilierten Statement ergänzen und ausführen i. d. R. ist es schneller (besonders bei komplexen Statements!
      command.ExecuteNonQuery();
   } // Das Objekt wird zerstört und die Verbindung an den Pool zurückgegeben! 
}

geht das auch für den Update Befehl?
ist aber immer noch ziemlich string lastig.

Muss man nicht, aber das wird soviel ich weiß dringend empfohlen. Dabei bedient sich der Connector dem Pooling-Verfahren, so dass wenn du die Verbindung aufbaust eine Verbindung aus dem Pool genommen wird.

auch wenn viele Datensätze hinter ein ander hinein geschrieben werden sollen?

Datenbanken sind eigentlich so ziemlich die langsamste Komponente bei der Softwareentwicklung (die Code ausführung, Dateien selber schreiben, Netzwerkoperationen etc. gehen schneller!) aber trotzdem setzen es alle ein.

das klingt so falsch in deiner Aussage?

Zeiger auf Datenbanken?! (Kommst du aus der C/C++-Welt?) Sowas habe ich noch nie gehört... Da das ein extrem mächtiges aber auch sehr gefährliches Werkzeug währe, würde keiner die Gewährleistung übernehmen können und wollen, das die Datenbank nach deinen eigenen Operationen nicht komplett zerstört währe.

jup

Gruß
RudolfG

gruß

 

[RudolfG]

geht das auch für den Update Befehl?
ist aber immer noch ziemlich string lastig.

Ja das gilt für alle Statements und Sry aber anderes kann ich leider nicht bieten.

auch wenn viele Datensätze hinter ein ander hinein geschrieben werden sollen?

Wenn man z. B. mehrere Daten in eine Tabelle einfügen möchte sollte man es nicht so machen.

Beispiel:

public void InsertRow(string myConnectionString)
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }
 
   using (MySqlConnection myConnection = new MySqlConnection(myConnectionString))
   {
      MySqlCommand command = myConnection.CreateCommand();
      command.CommandText = "insert into orders(id, customerid, amaount) values(?id, ?customer_id, ?amount);"
      conn.Open();
 
      // Das Statement wird auf dem Server schon vorkompiliert
      command.Prepare();

     for (int i = 0; i < 100; ++i)
     {
         double d = i * 1.23;

         // Hier werden die Parameter hinzufügt
         command.Parameters.AddWithValue("id", 1001);
         command.Parameters.AddWithValue("customer_id", 23);
         command.Parameters.AddWithValue("amount", d);
 
         // Hier muss der Server nur noch die Parameter mit dem vorkompilierten Statement ergänzen und ausführen i. d. R. ist es schneller (besonders bei komplexen Statements!
         command.ExecuteNonQuery();
         command.Parameters.Clear();
      }
   } // Das Objekt wird zerstört und die Verbindung an den Pool zurückgegeben! 
}

Bei mehreren einfüge Operationen kann ja das vorkompilierte Statement vom Server übernommen werden, anstatt es immer wieder neu zu kompilieren. Hier müssen nur die Parameter neu gesetzt und das Statement ausgeführt werden.

das klingt so falsch in deiner Aussage?

Sry aber ich verstehe nicht ganz was du mir damit sagen möchtest. Stimmt das nicht? Wenn nicht dann bitte ich um eine Begründung, da ich es zumindest immer so gelernt habe.

jup

Wie du in meiner Signatur sehen kannst, programmiere ich auch C++ und ich weiß, das sonst keiner das Wort "Zeiger" in den Mund nimmt^^.

Gruß
RudolfG

 

[FJK]

Sry aber ich verstehe nicht ganz was du mir damit sagen möchtest. Stimmt das nicht? Wenn nicht dann bitte ich um eine Begründung, da ich es zumindest immer so gelernt habe.

ich meine damit:
Das sich deine Ausage so anhört, als sei es verkehrt wenn man eine DB benutzt, weil sie eben so verdammt langsam ist.

Wie du in meiner Signatur sehen kannst, programmiere ich auch C++ und ich weiß, das sonst keiner das Wort "Zeiger" in den Mund nimmt^^.

Gruß
RudolfG

zeiger sind toll, aber auch gefährlich.
trotzdem vermisse ich sie

 

[RudolfG]

ich meine damit:
Das sich deine Ausage so anhört, als sei es verkehrt wenn man eine DB benutzt, weil sie eben so verdammt langsam ist.

Nein überhaupt nicht, ich benutze diese auch überall wo es nur sinnvoll ist und ich mehr als einpaar Datensätze ablegen muss. Die Datenbanken bieten eine extrem gute und leichte Art die Daten abzulegen/abzufragen. Können von fast allen Programmiersprachen verarbeitet werden und der Server kümmert sich um sehr viele "Kleinigkeiten" bei denen man sich sonst die Finger wund Programmieren würde. Dieser Vorteil hat auch einen Nachteil und das ist nun mal die Performance, diese Bewegt sich aber meistens für den Anwender im nicht spürbaren Bereich.

Solltest du mal Millionen von Datensätze suchen und ausgeben müssen, wird das Statement aber schon ein wenig dauern. Hier kann man aber mit bestimmten Tools (Profiler) die SQL-Statements oder den SQL-Server so weit optimieren (z. B. bestimmte Spalten zu indexieren etc.), dass die Anfragen trotzdem sehr schnell verarbeitet werden können (hier werden natürlich entsprechende Kenntnisse vom System und der Technik dahinter vorausgesetzt!).

zeiger sind toll, aber auch gefährlich.
trotzdem vermisse ich sie

Da sind wir einer Meinung

 

[FJK]

Wenn man z. B. mehrere Daten in eine Tabelle einfügen möchte sollte man es nicht so machen.

Beispiel:

public void InsertRow(string myConnectionString)
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }
 
   using (MySqlConnection myConnection = new MySqlConnection(myConnectionString))
   {
      MySqlCommand command = myConnection.CreateCommand();
      command.CommandText = "insert into orders(id, customerid, amaount) values(?id, ?customer_id, ?amount);"
      conn.Open();
 
      // Das Statement wird auf dem Server schon vorkompiliert
      command.Prepare();

     for (int i = 0; i < 100; ++i)
     {
         double d = i * 1.23;

         // Hier werden die Parameter hinzufügt
         command.Parameters.AddWithValue("id", 1001);
         command.Parameters.AddWithValue("customer_id", 23);
         command.Parameters.AddWithValue("amount", d);
 
         // Hier muss der Server nur noch die Parameter mit dem vorkompilierten Statement ergänzen und ausführen i. d. R. ist es schneller (besonders bei komplexen Statements!
         command.ExecuteNonQuery();
         command.Parameters.Clear();
      }
   } // Das Objekt wird zerstört und die Verbindung an den Pool zurückgegeben! 
}

nochmal eine frage, wie sieht das Statement den für ein UPDATE Befehl aus?
wie wird da die WHERE Bedingung übergeben?

und ist es evt sogar schneller die gesamte DB zu löschen und mit INSERT neu zu befüllen, als alle Datensätze mit UPDATE zu bearbeiten?

 

[RudolfG]

nochmal eine frage, wie sieht das Statement den für ein UPDATE Befehl aus?
wie wird da die WHERE Bedingung übergeben?

Eigentlich genau wie beim dem Insert, aber hier mal das Beispiel mit Update.

public void UpdateRow(string myConnectionString)
{
    // If the connection string is empty, use a default.
    if(myConnectionString == "") 
    {
        myConnectionString = "Database=Test;Data Source=localhost;
                              User Id=username;Password=pass";
    }
 
   using (MySqlConnection myConnection = new MySqlConnection(myConnectionString))
   {
      MySqlCommand command = myConnection.CreateCommand();
      command.CommandText = "update orders set amount = ?amount where id = ?id;"
      conn.Open();
 
      // Das Statement wird auf dem Server schon vorkompiliert
      command.Prepare();
 
     for (int i = 0; i < 100; ++i)
     {
         double d = i * 1.23;
 
         // Hier werden die Parameter hinzufügt
         command.Parameters.AddWithValue("amount", d);
         command.Parameters.AddWithValue("id", 1000 +  i + 1);
 
         // Hier muss der Server nur noch die Parameter mit dem vorkompilierten Statement ergänzen und ausführen i. d. R. ist es schneller (besonders bei komplexen Statements!
         command.ExecuteNonQuery();
         command.Parameters.Clear();
      }
   } // Das Objekt wird zerstört und die Verbindung an den Pool zurückgegeben! 
}

und ist es evt sogar schneller die gesamte DB zu löschen und mit INSERT neu zu befüllen, als alle Datensätze mit UPDATE zu bearbeiten?

Das kann man meistens nicht machen, da eine Datenbank mehrere Tabellen mit Beziehungen unter einander (mittels Foreign Keys) besitzt. Diese vorher alle Auszulesen/zu Verwalten und dann alle in die neue Datenbank zu schreiben dürfte noch um einiges Länger dauern wie, das Update. Des Weiteren ist das Risiko, dass da irgendwas bei schief läuft unverhältnismäßig hoch.

DAS würde ich auf keinen Fall machen.

Normalerweise muss man nicht alle Datensätze einer Tabelle, geschweige einer Datenbank, ändern, sondern eben nur bestimmte gefilterte Datensätze. Wenn du mal in einer Tabelle für alle Datensätze bestimmte Spalten auf den gleichen Wert setzen musst macht man es ohne die Where-Anweisung. (Wenn es nicht mal ganz konkrete/spezielle Gründe dafür gibt, deutet diese Vorgehensweise oft auf eine fehlerhaft Designte-Datenbank hin!)

Gruß
RudolfG