Example usage for org.apache.commons.dbutils QueryRunner batch

List of usage examples for org.apache.commons.dbutils QueryRunner batch

Introduction

In this page you can find the example usage for org.apache.commons.dbutils QueryRunner batch.

Prototype

public int[] batch(Connection conn, String sql, Object[][] params) throws SQLException 

Source Link

Document

Execute a batch of SQL INSERT, UPDATE, or DELETE queries.

Usage

From source file:com.ouc.cpss.dao.BaseDao.java

/**
 * ?//w ww.j av  a  2  s .  c om
 *
 * @param conn 
 * @param sql sql?
 * @param params ??
 * @return
 */
public boolean batchUpdate(Connection conn, String sql, Object[][] params) throws SQLException {
    QueryRunner qRunner = new QueryRunner();
    int result = 0;
    boolean flag = false;
    result = qRunner.batch(conn, sql, params).length;
    if (result > 0) {
        flag = true;
    }
    return flag;
}

From source file:com.netflix.metacat.usermetadata.mysql.MysqlUserMetadataService.java

@Override
public void saveMetadatas(final String user, final List<? extends HasMetadata> metadatas, final boolean merge) {
    try {/*w  w w.  ja v a 2 s. com*/
        final Connection conn = poolingDataSource.getConnection();
        try {
            @SuppressWarnings("unchecked")
            final List<List<HasMetadata>> subLists = Lists.partition((List<HasMetadata>) metadatas,
                    config.getUserMetadataMaxInClauseItems());
            for (List<HasMetadata> hasMetadatas : subLists) {
                final List<String> uris = Lists.newArrayList();
                final List<QualifiedName> names = Lists.newArrayList();
                // Get the names and uris
                final List<HasDefinitionMetadata> definitionMetadatas = Lists.newArrayList();
                final List<HasDataMetadata> dataMetadatas = Lists.newArrayList();
                hasMetadatas.stream().forEach(hasMetadata -> {
                    if (hasMetadata instanceof HasDefinitionMetadata) {
                        final HasDefinitionMetadata oDef = (HasDefinitionMetadata) hasMetadata;
                        names.add(oDef.getDefinitionName());
                        if (oDef.getDefinitionMetadata() != null) {
                            definitionMetadatas.add(oDef);
                        }
                    }
                    if (hasMetadata instanceof HasDataMetadata) {
                        final HasDataMetadata oData = (HasDataMetadata) hasMetadata;
                        if (oData.isDataExternal() && oData.getDataMetadata() != null
                                && oData.getDataMetadata().size() > 0) {
                            uris.add(oData.getDataUri());
                            dataMetadatas.add(oData);
                        }
                    }
                });
                if (!definitionMetadatas.isEmpty() || !dataMetadatas.isEmpty()) {
                    // Get the existing metadata based on the names and uris
                    final Map<String, ObjectNode> definitionMap = getDefinitionMetadataMap(names);
                    final Map<String, ObjectNode> dataMap = getDataMetadataMap(uris);
                    // Curate the list of existing and new metadatas
                    final List<Object[]> insertDefinitionMetadatas = Lists.newArrayList();
                    final List<Object[]> updateDefinitionMetadatas = Lists.newArrayList();
                    final List<Object[]> insertDataMetadatas = Lists.newArrayList();
                    final List<Object[]> updateDataMetadatas = Lists.newArrayList();
                    definitionMetadatas.stream().forEach(oDef -> {
                        final QualifiedName qualifiedName = oDef.getDefinitionName();
                        if (qualifiedName != null && oDef.getDefinitionMetadata() != null
                                && oDef.getDefinitionMetadata().size() != 0) {
                            final String name = qualifiedName.toString();
                            final ObjectNode oNode = definitionMap.get(name);
                            if (oNode == null) {
                                insertDefinitionMetadatas.add(
                                        new Object[] { metacatJson.toJsonString(oDef.getDefinitionMetadata()),
                                                user, user, name, });
                            } else {
                                metacatJson.mergeIntoPrimary(oNode, oDef.getDefinitionMetadata());
                                updateDefinitionMetadatas
                                        .add(new Object[] { metacatJson.toJsonString(oNode), user, name });
                            }
                        }
                    });
                    dataMetadatas.stream().forEach(oData -> {
                        final String uri = oData.getDataUri();
                        final ObjectNode oNode = dataMap.get(uri);
                        if (oData.getDataMetadata() != null && oData.getDataMetadata().size() != 0) {
                            if (oNode == null) {
                                insertDataMetadatas.add(new Object[] {
                                        metacatJson.toJsonString(oData.getDataMetadata()), user, user, uri, });
                            } else {
                                metacatJson.mergeIntoPrimary(oNode, oData.getDataMetadata());
                                updateDataMetadatas
                                        .add(new Object[] { metacatJson.toJsonString(oNode), user, uri });
                            }
                        }
                    });
                    //Now run the queries
                    final QueryRunner runner = new QueryRunner();
                    if (!insertDefinitionMetadatas.isEmpty()) {
                        runner.batch(conn, SQL.INSERT_DEFINITION_METADATA, insertDefinitionMetadatas
                                .toArray(new Object[insertDefinitionMetadatas.size()][4]));
                    }
                    if (!updateDefinitionMetadatas.isEmpty()) {
                        runner.batch(conn, SQL.UPDATE_DEFINITION_METADATA, updateDefinitionMetadatas
                                .toArray(new Object[updateDefinitionMetadatas.size()][3]));
                    }
                    if (!insertDataMetadatas.isEmpty()) {
                        runner.batch(conn, SQL.INSERT_DATA_METADATA,
                                insertDataMetadatas.toArray(new Object[insertDataMetadatas.size()][4]));
                    }
                    if (!updateDataMetadatas.isEmpty()) {
                        runner.batch(conn, SQL.UPDATE_DATA_METADATA,
                                updateDataMetadatas.toArray(new Object[updateDataMetadatas.size()][3]));
                    }
                }
            }
            conn.commit();
        } catch (SQLException e) {
            conn.rollback();
            throw e;
        } finally {
            conn.close();
        }
    } catch (SQLException e) {
        log.error("Sql exception", e);
        throw new UserMetadataServiceException("Failed to save metadata", e);
    }
}

