test_common.cpp

/*
 * Copyright (c) 2008, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/



#include<list>
#include<map>
#include<memory>
#include<iostream>
#include<sstream>
#include<string>
#ifndef _WIN32
#include<inttypes.h>
#endif

/*
 __FUNCTION__/__func__ is not portable. We do not promise
 that our example definition covers each and every compiler.
 If not, it is up to you to find a different definition for
 your setup.
*/
#if __STDC_VERSION__ < 199901L
# if __GNUC__ >= 2
# defineCPPCONN_FUNC __FUNCTION__
# else
# defineCPPCONN_FUNC"(function n/a)"
# endif
#elif defined(_MSC_VER)
# if _MSC_VER < 1300
# defineCPPCONN_FUNC"(function n/a)"
# else
# defineCPPCONN_FUNC __FUNCTION__
# endif
#elif (defined __func__)
# defineCPPCONN_FUNC __func__
#else
# defineCPPCONN_FUNC"(function n/a)"
#endif

#ifndef __LINE__
 #define__LINE__"(line number n/a)"
#endif

#defineensure(msg, stmt) do {++total_tests;if(!(stmt)){printf("\n# Error! line=%d: %s\n# ",__LINE__,msg);++total_errors;throwsql::SQLException("error");} else { printf(".");}} while (0)
#defineensure_equal(msg, op1, op2) do {++total_tests;if((op1)!=(op2)){printf("\n# Error! line=%d: %s\n# ",__LINE__,msg);++total_errors;throwsql::SQLException("error");} else { printf(".");}}while(0)
#defineensure_equal_int(msg, op1, op2) do {++total_tests;if((op1)!=(op2)){printf("\n# Error! line=%d: %s Op1=%d Op2=%d\n# ",__LINE__,msg,op1,op2);++total_errors;throwsql::SQLException("error");} else { printf(".");}}while(0)
#defineensure_equal_str(msg, op1, op2) do {++total_tests;if((op1)!=(op2)){printf("\n# Error! line=%d: %s Op1=%s Op2=%s\n# ",__LINE__,msg,op1.c_str(),op2.c_str());++total_errors;throwsql::SQLException("error");} else { printf(".");}}while(0)
#defineensure_equal_int64(msg, op1, op2) do {++total_tests;if((op1)!=(op2)){printf("\n# Error! line=%d: %s Op1=%lld Op2=%lld\n# ",__LINE__,msg,(longlong)op1,(longlong)op2);++total_errors;throwsql::SQLException("error");} else { printf(".");}}while(0)
#defineensure_equal_uint64(msg, op1, op2) do {++total_tests;if((op1)!=(op2)){printf("\n# Error! line=%d: %s Op1=%llu Op2=%llu\n# ",__LINE__,msg,(unsignedlonglong)op1,(unsignedlonglong)op2);++total_errors;throwsql::SQLException("error");} else { printf(".");}}while(0)

staticint total_errors = 0;
staticint total_tests = 0;
staticint silent = 1;

#defineUSED_DATABASE"test"

#defineENTER_FUNCTION() if (!silent) printf("# >>>> %s\n# ", CPPCONN_FUNC);
#defineLEAVE_FUNCTION() if (!silent) printf("# <<<< %s\n# ", CPPCONN_FUNC); else printf("\n# ");

#if defined(_WIN32) || defined(_WIN64)
#pragma warning(disable:4251)
#pragma warning(disable:4800)
#endif

#if defined(_WIN32) || defined(_WIN64)
#pragma warning(disable:4251)
#endif

#include<stdio.h>


#ifndef L64
#ifdef _WIN32
#defineL64(x) x##i64
#else
#defineL64(x) x##LL
#endif
#endif

#ifndef UL64
#ifdef _WIN32
#defineUL64(x) x##ui64
#else
#defineUL64(x) x##ULL
#endif
#endif


