Legen Sie den gesamten Wert der DataTable bulk in postgreSQL Tabelle

Einfach Einfügen Über Parameter

Ihrem Projekt verweisen müssen den folgenden Aufbau: Npgsql. Wenn dieser Verweis nicht sichtbar innerhalb Visual Studio, dann:

1. durchsuchen, um den connector-Installationsordner
2. Ausführen: GACInstall.exe
3. Neu Starten Visual Studio.

Beispieltabelle

CREATE TABLE "OrderHistory"
(
  "OrderId" bigint NOT NULL,
  "TotalAmount" bigint,
  CONSTRAINT "OrderIdPk" PRIMARY KEY ("OrderId")
)
WITH (
  OIDS=FALSE
);
ALTER TABLE "OrderHistory"
  OWNER TO postgres;
GRANT ALL ON TABLE "OrderHistory" TO postgres;
GRANT ALL ON TABLE "OrderHistory" TO public;
ALTER TABLE "OrderHistory" ALTER COLUMN "OrderId" SET (n_distinct=1);

GRANT SELECT("OrderId"), UPDATE("OrderId"), INSERT("OrderId"), REFERENCES("OrderId") ON "OrderHistory" TO public;
GRANT SELECT("TotalAmount"), UPDATE("TotalAmount"), INSERT("TotalAmount"), REFERENCES("TotalAmount") ON "OrderHistory" TO public;

Beispielcode

Sicher sein, verwenden Sie die folgenden Richtlinien:

using Npgsql;
using NpgsqlTypes;

Geben Sie den folgenden Quellcode in Ihre Methode:

//Make sure that the user has the INSERT privilege for the OrderHistory table.
NpgsqlConnection connection = new NpgsqlConnection("PORT=5432;TIMEOUT=15;POOLING=True;MINPOOLSIZE=1;MAXPOOLSIZE=20;COMMANDTIMEOUT=20;COMPATIBLE=2.2.4.3;DATABASE=test;HOST=127.0.0.1;PASSWORD=test;USER ID=test");

connection.Open();

DataSet dataSet = new DataSet();

NpgsqlDataAdapter dataAdapter = new NpgsqlDataAdapter("select * from OrderHistory where OrderId=-1", connection);
dataAdapter.InsertCommand = new NpgsqlCommand("insert into OrderHistory(OrderId, TotalAmount) " +
                        " values (:a, :b)", connection);
dataAdapter.InsertCommand.Parameters.Add(new NpgsqlParameter("a", NpgsqlDbType.Bigint));
dataAdapter.InsertCommand.Parameters.Add(new NpgsqlParameter("b", NpgsqlDbType.Bigint));
dataAdapter.InsertCommand.Parameters[0].Direction = ParameterDirection.Input;
dataAdapter.InsertCommand.Parameters[1].Direction = ParameterDirection.Input;
dataAdapter.InsertCommand.Parameters[0].SourceColumn = "OrderId";
dataAdapter.InsertCommand.Parameters[1].SourceColumn = "TotalAmount";

dataAdapter.Fill(dataSet);

DataTable newOrders = dataSet.Tables[0];
DataRow newOrder = newOrders.NewRow();
newOrder["OrderId"] = 20;
newOrder["TotalAmount"] = 20.0;

newOrders.Rows.Add(newOrder);
DataSet ds2 = dataSet.GetChanges();
dataAdapter.Update(ds2);
dataSet.Merge(ds2);
dataSet.AcceptChanges();

connection.Close();

Gedanken Auf Die Leistung

Den original-Beitrag keine Erwähnung von performance-Anforderungen. Es wurde beantragt, dass die Lösung des Problems muss:

1. einfügen mit einem DataTable
2. einfügen von Daten ohne Verwendung einer Schleife

Wenn Sie das einfügen, erhebliche Mengen von Daten, dann würde ich vorschlagen, dass Sie werfen Sie einen Blick auf Ihre performance-Optionen. Die Postgres Dokumentation schlägt vor, dass Sie:

• Deaktivieren Der Autocommit -
• Verwenden Sie die COPY Befehl
• Entfernen Indizes
• Entfernen Foreign Key-Einschränkungen
• etc.

Weitere Informationen über die Optimierung von Postgres-Einsätze, bitte schauen Sie auf:

• PostgresSql.org: Einfügen Von Daten
• PostgresSql.org: Einfügen + Performance Tipps
• StackOverflow: Wie zu beschleunigen einfügen Leistung in PostgreSQL

Außerdem gibt es eine Menge anderer Faktoren, die Auswirkungen auf Systemleistung. Für eine high-level Einführung, werfen Sie einen Blick auf:

• ADO.NET SQL Server Performance-Engpass
  • Dieser Beitrag skizziert die Allgemeinen (d.h. nicht-SqlServer) Strategien zur Optimierung von performance.

