Vorbereitete Anweisungen für weite Einfügungen verwenden

Die Methode PreparedStatement.addBatch() ist bei der Durchführung von Einfügungen in Stapeln (weiten Einfügungen) nützlich. Es folgen einige Richtlinien zur Verwendung dieser Methode.

Eine INSERT-Anweisung sollte unter Verwendung einer der Connection.prepareStatement()-Methoden vorbereitet werden.

// Build the INSERT statement
String sqlStr = "INSERT INTO Departments " +
            "( DepartmentID, DepartmentName ) " +
            "VALUES ( ? , ? )";
// Prepare the statement
PreparedStatement stmt =
     con.prepareStatement( sqlStr );

Die Parameter für die vorbereitete INSERT-Anweisung sollten folgendermaßen festgelegt und in Stapeln gesetzt werden.

// loop to batch "n" sets of parameters
for( i=0; i < n; i++ ) 
{
    // Note "stmt" is the original prepared insert statement from step 1.
    stmt.setSomeType( 1, param_1 );
    stmt.setSomeType( 2, param_2 );
    .
    .
    .
    // Note that there are "m" parameters in the statement.
    stmt.setSomeType( m , param_m );

    // Add the set of parameters to the batch and 
    // move to the next row of parameters.
    stmt.addBatch(); 
}

Beispiel:

for( i=0; i < 5; i++ ) 
{    
    stmt.setInt( 1, idValue );
    stmt.setString( 2, name );
    stmt.addBatch();
}

Der Stapel sollte anschließend unter Verwendung der Methode PreparedStatement.executeUpdate() ausgeführt werden.

Beachten Sie, dass nur die Methode PreparedStatement.addBatch() unterstützt wird und die Methode PreparedStatement.executeUpdate() aufgerufen werden muss, um den Stapel auszuführen. Es werden keine Methoden für das Anweisungsobjekt (d.h. Statement.addBatch(), Statement.clearBatch(), Statement.executeBatch() ) unterstützt, weil diese Methoden vollständig optional und nicht sehr nützlich sind. Bei solchen statischen Stapeln ist es am besten, Statement.execute() oder Statement.executeQuery() in einer einzigen Zeichenfolge aufzurufen, wobei die gestapelten Anweisungen innerhalb von BEGIN...END gesetzt werden.

Hinweise

BLOB-Parameter werden in Batches nicht unterstützt.
Zeichenfolgen-/Binärdaten-Parameter werden unterstützt, aber die Größe solcher Parameter kann zu einem Problem werden. Standardmäßig ist der Zeichenfolgen-/Binärdaten-Parameter auf 255 Zeichen oder 510 Byte beschränkt. Der Grund für diese Beschränkung ist das ODBC-Protokoll, das hier nicht im einzelnen erörtert werden kann. Um weitere Hinweise zu erhalten, wird empfohlen, die Dokumentation zur Weiterleitung von Parameter-Arrays in ODBC zu lesen. Wenn eine Anwendung größere Zeichenfolgen- oder Binärdaten-Parameter in einem Stapel übergeben muss, gibt es eine zusätzliche Methode, setBatchStringSize, um die Größe des Zeichenfolgen-/Binärdaten-Parameters zu erhöhen. Beachten Sie, dass diese Methode vor dem ersten addBatch()-Aufruf aufgerufen werden muss. Wenn die Methode nach dem ersten addBatch()-Aufruf aufgerufen wird, wird die neue Größeneinstellung ignoriert. Wenn diese Methode zum Ändern der Größe eines Zeichenfolgen-/Binärdaten-Parameters aufgerufen wird, muss daher die Anwendung vorher wissen, was der maximale Zeichenfolgen- oder Binärdatenwert für diesen Parameter sein wird.

Um die Methode setBatchStringSize zu verwenden, müssen Sie den obenstehenden "Code" folgendermaßen ändern:

// You need to cast "stmt" to an IPreparedStatment object 
// to change the size of string/binary parameters.
ianywhere.ml.jdbcodbc.IPreparedStatement _stmt =
    (ianywhere.ml.jdbcodbc.IPreparedStatement)stmt;

// Now, for example, change the size of string parameter 4 
// from the default 255 characters to 300 characters.
// Note that string parameters are measured in "characters".
_stmt.setBatchStringSize( 4, 300 ); 

// Change the size of binary parameter 6 
// from the default 510 bytes to 750 bytes.
// Note that binary parameters are measured in "bytes".
_stmt.setBatchStringSize( 6, 750 ); 

// loop to batch "n" sets of parameters 
// where n should not be too large
for( i=0; i < n; i++ )
{
    // stmt is the prepared insert statement from step 1
    stmt.setSomeType( 1, param_1 ); 
    stmt.setSomeType( 2, param_2 );
    .
    .
    .
    // Note that there are "m" parameters in the statement.
    stmt.setSomeType( m , param_m );

    // Add the set of parameters to the batch and 
    // move to the next row of parameters.
    stmt.addBatch(); 
}

Die maximale Zeichenfolgen-/Binärdatengröße sollte nur mit Vorsicht geändert werden. Wenn das Maximum zu hoch angesetzt ist, werden die zusätzlichen Speicherzuweisungskosten wahrscheinlich etwaige Performancesteigerungen aufwiegen, die von der Verwendung des Stapels herrühren. Auch besteht die Möglichkeit, dass die Anwendung den maximalen Zeichenfolgen-/Binärdatenwert bei einem bestimmten Parameter nicht kennt. Daher wird empfohlen, die maximale Zeichenfolgen- oder Binärdatengröße eines Parameters nicht zu ändern, sondern stattdessen die Stapelmethode zu verwenden, bis auf einen Zeichenfolgen- oder Binärdatenwert gestoßen wird, der größer als der aktuelle bzw. der Standardwert ist. Die Anwendung kann an diesem Punkt executeBatch() aufrufen, um die Parameter auszuführen, die derzeit im Stapel sind, und dann den regulären Satz und die Methode executeUpdate()aufrufen, bis die großen Zeichenfolgen-/Binärdaten-Parameter verarbeitet sind, um dann in den Stapelmodus zurückzuwechseln, wenn wieder kleinere Zeichenfolgen-/Binärdaten-Parameter angetroffen werden.

Kommentieren Sie diese Seite in DocCommentXchange.
Senden Sie uns Feedback über diese Seite via E-Mail.