/* {{{ */
staticboolpopulate_blob_table(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

 stmt->execute("USE " + database);
 stmt->execute("DROP TABLE IF EXISTS test_blob");
if (true == stmt->execute("CREATE TABLE test_blob (a longblob) ENGINE=MYISAM")) {
returnfalse;
 }
returntrue;
}
/* }}} */


/* {{{ */
staticboolpopulate_insert_data(sql::Statement * stmt)
{
return stmt->execute("INSERT INTO test_function (a,b,c,d,e) VALUES(1, 111, NULL, '222', 'xyz')");
}
/* }}} */


/* {{{ */
staticboolpopulate_test_table(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

 stmt->execute("USE " + database);
 stmt->execute("DROP TABLE IF EXISTS test_function");
if (true == stmt->execute("CREATE TABLE test_function (a integer unsigned not null, b integer, c integer default null, d char(10), e varchar(10) character set utf8 collate utf8_bin) ENGINE=MYISAM")) {
returnfalse;
 }

if (true == populate_insert_data(stmt.get())) {
 stmt->execute("DROP TABLE test_function");
returnfalse;
 }
returntrue;
}
/* }}} */


/* {{{ */
staticboolpopulate_TX_insert_data(sql::Statement * stmt)
{
return stmt->execute("INSERT INTO test_function_tx (a,b,c,d,e) VALUES(1, 111, NULL, '222', 'xyz')");
}
/* }}} */


/* {{{ */
staticboolpopulate_TX_test_table(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

 stmt->execute("USE " + database);
 stmt->execute("DROP TABLE IF EXISTS test_function_tx");
if (true == stmt->execute("CREATE TABLE test_function_tx(a integer unsigned not null, b integer, c integer default null, d char(10), e varchar(10) character set utf8 collate utf8_bin) engine = innodb")) {
returnfalse;
 }

if (true == populate_TX_insert_data(stmt.get())) {
 stmt->execute("DROP TABLE test_function_tx");
returnfalse;
 }
 stmt->getConnection()->commit();
returntrue;
}
/* }}} */


/* {{{ */
staticboolpopulate_test_table_PS(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
 std::unique_ptr<sql::Statement> stmt1(conn->createStatement());
ensure("stmt1 is NULL", stmt1.get() != NULL);
 stmt1->execute("USE " + database);

 std::unique_ptr<sql::PreparedStatement> stmt2(
 conn->prepareStatement("DROP TABLE IF EXISTS test_function"));
ensure("stmt2 is NULL", stmt2.get() != NULL);
 stmt2->executeUpdate();

 std::unique_ptr<sql::PreparedStatement> stmt3(conn->prepareStatement(
"CREATE TABLE test_function(a integer unsigned not null, b integer, c "
"integer default null, d char(10), e varchar(10) character set utf8 "
"collate utf8_bin)"));
ensure("stmt3 is NULL", stmt3.get() != NULL);
 stmt3->executeUpdate();

 std::unique_ptr<sql::PreparedStatement> stmt4(
 conn->prepareStatement("INSERT INTO test_function (a,b,c,d,e) VALUES(1, "
"111, NULL, '222', 'xyz')"));
ensure("stmt4 is NULL", stmt4.get() != NULL);
 stmt4->executeUpdate();

returntrue;
}
/* }}} */


/* {{{ */
staticboolpopulate_TX_test_table_PS(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
 std::unique_ptr<sql::Statement> stmt1(conn->createStatement());
ensure("stmt is NULL", stmt1.get() != NULL);
 stmt1->execute("USE " + database);

 std::unique_ptr<sql::PreparedStatement> stmt2(
 conn->prepareStatement("DROP TABLE IF EXISTS test_function_tx"));
ensure("stmt2 is NULL", stmt2.get() != NULL);
 stmt2->executeUpdate();

 std::unique_ptr<sql::PreparedStatement> stmt3(conn->prepareStatement(
"CREATE TABLE test_function_tx(a integer unsigned not null, b integer, c "
"integer default null, d char(10), e varchar(10) character set utf8 "
"collate utf8_bin) engine = innodb"));
ensure("stmt3 is NULL", stmt3.get() != NULL);
 stmt3->executeUpdate();

 std::unique_ptr<sql::PreparedStatement> stmt4(
 conn->prepareStatement("INSERT INTO test_function_tx (a,b,c,d,e) "
"VALUES(1, 111, NULL, '222', 'xyz')"));
ensure("stmt4 is NULL", stmt4.get() != NULL);
 stmt4->executeUpdate();

returntrue;
}
/* }}} */


