int
main(int argc, char **argv)
{
char buff[64];
SQLLEN ind;
odbc_use_version3 = 1;
odbc_connect();
odbc_check_cursor();
exec_direct("CREATE TABLE #t1 ( k INT, c VARCHAR(20))");
exec_direct("INSERT INTO #t1 VALUES (1, 'aaa')");
odbc_reset_statement();
CHKSetStmtAttr(SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_LOCK, SQL_IS_UINTEGER, "S");
CHKSetCursorName(T("c112"), SQL_NTS, "S");
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(SQL_AUTOCOMMIT_OFF), 0, "S");
CHKPrepare(T("SELECT * FROM #t1 FOR UPDATE"), SQL_NTS, "S");
CHKExecute("S");
CHKFetch("S");
exec_direct("UPDATE #t1 SET c = 'xxx' WHERE CURRENT OF c112");
CHKCloseCursor("SI");
CHKEndTran(SQL_HANDLE_DBC, odbc_conn, SQL_COMMIT, "S");
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(SQL_AUTOCOMMIT_ON), 0, "S");
CHKExecDirect(T("SELECT c FROM #t1 WHERE k = 1"), SQL_NTS, "S");
CHKFetch("S");
CHKGetData(1, SQL_C_CHAR, buff, sizeof(buff), &ind, "S");
printf(">> New value after update = [%s] (should be [xxx]) \n", buff);
CHKFreeHandle(SQL_HANDLE_STMT, (SQLHANDLE) odbc_stmt, "S");
odbc_stmt = SQL_NULL_HSTMT;
odbc_disconnect();
return 0;
}
int
main(void)
{
odbc_use_version3 = 1;
odbc_mark_sockets_opened();
odbc_connect();
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, (void *) SQL_AUTOCOMMIT_OFF, 0, "S");
odbc_command("SELECT 1");
CHKMoreResults("No");
if (!close_last_socket()) {
fprintf(stderr, "Error closing connection\n");
return 1;
}
CHKEndTran(SQL_HANDLE_DBC, odbc_conn, SQL_ROLLBACK, "E");
/* the error should be written in the connection, not in the statement */
ReadErrorConn();
if (strcmp(odbc_sqlstate, "08S01") != 0 || strstr(odbc_err, "Write to the server") == NULL) {
odbc_disconnect();
fprintf(stderr, "Unexpected error message %s %s\n", odbc_sqlstate, odbc_err);
return 1;
}
odbc_disconnect();
return 0;
}
static int
Test(int txn, const char *expected)
{
int dirty, repeatable, phantom;
char buf[128];
SWAP_CONN();
if (test_with_connect) {
odbc_disconnect();
ConnectWithTxn(txn);
CHKSetStmtAttr(SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 2, 0, "S");
} else {
CHKSetConnectAttr(SQL_ATTR_TXN_ISOLATION, int2ptr(txn), 0, "S");
}
SWAP_CONN();
dirty = CheckDirtyRead();
repeatable = CheckNonrepeatableRead();
phantom = CheckPhantom();
sprintf(buf, "dirty %d non repeatable %d phantom %d", dirty, repeatable, phantom);
if (strcmp(buf, expected) != 0) {
if (hide_error) {
hide_error = 0;
return 0;
}
fprintf(stderr, "detected wrong TXN\nexpected '%s' got '%s'\n", expected, buf);
exit(1);
}
hide_error = 0;
return 1;
}
static void
insert_test_man(void)
{
SQLLEN sql_nts = SQL_NTS;
SQLINTEGER commit_off = SQL_AUTOCOMMIT_OFF;
SQLINTEGER commit_on = SQL_AUTOCOMMIT_ON;
SQLINTEGER id = 0;
char string[64];
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(commit_off), SQL_IS_INTEGER, "SI");
odbc_reset_statement();
CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, sizeof(id), 0, &id, 0, &sql_nts, "SI");
CHKBindParameter(2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, sizeof(string), 0, string, 0, &sql_nts, "SI");
CHKPrepare(T("insert into test values (?, ?)"), SQL_NTS, "SI");
for (id = 0; id < 20; id++) {
sprintf(string, "This is a test (%d)", (int) id);
CHKExecute("SI");
}
SQLEndTran(SQL_HANDLE_DBC, odbc_conn, SQL_COMMIT);
SQLSetConnectAttr(odbc_conn, SQL_ATTR_AUTOCOMMIT, int2ptr(commit_on), SQL_IS_INTEGER);
odbc_reset_statement();
}
static void
AutoCommit(int onoff)
{
CHKSetConnectAttr(SQL_ATTR_AUTOCOMMIT, int2ptr(onoff), 0, "S");
}
int
main(int argc, char *argv[])
{
odbc_use_version3 = 1;
odbc_connect();
/* Invalid argument value */
CHKSetConnectAttr(SQL_ATTR_TXN_ISOLATION, int2ptr(SQL_TXN_REPEATABLE_READ | SQL_TXN_READ_COMMITTED), 0, "E");
ReadErrorConn();
if (strcmp(odbc_sqlstate, "HY024") != 0) {
odbc_disconnect();
fprintf(stderr, "Unexpected success\n");
return 1;
}
/* here we can't use temporary table cause we use two connection */
odbc_command("IF OBJECT_ID('test_transaction') IS NOT NULL DROP TABLE test_transaction");
odbc_command("CREATE TABLE test_transaction(n NUMERIC(18,0) PRIMARY KEY, t VARCHAR(30))");
CHKSetStmtAttr(SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 2, 0, "S");
AutoCommit(SQL_AUTOCOMMIT_OFF);
odbc_command("INSERT INTO test_transaction(n, t) VALUES(1, 'initial')");
#ifdef ENABLE_DEVELOPING
/* test setting with active transaction "Operation invalid at this time" */
CHKSetConnectAttr(SQL_ATTR_TXN_ISOLATION, int2ptr(SQL_TXN_REPEATABLE_READ), 0, "E");
ReadErrorConn();
if (strcmp(odbc_sqlstate, "HY011") != 0) {
odbc_disconnect();
fprintf(stderr, "Unexpected success\n");
return 1;
}
#endif
EndTransaction(SQL_COMMIT);
odbc_command("SELECT * FROM test_transaction");
/* test setting with pending data */
CHKSetConnectAttr(SQL_ATTR_TXN_ISOLATION, int2ptr(SQL_TXN_REPEATABLE_READ), 0, "E");
ReadErrorConn();
if (strcmp(odbc_sqlstate, "HY011") != 0) {
odbc_disconnect();
fprintf(stderr, "Unexpected success\n");
return 1;
}
SQLMoreResults(odbc_stmt);
EndTransaction(SQL_COMMIT);
/* save this connection and do another */
SWAP_CONN();
odbc_connect();
CHKSetStmtAttr(SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 2, 0, "S");
AutoCommit(SQL_AUTOCOMMIT_OFF);
SWAP_CONN();
for (test_with_connect = 0; test_with_connect <= 1; ++test_with_connect) {
Test(SQL_TXN_READ_UNCOMMITTED, "dirty 1 non repeatable 1 phantom 1");
Test(SQL_TXN_READ_COMMITTED, "dirty 0 non repeatable 1 phantom 1");
if (odbc_db_is_microsoft()) {
Test(SQL_TXN_REPEATABLE_READ, "dirty 0 non repeatable 0 phantom 1");
} else {
hide_error = 1;
if (!Test(SQL_TXN_REPEATABLE_READ, "dirty 0 non repeatable 0 phantom 1"))
Test(SQL_TXN_REPEATABLE_READ, "dirty 0 non repeatable 0 phantom 0");
}
Test(SQL_TXN_SERIALIZABLE, "dirty 0 non repeatable 0 phantom 0");
}
odbc_disconnect();
SWAP_CONN();
EndTransaction(SQL_COMMIT);
/* Sybase do not accept DROP TABLE during a transaction */
AutoCommit(SQL_AUTOCOMMIT_ON);
odbc_command("DROP TABLE test_transaction");
odbc_disconnect();
return 0;
}
static void
my_attrs(void)
{
CHKSetConnectAttr(SQL_ATTR_TXN_ISOLATION, int2ptr(global_txn), 0, "S");
AutoCommit(SQL_AUTOCOMMIT_OFF);
}
int
main(int argc, char *argv[])
{
SQLTCHAR tmp[2048];
char conn[128];
SQLTCHAR sqlstate[6];
SQLSMALLINT len;
int port;
time_t start_time, end_time;
#ifdef _WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD(1, 1), &wsaData);
#endif
if (tds_mutex_init(&mtx))
return 1;
if (odbc_read_login_info())
exit(1);
/*
* prepare our odbcinst.ini
* is better to do it before connect cause uniODBC cache INIs
* the name must be odbcinst.ini cause unixODBC accept only this name
*/
if (odbc_driver[0]) {
FILE *f = fopen("odbcinst.ini", "w");
if (f) {
fprintf(f, "[FreeTDS]\nDriver = %s\n", odbc_driver);
fclose(f);
/* force iODBC */
setenv("ODBCINSTINI", "./odbcinst.ini", 1);
setenv("SYSODBCINSTINI", "./odbcinst.ini", 1);
/* force unixODBC (only directory) */
setenv("ODBCSYSINI", ".", 1);
}
}
for (port = 12340; port < 12350; ++port)
if (!init_fake_server(port))
break;
if (port == 12350) {
fprintf(stderr, "Cannot bind to a port\n");
return 1;
}
printf("Fake server bound at port %d\n", port);
init_connect();
CHKSetConnectAttr(SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER) 10, sizeof(SQLINTEGER), "SI");
CHKSetConnectAttr(SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) 10, SQL_IS_UINTEGER, "SI");
/* this is expected to work with unixODBC */
printf("try to connect to our port just to check connection timeout\n");
sprintf(conn, "DRIVER=FreeTDS;SERVER=127.0.0.1;Port=%d;TDS_Version=7.0;UID=test;PWD=test;DATABASE=tempdb;", port);
start_time = time(NULL);
CHKDriverConnect(NULL, T(conn), SQL_NTS, tmp, ODBC_VECTOR_SIZE(tmp), &len, SQL_DRIVER_NOPROMPT, "E");
end_time = time(NULL);
memset(sqlstate, 'X', sizeof(sqlstate));
tmp[0] = 0;
CHKGetDiagRec(SQL_HANDLE_DBC, odbc_conn, 1, sqlstate, NULL, tmp, ODBC_VECTOR_SIZE(tmp), NULL, "SI");
odbc_disconnect();
tds_mutex_lock(&mtx);
CLOSESOCKET(fake_sock);
tds_mutex_unlock(&mtx);
tds_thread_join(fake_thread, NULL);
printf("Message: %s - %s\n", C(sqlstate), C(tmp));
if (strcmp(C(sqlstate), "HYT00") || !strstr(C(tmp), "Timeout")) {
fprintf(stderr, "Invalid timeout message\n");
return 1;
}
if (end_time - start_time < 10 || end_time - start_time > 16) {
fprintf(stderr, "Unexpected connect timeout (%d)\n", (int) (end_time - start_time));
return 1;
}
printf("Done.\n");
ODBC_FREE();
return 0;
}
int
main(int argc, char *argv[])
{
char tmp[1024];
if (odbc_read_login_info())
exit(1);
/* try setting db name before connect */
printf("SQLConnect before 1..\n");
init_connect();
set_dbname("master");
normal_connect();
check_dbname("master");
/* check change after connection */
printf("SQLConnect after..\n");
set_dbname("tempdb");
check_dbname("tempdb");
printf("SQLConnect after not existing..\n");
strcpy(tmp, "IDontExist");
CHKSetConnectAttr(SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER) tmp, strlen(tmp), "E");
check_dbname("tempdb");
odbc_disconnect();
/* try setting db name before connect */
printf("SQLConnect before 2..\n");
init_connect();
set_dbname("tempdb");
normal_connect();
check_dbname("tempdb");
odbc_disconnect();
/* try connect string with using DSN */
printf("SQLDriverConnect before 1..\n");
sprintf(tmp, "DSN=%s;UID=%s;PWD=%s;DATABASE=%s;", odbc_server, odbc_user, odbc_password, odbc_database);
init_connect();
set_dbname("master");
driver_connect(tmp);
check_dbname(odbc_database);
odbc_disconnect();
/* try connect string with using DSN */
printf("SQLDriverConnect before 2..\n");
sprintf(tmp, "DSN=%s;UID=%s;PWD=%s;", odbc_server, odbc_user, odbc_password);
init_connect();
set_dbname("tempdb");
driver_connect(tmp);
check_dbname("tempdb");
odbc_disconnect();
if (failed) {
printf("Some tests failed\n");
return 1;
}
printf("Done.\n");
return 0;
}
static void
set_dbname(const char *dbname)
{
CHKSetConnectAttr(SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER) T(dbname), strlen(dbname)*sizeof(SQLTCHAR), "SI");
}
