使用多个连接的单个事务.(MYSQL/JDBC)

Question

我正在处理的应用程序是一个基于Java的ETL过程,它将数据加载到多个表中.DBMS是Infobright(基于MYSQL的DBMS,适用于数据仓库).

数据加载应以原子方式完成; 但是,出于性能原因,我想同时将数据加载到多个表中(使用LOAD DATA INFILE命令).这意味着我需要打开多个连接.

有没有任何解决方案允许我原子地并行地进行负载？(我猜测答案可能取决于我加载的表格的引擎;大多数是Brighthouse,它允许事务,但没有XA和没有保存点).

为了进一步澄清,我想避免让我们说:

• 我将数据加载到5个表中
• 我提交前4个表的负载
• 第5个表的提交失败

在这种情况下,我无法回滚前4个加载,因为它们已经被提交.

Answer 1

介绍

正如我所承诺的,我已经破解了一个完整的例子.我使用MySQL并创建了三个表,如下所示:

CREATE TABLE `test{1,2,3}` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `data` varchar(255) NOT NULL UNIQUE,
  PRIMARY KEY (`id`)
);

test2 最初包含一行.

INSERT INTO `test2` (`data`) VALUES ('a');

(我已将完整的代码发布到http://pastebin.com.)

以下示例执行了几项操作.

1. 设置threads于3这就决定许多工作将如何并行运行.
2. 创建threads连接数.
3. 为每个表发布一些示例数据(默认情况下,数据适用a于每个表).
4. 创建threads要运行的作业数,并使用数据加载它们.
5. threads以线程数运行作业并等待其完成(成功与否).
6. 如果没有发生异常,则提交每个连接; 否则它会回滚每一个.
7. 关闭连接(但这些可以重复使用).

_{(注意,我已经使用了Java 7的自动资源管理功能SQLTask.call().)}

逻辑

public static void main(String[] args) throws SQLException, InterruptedException {
  int threads = 3;
  List<Connection> connections = getConnections(threads);
  Map<String, String> tableData = getTableData(threads);
  List<SQLTask> tasks = getTasks(threads, connections);
  setData(tableData, tasks);
  try {
    runTasks(tasks);
    commitConnections(connections);
  } catch (ExecutionException ex) {
    rollbackConnections(connections);
  } finally {
    closeConnections(connections);
  }
}

数据

private static Map<String, String> getTableData(int threads) {
  Map<String, String> tableData = new HashMap<>();
  for (int i = 1; i <= threads; i++)
    tableData.put("test" + i, "a");
  return tableData;
}

任务

private static final class SQLTask implements Callable<Void> {

  private final Connection connection;

  private String data;
  private String table;

  public SQLTask(Connection connection) {
    this.connection = connection;
  }

  public void setTable(String table) {
    this.table = table;
  }

  public void setData(String data) {
    this.data = data;
  }

  @Override
  public Void call() throws SQLException {
    try (Statement statement = connection.createStatement()) {
      statement.executeUpdate(String.format(
        "INSERT INTO `%s` (data) VALUES  ('%s');", table, data));
    }
    return null;
  }
}

private static List<SQLTask> getTasks(int threads, List<Connection> connections) {
  List<SQLTask> tasks = new ArrayList<>();
  for (int i = 0; i < threads; i++)
    tasks.add(new SQLTask(connections.get(i)));
  return tasks;
}

private static void setData(Map<String, String> tableData, List<SQLTask> tasks) {
  Iterator<Entry<String, String>> i = tableData.entrySet().iterator();
  Iterator<SQLTask> j = tasks.iterator();
  while (i.hasNext()) {
    Entry<String, String> entry = i.next();
    SQLTask task = j.next();
    task.setTable(entry.getKey());
    task.setData(entry.getValue());
  }
}

跑

private static void runTasks(List<SQLTask> tasks) 
    throws ExecutionException, InterruptedException {
  ExecutorService executorService = Executors.newFixedThreadPool(tasks.size());
  List<Future<Void>> futures = executorService.invokeAll(tasks);
  executorService.shutdown();
  for (Future<Void> future : futures)
    future.get();
}

结果

给定返回的默认数据 getTableData(...)

test1 -> `a`
test2 -> `a`
test3 -> `a`

并且test2已经包含a(并且data列是唯一的)第二个作业将失败并抛出异常的事实,因此每个连接都将被回滚.

如果不是as而是返回bs,那么将安全地提交连接.

这可以用类似的方式完成LOAD DATA.

OP对我的回答做出回应之后,我意识到她/他想要做的事情是不可能以简单明了的方式做到的.

基本上问题是,在成功提交之后,无法回滚已提交的数据,因为操作是原子操作.鉴于在给定的情况下需要多次提交,除非一个人跟踪所有数据(在所有事务中)并且如果发生某些事情,则删除所有成功提交的内容.

有一个很好的答案与提交和回滚的问题.