1. Beschreibung

In JDBC kann die Methode ?executeBatch“ mehrere DML-Anweisungen stapelweise ausführen, und die Effizienz ist viel h?her als die einzelne Ausführung von ?executeUpdate“. Wie implementiert man die Batch-Ausführung in MySQL und Oracle? Dieser Artikel stellt Ihnen das Prinzip dahinter vor.

2. Einführung in das Experiment

Dieses Experiment wird in den folgenden drei Schritten durchgeführt:a Zeichnen Sie den Zeitaufwand für die Stapelausführung und die Einzelausführung von JDBC auf und Einzelausführung von JDBC in Oracle

c Zeichnen Sie die zeitaufw?ndige Ausführung von Oracle Plsql und Einzelausführung auf

Die relevanten Java- und Datenbankversionen sind wie folgt: Java17, Mysql8, Oracle11G

Erstellen eine Tabelle in MySQL bzw. Oracle

create table t (  -- mysql中創(chuàng)建表的語句
    id    int,
    name1 varchar(100),
    name2 varchar(100),
    name3 varchar(100),
    name4 varchar(100)
);

create table t (  -- oracle中創(chuàng)建表的語句
    id    number,
    name1 varchar2(100),
    name2 varchar2(100),
    name3 varchar2(100),
    name4 varchar2(100)
);

Vor dem Experiment müssen Sie die Prüfung der Datenbank aktivieren

Ein paar Punkte sind im Code zu beachten:

MySQL-URL muss hinzugefügt werden useServerPrepStmts= true&rewriteBatchedStatements=true Parameter.

batchCnt stellt die Anzahl der in jedem Stapel ausgeführten SQL-Anweisungen dar, und 0 steht für eine einzelne Ausführung.

Erster MySQL-Test

set global general_log = 1;

Geben Sie verschiedene BatchCnt-Werte ein, um die Ausführungszeit anzuzeigen

• batchCnt=50 Gesamtzahl der Elemente: 10000, Einfügung pro Stapel: 50, Gesamtzeit: 4369 Millisekunden

  batchCnt= 100 Gesamtzahl der Elemente: 10000, jeder Einfügungsstapel: 100, Gesamtzeitverbrauch: 2598 Millisekunden
batchCnt=200 Gesamtzahl der Elemente: 10000, jeder Einfügungsstapel: 200, Gesamtzeitverbrauch: 2211 Millisekunden
• batchCnt=1000 Gesamt Anzahl der Elemente: 10000, jeder Stapel von Einfügungen: 1000, Gesamtzeitaufwand: 2099 Millisekunden

  batchCnt=10000 Gesamtzahl der Elemente: 10000, jeder Stapeleinfügung: 10000, Gesamtzeitaufwand: 2418 Millisekunden

  batchCnt=0 Gesamtzahl der Elemente : 10000, einzelne Einfügung, insgesamt aufgewendete Zeit: 59620 Millisekunden

Sehen Sie sich das allgemeine Protokoll an

batchCnt=5

batchCnt=0

Wir k?nnen mehrere Schlussfolgerungen ziehen:



Die Effizienz der Stapelausführung ist im Vergleich erheblich verbessert zur Einzelausführung.

Die Stapelausführung von MySQL schreibt SQL tats?chlich neu und führt mehrere Einfügungen zur Ausführung in Einfügung xx Werte (), () ... zusammen.

Beim ?ndern von batchCnt von 50 auf 100 verkürzt sich die Zeit grunds?tzlich um die H?lfte, aber wenn der Wert erweitert wird, ist die Zeitverkürzung nicht offensichtlich und die Ausführungszeit erh?ht sich sogar.

• Analysegrund:

Nachdem der Client die auszuführende SQL-Anweisung an den Datenbankserver gesendet hat, führt die Datenbank die SQL-Anweisung aus und gibt das Ergebnis an den Client zurück. Gesamtzeitaufwand = Datenbankausführungszeit + Netzwerkübertragungszeit. Die Reduzierung der Anzahl der Roundtrips durch Batch-Ausführung reduziert die Netzwerkübertragungszeit und damit die Gesamtzeit. Wenn jedoch ?batchCnt“ gr??er wird, ist die Verkürzung der Gesamtzeit nicht so offensichtlich, selbst wenn die Netzwerkübertragungszeit nicht mehr der Hauptengpass ist. Insbesondere wenn ?batchCnt=10000“, also alle 10.000 Anweisungen gleichzeitig ausgeführt werden, wird die Zeit l?nger. Dies kann daran liegen, dass das Programm und die Datenbank bei der Vorbereitung dieser Eingabeparameter mehr Zeit ben?tigen. Ich sch?tze).

