mysql/test/integration/prepared_statement_lifecycle.cpp

/*
 * prepared_statement_lifecycle.cpp
 *
 *  Created on: Feb 18, 2020
 *      Author: ruben
 */

#include "integration_test_common.hpp"

using namespace mysql::test;
using mysql::row;
using mysql::value;

namespace
{

struct PreparedStatementLifecycleTest : NetworkTest<>
{
	std::int64_t get_table_size(const std::string& table)
	{
		return std::get<std::int64_t>(
			conn.query("SELECT COUNT(*) FROM " + table).fetch_all().at(0).values().at(0));
	}

	std::int32_t get_updates_table_value()
	{
		return std::get<std::int32_t>(
			conn.query("SELECT field_int FROM updates_table WHERE field_varchar = 'f0'")
				.fetch_all().at(0).values().at(0));
	}
};

TEST_P(PreparedStatementLifecycleTest, SelectWithParametersMultipleExecutions)
{
	auto* net = GetParam();

	// Prepare a statement
	auto stmt = net->prepare_statement(
		conn,
		"SELECT * FROM two_rows_table WHERE id = ? OR field_varchar = ?"
	);
	stmt.validate_no_error();

	// Execute it. Only one row will be returned (because of the id)
	auto result = net->execute_statement(stmt.value, makevalues(1, "non_existent"));
	result.validate_no_error();
	EXPECT_TRUE(result.value.valid());
	EXPECT_FALSE(result.value.complete());
	validate_2fields_meta(result.value, "two_rows_table");

	auto rows = net->fetch_all(result.value);
	rows.validate_no_error();
	ASSERT_EQ(rows.value.size(), 1);
	EXPECT_EQ(static_cast<const row&>(rows.value[0]), (makerow(1, "f0")));
	EXPECT_TRUE(result.value.complete());

	// Execute it again, but with different values. This time, two rows are returned
	result = net->execute_statement(stmt.value, makevalues(1, "f1"));
	result.validate_no_error();
	EXPECT_TRUE(result.value.valid());
	EXPECT_FALSE(result.value.complete());
	validate_2fields_meta(result.value, "two_rows_table");

	rows = net->fetch_all(result.value);
	rows.validate_no_error();
	ASSERT_EQ(rows.value.size(), 2);
	EXPECT_EQ(static_cast<const row&>(rows.value[0]), (makerow(1, "f0")));
	EXPECT_EQ(static_cast<const row&>(rows.value[1]), (makerow(2, "f1")));
	EXPECT_TRUE(result.value.complete());
}

TEST_P(PreparedStatementLifecycleTest, InsertWithParametersMultipleExecutions)
{
	auto* net = GetParam();

	// Get the number of rows before insertion
	auto rows_before = get_table_size("inserts_table");

	// Prepare a statement
	auto stmt = net->prepare_statement(
		conn,
		"INSERT INTO inserts_table (field_varchar) VALUES (?)"
	);
	stmt.validate_no_error();

	// Insert one value
	auto result = net->execute_statement(stmt.value, makevalues("value0"));
	result.validate_no_error();
	EXPECT_TRUE(result.value.valid());
	EXPECT_TRUE(result.value.complete());
	EXPECT_TRUE(result.value.fields().empty());

	// Insert another one
	result = net->execute_statement(stmt.value, makevalues("value1"));
	result.validate_no_error();
	EXPECT_TRUE(result.value.valid());
	EXPECT_TRUE(result.value.complete());
	EXPECT_TRUE(result.value.fields().empty());

	// Validate we did something
	auto rows_after = get_table_size("inserts_table");
	EXPECT_EQ(rows_after, rows_before + 2);
}

TEST_P(PreparedStatementLifecycleTest, UpdateWithParametersMultipleExecutions)
{
	auto* net = GetParam();

	// Prepare a statement
	auto stmt = net->prepare_statement(
		conn,
		"UPDATE updates_table SET field_int = ? WHERE field_varchar = ?"
	);
	stmt.validate_no_error();

	// Set field_int to something
	auto result = net->execute_statement(stmt.value, makevalues(200, "f0"));
	result.validate_no_error();
	EXPECT_TRUE(result.value.valid());
	EXPECT_TRUE(result.value.complete());
	EXPECT_TRUE(result.value.fields().empty());

	// Verify that took effect
	EXPECT_EQ(get_updates_table_value(), 200);

	// Set field_int to something different
	result = net->execute_statement(stmt.value, makevalues(250, "f0"));
	result.validate_no_error();
	EXPECT_TRUE(result.value.valid());
	EXPECT_TRUE(result.value.complete());
	EXPECT_TRUE(result.value.fields().empty());

	// Verify that took effect
	EXPECT_EQ(get_updates_table_value(), 250);
}

TEST_P(PreparedStatementLifecycleTest, MultipleStatements)
{
	auto* net = GetParam();

	// Prepare an update
	auto stmt_update = net->prepare_statement(
		conn,
		"UPDATE updates_table SET field_int = ? WHERE field_varchar = ?"
	);
	stmt_update.validate_no_error();

	// Prepare a select
	auto stmt_select = net->prepare_statement(
		conn,
		"SELECT field_int FROM updates_table WHERE field_varchar = ?"
	);
	stmt_select.validate_no_error();

	// They have different IDs
	EXPECT_NE(stmt_update.value.id(), stmt_select.value.id());

	// Execute update
	auto update_result = net->execute_statement(stmt_update.value, makevalues(210, "f0"));
	update_result.validate_no_error();
	EXPECT_TRUE(update_result.value.complete());

	// Execute select
	auto select_result = net->execute_statement(stmt_select.value, makevalues("f0"));
	select_result.validate_no_error();
	auto rows = net->fetch_all(select_result.value);
	rows.validate_no_error();
	EXPECT_EQ(rows.value.size(), 1);
	EXPECT_EQ(static_cast<row&>(rows.value[0]), makerow(210));

	// Execute update again
	update_result = net->execute_statement(stmt_update.value, makevalues(220, "f0"));
	update_result.validate_no_error();
	EXPECT_TRUE(update_result.value.complete());

	// Execute select again
	select_result = net->execute_statement(stmt_select.value, makevalues("f0"));
	select_result.validate_no_error();
	rows = net->fetch_all(select_result.value);
	rows.validate_no_error();
	EXPECT_EQ(rows.value.size(), 1);
	EXPECT_EQ(static_cast<row&>(rows.value[0]), makerow(220));
}

MYSQL_NETWORK_TEST_SUITE(PreparedStatementLifecycleTest);

}