llvm::SmallDenseMap<int64_t, llvm::SmallVector<string, 4>> result;
  llvm::SmallDenseMap<int64_t, llvm::StringSet<>> result_sets;
  auto insert = [&](Value v, const string& source, const Block& func_block) {
    auto arg = v.dyn_cast<BlockArgument>();
    if (!arg || arg.getOwner() != &func_block) return;
    auto insert_res = result_sets[arg.getArgNumber()].insert(source);
    if (!insert_res.second) return;

    /**
     * 結果セットを閉じます。
     * <p>
     * {@link ResultSet#close()}が例外をスローした場合はログにエラーメッセージを出力します。 例外は再スローされません。
     * </p>
     *
     * @param resultSet
     *            結果セット
     */
    public static void close(final ResultSet resultSet) {
        if (resultSet == null) {
            return;
        }
        try {
            resultSet.close();
        } catch (final SQLException e) {

                ResultSet resultSet = statement.executeQuery()
            ) {
                while (resultSet.next()) {
                    String testClass = resultSet.getString(1);
                    String testName = resultSet.getString(2);
                    String testProject = resultSet.getString(3);
                    BigDecimal value = resultSet.getBigDecimal(4);

                        try (ResultSet resultSet = operationsForExecution.executeQuery()) {
                            while (resultSet.next()) {
                                String displayName = resultSet.getString(1);
                                List<String> tasksToRun = toList(resultSet.getObject(2));
                                List<String> cleanTasks = toList(resultSet.getObject(7));

	}

	// reset calls, make the backend return success for three user tokens
	calledWithToken = []string{}
	resultUsers, resultOk, resultErr = map[string]user.Info{}, true, nil
	resultUsers["usertoken1"] = &user.DefaultInfo{Name: "user1"}
	resultUsers["usertoken2"] = &user.DefaultInfo{Name: "user2"}
	resultUsers["usertoken3"] = &user.DefaultInfo{Name: "user3"}

	// populate cache

	expectedOrder := testSetSET{"a", "b", "c", "aa", "bb", "cc"}
	var resultSet testSetSET
	rest, err := Unmarshal(output, &resultSet)
	if err != nil {
		t.Errorf("%v", err)
	}
	if len(rest) != 0 {
		t.Error("Unmarshal returned extra garbage")
	}
	if !reflect.DeepEqual(expectedOrder, resultSet) {
		t.Errorf("Unexpected SET content. got: %s, want: %s", resultSet, expectedOrder)
	}
}

 */

package org.gradle.performance.results;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

class DataBaseSchemaUtil {
    static boolean columnExists(Connection connection, String table, String column) throws SQLException {
        ResultSet columns = null;
        boolean exists;

        try {

    /**
     * クエリを実行します。
     *
     * @param ps
     *            {@link PreparedStatement}。{@literal null}であってはいけません
     * @return {@link ResultSet}
     * @throws SQLRuntimeException
     *             {@link SQLException}が発生した場合
     */
    public static ResultSet executeQuery(final PreparedStatement ps) throws SQLRuntimeException {
        assertArgumentNotNull("ps", ps);

        try {
            return ps.executeQuery();

import static org.codelibs.core.log.Logger.format;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import org.codelibs.core.exception.SQLRuntimeException;
import org.codelibs.core.log.Logger;

/**
 * {@link Statement}用のユーティリティクラスです。
 *

  // of the `QuantizationResults`.
  std::string result_str{};
  TextFormat::PrintToString(report.GetQuantizationResults(), &result_str);

  EXPECT_THAT(report.ToString(), HasSubstr("Quantization Report"));
  EXPECT_THAT(report.ToString(), HasSubstr(result_str));
  EXPECT_THAT(report.ToString(), HasSubstr("Quantization Report End"));
}