Asynchrones Zurückspeichern eines Datasets in die Datenbank

  • VB.NET
  • .NET 5–6

Es gibt 9 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Asynchrones Zurückspeichern eines Datasets in die Datenbank

    Servus,

    ich habe 1000 Datensätze, welche ich noch aufbereiten muss und in das DataSet in die jeweiligen Tabellen einspeichern muss. Aus den 1000 Datensätze entstehen dadurch insgesamt 78000 neue einträge in dem Dataset. Diese will ich asnychron zurückspeicher in meine Datenbank(mySQL). Momentan braucht er dafür ca. 18 Minuten um die Datensätze synchron zurückzuspeichern.

    Irgendwo habe ich aber dabei einen Denkfehler. Ich will, das er jede Tabelle asynchron zurückspeichert. Ich habe es mit 3 verschiedenen Varianten Probiert:


    Variante 1:
    Spoiler anzeigen

    ich Rufe für jede geaddete Row einen Sub auf, der den jeweiligen Command erzeugt.

    VB.NET-Quellcode

    1. For Each item As Updater.productData.Unterkategorie4Row In productData.Unterkategorie4.Select("", "", DataViewRowState.Added)
    2. IUnter4(item, "Insert")
    3. Next
    5. Async Sub IUnter4(ds As productData.Unterkategorie4Row, Command As String)
    6. Dim Mysqlcmd As New MySqlCommand
    7. Dim connStr As New MySqlConnectionStringBuilder With {
    8. .Server = Server,
    9. .Database = "productdata",
    10. .UserID = User,
    11. .Password = Password,
    12. .Port = 3306
    13. }
    15. Select Case Command
    16. Case "Insert"
    18. Using conn As New MySqlConnection(connStr.ToString)
    20. Await conn.OpenAsync()
    22. Mysqlcmd.Connection = conn
    23. Mysqlcmd.CommandText = "INSERT INTO `unterkategorie4`(`ID`, `Name`, `Auslesen`, `Unter3ID`, `Pfad`) VALUES " _
    24. & "('" & ds.ID & "','" & ds.Name & "','" & ds.Auslesen & "','" & ds.Unter3ID & "','" & ds.Pfad & "')"
    25. Await Mysqlcmd.ExecuteNonQueryAsync()
    27. End Using
    29. Case "Update"
    30. Using conn As New MySqlConnection(connStr.ToString)
    32. Await conn.OpenAsync()
    34. Mysqlcmd.Connection = conn
    35. Mysqlcmd.CommandText = "UPDATE `unterkategorie4` SET `ID`='" & ds.ID & " ',`Name`='" & ds.Name & "',`Auslesen`='" & ds.Auslesen & "',`Unter3ID`='" & ds.Unter3ID & "',`Pfad`='" & ds.Pfad & "' WHERE `ID` = '" & ds.ID & "'"
    36. Await Mysqlcmd.ExecuteNonQueryAsync()
    38. End Using
    39. Case "Delete"
    40. Using conn As New MySqlConnection(connStr.ToString)
    42. Await conn.OpenAsync()
    44. Mysqlcmd.Connection = conn
    45. Mysqlcmd.CommandText = "DELETE FROM `unterkategorie4` WHERE `ID` = '" & ds.ID & "')"
    46. Await Mysqlcmd.ExecuteNonQueryAsync()
    48. End Using
    49. End Select


    Hier bekomme ich den Fehler, das schon eine besthender OpenReader vorhanden ist.


    Variante 2:
    Spoiler anzeigen
    Ich erzeuge für jede geaddete Row im Vorfeld einen MySqlCommand, diese übergebe ich der Asynchronen Methode:

    VB.NET-Quellcode

    1. For Each item As Woocommerce.Woocommerce.Woocommerce.wp_term_taxonomyRow In Woocom.wp_term_taxonomy.Select("", "", Data.DataViewRowState.Added)
    2. Mysqlcmd.CommandText = "INSERT INTO `wp_term_taxonomy`(
    3. `term_taxonomy_id`,
    4. `term_id`,
    5. `taxonomy`,
    6. `description`,
    7. `parent`,
    8. `count`
    9. )
    10. VALUES(
    11. '" & item.term_taxonomy_id & "',
    12. '" & item.term_id & "',
    13. '" & item.taxonomy & "',
    14. '" & item.description & "',
    15. '" & item.parent & "',
    16. '" & item.count & "'
    17. )"
    18. Iwp_term_taxonomy(Mysqlcmd)
    19. Next
    20. Async Sub Iwp_term_taxonomy(Mysqlcmd As MySqlCommand)
    21. Dim connStr As New MySqlConnectionStringBuilder With {
    22. .Server = Server,
    23. .Database = "wordpress",
    24. .UserID = User,
    25. .Password = Password,
    26. .Port = 3306
    27. }
    28. Using conn As New MySqlConnection(connStr.ToString)
    30. Await conn.OpenAsync()
    31. Mysqlcmd.Connection = conn
    32. Await Mysqlcmd.ExecuteNonQueryAsync()
    33. End Using
    35. End Sub


    Hier erhalte ich auch den Fehler, das es schon ein vorhandener openReader vorhanden ist.


    und Variante 3:
    Spoiler anzeigen

    Ich rufe eine Methode auf, welche direkt während die verbindung zur Datenbank besteht, jede geaddete Row in ein Mysqlcmd umwandelt, welcher dann ausgeführt wird.

    VB.NET-Quellcode

    1. Async Sub Iwp_terms()
    3. Dim Mysqlcmd As New MySqlCommand
    4. Dim connStr As New MySqlConnectionStringBuilder With {
    5. .Server = Server,
    6. .Database = "wordpress",
    7. .UserID = User,
    8. .Password = Password,
    9. .Port = 3306
    10. }
    12. Using conn As New MySqlConnection(connStr.ToString)
    13. Await conn.OpenAsync()
    14. Mysqlcmd.Connection = conn
    15. For Each item As Woocommerce.Woocommerce.Woocommerce.wp_termsRow In Program.Woocom.wp_terms.Select("", "", Data.DataViewRowState.Added)
    16. Mysqlcmd.CommandText = "INSERT INTO `wp_terms`(
    17. `term_id`,
    18. `name`,
    19. `slug`,
    20. `term_group`
    21. )
    22. VALUES(
    23. '" & item.term_id & "',
    24. '" & item.name & "',
    25. '" & item.slug & "',
    26. '" & item.term_group & "'
    27. )"
    28. Await Mysqlcmd.ExecuteNonQueryAsync()
    29. Next
    30. For Each item As Woocommerce.Woocommerce.Woocommerce.wp_termsRow In Program.Woocom.wp_terms.Select("", "", Data.DataViewRowState.ModifiedCurrent)
    32. Mysqlcmd.CommandText &= "UPDATE
    33. `wp_terms`
    34. SET
    36. `name` = '" & item.name & "',
    37. `slug` = '" & item.slug & "',
    38. `term_group` = '" & item.term_group & "'
    39. WHERE
    40. `term_id` = '" & item.term_id & "'"
    41. Await Mysqlcmd.ExecuteNonQueryAsync()
    42. Next
    43. For Each item As Woocommerce.Woocommerce.Woocommerce.wp_termsRow In Program.Woocom.wp_terms.Select("", "", Data.DataViewRowState.Deleted)
    44. Mysqlcmd.CommandText &= "DELETE FROM `wp_terms` WHERE `term_id` = '" & item.term_id & "'"
    45. Await Mysqlcmd.ExecuteNonQueryAsync()
    46. Next
    48. End Using
    50. End Sub


    Hier wird nur ein Datensatz zurückgespeichert.


    Ich denke, ich verstehe hier die Asynchrone Methode nicht so ganz. Wo ist hierbei mein Denkfehler?

    *Topic verschoben*

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    lern doch erstmal, wie man ganz normal ein Dataset in die Db updated.
    Da erzeugt man nicht für jeden Datensatz ein Command, und man verwendet auch DbParameter.
    Am einfachsten ist es mit einem DataAdapter.
    Ungefähr sowas:

    VB.NET-Quellcode

    1. using con=new MySqlConnection(<connectionstring>), cmd=new MySqlCommand("Select foo from bar", con), adp=new MySqlDataAdapter(cmd), bldr=new MySqlCommandBuilder(adp)
    2. adp.Update(<myDataTable>)
    3. End Using
    so ungefähr, such dir die Doku zu den angegebenen Begriffen. Am besten mittm CommandBuilder anfangen, da dürfte die Suche dannn auch ganz brauchbare Beispiele erbringen.

    Deine Vorgehensweise ist jdfs. komplett NoGo, du öffnest da Scheunentore für SqlInjection-Angriffe: gugge Must-Know: Sql-Injection


    Als nächste Stufe sollte man über einen Bulk-Insert nachdenken. Das ist aber eine Spezial-Vorgehensweise, die auch von jedem DbProvider anders abgehandelt wird, und wie MySql das macht weissichnich.
    Erst danach: Also wenn du gelernt hast, mit einem DataAdapter zu arbeiten (und somit SqlInjection-sicher programmieren kannst), und wenn das zu langsam ist, und du dann MySql-Bulk-Insert gelernt hast, und immer noch zu langsam - danach kannst du nochmal nach Async fragen.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Guten Morgen,

    also bei mehreren SQL Statements sammle ich diese in einen StringBuilder und übergeben diese gesammelt an den MySQL Server. Hier verwende ich aber kein Async, weil alles auf einmal übergeben wird. Allerdings sind es bei mir nicht so viele wie bei dir. Ich weiß nicht, ob es begrenzt ist. Aber du könntest es ja zu Testzwecken versuchen.

    Z.B (Hab jetzt nur Copy&Paste gemacht, sollte nur eine Anregung sein)

    VB.NET-Quellcode

    1. Private sqlCommands as StringBuilder = new StringBuilder()
    3. For Each item As Updater.productData.Unterkategorie4Row In productData.Unterkategorie4.Select("", "", DataViewRowState.Added)
    4. Command = ??? ' Muss noch zugewiesen werden
    5. Select Case Command
    6. Case "Insert"
    7. sqlCommands.AppenLine("INSERT INTO `unterkategorie4`(`ID`, `Name`, `Auslesen`, `Unter3ID`, `Pfad`) VALUES " _
    8. & "('" & item.ID & "','" & item.Name & "','" & item.Auslesen & "','" & item.Unter3ID & "','" & item.Pfad & "');")
    9. Case "Update"
    10. sqlCommands.AppenLine("UPDATE `unterkategorie4` SET `ID`='" & item.ID & " ',`Name`='" & item.Name & "',`Auslesen`='" & item.Auslesen & "',`Unter3ID`='" & item.Unter3ID & "',`Pfad`='" & item.Pfad & "' WHERE `ID` = '" & item.ID & "';")
    11. Case "Delete"
    12. sqlCommands.AppendLine("DELETE FROM `unterkategorie4` WHERE `ID` = '" & item.ID & "');")
    13. End Select
    14. Next
    16. Dim connStr As New MySqlConnectionStringBuilder With {
    17. .Server = Server,
    18. .Database = "productdata",
    19. .UserID = User,
    20. .Password = Password,
    21. .Port = 3306
    22. }
    23. Using conn As MySqlConnction = New MySqlConnection(connStr.ToString)
    24. if conn.State <> ConnectionState.Closed then
    25. conn.Close()
    26. end if
    27. conn.Open()
    28. using cmd as MySQLCommand = new MySqlCommand(sqlCommands.ToString(), conn)
    29. cmd.ExecuteNonQuery()
    30. using
    31. End Using


    Den Execute könntest auch Asynchron absetzen...

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „GerhardW“ ()

    So ich habe mir jetzt mal den Dataadapter und den BulkLoader bzw. BulkCopy angeschaut.

    Beim Dataadapter komme ich leider nicht weiter, bzgl. der übermittlung der Werte. Er erkennt zwar, das

    VB.NET-Quellcode

    1. Dim ConnStr As New MySqlConnectionStringBuilder With {
    2. .Server = "localhost",
    3. .Database = "wordpress",
    4. .UserID = "root"
    5. }
    7. Using conn As New MySqlConnection(ConnStr.ToString & ";Allow User Variables=true")
    8. conn.Open()
    10. Dim Adt As New MySqlDataAdapter
    12. Adt.InsertCommand = New MySqlCommand("insert into `wp_terms`(`term_id`,`name`, `slug`, `term_group`) values (@term_id,@name,@slug,@term_group)", conn) 'dem Adapter den InsertCommand zuweisen
    14. Adt.InsertCommand.Parameters.Add("@term_id", MySqlDbType.Int32) ' die Datentypen der jeweiligen Parameters zuweisen
    15. Adt.InsertCommand.Parameters.Add("@name", MySqlDbType.String)
    16. Adt.InsertCommand.Parameters.Add("@slug", MySqlDbType.String)
    17. Adt.InsertCommand.Parameters.Add("@term_group", MySqlDbType.Int32)
    19. Adt.Update(Woocommercer.wp_terms) ' Hinzugefügte Daten in die Datenbank schreiben
    20. End Using
    22. Sub AddnewStuff() 'Testweise hinzufügen neuer Daten
    23. For i As Integer = 0 To 10
    24. Woocommercer.wp_terms.Addwp_termsRow("Test" & i, "Test" & i, i)
    25. Next
    26. End Sub


    So, das resultat aus dem Code ist, das er mir 10 leere Spalten in der Datentabelle erstellt, ohne Werte. Sprich, ich muss dem Adapter noch sagen, das der Wert für "@name" in der Spalte "name" aus dem DataSet ist. Nur wie kann ich diese Relation übergeben?

    Den Update und Delete Command werde ich noch hinzufügen, wenn der InsertCommand funktioniert, da ich denke, das diese gleich aufgebaut ist

    @GerhardW danke, so habe ich es ja auch gemacht. Jedoch ist hierbei der Nachteil der Möglichkeit einer Injection, wodurch die Daten aus der Datenbank ausgegeben werden können z.B.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „trix0“ ()

    In deinen Zeilen 14-17 fügst du neue Parameter hinzu, schön. Nur fehlt eben der eigentliche Wert der Parameter.

    Infos dazu findest du hier, wenn du ganz noch unten scrollst.

    das habe ich auch schon probiert. Leider trägt er dann 10 mal den selben wert ein:

    VB.NET-Quellcode

    1. Sub Main(args As String())
    2. LoadData()
    3. AddnewStuff()
    4. For Each item As MySQLBULKLOADERTEST.Woocommerce.wp_termsRow In Woocommercer.wp_terms.Select("", "", Data.DataViewRowState.Added)
    5. SaveData(item)
    7. Next
    9. End Sub
    10. Sub SaveData(item As MySQLBULKLOADERTEST.Woocommerce.wp_termsRow)
    12. Dim ConnStr As New MySqlConnectionStringBuilder With {
    13. .Server = "localhost",
    14. .Database = "wordpress",
    15. .UserID = "root"
    16. }
    18. Using conn As New MySqlConnection(ConnStr.ToString & ";Allow User Variables=true;AllowLoadLocalInfile=true")
    19. conn.Open()
    21. Dim Adt As New MySqlDataAdapter()
    23. Adt.InsertCommand = New MySqlCommand("insert into `wp_terms`(`name`, `slug`, `term_group`) values (@name,@slug,@term_group)", conn)
    25. Adt.InsertCommand.Parameters.Add("@name", MySqlDbType.String).Value = item.name
    26. Adt.InsertCommand.Parameters.Add("@slug", MySqlDbType.String).Value = item.slug
    27. Adt.InsertCommand.Parameters.Add("@term_group", MySqlDbType.Int32).Value = item.term_group
    28. Adt.Update(Woocommercer, "wp_terms")
    30. End Using
    32. End Sub
    34. Sub AddnewStuff()
    35. For i As Integer = 0 To 10
    36. Woocommercer.wp_terms.Addwp_termsRow("Test;" & i, "Test;" & i, i)
    37. Next
    39. 'Dim merow = Woocommercer.wp_terms.LastOrDefault(Function(x) x.name = "Allgemein")
    41. 'merow.name = "Test Allgemein"
    43. End Sub


    ich bekomme 10 man dann den Wert Typ:0 zurückgespeichert und nicht wie gewünscht durchnummeriert.

    in post#2 empfahl ich, dass du nach Codebeispielen für CommandBuilder suchst.
    Dein Umgang mittm DataAdapter ist so falsch, dass ich kaum glaube, dass du meine Empfehlung umgesetzt hast.
    Kein Mensch (soweitichweiss) würde einem DataAdapter ein InsertCommand zuweisen - oder fandest du tatsächlich Vorlagen, die solch ein Vorgehen zeigteten?

    hier ein einfaches Bsp. "Insert mit Ratenzahlun(en)" durchnummeriert

    VB.NET-Quellcode

    1. 'command: Insert Ratenzahlungen
    2. 'tabellen Felder:
    3. 'ID = Autoincrement
    4. 'RatenNr = Integer
    5. 'Ratenbetraege = Double
    6. 'RatenDatum = Date
    7. 'RechnungsNr = Integer
    9. Public Sub AddRatenzahlungen(ByVal nZahlungen As Integer, _
    10. ByVal RechnungsBetrag As Double, _
    11. ByVal RatenDatum As Date, _
    12. ByVal RechnungsNr As Integer)
    13. Dim sDB As String = "D:\TestCheck.mdb"
    14. Dim sCon As String = "Provider=Microsoft.Jet.OLEDB.4.0;" & _
    15. "Data Source=" & sDB & ";"
    16. Dim Ratenbetraege As Double = FormatNumber(RechnungsBetrag / nZahlungen, 2)
    17. Dim Con As OleDb.OleDbConnection = New OleDb.OleDbConnection(sCon)
    18. Con.Open()
    20. For iCounter = 1 To nZahlungen Step 1
    21. Dim sql = <sql>
    22. Insert Into tbl_RatenPlan
    23. (RatenNr,Ratenbetraege,RatenDatum,RechnungsNr) Values (?,?,?,?)
    24. </sql>.Value
    25. Dim cmd As New OleDb.OleDbCommand(sql, Con)
    26. cmd.Parameters.Add("RatenNr", OleDbType.Integer).Value = iCounter
    27. cmd.Parameters.AddWithValue("Ratenbetraege", Ratenbetraege)
    28. cmd.Parameters.AddWithValue("RatenDatum", RatenDatum.AddMonths(iCounter - 1))
    29. cmd.Parameters.AddWithValue("RechnungsNr", RechnungsNr)
    30. cmd.ExecuteNonQuery()
    31. Debug.WriteLine(String.Join(",", iCounter, Ratenbetraege, RatenDatum.AddMonths(iCounter - 1), RechnungsNr))
    33. Next
    34. Con.Close()
    35. End Sub
    37. Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button2.Click
    38. 'AddRatenzahlungen parameters:
    39. '1) wieviele Raten = 15
    40. '2) RechnungsBetrag = 3253.12
    41. '3) erste Rate fällig = 17.11.2022
    42. '4) RechnungsNr(Fremdschlüssel) = 123
    43. AddRatenzahlungen(15, 3253.12, CDate("17.11.2022"), 123)
    44. End Sub


    verwendet habe ich eine Access DB

    Okay, ich hab es (glaube ich) jetzt richtig gemacht. Zumindest erhalte ich das gewünschte Resultat

    VB.NET-Quellcode

    1. Sub SaveData()
    3. Dim ConnStr As New MySqlConnectionStringBuilder With {
    4. .Server = "localhost",
    5. .Database = "wordpress",
    6. .UserID = "root"
    7. }
    9. Using conn As New MySqlConnection(ConnStr.ToString)
    10. conn.Open()
    11. Dim Dtadapter As New MySqlDataAdapter("Select * from wp_terms", conn)
    13. Dim test As New MySqlCommandBuilder(Dtadapter)
    15. Dtadapter.Update(Woocommercer, "wp_terms")
    17. End Using
    19. End Sub


    Die Daten für die Verbindung sind testweise, diese habe ich zu testzwecken in Klartext rein geschrieben. Kann es wirklich so einfach sein, SQL-Injection sicher zu programmieren?

    trix0 schrieb:

    Kann es wirklich so einfach sein, SQL-Injection sicher zu programmieren?
    Ja.
    Deswegen regichmich ja immer auf, wenns nicht gemacht wird.
    Eiglich reg ich mich auf, dasses überhaupt erlaubt - bzw dasses ühaupt möglich ist, es zu unterlassen.
    Es gibt weltweite Untersuchungen zu IT-Sicherheitslücken und was sie an Schaden anrichten, und SqlInjection rangiert mit Abstand auf Platz 1.
    Und das komplett unnötigerweise.

    Imo müsste man einen Sql-Dialekt auf den Markt bringen, bei dem Werte überhaupt nicht mehr unparametrisiert codierbar sind.


    Aber jetzt guck nochma post#2.
    Ich habe 1) connection, 2) command, 3) dataAdapter und 4) CommandBuilder alle im Using-Block, sodass sie nach verwendung disposed werden.
    bei dir wird nur die connection disposed.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „ErfinderDesRades“ ()

Facebook
Telefonspende