• Noch etwas: Kann der Wert von ?batchCnt“ unendlich gro? sein? Angenommen, ich muss 100 Millionen Artikel einfügen. Kann ich dann 100 Millionen Artikel gleichzeitig einfügen? Natürlich nicht, wir berücksichtigen nicht das Platzproblem beim Rückg?ngigmachen. Erstens verfügt Ihr Computer nicht über einen so gro?en Speicher, um alle 100 Millionen SQL-Eingabeparameter auf einmal zu speichern. Zweitens verfügt MySQL auch über einen Parameter max_allowed_packet Die L?nge einer einzelnen Anweisung betr?gt maximal 1 GB. Wenn die Anweisung zu lang ist, wird die Meldung ?Paket für Abfrage ist zu gro? (1.773.901 > 1.599.488)“ gemeldet. Sie k?nnen diesen Wert auf dem Server ?ndern, indem Sie die Variable ?max_allowed_packet“ festlegen. Als n?chstes testen Sie Oracle Gesamtzahl der Elemente: 10000, jeder Einfügungsstapel: 100, Gesamtzeitverbrauch: 1324 Millisekunden
batchCnt=200 Gesamtzahl der Elemente: 10000, jeder Einfügungsstapel: 200, Gesamtzeitverbrauch: 856 Millisekunden
• batchCnt=1000 Gesamtzahl Anzahl der Elemente: 10.000, jeder Stapel von Einfügungen: 1.000, Gesamtzeitaufwand: 785 Millisekunden

  batchCnt=10.000 Gesamtzahl der Elemente: 10.000, jeder Stapeleinfügung: 10.000, Gesamtaufwand: 804 Millisekunden

  batchCnt=0 Gesamtzahl der Elemente: 10000, einzelne Einfügung, insgesamt aufgewendete Zeit: 60830 Millisekunden

Der Effekt der Ausführung in Oracle ist grunds?tzlich der gleiche wie der in MySQL, und die Effizienz von Batch-Vorg?ngen ist deutlich h?her als die der Einzelausführung. Das Problem besteht darin, dass es in Oracle keine solche Syntax zum Einfügen von xx-Werten(),()... gibt. Wie wird also eine Stapelausführung erreicht?

Sehen Sie sich die Audit-Ansicht dba_audit_trail an, wenn ?batchCnt=50“ ausgeführt wird

從審計的結果中可以看到，batchCnt=50的時候，審計記錄只有200條（扣除登入和登出），也就是sql只執(zhí)行了200次。sql_text沒有發(fā)生改寫，仍然是"insert into t values (:1 , :2 , :3 , :4 , :5 )"，而且sql_bind只記錄了批量執(zhí)行的最后一個參數(shù)，即50的倍數(shù)。根據(jù)awr報告可以看出，實際只執(zhí)行了200次（由于篇幅限制，省略了awr截圖）。那么oracle是怎么做到只執(zhí)行200次但插入1萬條記錄的呢？我們來看看oracle中使用存儲過程的批量插入。

四、存儲過程

準備數(shù)據(jù)：

首先將t表清空 truncate table t;

用java往t表灌10萬數(shù)據(jù) exec("oracle", 100000, 1000);

創(chuàng)建t1表 create table t1 as select * from t where 1 = 0;

以下兩個過程的意圖一致，均為將t表中的數(shù)據(jù)導入t1表。nobatch是單次執(zhí)行，usebatch是批量執(zhí)行。

create or replace procedure nobatch is
begin
  for x in (select * from t)
  loop
    insert into t1 (id, name1, name2, name3, name4)
    values (x.id, x.name1, x.name2, x.name3, x.name4);
  end loop;
  commit;
end nobatch;
/

create or replace procedure usebatch (p_array_size in pls_integer)
is
  type array is table of t%rowtype;
  l_data array;
  cursor c is select * from t;
begin
  open c;
  loop
    fetch c bulk collect into l_data limit p_array_size;
    forall i in 1..l_data.count insert into t1 values l_data(i);
    exit when c%notfound;
  end loop;
  commit;
  close c;
end usebatch;
/

執(zhí)行上述存儲過程

SQL> exec nobatch; ?
Elapsed: 00:00:32.92

SQL> exec usebatch(50);
Elapsed: 00:00:00.77

SQL> exec usebatch(100);
Elapsed: 00:00:00.47

SQL> exec usebatch(1000);
Elapsed: 00:00:00.19

SQL> exec usebatch(100000);
Elapsed: 00:00:00.26

存儲過程批量執(zhí)行效率也遠遠高于單條執(zhí)行。查看usebatch(50)執(zhí)行時的審計日志，sql_bind也只記錄了批量執(zhí)行的最后一個參數(shù)，即50的倍數(shù)。與使用executeBatch方法在記錄內容方面相同。因此可以推斷，JDBC的executeBatch和存儲過程的批量執(zhí)行都采用了相同的方法

存儲過程的這個關鍵點就是forall。查閱相關文檔。

The FORALL statement runs one DML statement multiple times, with different values in the VALUES and WHERE clauses.
The different values come from existing, populated collections or host arrays. The FORALL statement is usually much faster than an equivalent FOR LOOP statement.
The FORALL syntax allows us to bind the contents of a collection to a single DML statement, allowing the DML to be run for each row in the collection without requiring a context switch each time.

翻譯過來就是forall很快，原因就是不需要每次執(zhí)行的時候等待參數(shù)。

Das obige ist der detaillierte Inhalt vonSo implementieren Sie JDBC-Batch-Insert in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!