void pool_user_init(TDS_POOL * pool) { dlist_user_init(&pool->users); dlist_user_init(&pool->waiters); pool->ctx = tds_alloc_context(NULL); }
bool OpenDB() { CloseDB(); TDSCONNECTION* conn = NULL; login = tds_alloc_login(); tds_set_app(login, "TSQL"); tds_set_library(login,"TDS-Library"); tds_set_host(login, ""); tds_set_server(login, host.host.c_str()); tds_set_server_addr(login, host.host.c_str()); tds_set_user(login, host.user.c_str()); tds_set_passwd(login, host.pass.c_str()); tds_set_port(login, host.port); tds_set_packet(login, 512); context = tds_alloc_context(this); context->msg_handler = HandleMessage; context->err_handler = HandleError; sock = tds_alloc_socket(context, 512); tds_set_parent(sock, NULL); conn = tds_read_config_info(NULL, login, context->locale); if (tds_connect(sock, conn) == TDS_SUCCEED) { tds_free_connection(conn); return 1; } tds_free_connection(conn); return 0; }
/* * pool_mbr_login open a single pool login, to be call at init time or * to reconnect. */ static TDSSOCKET * pool_mbr_login(TDS_POOL * pool) { TDSCONTEXT *context; TDSLOGIN *login; TDSSOCKET *tds; TDSCONNECTION *connection; int rc; char *query; char hostname[MAXHOSTNAMELEN]; login = tds_alloc_login(); tds_set_passwd(login, pool->password); tds_set_user(login, pool->user); tds_set_app(login, "tdspool"); #if HAVE_GETHOSTNAME if (gethostname(hostname, MAXHOSTNAMELEN) < 0) #endif tds_strlcpy(hostname, "tdspool", MAXHOSTNAMELEN); tds_set_host(login, hostname); tds_set_library(login, "TDS-Library"); tds_set_server(login, pool->server); tds_set_client_charset(login, "iso_1"); tds_set_language(login, "us_english"); tds_set_packet(login, 512); context = tds_alloc_context(NULL); tds = tds_alloc_socket(context, 512); connection = tds_read_config_info(tds, login, context->locale); if (!connection || tds_connect_and_login(tds, connection) != TDS_SUCCEED) { tds_free_socket(tds); tds_free_connection(connection); /* what to do? */ fprintf(stderr, "Could not open connection to server %s\n", pool->server); return NULL; } tds_free_connection(connection); /* * FIXME -- tds_connect_and_login no longer preallocates the in_buf need to * do something like what tds_read_packet does */ tds->in_buf = (unsigned char *) calloc(BLOCKSIZ, 1); if (pool->database && strlen(pool->database)) { query = (char *) malloc(strlen(pool->database) + 5); sprintf(query, "use %s", pool->database); rc = tds_submit_query(tds, query); free(query); if (rc != TDS_SUCCEED) { fprintf(stderr, "changing database failed\n"); return NULL; } if (tds_process_simple_query(tds) != TDS_SUCCEED) return NULL; } return tds; }
int try_tds_login(TDSLOGIN ** login, TDSSOCKET ** tds, const char *appname, int verbose) { TDSCONNECTINFO *connect_info; if (verbose) { fprintf(stdout, "Entered tds_try_login()\n"); } if (!login) { fprintf(stderr, "Invalid TDSLOGIN**\n"); return TDS_FAIL; } if (!tds) { fprintf(stderr, "Invalid TDSSOCKET**\n"); return TDS_FAIL; } if (verbose) { fprintf(stdout, "Trying read_login_info()\n"); } read_login_info(); if (verbose) { fprintf(stdout, "Setting login parameters\n"); } *login = tds_alloc_login(); if (!*login) { fprintf(stderr, "tds_alloc_login() failed.\n"); return TDS_FAIL; } tds_set_passwd(*login, PASSWORD); tds_set_user(*login, USER); tds_set_app(*login, appname); tds_set_host(*login, "myhost"); tds_set_library(*login, "TDS-Library"); tds_set_server(*login, SERVER); tds_set_client_charset(*login, CHARSET); tds_set_language(*login, "us_english"); if (verbose) { fprintf(stdout, "Connecting to database\n"); } test_context = tds_alloc_context(); *tds = tds_alloc_socket(test_context, 512); tds_set_parent(*tds, NULL); connect_info = tds_read_config_info(NULL, *login, test_context->locale); if (!connect_info || tds_connect(*tds, connect_info) == TDS_FAIL) { if (connect_info) { *tds = NULL; tds_free_connect(connect_info); } fprintf(stderr, "tds_connect() failed\n"); return TDS_FAIL; } tds_free_connect(connect_info); return TDS_SUCCEED; }
/* * pool_mbr_login open a single pool login, to be call at init time or * to reconnect. */ static TDSSOCKET * pool_mbr_login(TDS_POOL * pool) { TDSCONTEXT *context; TDSLOGIN *login; TDSSOCKET *tds; TDSLOGIN *connection; char hostname[MAXHOSTNAMELEN]; login = tds_alloc_login(1); if (gethostname(hostname, MAXHOSTNAMELEN) < 0) strlcpy(hostname, "tdspool", MAXHOSTNAMELEN); if (!tds_set_passwd(login, pool->password) || !tds_set_user(login, pool->user) || !tds_set_app(login, "tdspool") || !tds_set_host(login, hostname) || !tds_set_library(login, "TDS-Library") || !tds_set_server(login, pool->server) || !tds_set_client_charset(login, "iso_1") || !tds_set_language(login, "us_english")) { tds_free_login(login); return NULL; } if (pool->database && strlen(pool->database)) { if (!tds_dstr_copy(&login->database, pool->database)) { tds_free_login(login); return NULL; } } context = tds_alloc_context(NULL); tds = tds_alloc_socket(context, 512); connection = tds_read_config_info(tds, login, context->locale); if (!connection || TDS_FAILED(tds_connect_and_login(tds, connection))) { tds_free_socket(tds); tds_free_login(connection); /* what to do? */ fprintf(stderr, "Could not open connection to server %s\n", pool->server); return NULL; } tds_free_login(connection); if (pool->database && strlen(pool->database)) { if (strcasecmp(tds->conn->env.database, pool->database) != 0) { fprintf(stderr, "changing database failed\n"); return NULL; } } return tds; }
CS_RETCODE cs_ctx_alloc(CS_INT version, CS_CONTEXT ** ctx) { TDSCONTEXT *tds_ctx; tdsdump_log(TDS_DBG_FUNC, "cs_ctx_alloc(%d, %p)\n", version, ctx); *ctx = (CS_CONTEXT *) calloc(1, sizeof(CS_CONTEXT)); tds_ctx = tds_alloc_context(*ctx); if (!tds_ctx) { free(*ctx); return CS_FAIL; } (*ctx)->tds_ctx = tds_ctx; if (tds_ctx->locale && !tds_ctx->locale->date_fmt) { /* set default in case there's no locale file */ tds_ctx->locale->date_fmt = strdup(STD_DATETIME_FMT); } return CS_SUCCEED; }
int try_tds_login(TDSLOGIN ** login, TDSSOCKET ** tds, const char *appname, int verbose) { TDSLOGIN *connection; const char* base_appname; base_appname = strrchr(appname, '/'); if (base_appname == NULL) { base_appname = appname; } else { ++base_appname; } if (verbose) { fprintf(stdout, "Entered tds_try_login()\n"); } if (!login) { fprintf(stderr, "Invalid TDSLOGIN**\n"); return TDS_FAIL; } if (!tds) { fprintf(stderr, "Invalid TDSSOCKET**\n"); return TDS_FAIL; } if (verbose) { fprintf(stdout, "Trying read_login_info()\n"); } read_login_info(); if (verbose) { fprintf(stdout, "Setting login parameters\n"); } *login = tds_alloc_login(1); if (!*login) { fprintf(stderr, "tds_alloc_login() failed.\n"); return TDS_FAIL; } tds_set_passwd(*login, PASSWORD); tds_set_user(*login, USER); tds_set_app(*login, base_appname); tds_set_host(*login, "myhost"); tds_set_library(*login, "TDS-Library"); tds_set_server(*login, SERVER); tds_set_client_charset(*login, CHARSET); tds_set_language(*login, "us_english"); if (verbose) { fprintf(stdout, "Connecting to database\n"); } test_context = tds_alloc_context(NULL); *tds = tds_alloc_socket(test_context, 512); tds_set_parent(*tds, NULL); connection = tds_read_config_info(*tds, *login, test_context->locale); if (!connection || tds_connect_and_login(*tds, connection) != TDS_SUCCESS) { if (connection) { tds_free_socket(*tds); *tds = NULL; tds_free_login(connection); } fprintf(stderr, "tds_connect_and_login() failed\n"); return TDS_FAIL; } tds_free_login(connection); return TDS_SUCCESS; }
static int mssql_connect(void) { #if (defined(FREETDS_0_63) || defined(FREETDS_0_64)) TDSCONNECTION *connection = NULL; #else TDSCONNECTINFO *connection = NULL; #endif char query[128]; /* Connect to M$SQL Server */ if (!(login = tds_alloc_login())) { ast_log(LOG_ERROR, "tds_alloc_login() failed.\n"); return -1; } tds_set_server(login, hostname); tds_set_user(login, dbuser); tds_set_passwd(login, password); tds_set_app(login, "TSQL"); tds_set_library(login, "TDS-Library"); #ifndef FREETDS_PRE_0_62 tds_set_client_charset(login, charset); #endif tds_set_language(login, language); tds_set_packet(login, 512); tds_set_version(login, 7, 0); #ifdef FREETDS_0_64 if (!(context = tds_alloc_context(NULL))) #else if (!(context = tds_alloc_context())) #endif { ast_log(LOG_ERROR, "tds_alloc_context() failed.\n"); goto connect_fail; } if (!(tds = tds_alloc_socket(context, 512))) { ast_log(LOG_ERROR, "tds_alloc_socket() failed.\n"); goto connect_fail; } tds_set_parent(tds, NULL); connection = tds_read_config_info(tds, login, context->locale); if (!connection) { ast_log(LOG_ERROR, "tds_read_config() failed.\n"); goto connect_fail; } if (tds_connect(tds, connection) == TDS_FAIL) { ast_log(LOG_ERROR, "Failed to connect to MSSQL server.\n"); tds = NULL; /* freed by tds_connect() on error */ #if (defined(FREETDS_0_63) || defined(FREETDS_0_64)) tds_free_connection(connection); #else tds_free_connect(connection); #endif connection = NULL; goto connect_fail; } #if (defined(FREETDS_0_63) || defined(FREETDS_0_64)) tds_free_connection(connection); #else tds_free_connect(connection); #endif connection = NULL; sprintf(query, "USE %s", dbname); #ifdef FREETDS_PRE_0_62 if ((tds_submit_query(tds, query) != TDS_SUCCEED) || (tds_process_simple_query(tds, &result_type) != TDS_SUCCEED || result_type != TDS_CMD_SUCCEED)) #else if ((tds_submit_query(tds, query) != TDS_SUCCEED) || (tds_process_simple_query(tds) != TDS_SUCCEED)) #endif { ast_log(LOG_ERROR, "Could not change database (%s)\n", dbname); goto connect_fail; } connected = 1; return 0; connect_fail: mssql_disconnect(); return -1; }
int main(int argc, char **argv) { /* the conversion pair matrix */ typedef struct { int srctype; int desttype; int yn; } ANSWER; const static ANSWER answers[] = { # include "tds_willconvert.h" }; /* some default inputs */ static const int bit_input = 1; /* timing variables to compute performance */ struct timeval start, end; double starttime, endtime; int i, j, iterations = 0, result; TDS_CHAR *src = NULL; TDS_UINT srclen; CONV_RESULT cr; TDS_NUMERIC numeric; TDS_MONEY money; TDS_MONEY4 money4; TDS_DATETIME datetime; TDS_DATETIME4 datetime4; TDS_TINYINT tds_tinyint; TDS_SMALLINT tds_smallint; TDS_INT tds_int; TDS_INT8 tds_int8; TDS_REAL tds_real; TDS_FLOAT tds_float; if (argc > 1) { iterations = atoi(argv[1]); printf("Computing %d iterations\n", iterations); } ctx = tds_alloc_context(NULL); assert(ctx); if (ctx->locale && !ctx->locale->date_fmt) { /* set default in case there's no locale file */ ctx->locale->date_fmt = tds_strdup(STD_DATETIME_FMT); } /* * Test every possible conversion pair */ for (i = 0; i < sizeof(answers) / sizeof(ANSWER); i++) { if (!answers[i].yn) continue; /* don't attempt nonconvertible types */ if (answers[i].srctype == answers[i].desttype) continue; /* don't attempt same types */ cr.n.precision = 8; cr.n.scale = 2; switch (answers[i].srctype) { case SYBCHAR: case SYBVARCHAR: case SYBTEXT: case SYBBINARY: case SYBVARBINARY: case SYBIMAGE: switch (answers[i].desttype) { case SYBCHAR: case SYBVARCHAR: case SYBTEXT: case SYBDATETIME: case SYBDATETIME4: src = "Jan 1, 1999"; break; case SYBBINARY: case SYBIMAGE: src = "0xbeef"; break; case SYBINT1: case SYBINT2: case SYBINT4: case SYBINT8: src = "255"; break; case SYBFLT8: case SYBREAL: case SYBNUMERIC: case SYBDECIMAL: case SYBMONEY: case SYBMONEY4: src = "1999.25"; cr.n.precision = 8; cr.n.scale = 2; break; case SYBBIT: default: src = "1"; break; } assert(src); srclen = strlen(src); break; case SYBINT1: src = (char *) &tds_tinyint; srclen = sizeof(tds_tinyint); break; case SYBINT2: src = (char *) &tds_smallint; srclen = sizeof(tds_smallint); break; case SYBINT4: src = (char *) &tds_int; srclen = sizeof(tds_int); break; case SYBINT8: src = (char *) &tds_int8; srclen = sizeof(tds_int8); break; case SYBFLT8: tds_float = 3.14159; src = (char *) &tds_float; srclen = sizeof(tds_float); break; case SYBREAL: tds_real = 3.14159; src = (char *) &tds_real; srclen = sizeof(tds_real); break; case SYBNUMERIC: case SYBDECIMAL: src = (char *) &numeric; srclen = sizeof(numeric); break; case SYBMONEY: src = (char *) &money; srclen = sizeof(money); break; case SYBMONEY4: src = (char *) &money4; srclen = sizeof(money4); break; case SYBBIT: src = (char *) &bit_input; srclen = sizeof(bit_input); break; case SYBDATETIME: src = (char *) &datetime; srclen = sizeof(datetime); break; case SYBDATETIME4: src = (char *) &datetime4; srclen = sizeof(datetime4); break; /***** not defined yet case SYBBOUNDARY: case SYBSENSITIVITY: fprintf (stderr, "type %d not supported\n", answers[i].srctype ); continue; break; *****/ default: fprintf(stderr, "no such type %d\n", answers[i].srctype); return -1; } /* * Now at last do the conversion */ result = tds_convert(ctx, answers[i].srctype, src, srclen, answers[i].desttype, &cr); free_convert(answers[i].desttype, &cr); if (result < 0) { if (result == TDS_CONVERT_NOAVAIL) /* tds_willconvert returned true, but it lied. */ fprintf(stderr, "Conversion not yet implemented:\n\t"); fprintf(stderr, "failed (%d) to convert %d (%s, %d bytes) : %d (%s).\n", result, answers[i].srctype, tds_prtype(answers[i].srctype), srclen, answers[i].desttype, tds_prtype(answers[i].desttype)); if (result != TDS_CONVERT_NOAVAIL) return result; } printf("converted %d (%s, %d bytes) : %d (%s, %d bytes).\n", answers[i].srctype, tds_prtype(answers[i].srctype), srclen, answers[i].desttype, tds_prtype(answers[i].desttype), result); /* * In the first iteration, start with varchar -> others. * By saving the output, we initialize subsequent inputs. */ switch (answers[i].desttype) { case SYBNUMERIC: case SYBDECIMAL: numeric = cr.n; break; case SYBMONEY: money = cr.m; break; case SYBMONEY4: money4 = cr.m4; break; case SYBDATETIME: datetime = cr.dt; break; case SYBDATETIME4: datetime4 = cr.dt4; break; case SYBINT1: tds_tinyint = cr.ti; break; case SYBINT2: tds_smallint = cr.si; break; case SYBINT4: tds_int = cr.i; break; case SYBINT8: tds_int8 = cr.bi; break; default: break; } /* * If an iteration count was passed on the command line (not by "make check") * run the conversion N times and print the conversions per second. */ result = gettimeofday(&start, NULL); starttime = (double) start.tv_sec + (double) start.tv_usec * 0.000001; for (j = 0; result >= 0 && j < iterations; j++) { result = tds_convert(ctx, answers[i].srctype, src, srclen, answers[i].desttype, &cr); free_convert(answers[i].desttype, &cr); } if (result < 0) continue; result = gettimeofday(&end, NULL); endtime = (double) end.tv_sec + (double) end.tv_usec * 0.000001; if (endtime != starttime) { printf("%9.0f iterations/second converting %13s => %s.\n", j / (endtime - starttime), tds_prtype(answers[i].srctype), tds_prtype(answers[i].desttype)); } } tds_free_context(ctx); return g_result; }
// Connect to the server bool TdsDatabaseLayer::Connect() { m_pLogin = tds_alloc_login(); if (m_pLogin == NULL) { //fprintf(stderr, "tds_alloc_login() failed.\n"); SetError(DATABASE_LAYER_ERROR, wxT("Failed to allocate login")); // Reset the variables so there are not mistaken as initialized m_pDatabase = NULL; m_pLogin = NULL; if (m_pContext) { tds_free_context(m_pContext); m_pContext = NULL; } ThrowDatabaseException(); return false; } wxCharBuffer serverBuffer = ConvertToUnicodeStream(m_strServer); tds_set_server(m_pLogin, serverBuffer); wxCharBuffer loginBuffer = ConvertToUnicodeStream(m_strLogin); tds_set_user(m_pLogin, loginBuffer); wxCharBuffer passwordBuffer = ConvertToUnicodeStream(m_strPassword); tds_set_passwd(m_pLogin, passwordBuffer); tds_set_app(m_pLogin, "DatabaseLayer"); tds_set_library(m_pLogin, "TDS-Library"); tds_set_client_charset(m_pLogin, "UTF-8"); switch (m_nTdsVersion) { case TDS_42: tds_set_version(m_pLogin, 4, 2); break; case TDS_46: tds_set_version(m_pLogin, 4, 6); break; case TDS_50: tds_set_version(m_pLogin, 5, 0); break; case TDS_70: tds_set_version(m_pLogin, 7, 0); break; case TDS_80: tds_set_version(m_pLogin, 8, 0); break; default: tds_set_version(m_pLogin, 0, 0); break; }; m_pContext = tds_alloc_context(NULL); if (m_pContext == NULL) { //fprintf(stderr, "tds_alloc_context() failed.\n"); SetError(DATABASE_LAYER_ERROR, wxT("Failed to allocate context")); // Reset the variables so there are not mistaken as initialized m_pDatabase = NULL; if (m_pLogin) { tds_free_login(m_pLogin); m_pLogin = NULL; } if (m_pContext) { tds_free_context(m_pContext); m_pContext = NULL; } ThrowDatabaseException(); return false; } m_pContext->msg_handler = tsql_handle_message; m_pContext->err_handler = tsql_handle_error; // Add the context (and this databaselayer) from the lookup map // used by the error handler TdsDatabaseLayer::AddTdsLayer(m_pContext, this); m_pDatabase = tds_alloc_socket(m_pContext, 512); if (m_pDatabase == NULL) { //fprintf(stderr, "tds_alloc_socket() failed.\n"); SetError(DATABASE_LAYER_ERROR, wxT("Failed to allocate socket")); // Reset the variables so there are not mistaken as initialized m_pDatabase = NULL; if (m_pLogin) { tds_free_login(m_pLogin); m_pLogin = NULL; } if (m_pContext) { tds_free_context(m_pContext); m_pContext = NULL; } ThrowDatabaseException(); return false; } tds_set_parent(m_pDatabase, NULL); TDSCONNECTION* pConnection = tds_read_config_info(NULL, m_pLogin, m_pContext->locale); if (!pConnection || tds_connect(m_pDatabase, pConnection) == TDS_FAIL) { if (pConnection) { tds_free_socket(m_pDatabase); //m_pDatabase = NULL; tds_free_connection(pConnection); } //fprintf(stderr, "tds_connect() failed\n"); if (GetErrorCode() == DATABASE_LAYER_OK) { SetError(DATABASE_LAYER_ERROR, wxT("Database connection failed")); } // Reset the variables so there are not mistaken as initialized m_pDatabase = NULL; if (m_pLogin) { tds_free_login(m_pLogin); m_pLogin = NULL; } if (m_pContext) { tds_free_context(m_pContext); m_pContext = NULL; } ThrowDatabaseException(); return false; } tds_free_connection(pConnection); return true; }
int main(int argc, char **argv) { TDSCONTEXT *ctx; TDSSOCKET *tds; TDSLOGIN *login; TDSRESULTINFO *resinfo; if (argc < 2 || atoi(argv[1]) <= 0) { fprintf(stderr, "syntax: %s <port>\n", argv[0]); return 1; } ctx = tds_alloc_context(NULL); tds = tds_listen(ctx, atoi(argv[1])); if (!tds) return 1; /* get_incoming(tds->s); */ login = tds_alloc_read_login(tds); if (!login) { fprintf(stderr, "Error reading login\n"); exit(1); } dump_login(login); if (!strcmp(tds_dstr_cstr(&login->user_name), "guest") && !strcmp(tds_dstr_cstr(&login->password), "sybase")) { tds->out_flag = TDS_REPLY; tds_env_change(tds, TDS_ENV_DATABASE, "master", "pubs2"); tds_send_msg(tds, 5701, 2, 10, "Changed database context to 'pubs2'.", "JDBC", "ZZZZZ", 1); if (!login->suppress_language) { tds_env_change(tds, TDS_ENV_LANG, NULL, "us_english"); tds_send_msg(tds, 5703, 1, 10, "Changed language setting to 'us_english'.", "JDBC", "ZZZZZ", 1); } tds_env_change(tds, TDS_ENV_PACKSIZE, NULL, "512"); /* TODO set mssql if tds7+ */ tds_send_login_ack(tds, "sql server"); if (IS_TDS50(tds)) tds_send_capabilities_token(tds); tds_send_done_token(tds, 0, 1); } else { /* send nack before exiting */ exit(1); } tds_flush_packet(tds); tds_free_login(login); login = NULL; /* printf("incoming packet %d\n", tds_read_packet(tds)); */ printf("query : %s\n", tds_get_generic_query(tds)); tds->out_flag = TDS_REPLY; resinfo = tds_alloc_results(1); resinfo->columns[0]->column_type = SYBVARCHAR; resinfo->columns[0]->column_size = 30; strcpy(resinfo->columns[0]->column_name, "name"); resinfo->columns[0]->column_namelen = 4; resinfo->current_row = (TDS_UCHAR*) "pubs2"; resinfo->columns[0]->column_data = resinfo->current_row; tds_send_result(tds, resinfo); tds_send_control_token(tds, 1); tds_send_row(tds, resinfo); tds_send_done_token(tds, 16, 1); tds_flush_packet(tds); sleep(30); tds_free_results(resinfo); tds_free_socket(tds); tds_free_context(ctx); return 0; }
int main(int argc, char **argv) { int srctype; int desttype; /* some default inputs */ static const int bit_input = 1; /* timing variables to compute performance */ struct timeval start, end; double starttime, endtime; int i, j, iterations = 0, result; TDS_CHAR *src = NULL; TDS_UINT srclen; CONV_RESULT cr; TDS_NUMERIC numeric; TDS_MONEY money; TDS_MONEY4 money4; TDS_DATETIME datetime; TDS_DATETIME4 datetime4; TDS_DATETIMEALL dta; TDS_DATE date; TDS_TIME time; TDS_BIGDATETIME bigdatetime; TDS_BIGTIME bigtime; TDS_TINYINT tds_tinyint; TDS_SMALLINT tds_smallint; TDS_INT tds_int; TDS_INT8 tds_int8; TDS_USMALLINT tds_usmallint; TDS_UINT tds_uint; TDS_UINT8 tds_uint8; TDS_REAL tds_real; TDS_FLOAT tds_float; TDS_UNIQUE tds_unique; if (argc > 1) { iterations = atoi(argv[1]); printf("Computing %d iterations\n", iterations); } setbuf(stdout, NULL); setbuf(stderr, NULL); ctx = tds_alloc_context(NULL); assert(ctx); if (ctx->locale && !ctx->locale->date_fmt) { /* set default in case there's no locale file */ ctx->locale->date_fmt = strdup(STD_DATETIME_FMT); } /* * Test every possible conversion pair */ for (i = 0; i < 0x10000; i++) { srctype = i >> 8; desttype = i & 0xff; srctype = (srctype + SYBCHAR) & 0xff; if (!tds_willconvert(srctype, desttype)) { /* pass a CONV_RESULT as input for make sure size and alignment is enough * for all types */ CONV_RESULT src; memset(&src, 0, sizeof(src)); result = tds_convert(ctx, srctype, (const TDS_CHAR *) &src, 4, desttype, &cr); if (result >= 0) free_convert(desttype, &cr); if (result != TDS_CONVERT_NOAVAIL) { printf("NOT EXPECTED: converted %d (%s, %d bytes) : %d (%s, %d bytes).\n", srctype, tds_prtype(srctype), srclen, desttype, tds_prtype(desttype), result); exit(1); } continue; /* don't attempt nonconvertible types */ } if (srctype == desttype) continue; /* don't attempt same types */ /* valid types should have a name ! */ assert(tds_prtype(srctype)[0] != 0); assert(tds_prtype(desttype)[0] != 0); cr.n.precision = 8; cr.n.scale = 2; switch (srctype) { case SYBCHAR: case SYBVARCHAR: case SYBTEXT: case SYBBINARY: case SYBVARBINARY: case SYBIMAGE: case SYBLONGBINARY: case XSYBBINARY: case XSYBVARBINARY: case XSYBCHAR: case XSYBVARCHAR: switch (desttype) { case SYBCHAR: case SYBVARCHAR: case SYBTEXT: case SYBDATETIME: case SYBDATETIME4: src = "Jan 1, 1999"; break; case SYBMSDATE: case SYBMSDATETIME2: case SYBMSDATETIMEOFFSET: case SYBDATE: src = "2012-11-27"; break; case SYBMSTIME: case SYBTIME: src = "15:27:12"; break; case SYB5BIGTIME: src = "15:27:12.327862"; break; case SYB5BIGDATETIME: src = "2015-09-12 21:48:12.638161"; break; case SYBBINARY: case SYBIMAGE: src = "0xbeef"; break; case SYBINT1: case SYBINT2: case SYBINT4: case SYBINT8: case SYBUINT1: case SYBUINT2: case SYBUINT4: case SYBUINT8: src = "255"; break; case SYBFLT8: case SYBREAL: case SYBNUMERIC: case SYBDECIMAL: case SYBMONEY: case SYBMONEY4: src = "1999.25"; cr.n.precision = 8; cr.n.scale = 2; break; case SYBUNIQUE: src = "A8C60F70-5BD4-3E02-B769-7CCCCA585DCC"; break; case SYBBIT: default: src = "1"; break; } assert(src); srclen = strlen(src); break; case SYBINT1: case SYBUINT1: src = (char *) &tds_tinyint; srclen = sizeof(tds_tinyint); break; case SYBINT2: src = (char *) &tds_smallint; srclen = sizeof(tds_smallint); break; case SYBINT4: src = (char *) &tds_int; srclen = sizeof(tds_int); break; case SYBINT8: src = (char *) &tds_int8; srclen = sizeof(tds_int8); break; case SYBUINT2: src = (char *) &tds_usmallint; srclen = sizeof(tds_usmallint); break; case SYBUINT4: src = (char *) &tds_uint; srclen = sizeof(tds_uint); break; case SYBUINT8: src = (char *) &tds_uint8; srclen = sizeof(tds_uint8); break; case SYBFLT8: tds_float = 3.14159; src = (char *) &tds_float; srclen = sizeof(tds_float); break; case SYBREAL: tds_real = (TDS_REAL) 3.14159; src = (char *) &tds_real; srclen = sizeof(tds_real); break; case SYBNUMERIC: case SYBDECIMAL: src = (char *) &numeric; srclen = sizeof(numeric); break; case SYBMONEY: src = (char *) &money; srclen = sizeof(money); break; case SYBMONEY4: src = (char *) &money4; srclen = sizeof(money4); break; case SYBBIT: case SYBBITN: src = (char *) &bit_input; srclen = sizeof(bit_input); break; case SYBDATETIME: src = (char *) &datetime; srclen = sizeof(datetime); break; case SYBDATETIME4: src = (char *) &datetime4; srclen = sizeof(datetime4); break; case SYBDATE: src = (char *) &date; srclen = sizeof(date); break; case SYBTIME: src = (char *) &time; srclen = sizeof(time); break; case SYB5BIGTIME: src = (char *) &bigtime; srclen = sizeof(bigtime); break; case SYB5BIGDATETIME: src = (char *) &bigdatetime; srclen = sizeof(bigdatetime); break; case SYBUNIQUE: src = (char *) &tds_unique; srclen = sizeof(tds_unique); break; case SYBMSTIME: case SYBMSDATE: case SYBMSDATETIME2: case SYBMSDATETIMEOFFSET: src = (char *) &dta; srclen = sizeof(dta); break; /***** not defined yet case SYBBOUNDARY: case SYBSENSITIVITY: fprintf (stderr, "type %d not supported\n", srctype ); continue; break; *****/ default: fprintf(stderr, "no such type %d (%s)\n", srctype, tds_prtype(srctype)); return -1; } /* * Now at last do the conversion */ result = tds_convert(ctx, srctype, src, srclen, desttype, &cr); if (result >= 0) free_convert(desttype, &cr); if (result < 0) { if (result == TDS_CONVERT_NOAVAIL) /* tds_willconvert returned true, but it lied. */ fprintf(stderr, "Conversion not yet implemented:\n\t"); fprintf(stderr, "failed (%d) to convert %d (%s, %d bytes) : %d (%s).\n", result, srctype, tds_prtype(srctype), srclen, desttype, tds_prtype(desttype)); if (result == TDS_CONVERT_NOAVAIL) exit(1); } printf("converted %d (%s, %d bytes) -> %d (%s, %d bytes).\n", srctype, tds_prtype(srctype), srclen, desttype, tds_prtype(desttype), result); /* * In the first iteration, start with varchar -> others. * By saving the output, we initialize subsequent inputs. */ switch (desttype) { case SYBNUMERIC: case SYBDECIMAL: numeric = cr.n; break; case SYBMONEY: money = cr.m; break; case SYBMONEY4: money4 = cr.m4; break; case SYBDATETIME: datetime = cr.dt; break; case SYBDATETIME4: datetime4 = cr.dt4; break; case SYBDATE: date = cr.date; break; case SYBTIME: time = cr.time; break; case SYBMSDATETIME2: dta = cr.dta; break; case SYB5BIGTIME: bigtime = cr.bigtime; break; case SYB5BIGDATETIME: bigdatetime = cr.bigdatetime; break; case SYBINT1: case SYBUINT1: tds_tinyint = cr.ti; break; case SYBINT2: tds_smallint = cr.si; break; case SYBINT4: tds_int = cr.i; break; case SYBINT8: tds_int8 = cr.bi; break; case SYBUINT2: tds_usmallint = cr.usi; break; case SYBUINT4: tds_uint = cr.ui; break; case SYBUINT8: tds_uint8 = cr.ubi; break; case SYBUNIQUE: tds_unique = cr.u; break; default: break; } /* * If an iteration count was passed on the command line (not by "make check") * run the conversion N times and print the conversions per second. */ result = gettimeofday(&start, NULL); starttime = (double) start.tv_sec + (double) start.tv_usec * 0.000001; for (j = 0; result >= 0 && j < iterations; j++) { result = tds_convert(ctx, srctype, src, srclen, desttype, &cr); if (result >= 0) free_convert(desttype, &cr); } if (result < 0) continue; result = gettimeofday(&end, NULL); endtime = (double) end.tv_sec + (double) end.tv_usec * 0.000001; if (endtime != starttime) { printf("%9.0f iterations/second converting %13s => %s.\n", j / (endtime - starttime), tds_prtype(srctype), tds_prtype(desttype)); } } tds_free_context(ctx); return g_result; }