/* {{{ */
staticboolpopulate_test_table_PS_integers(
 std::unique_ptr<sql::Connection> &conn, std::string database) {
 std::unique_ptr<sql::Statement> stmt1(conn->createStatement());
ensure("stmt1 is NULL", stmt1.get() != NULL);
 stmt1->execute("USE " + database);

 std::unique_ptr<sql::PreparedStatement> stmt2(
 conn->prepareStatement("DROP TABLE IF EXISTS test_function_int"));
ensure("stmt2 is NULL", stmt2.get() != NULL);
 stmt2->executeUpdate();

 std::unique_ptr<sql::PreparedStatement> stmt3(conn->prepareStatement(
"CREATE TABLE test_function_int(i integer, i_uns integer unsigned, b "
"bigint, b_uns bigint unsigned)"));
ensure("stmt3 is NULL", stmt3.get() != NULL);
 stmt3->executeUpdate();

returntrue;
}
/* }}} */


/* {{{ */
staticvoidtest_autocommit(std::unique_ptr<sql::Connection> &conn) {
ENTER_FUNCTION();
try {
 conn->setAutoCommit(1);
ensure("AutoCommit", conn->getAutoCommit() == true);

 conn->setAutoCommit(0);
ensure("AutoCommit", conn->getAutoCommit() == false);
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_connection_0(std::unique_ptr<sql::Connection> &conn) {
ENTER_FUNCTION();
try {
char buff[64];

 std::unique_ptr<sql::Statement> stmt1(conn->createStatement());
ensure("stmt1 is NULL", stmt1.get() != NULL);
 std::unique_ptr<sql::ResultSet> rset1(
 stmt1->executeQuery("SELECT CONNECTION_ID()"));
ensure("res1 is NULL", rset1.get() != NULL);

ensure("res1 is empty", rset1->next() != false);

ensure("connection is closed", !conn->isClosed());

snprintf(buff, sizeof(buff)-1, "KILL %d", rset1->getInt(1));

try {
 stmt1->execute(buff);
 } catch (sql::SQLException &) {
/*
 If this is mac, we will get an error.
 MySQL on Mac closes the connection without sending response
*/
 }
try {
 std::unique_ptr<sql::ResultSet> rset2(
 stmt1->executeQuery("SELECT CONNECTION_ID()"));
ensure("no exception", false);
 } catch (sql::SQLException &) {
ensure("Exception correctly thrown", true);
 }
ensure("connection is open", conn->isClosed() == false);
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_connection_1(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt1(conn->createStatement());
ensure("stmt1 is NULL", stmt1.get() != NULL);
ensure("connection is closed", !conn->isClosed());
 conn->setAutoCommit(false);

ensure("Data not populated", true == populate_TX_test_table(conn, database));

 std::unique_ptr<sql::ResultSet> rset1(
 stmt1->executeQuery("SELECT COUNT(*) FROM test_function_tx"));
ensure("res1 is NULL", rset1.get() != NULL);
ensure("res1 is empty", rset1->next() != false);
int count_full_before = rset1->getInt(1);
ensure_equal_int("res1 has more rows ", rset1->next(), false);

 std::string savepointName("firstSavePoint");
 std::unique_ptr<sql::Savepoint> savepoint(
 conn->setSavepoint(savepointName));

populate_TX_insert_data(stmt1.get());
 std::unique_ptr<sql::ResultSet> rset2(
 stmt1->executeQuery("SELECT COUNT(*) FROM test_function_tx"));
ensure("res2 is NULL", rset2.get() != NULL);
ensure_equal_int("res2 is empty", rset2->next(), true);
int count_full_after = rset2->getInt(1);
ensure_equal_int("res2 has more rows ", rset2->next(), false);
ensure_equal_int("wrong number of rows", count_full_after, (count_full_before * 2));

 conn->rollback(savepoint.get());
 std::unique_ptr<sql::ResultSet> rset3(
 stmt1->executeQuery("SELECT COUNT(*) FROM test_function_tx"));
ensure("res3 is NULL", rset3.get() != NULL);
ensure_equal_int("res3 is empty", rset3->next(), true);
int count_full_after_rollback = rset3->getInt(1);
ensure_equal_int("res3 has more rows ", rset3->next(), false);
ensure_equal_int("wrong number of rows", count_full_after_rollback, count_full_before);

 conn->releaseSavepoint(savepoint.get());
try {
/* The second call should throw an exception */
 conn->releaseSavepoint(savepoint.get());
 ++total_errors;
 } catch (sql::SQLException &) {}

/* Clean */
 stmt1->execute("USE " + database);
 stmt1->execute("DROP TABLE test_function_tx");
 } catch (sql::MethodNotImplementedException &) {
printf("\n# SKIP: RELEASE SAVEPOINT not available in this MySQL version\n");
printf("# ");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_connection_2(std::unique_ptr<sql::Connection> &conn,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt1 is NULL", stmt.get() != NULL);

ensure("Wrong catalog", conn->getCatalog() == "def" || conn->getCatalog() == "");
 stmt->execute("USE " + database);
 std::string newCatalog(conn->getSchema());
ensure(std::string("Wrong catalog '" + newCatalog + "'/'" + database + "'").c_str(), newCatalog == std::string(database));

try {
 conn->setCatalog(std::string("doesnt_actually_exist"));
// printf("\n# ERR: Accepting invalid catalog");
// ++total_errors;
 } catch (sql::SQLException &) {}
 conn->setSchema(std::string("information_schema"));
 std::string newCatalog2(conn->getSchema());
ensure("Wrong catalog", newCatalog2 == std::string("information_schema"));
 } catch (sql::SQLException &e) {
/* Error: 1049 SQLSTATE: 42000 (ER_BAD_DB_ERROR) - information_schema not available */
if (e.getErrorCode() != 1049) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_connection_3(std::unique_ptr<sql::Connection> &conn,
 std::string user) {
ENTER_FUNCTION();
try {
 sql::DatabaseMetaData * meta = conn->getMetaData();
ensure("getUserName() failed", user == meta->getUserName().substr(0, user.length()));
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_statement_0(std::unique_ptr<sql::Connection> &conn) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("AutoCommit", conn.get() == stmt->getConnection());
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test simple update statement against statement object */
staticvoidtest_statement_1(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
if (false == stmt->execute("SELECT * FROM test_function"))
ensure("False returned for SELECT", false);

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test simple query against statement object */
staticvoidtest_statement_2(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
if (false == stmt->execute("SELECT * FROM test_function"))
ensure("False returned for SELECT", false);

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test executeQuery() - returning a result set*/
staticvoidtest_statement_3(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
/* Get a result set */
try {
 std::unique_ptr<sql::ResultSet> rset(
 stmt->executeQuery("SELECT * FROM test_function"));
ensure("NULL returned for result set", rset.get() != NULL);
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
 ++total_errors;
printf("# ");
 }

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test executeQuery() - returning empty result set */
staticvoidtest_statement_4(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
/* Get a result set */
try {
 std::unique_ptr<sql::ResultSet> rset(
 stmt->executeQuery("SELECT * FROM test_function WHERE 1=2"));
ensure("NULL returned for result set", rset.get() != NULL);
ensure_equal_int("Non-empty result set", false, rset->next());

 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test executeQuery() - use it for inserting, should generate an exception */
staticvoidtest_statement_5(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
/* Get a result set */
try {
 std::unique_ptr<sql::ResultSet> rset(
 stmt->executeQuery("INSERT INTO test_function VALUES(2,200)"));
ensure("NULL returned for result set", rset.get() == NULL);
 } catch (sql::SQLException &) {
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test executeUpdate() - check the returned value */
staticvoidtest_statement_6(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
/* Get a result set */
try {
ensure("Number of updated rows", stmt->executeUpdate("UPDATE test_function SET a = 123") == 1);
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
 ++total_errors;
 }

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test executeUpdate() - execute a SELECT, should get an exception */
staticvoidtest_statement_7(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));
/* Get a result set */
try {
 stmt->executeUpdate("SELECT * FROM test_function");
ensure("No exception thrown", false);
 } catch (sql::SQLException &) {
 } catch (...) {
printf("\n# ERR: Incorrectly sql::SQLException ist not thrown\n");
printf("# ");
 ++total_errors;
 }

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


#if0
/* {{{ Test getFetchSize() - should return int value */
/* XXX: Test fails because getFetchSize() is not implemented*/
static void test_statement_xx(std::unique_ptr<sql::Connection> & conn, std::unique_ptr<sql::Connection> & conn2)
{
 ENTER_FUNCTION();
 try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
 ensure("stmt is NULL", stmt.get() != NULL);

 ensure("fetchSize is negative", stmt->getFetchSize() > 0);
 } catch (sql::SQLException &e) {
 printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
 printf("# ");
 ++total_errors;
 } catch (...) {
 printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
 printf("# ");
 ++total_errors;
 }
 LEAVE_FUNCTION();
}
/* }}} */

/* {{{ Test setFetchSize() - set and get the value */
/* XXX: Doesn't pass because setFetchSize() is unimplemented */
static void test_statement_xx(std::unique_ptr<sql::Connection> & conn)
{
 ENTER_FUNCTION();
 try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
 ensure("stmt is NULL", stmt.get() != NULL);

 int setFetchSize = 50;

 stmt->setFetchSize(setFetchSize);

 ensure_equal("Non-equal", setFetchSize, stmt->getFetchSize());
 } catch (sql::SQLException &e) {
 printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
 printf("# ");
 ++total_errors;
 } catch (...) {
 printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
 printf("# ");
 ++total_errors;
 }
}
/* }}} */


/* {{{ Test setFetchSize() - set negative value and expect an exception */
/* XXX: Doesn't pass because setFetchSize() is unimplemented */
static void test_statement_xx(std::unique_ptr<sql::Connection> & conn)
{
 ENTER_FUNCTION();
 try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
 ensure("stmt is NULL", stmt.get() != NULL);

 try {
 stmt->setFetchSize(-1);
 ensure("No exception", false);
 } catch (sql::InvalidArgumentException) {
 printf("INFO: Caught sql::InvalidArgumentException\n");
 }
 } catch (sql::SQLException &e) {
 printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
 printf("# ");
 ++total_errors;
 } catch (...) {
 printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
 printf("# ");
 ++total_errors;
 }
 LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test setQueryTimeout() - set negative value and expect an exception */
/* XXX: Doesn't pass because setQueryTimeout() is unimplemented */
static void test_statement_xx(std::unique_ptr<sql::Connection> & conn)
{
 ENTER_FUNCTION();
 try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
 ensure("stmt is NULL", stmt.get() != NULL);

 try {
 stmt->setQueryTimeout(-1);
 printf("\n# ERR:No exception\n");
 } catch (sql::InvalidArgumentException &) {}
 } catch (sql::SQLException &e) {
 printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
 printf("# ");
 ++total_errors;
 } catch (...) {
 printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
 printf("# ");
 ++total_errors;
 }
 LEAVE_FUNCTION();
}
/* }}} */
#endif


/* {{{ Test getResultSet() - execute() a query and get the result set */
staticvoidtest_statement_8(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));

ensure("sql::Statement::execute returned false", true == stmt->execute("SELECT * FROM test_function"));

 std::unique_ptr<sql::ResultSet> rset(stmt->getResultSet());
ensure("rset is NULL", rset.get() != NULL);

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
}
/* }}} */


/* {{{ Test getResultSet() - execute() an update query and get the result set - should be empty */
staticvoidtest_statement_9(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);

ensure("Data not populated", true == populate_test_table(conn, database));

ensure("sql::Statement::execute returned true", false == stmt->execute("UPDATE test_function SET a = 222"));

 std::unique_ptr<sql::ResultSet> rset(stmt->getResultSet());
ensure("rset is not NULL", rset.get() == NULL);

/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ Test metadata usage after result set has been closed */
staticvoidtest_statement_10(std::unique_ptr<sql::Connection> &conn,
 std::unique_ptr<sql::Connection> &conn2,
 std::string database) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("stmt is NULL", stmt.get() != NULL);
ensure("Data not populated", true == populate_test_table(conn, database));

 std::unique_ptr<sql::ResultSet> res(
 stmt->executeQuery("SELECT * FROM test_function"));
ensure("ResultSet is empty", res->rowsCount() > 0);
 sql::ResultSetMetaData * meta = res->getMetaData();
ensure("Error while reading a row ", res->next());
ensure_equal_str("Table name differs", meta->getTableName(1), std::string("test_function"));
 res->close();
try {
ensure_equal_str("Table name differs", meta->getTableName(1), std::string("test_function"));
ensure("Exception not correctly thrown", false);
 } catch (sql::SQLException &/*e*/) {
// exception correctly thrown
 }
/* Clean */
 std::unique_ptr<sql::Statement> stmt2(conn2->createStatement());
ensure("stmt is NULL", stmt2.get() != NULL);
 stmt2->execute("USE " + database);
 stmt2->execute("DROP TABLE test_function");
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 } catch (...) {
printf("\n# ERR: Caught unknown exception at %s::%d\n", CPPCONN_FUNC, __LINE__);
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_result_set_0(std::unique_ptr<sql::Connection> &conn) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt(conn->createStatement());
ensure("AutoCommit", conn.get() == stmt->getConnection());

 std::unique_ptr<sql::ResultSet> result(
 stmt->setResultSetType(sql::ResultSet::TYPE_SCROLL_INSENSITIVE)
 ->executeQuery("SELECT 1, 2, 3"));

ensure_equal_int("isFirst", result->isFirst(), false);

ensure_equal_int("isLast", result->isLast(), false);
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */
staticvoidtest_result_set_1(std::unique_ptr<sql::Connection> &conn) {
ENTER_FUNCTION();
try {
 std::unique_ptr<sql::Statement> stmt1(conn->createStatement());
ensure("stmt1 is NULL", stmt1.get() != NULL);
 stmt1->setResultSetType(sql::ResultSet::TYPE_SCROLL_INSENSITIVE);

 std::unique_ptr<sql::ResultSet> rset1(stmt1->executeQuery("SELECT 1"));
ensure("res1 is NULL", rset1.get() != NULL);

 std::unique_ptr<sql::ResultSet> rset2(stmt1->executeQuery("SELECT 1"));
ensure("res2 is NULL", rset2.get() != NULL);

ensure("res1 is empty", rset1->next() != false);
ensure("res2 is empty", rset2->next() != false);
 } catch (sql::SQLException &e) {
printf("\n# ERR: Caught sql::SQLException at %s::%d [%s] (%d/%s)\n", CPPCONN_FUNC, __LINE__, e.what(), e.getErrorCode(), e.getSQLStateCStr());
printf("# ");
 ++total_errors;
 }
LEAVE_FUNCTION();
}
/* }}} */


/* {{{ */