From source file:org.sonar.server.db.migrations.v36.ViolationConverter.java

private void convert(List<Map<String, Object>> rows, Long[] violationIds) throws SQLException {
    Connection readConnection = null;
    Connection writeConnection = null;
    try {/*  w  w  w.  j a v a  2 s  .  c  o  m*/
        readConnection = db.getDataSource().getConnection();
        writeConnection = db.getDataSource().getConnection();
        writeConnection.setAutoCommit(false);

        List<Object[]> allParams = Lists.newArrayList();
        List<Map<String, Object>> allComments = Lists.newArrayList();

        QueryRunner runner = new QueryRunner();
        for (Map<String, Object> row : rows) {
            Long componentId = (Long) row.get(PROJECT_ID);
            if (componentId == null) {
                continue;
            }
            String issueKey = UUID.randomUUID().toString();
            String status, severity, reporter = null;
            boolean manualSeverity;
            Object createdAt = Objects.firstNonNull(row.get(CREATED_AT), ONE_YEAR_AGO);
            Object updatedAt;
            Long reviewId = (Long) row.get(REVIEW_ID);
            if (reviewId == null) {
                // violation without review
                status = STATUS_OPEN;
                manualSeverity = false;
                severity = (String) row.get(SEVERITY);
                updatedAt = createdAt;
            } else {
                // violation + review
                String reviewStatus = (String) row.get(REVIEW_STATUS);
                status = (STATUS_OPEN.equals(reviewStatus) ? STATUS_CONFIRMED : reviewStatus);
                manualSeverity = Objects.firstNonNull((Boolean) row.get(REVIEW_MANUAL_SEVERITY), false);
                severity = (String) row.get(REVIEW_SEVERITY);
                updatedAt = Objects.firstNonNull(row.get(REVIEW_UPDATED_AT), ONE_YEAR_AGO);
                if ((Boolean) row.get(REVIEW_MANUAL_VIOLATION)) {
                    reporter = referentials.userLogin((Long) row.get(REVIEW_REPORTER_ID));
                }

                List<Map<String, Object>> comments = runner.query(readConnection,
                        ReviewCommentsHandler.SQL + reviewId, new ReviewCommentsHandler());
                for (Map<String, Object> comment : comments) {
                    comment.put(ISSUE_KEY, issueKey);
                    allComments.add(comment);
                }
            }
            Object[] params = new Object[20];
            params[0] = issueKey;
            params[1] = componentId;
            params[2] = row.get(ROOT_PROJECT_ID);
            params[3] = row.get(RULE_ID);
            params[4] = severity;
            params[5] = manualSeverity;
            params[6] = row.get(MESSAGE);
            params[7] = row.get(LINE);
            params[8] = row.get(COST);
            params[9] = status;
            params[10] = row.get(REVIEW_RESOLUTION);
            params[11] = row.get(CHECKSUM);
            params[12] = reporter;
            params[13] = referentials.userLogin((Long) row.get(REVIEW_ASSIGNEE_ID));
            params[14] = referentials.actionPlan((Long) row.get(PLAN_ID));
            params[15] = row.get(REVIEW_DATA);
            params[16] = createdAt;
            params[17] = updatedAt;
            params[18] = createdAt;
            params[19] = updatedAt;
            allParams.add(params);
        }
        runner.batch(writeConnection, SQL_INSERT_ISSUE, allParams.toArray(new Object[allParams.size()][]));
        insertComments(writeConnection, allComments);
        runner.update(writeConnection, SQL_DELETE_RULE_FAILURES, violationIds);
        writeConnection.commit();
        progress.increment(rows.size());

    } finally {
        DbUtils.closeQuietly(readConnection);
        DbUtils.closeQuietly(writeConnection);
    }
}