int
start_parse_prepared_query(struct _hstmt *stmt, int compute_row)
{
/* TODO should be NULL already ?? */
tds_free_param_results(stmt->params);
stmt->params = NULL;
stmt->param_num = 0;
stmt->param_num = stmt->prepared_query_is_func ? 2 : 1;
return parse_prepared_query(stmt, compute_row);
}
DatabaseResultSet* TdsPreparedStatement::RunQueryWithResults()
{
ResetErrorCodes();
//fprintf(stderr, "Running statement with results\n");
// Prepare the statement
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(m_strOriginalQuery);
//fprintf(stderr, "Preparing statement: '%s'\n", (const char*)sqlBuffer);
m_pStatement = NULL;
int nReturn = tds_submit_prepare(m_pDatabase, sqlBuffer, NULL, &m_pStatement, m_pParameters);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_prepare() failed for query '%s'\n", m_strOriginalQuery.c_str());
if (m_pStatement != NULL)
tds_free_dynamic(m_pDatabase, m_pStatement);
if (m_pParameters != NULL)
tds_free_param_results(m_pParameters);
SetErrorInformationFromDatabaseLayer();
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
FreeAllocatedResultSets();
tds_free_input_params(m_pStatement);
m_pStatement->params = m_pParameters;
// Execute the query
//fprintf(stderr, "Statement prepared. Ready to execute\n");
nReturn = tds_submit_execute(m_pDatabase, m_pStatement);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_execute() failed for query '%s'\n", m_pStatement->query);
//fprintf(stderr, "tds_submit_execute() return code: %d\n", nReturn);
SetErrorInformationFromDatabaseLayer();
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
TdsResultSet* pResultSet = new TdsResultSet(m_pDatabase);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
//fprintf(stderr, "Returning prepared statement result set\n");
return pResultSet;
}
int TdsPreparedStatement::RunQuery()
{
ResetErrorCodes();
//fprintf(stderr, "Running statement\n");
//fprintf(stderr, "m_pDatabase %d\n", m_pDatabase);
//fprintf(stderr, "m_pStatement %d\n", m_pStatement);
//fprintf(stderr, "m_pParameters %d\n", m_pParameters);
// Prepare the statement
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(m_strOriginalQuery);
//fprintf(stderr, "Preparing statement: '%s'\n", (const char*)sqlBuffer);
m_pStatement = NULL;
int nReturn = tds_submit_prepare(m_pDatabase, sqlBuffer, NULL, &m_pStatement, m_pParameters);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_prepare() failed for query '%s'\n", m_strOriginalQuery.c_str());
if (m_pStatement != NULL)
tds_free_dynamic(m_pDatabase, m_pStatement);
if (m_pParameters != NULL)
tds_free_param_results(m_pParameters);
SetErrorInformationFromDatabaseLayer();
FreeAllocatedResultSets();
ThrowDatabaseException();
return DATABASE_LAYER_QUERY_RESULT_ERROR;
}
FreeAllocatedResultSets();
tds_free_input_params(m_pStatement);
m_pStatement->params = m_pParameters;
// Execute the query
nReturn = tds_submit_execute(m_pDatabase, m_pStatement);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_execute() failed for statement '%s'\n", m_pStatement->query);
SetErrorInformationFromDatabaseLayer();
FreeAllocatedResultSets();
ThrowDatabaseException();
}
//fprintf(stderr, "Statement executed. Freeing results\n");
FreeAllocatedResultSets();
return DATABASE_LAYER_QUERY_RESULT_ERROR;
}
static int
odbc_set_stmt(TDS_STMT * stmt, char **dest, const char *sql, int sql_len)
{
char *p;
assert(dest == &stmt->prepared_query || dest == &stmt->query);
if (sql_len == SQL_NTS)
sql_len = strlen(sql);
else if (sql_len <= 0)
return SQL_ERROR;
/* TODO already NULL ?? */
tds_free_param_results(stmt->params);
stmt->params = NULL;
stmt->param_num = 0;
stmt->param_count = 0;
stmt->prepared_query_is_func = 0;
stmt->prepared_query_is_rpc = 0;
if (stmt->prepared_query) {
free(stmt->prepared_query);
stmt->prepared_query = NULL;
}
if (stmt->query) {
free(stmt->query);
stmt->query = NULL;
}
*dest = p = (char *) malloc(sql_len + 1);
if (!p)
return SQL_ERROR;
if (sql) {
memcpy(p, sql, sql_len);
p[sql_len] = 0;
} else {
p[0] = 0;
}
return SQL_SUCCESS;
}
/**
* \ingroup dblib_rpc
* \brief Execute the procedure and free associated memory
*
* \param dbproc contains all information needed by db-lib to manage communications with the server.
* \retval SUCCEED normal.
* \retval FAIL on error
* \sa dbrpcinit(), dbrpcparam()
*/
RETCODE
dbrpcsend(DBPROCESS * dbproc)
{
DBREMOTE_PROC *rpc;
/* sanity */
if (dbproc == NULL || dbproc->rpc == NULL /* dbrpcinit should allocate pointer */
|| dbproc->rpc->name == NULL) { /* can't be ready without a name */
return FAIL;
}
dbproc->dbresults_state = _DB_RES_INIT;
/* FIXME do stuff */
tdsdump_log(TDS_DBG_FUNC, "dbrpcsend()\n");
for (rpc = dbproc->rpc; rpc != NULL; rpc = rpc->next) {
int erc;
TDSPARAMINFO *pparam_info = NULL;
/*
* [email protected]: allow stored procedures to have no
* paramaters
*/
if (rpc->param_list != NULL) {
pparam_info = param_info_alloc(dbproc->tds_socket, rpc);
if (!pparam_info)
return FAIL;
}
erc = tds_submit_rpc(dbproc->tds_socket, dbproc->rpc->name, pparam_info);
tds_free_param_results(pparam_info);
if (erc == TDS_FAIL)
return FAIL;
}
/* free up the memory */
rpc_clear(dbproc->rpc);
dbproc->rpc = NULL;
return SUCCEED;
}
/**
* Allocate memory and copy the rpc information into a TDSPARAMINFO structure.
*/
static TDSPARAMINFO *
param_info_alloc(TDSSOCKET * tds, DBREMOTE_PROC * rpc)
{
int i;
DBREMOTE_PROC_PARAM *p;
TDSCOLUMN *pcol;
TDSPARAMINFO *params = NULL, *new_params;
BYTE *temp_value;
int temp_datalen;
int temp_type;
int param_is_null;
/* sanity */
if (rpc == NULL)
return NULL;
/* see v 1.10 2002/11/23 for first broken attempt */
for (i = 0, p = rpc->param_list; p != NULL; p = p->next, i++) {
const unsigned char *prow;
if (!(new_params = tds_alloc_param_result(params))) {
tds_free_param_results(params);
tdsdump_log(TDS_DBG_ERROR, "out of rpc memory!");
return NULL;
}
params = new_params;
/*
* Determine whether an input parameter is NULL
* or not.
*/
param_is_null = 0;
temp_type = p->type;
temp_value = p->value;
temp_datalen = p->datalen;
if (p->datalen == 0)
param_is_null = 1;
tdsdump_log(TDS_DBG_INFO1, "parm_info_alloc(): parameter null-ness = %d\n", param_is_null);
if (param_is_null || (p->status & DBRPCRETURN)) {
if (param_is_null) {
temp_datalen = 0;
temp_value = NULL;
} else if (is_fixed_type(temp_type)) {
temp_datalen = tds_get_size_by_type(temp_type);
}
temp_type = tds_get_null_type(temp_type);
} else if (is_fixed_type(temp_type)) {
temp_datalen = tds_get_size_by_type(temp_type);
}
pcol = params->columns[i];
/* meta data */
if (p->name) {
tds_strlcpy(pcol->column_name, p->name, sizeof(pcol->column_name));
pcol->column_namelen = strlen(pcol->column_name);
}
tds_set_param_type(tds, pcol, temp_type);
if (p->maxlen > 0)
pcol->column_size = p->maxlen;
else {
if (is_fixed_type(p->type)) {
pcol->column_size = tds_get_size_by_type(p->type);
} else {
pcol->column_size = p->datalen;
}
}
pcol->on_server.column_size = pcol->column_size;
pcol->column_output = p->status;
pcol->column_cur_size = temp_datalen;
prow = param_row_alloc(params, pcol, i, temp_value, temp_datalen);
if (!prow) {
tds_free_param_results(params);
tdsdump_log(TDS_DBG_ERROR, "out of memory for rpc row!");
return NULL;
}
}
return params;
}
