Method RequestExecuteSQL

src/sdk/sql_sdk_test.h:421–519

}

void SQLSDKQueryTest::RequestExecuteSQL(hybridse::sqlcase::SqlCase& sql_case,  // NOLINT
                                        std::shared_ptr<SQLRouter> router, bool has_batch_request, bool is_procedure,
                                        bool is_asyn) {
    hybridse::sdk::Status status;
    // execute SQL
    std::string sql = sql_case.sql_str();
    for (size_t i = 0; i < sql_case.inputs().size(); i++) {
        std::string placeholder = "{" + std::to_string(i) + "}";
        boost::replace_all(sql, placeholder, sql_case.inputs()[i].name_);
    }
    boost::replace_all(sql, "{auto}", hybridse::sqlcase::SqlCase::GenRand("auto_t"));
    LOG(INFO) << sql;
    std::string lower_sql = sql;
    boost::to_lower(lower_sql);
    if (boost::algorithm::starts_with(lower_sql, "select")) {
        LOG(INFO) << "GetRequestRow start";
        auto request_row = router->GetRequestRow(sql_case.db(), sql, &status);
        LOG(INFO) << "GetRequestRow done";
        // success check
        LOG(INFO) << "sql case success check: required success " << (sql_case.expect().success_ ? "true" : "false");
        if (!sql_case.expect().success_) {
            if ((request_row)) {
                FAIL() << "sql case expect success == false";
            }
            LOG(INFO) << "sql case success false check done!";
            return;
        }
        if (!request_row) {
            FAIL() << "sql case expect success == true";
        }

        hybridse::type::TableDef insert_table;
        std::vector<hybridse::codec::Row> insert_rows;
        std::vector<std::string> inserts;
        if (!has_batch_request) {
            ASSERT_TRUE(sql_case.ExtractInputTableDef(insert_table, 0));
            ASSERT_TRUE(sql_case.ExtractInputData(insert_rows, 0));
            sql_case.BuildInsertSqlListFromInput(0, &inserts);
        } else {
            ASSERT_TRUE(sql_case.ExtractInputTableDef(sql_case.batch_request_, insert_table));
            ASSERT_TRUE(sql_case.ExtractInputData(sql_case.batch_request_, insert_rows));
        }
        CheckSchema(insert_table.columns(), *(request_row->GetSchema().get()));
        LOG(INFO) << "Request Row:\n";
        PrintRows(insert_table.columns(), insert_rows);

        hybridse::codec::RowView row_view(insert_table.columns());
        std::vector<std::shared_ptr<hybridse::sdk::ResultSet>> results;
        LOG(INFO) << "Request execute sql start!";
        for (size_t i = 0; i < insert_rows.size(); i++) {
            row_view.Reset(insert_rows[i].buf());
            CovertHybridSERowToRequestRow(&row_view, request_row);
            std::shared_ptr<hybridse::sdk::ResultSet> rs;
            if (is_procedure) {
                if (is_asyn) {
                    LOG(INFO) << "-------asyn procedure----------";
                    auto future = router->CallProcedure(sql_case.db(), sql_case.sp_name_, 1000, request_row, &status);
                    if (!future || status.code != 0) FAIL() << "sql case expect success == true";