Andere Optionen

• Stimmt das .NET connector-Unterstützung der Postgres Copy Befehl?
  • Wenn nicht, können Sie laden Sie die source code für die Npgsql Stecker und fügen Sie Ihre eigenen BulkCopy() Methode. Werden Sie sicher, überprüfen Sie die Quell-code-Lizenzierungs-Vereinbarung zuerst.
• Überprüfen, um zu sehen, ob Postgres unterstützt Tabellenwert-Parameter.
  • Dieser Ansatz ermöglicht Ihnen, eine Tabelle in eine Postgres - Funktion, die können dann legen Sie die Daten direkt in das Ziel.
• Kauf einer Postgres .NET-connector von einem Hersteller, die auch die erforderliche Funktion.

Weitere Verweise

• Postgres .NET Connector - frei & open-source -

Ich habe auch festgestellt, dass es keine "ready to use" - Lösung noch nicht. Wahrscheinlich können Sie überprüfen, meine andere Antwort, in dem ich beschreibe, ein kleiner Helfer den ich erstellt habe für dieses problem den Einsatz der anderen Helfer wirklich einfach: https://stackoverflow.com/a/46063313/6654362
Ich denke, das ist derzeit die beste Lösung.
Ich geschrieben das die Lösung aus dem link in das Amt starb.

Bearbeiten:
Ich habe vor kurzem laufen in ähnliches problem, aber wir waren mit Postgresql. Ich wollte verwenden Sie eine effektive bulkinsert, was sich als ziemlich schwierig. Ich habe nicht gefunden eine angemessene freie Bibliothek, dies zu tun auf dieser DB. Ich fand nur diese Helfer:
https://bytefish.de/blog/postgresql_bulk_insert/
die ist auch auf Nuget. Ich habe geschrieben eine kleine mapper, die automatisch zugeordneten Eigenschaften den Weg Entity Framework:

public static PostgreSQLCopyHelper<T> CreateHelper<T>(string schemaName, string tableName)
        {
            var helper = new PostgreSQLCopyHelper<T>("dbo", "\"" + tableName + "\"");
            var properties = typeof(T).GetProperties();
            foreach(var prop in properties)
            {
                var type = prop.PropertyType;
                if (Attribute.IsDefined(prop, typeof(KeyAttribute)) || Attribute.IsDefined(prop, typeof(ForeignKeyAttribute)))
                    continue;
                switch (type)
                {
                    case Type intType when intType == typeof(int) || intType == typeof(int?):
                        {
                            helper = helper.MapInteger("\"" + prop.Name + "\"",  x => (int?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type stringType when stringType == typeof(string):
                        {
                            helper = helper.MapText("\"" + prop.Name + "\"", x => (string)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type dateType when dateType == typeof(DateTime) || dateType == typeof(DateTime?):
                        {
                            helper = helper.MapTimeStamp("\"" + prop.Name + "\"", x => (DateTime?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type decimalType when decimalType == typeof(decimal) || decimalType == typeof(decimal?):
                        {
                            helper = helper.MapMoney("\"" + prop.Name + "\"", x => (decimal?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type doubleType when doubleType == typeof(double) || doubleType == typeof(double?):
                        {
                            helper = helper.MapDouble("\"" + prop.Name + "\"", x => (double?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type floatType when floatType == typeof(float) || floatType == typeof(float?):
                        {
                            helper = helper.MapReal("\"" + prop.Name + "\"", x => (float?)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                    case Type guidType when guidType == typeof(Guid):
                        {
                            helper = helper.MapUUID("\"" + prop.Name + "\"", x => (Guid)typeof(T).GetProperty(prop.Name).GetValue(x, null));
                            break;
                        }
                }
            }
            return helper;
        }

Ich es auf dem folgenden Weg (ich hatte entity named Unternehmen):

var undertakingHelper = BulkMapper.CreateHelper<Model.Undertaking>("dbo", nameof(Model.Undertaking));
undertakingHelper.SaveAll(transaction.UnderlyingTransaction.Connection as Npgsql.NpgsqlConnection, undertakingsToAdd));

Zeigte ich ein Beispiel mit der Transaktion, es kann aber auch mit der normalen Verbindung abgerufen aus dem Kontext. undertakingsToAdd Durchlaufen der normalen Entität Datensätze, die ich möchte bulkInsert in die DB.

Diese Lösung, auf die ich habe nach ein paar Stunden der Forschung und versucht, so, wie man erwarten konnte, viel schneller und schließlich einfach zu bedienen und kostenlos! Ich wirklich empfehlen, dass Sie diese Lösung verwenden, nicht nur für die oben genannten Gründen, aber auch, weil es der einzige ist, mit dem hatte ich keine Probleme mit Postgresql selbst, viele andere Lösungen, die einwandfrei funktionieren zum Beispiel mit SqlServer.