void TdsPreparedStatement::SetParamDate(int nPosition, const wxDateTime& dateValue)
{
//fprintf(stderr, "Setting param %d to date %s\n", nPosition, dateValue.Format().c_str());
ResetErrorCodes();
AllocateParameter(nPosition);
wxString dateAsString = dateValue.Format(wxT("%Y-%m-%d %H:%M:%S"));
//fprintf(stderr, "Setting param %d to date %s\n", nPosition, dateAsString.c_str());
CONV_RESULT cr;
wxCharBuffer dateCharBuffer = ConvertToUnicodeStream(dateAsString);
int bufferLength = GetEncodedStreamLength(dateAsString);
int ret = tds_convert(this->m_pDatabase->tds_ctx, SYBVARCHAR,
(TDS_CHAR*)(const char*)dateCharBuffer, bufferLength, SYBDATETIME, &cr);
//fprintf(stderr, "tds_convert returned %d, sizeof TDS_DATETIME = %d\n", ret, sizeof(TDS_DATETIME));
int valueSize = (ret < 0) ? sizeof(TDS_DATETIME) : ret;
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBDATETIMN;
curcol->on_server.column_type = SYBDATETIMN;
curcol->column_size = valueSize;
curcol->on_server.column_size = valueSize;
curcol->column_varint_size = 1;
curcol->column_cur_size = valueSize;
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, &cr.dt, valueSize);
}
static void
test(TDSSOCKET * tds, TDSDYNAMIC * dyn, TDS_INT n, const char *s)
{
TDSPARAMINFO *params;
TDSCOLUMN *curcol;
int len = (int)strlen(s);
tds_free_input_params(dyn);
if (!(params = tds_alloc_param_result(dyn->params)))
fatal_error("out of memory!");
dyn->params = params;
curcol = params->columns[0];
curcol->column_type = SYBINTN;
curcol->on_server.column_type = SYBINTN;
curcol->column_size = sizeof(TDS_INT);
curcol->on_server.column_size = sizeof(TDS_INT);
curcol->column_varint_size = 1;
curcol->column_cur_size = sizeof(TDS_INT);
/* TODO test error */
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, &n, sizeof(n));
if (!(params = tds_alloc_param_result(dyn->params)))
fatal_error("out of memory!");
dyn->params = params;
curcol = params->columns[1];
tds_set_param_type(tds, curcol, SYBVARCHAR);
curcol->column_size = 40;
curcol->column_cur_size = len;
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, s, len);
if (tds_submit_execute(tds, dyn) != TDS_SUCCEED)
fatal_error("tds_submit_execute() error");
if (discard_result(tds) != TDS_SUCCEED)
fatal_error("tds_submit_execute() output error");
}
void TdsPreparedStatement::SetParamBool(int nPosition, bool bValue)
{
//fprintf(stderr, "Setting param %d to boolean %d\n", nPosition, bValue);
ResetErrorCodes();
AllocateParameter(nPosition);
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBBITN;
curcol->on_server.column_type = SYBBITN;
curcol->column_size = sizeof(bool);
curcol->on_server.column_size = sizeof(bool);
curcol->column_varint_size = 1;
curcol->column_cur_size = sizeof(TDS_DATETIME);
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, &bValue , sizeof(bool));
}
void TdsPreparedStatement::SetParamDouble(int nPosition, double dblValue)
{
//fprintf(stderr, "Setting param %d to double %f\n", nPosition, dblValue);
ResetErrorCodes();
AllocateParameter(nPosition);
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBFLTN;
curcol->on_server.column_type = SYBFLTN;
curcol->column_size = sizeof(TDS_FLOAT);
curcol->on_server.column_size = sizeof(TDS_FLOAT);
curcol->column_varint_size = 1;
curcol->column_cur_size = sizeof(TDS_FLOAT);
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, &dblValue, sizeof(dblValue));
}
// set parameter
void TdsPreparedStatement::SetParamInt(int nPosition, int nValue)
{
//fprintf(stderr, "Setting param %d to int %d\n", nPosition, nValue);
ResetErrorCodes();
AllocateParameter(nPosition);
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBINTN;
curcol->on_server.column_type = SYBINTN;
curcol->column_size = sizeof(TDS_INT);
curcol->on_server.column_size = sizeof(TDS_INT);
curcol->column_varint_size = 1;
curcol->column_cur_size = sizeof(TDS_INT);
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, &nValue, sizeof(nValue));
}
void TdsPreparedStatement::SetParamBlob(int nPosition, const void* pData, long nDataLength)
{
//fprintf(stderr, "Setting param %d to blob\n", nPosition);
ResetErrorCodes();
AllocateParameter(nPosition);
/*
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBIMAGE;
curcol->on_server.column_type = SYBIMAGE;
curcol->column_size = 40;
//curcol->on_server.column_size = 40;
curcol->column_varint_size = 1;
curcol->column_cur_size = 40;
fprintf(stderr, "Setting blob column size to %d\n", nDataLength);
tds_alloc_param_data(m_pParameters, curcol);
BCPCOLDATA* pBcpColData = tds_alloc_bcp_column_data(nDataLength);
curcol->bcp_column_data = pBcpColData;
curcol->bcp_column_data->datalen = nDataLength;
memcpy(curcol->bcp_column_data->data, pData, nDataLength);
*/
CONV_RESULT cr;
//fprintf(stderr, "data length = %ld\n", nDataLength);
int ret = tds_convert(this->m_pDatabase->tds_ctx, SYBBINARY, (TDS_CHAR*)pData, nDataLength, SYBVARBINARY, &cr);
//fprintf(stderr, "tds_convert returned %d, data length = %ld\n", ret, nDataLength);
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBVARBINARY;
curcol->on_server.column_type = SYBVARBINARY;
curcol->column_size = ret;
curcol->on_server.column_size = ret;
curcol->column_varint_size = 1;
curcol->column_cur_size = ret;
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
//fprintf(stderr, "Ready for memcpy of %d bytes\n", ret);
memcpy(curcol->column_data, cr.ib, ret);
//fprintf(stderr, "Memcpy completed\n");
}
void TdsPreparedStatement::SetParamString(int nPosition, const wxString& strValue)
{
//fprintf(stderr, "Setting param %d to string '%s'\n", nPosition, strValue.c_str());
ResetErrorCodes();
AllocateParameter(nPosition);
//wxCharBuffer valueBuffer = ConvertToUnicodeStream(strValue);
//int nLength = GetEncodedStreamLength(strValue);
const char* valueBuffer = strValue.mb_str();
int nLength = strValue.Len();
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBVARCHAR;
curcol->on_server.column_type = SYBVARCHAR;
curcol->column_size = 40;//nLength+1;//40;
//curcol->on_server.column_size = 40;
curcol->column_varint_size = 1;
curcol->column_cur_size = nLength+1;
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
memcpy(curcol->column_data, valueBuffer, nLength+1);
}
void TdsPreparedStatement::SetParamNull(int nPosition)
{
//fprintf(stderr, "Setting param %d to NULL\n", nPosition);
ResetErrorCodes();
AllocateParameter(nPosition);
TDSCOLUMN* curcol = m_pParameters->columns[nPosition-1];
curcol->column_type = SYBVARCHAR;
curcol->on_server.column_type = SYBVARCHAR;
//curcol->column_size = sizeof(TDS_INT);
//curcol->on_server.column_size = 40;
curcol->column_varint_size = 1;
//curcol->column_cur_size = nLength;
//curcol->column_nullbind = -1;
curcol->column_cur_size = -1;
//tds_alloc_param_data(m_pParameters, curcol);
tds_alloc_param_data(curcol);
curcol->column_data = NULL;
//tds_alloc_param_data(m_pParameters, curcol);
//memcpy(curcol->column_data, valueBuffer, nLength);
}
static int
prepared_rpc(struct _hstmt *stmt, int compute_row)
{
int nparam = stmt->params ? stmt->params->num_cols : 0;
const char *p = stmt->prepared_pos - 1;
TDSCONNECTION *conn = stmt->dbc->tds_socket->conn;
for (;;) {
TDSPARAMINFO *temp_params;
TDSCOLUMN *curcol;
TDS_SERVER_TYPE type;
const char *start;
while (TDS_ISSPACE(*++p));
if (!*p)
return SQL_SUCCESS;
/* we have certainly a parameter */
if (!(temp_params = tds_alloc_param_result(stmt->params))) {
odbc_errs_add(&stmt->errs, "HY001", NULL);
return SQL_ERROR;
}
stmt->params = temp_params;
curcol = temp_params->columns[nparam];
switch (*p) {
case ',':
if (IS_TDS7_PLUS(conn)) {
tds_set_param_type(conn, curcol, SYBVOID);
curcol->column_size = curcol->column_cur_size = 0;
} else {
/* TODO is there a better type ? */
tds_set_param_type(conn, curcol, SYBINTN);
curcol->column_size = curcol->on_server.column_size = 4;
curcol->column_cur_size = -1;
}
if (compute_row)
if (!tds_alloc_param_data(curcol)) {
tds_free_param_result(temp_params);
return SQL_ERROR;
}
--p;
break;
default:
/* add next parameter to list */
start = p;
if (!(p = parse_const_param(p, &type))) {
tds_free_param_result(temp_params);
return SQL_ERROR;
}
tds_set_param_type(conn, curcol, type);
switch (type) {
case SYBVARCHAR:
curcol->column_size = p - start;
break;
case SYBVARBINARY:
curcol->column_size = (p - start) / 2 -1;
break;
default:
assert(0);
case SYBINT4:
case SYBFLT8:
curcol->column_cur_size = curcol->column_size;
break;
}
curcol->on_server.column_size = curcol->column_size;
/* TODO support other type other than VARCHAR, do not strip escape in prepare_call */
if (compute_row) {
char *dest;
int len;
CONV_RESULT cr;
if (!tds_alloc_param_data(curcol)) {
tds_free_param_result(temp_params);
return SQL_ERROR;
}
dest = (char *) curcol->column_data;
switch (type) {
case SYBVARCHAR:
if (*start != '\'') {
memcpy(dest, start, p - start);
curcol->column_cur_size = p - start;
} else {
++start;
for (;;) {
if (*start == '\'')
++start;
if (start >= p)
break;
*dest++ = *start++;
}
curcol->column_cur_size =
dest - (char *) curcol->column_data;
}
break;
case SYBVARBINARY:
cr.cb.len = curcol->column_size;
cr.cb.ib = dest;
len = tds_convert(NULL, SYBVARCHAR, start, p - start, TDS_CONVERT_BINARY, &cr);
if (len >= 0 && len <= curcol->column_size)
curcol->column_cur_size = len;
break;
case SYBINT4:
*((TDS_INT *) dest) = strtol(start, NULL, 10);
break;
case SYBFLT8:
*((TDS_FLOAT *) dest) = strtod(start, NULL);
break;
default:
break;
}
}
--p;
break;
case '?':
/* find binded parameter */
if (stmt->param_num > stmt->apd->header.sql_desc_count
|| stmt->param_num > stmt->ipd->header.sql_desc_count) {
tds_free_param_result(temp_params);
/* TODO set error */
return SQL_ERROR;
}
switch (odbc_sql2tds
(stmt, &stmt->ipd->records[stmt->param_num - 1], &stmt->apd->records[stmt->param_num - 1],
curcol, compute_row, stmt->apd, stmt->curr_param_row)) {
case SQL_ERROR:
return SQL_ERROR;
case SQL_NEED_DATA:
return SQL_NEED_DATA;
}
++stmt->param_num;
break;
}
++nparam;
while (TDS_ISSPACE(*++p));
if (!*p || *p != ',')
return SQL_SUCCESS;
stmt->prepared_pos = (char *) p + 1;
}
}
/**
* Convert parameters to libtds format
* @return SQL_SUCCESS, SQL_ERROR or SQL_NEED_DATA
*/
SQLRETURN
sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ipd, const struct _drecord *drec_apd, TDSCOLUMN *curcol,
int compute_row, const TDS_DESC* axd, unsigned int n_row)
{
TDS_DBC * dbc = stmt->dbc;
int dest_type, src_type, sql_src_type, res;
CONV_RESULT ores;
TDSBLOB *blob;
char *src;
unsigned char *dest;
int len;
TDS_DATETIME dt;
TDS_NUMERIC num;
SQL_NUMERIC_STRUCT *sql_num;
SQLINTEGER sql_len;
int need_data = 0, i;
/* TODO handle bindings of char like "{d '2002-11-12'}" */
tdsdump_log(TDS_DBG_INFO2, "type=%d\n", drec_ipd->sql_desc_concise_type);
/* what type to convert ? */
dest_type = odbc_sql_to_server_type(dbc->tds_socket, drec_ipd->sql_desc_concise_type);
if (dest_type == TDS_FAIL)
return SQL_ERROR;
tdsdump_log(TDS_DBG_INFO2, "trace\n");
/* TODO what happen for unicode types ?? */
tds_set_param_type(dbc->tds_socket, curcol, dest_type);
if (is_numeric_type(curcol->column_type)) {
curcol->column_prec = drec_ipd->sql_desc_precision;
curcol->column_scale = drec_ipd->sql_desc_scale;
}
if (drec_ipd->sql_desc_parameter_type != SQL_PARAM_INPUT)
curcol->column_output = 1;
/* compute destination length */
if (curcol->column_varint_size != 0) {
/* curcol->column_size = drec_apd->sql_desc_octet_length; */
/*
* TODO destination length should come from sql_desc_length,
* however there is the encoding problem to take into account
* we should fill destination length after conversion keeping
* attention to fill correctly blob/fixed type/variable type
*/
/* TODO location of this test is correct here ?? */
if (dest_type != SYBUNIQUE && dest_type != SYBBITN && !is_fixed_type(dest_type)) {
curcol->column_cur_size = 0;
curcol->column_size = drec_ipd->sql_desc_length;
if (curcol->column_size < 0)
curcol->column_size = 0x7FFFFFFFl;
}
} else if (dest_type != SYBBIT) {
/* TODO only a trick... */
tds_set_param_type(dbc->tds_socket, curcol, tds_get_null_type(dest_type));
}
/* get C type */
sql_src_type = drec_apd->sql_desc_concise_type;
if (sql_src_type == SQL_C_DEFAULT)
sql_src_type = odbc_sql_to_c_type_default(drec_ipd->sql_desc_concise_type);
/* test source type */
/* TODO test intervals */
src_type = odbc_c_to_server_type(sql_src_type);
if (src_type == TDS_FAIL)
return SQL_ERROR;
/* we have no data to convert, just return */
if (!compute_row)
return TDS_SUCCEED;
src = drec_apd->sql_desc_data_ptr;
if (src && n_row) {
SQLLEN len;
if (axd->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN) {
len = axd->header.sql_desc_bind_type;
if (axd->header.sql_desc_bind_offset_ptr)
src += *axd->header.sql_desc_bind_offset_ptr;
} else {
len = odbc_get_octet_len(sql_src_type, drec_apd);
if (len < 0)
/* TODO sure ? what happen to upper layer ?? */
return SQL_ERROR;
}
src += len * n_row;
}
/* if only output assume input is NULL */
if (drec_ipd->sql_desc_parameter_type == SQL_PARAM_OUTPUT) {
sql_len = SQL_NULL_DATA;
} else {
sql_len = odbc_get_param_len(drec_apd, drec_ipd, axd, n_row);
/* special case, MS ODBC handle conversion from "\0" to any to NULL, DBD::ODBC require it */
if (src_type == SYBVARCHAR && sql_len == 1 && drec_ipd->sql_desc_parameter_type == SQL_PARAM_INPUT_OUTPUT
&& src && *src == 0) {
sql_len = SQL_NULL_DATA;
}
}
/* compute source length */
switch (sql_len) {
case SQL_NULL_DATA:
len = 0;
break;
case SQL_NTS:
/* check that SQLBindParameter::ParameterValuePtr is not zero for input parameters */
if (!src) {
odbc_errs_add(&stmt->errs, "HY090", NULL);
return SQL_ERROR;
}
len = strlen(src);
break;
case SQL_DEFAULT_PARAM:
case SQL_DATA_AT_EXEC:
/* TODO */
return SQL_ERROR;
break;
default:
len = sql_len;
if (sql_len < 0) {
/* test for SQL_C_CHAR/SQL_C_BINARY */
switch (sql_src_type) {
case SQL_C_CHAR:
case SQL_C_BINARY:
break;
default:
return SQL_ERROR;
}
len = SQL_LEN_DATA_AT_EXEC(sql_len);
need_data = 1;
/* dynamic length allowed only for BLOB fields */
switch (drec_ipd->sql_desc_concise_type) {
case SQL_LONGVARCHAR:
case SQL_LONGVARBINARY:
break;
default:
return SQL_ERROR;
}
}
}
/* allocate given space */
if (!tds_alloc_param_data(curcol))
return SQL_ERROR;
if (need_data) {
curcol->column_cur_size = 0;
return SQL_NEED_DATA;
}
/* set null */
assert(drec_ipd->sql_desc_parameter_type != SQL_PARAM_OUTPUT || sql_len == SQL_NULL_DATA);
if (sql_len == SQL_NULL_DATA) {
curcol->column_cur_size = -1;
return TDS_SUCCEED;
}
if (!src) {
odbc_errs_add(&stmt->errs, "HY090", NULL);
return SQL_ERROR;
}
/* convert special parameters (not libTDS compatible) */
switch (src_type) {
case SYBDATETIME:
convert_datetime2server(drec_apd->sql_desc_concise_type, src, &dt);
src = (char *) &dt;
break;
case SYBDECIMAL:
case SYBNUMERIC:
sql_num = (SQL_NUMERIC_STRUCT *) src;
num.precision = sql_num->precision;
num.scale = sql_num->scale;
num.array[0] = sql_num->sign ^ 1;
/* test precision so client do not crash our library */
if (num.precision <= 0 || num.precision > 38 || num.scale > num.precision)
/* TODO add proper error */
return SQL_ERROR;
i = tds_numeric_bytes_per_prec[num.precision];
memcpy(num.array + 1, sql_num->val, i - 1);
tds_swap_bytes(num.array + 1, i - 1);
if (i < sizeof(num.array))
memset(num.array + i, 0, sizeof(num.array) - i);
src = (char *) #
break;
/* TODO intervals */
}
dest = curcol->column_data;
switch ((TDS_SERVER_TYPE) dest_type) {
case SYBCHAR:
case SYBVARCHAR:
case XSYBCHAR:
case XSYBVARCHAR:
ores.cc.c = (TDS_CHAR*) dest;
ores.cc.len = curcol->column_size;
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, TDS_CONVERT_CHAR, &ores);
if (res > curcol->column_size)
res = curcol->column_size;
break;
case SYBBINARY:
case SYBVARBINARY:
case XSYBBINARY:
case XSYBVARBINARY:
ores.cb.ib = (TDS_CHAR*) dest;
ores.cb.len = curcol->column_size;
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, TDS_CONVERT_BINARY, &ores);
if (res > curcol->column_size)
res = curcol->column_size;
break;
case SYBTEXT:
case SYBLONGBINARY:
case SYBIMAGE:
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, dest_type, &ores);
if (res < 0)
return SQL_ERROR;
blob = (TDSBLOB *) dest;
free(blob->textvalue);
blob->textvalue = ores.ib;
break;
case SYBNUMERIC:
case SYBDECIMAL:
((TDS_NUMERIC *) dest)->precision = drec_ipd->sql_desc_precision;
((TDS_NUMERIC *) dest)->scale = drec_ipd->sql_desc_scale;
case SYBINTN:
case SYBINT1:
case SYBINT2:
case SYBINT4:
case SYBINT8:
case SYBFLT8:
case SYBDATETIME:
case SYBBIT:
case SYBMONEY4:
case SYBMONEY:
case SYBDATETIME4:
case SYBREAL:
case SYBBITN:
case SYBFLTN:
case SYBMONEYN:
case SYBDATETIMN:
case SYBSINT1:
case SYBUINT2:
case SYBUINT4:
case SYBUINT8:
case SYBUNIQUE:
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, dest_type, (CONV_RESULT*) dest);
break;
default:
case XSYBNVARCHAR:
case XSYBNCHAR:
case SYBNVARCHAR:
case SYBNTEXT:
case SYBVOID:
case SYBVARIANT:
/* TODO ODBC 3.5 */
assert(0);
res = -1;
break;
}
if (res < 0)
return SQL_ERROR;
curcol->column_cur_size = res;
return SQL_SUCCESS;
}
/**
* Convert parameters to libtds format
* @return SQL_SUCCESS, SQL_ERROR or SQL_NEED_DATA
*/
SQLRETURN
odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ipd, const struct _drecord *drec_apd, TDSCOLUMN *curcol,
int compute_row, const TDS_DESC* axd, unsigned int n_row)
{
TDS_DBC * dbc = stmt->dbc;
TDSCONNECTION * conn = dbc->tds_socket->conn;
int dest_type, src_type, sql_src_type, res;
CONV_RESULT ores;
TDSBLOB *blob;
char *src, *converted_src;
unsigned char *dest;
int len;
TDS_DATETIMEALL dta;
TDS_NUMERIC num;
SQL_NUMERIC_STRUCT *sql_num;
SQLINTEGER sql_len;
int need_data = 0, i;
/* TODO handle bindings of char like "{d '2002-11-12'}" */
tdsdump_log(TDS_DBG_INFO2, "type=%d\n", drec_ipd->sql_desc_concise_type);
/* what type to convert ? */
dest_type = odbc_sql_to_server_type(conn, drec_ipd->sql_desc_concise_type, drec_ipd->sql_desc_unsigned);
if (!dest_type) {
odbc_errs_add(&stmt->errs, "07006", NULL); /* Restricted data type attribute violation */
return SQL_ERROR;
}
tdsdump_log(TDS_DBG_INFO2, "trace\n");
/* get C type */
sql_src_type = drec_apd->sql_desc_concise_type;
if (sql_src_type == SQL_C_DEFAULT)
sql_src_type = odbc_sql_to_c_type_default(drec_ipd->sql_desc_concise_type);
/* TODO what happen for unicode types ?? */
if (is_char_type(dest_type) && sql_src_type == SQL_C_WCHAR) {
TDSICONV *conv = conn->char_convs[is_unicode_type(dest_type) ? client2ucs2 : client2server_chardata];
tds_set_param_type(conn, curcol, dest_type);
curcol->char_conv = tds_iconv_get(conn, odbc_get_wide_name(conn), conv->to.charset.name);
memcpy(curcol->column_collation, conn->collation, sizeof(conn->collation));
} else {
#ifdef ENABLE_ODBC_WIDE
TDSICONV *conv = conn->char_convs[is_unicode_type(dest_type) ? client2ucs2 : client2server_chardata];
tds_set_param_type(conn, curcol, dest_type);
/* use binary format for binary to char */
if (is_char_type(dest_type))
curcol->char_conv = sql_src_type == SQL_C_BINARY ? NULL : tds_iconv_get(conn, tds_dstr_cstr(&dbc->original_charset), conv->to.charset.name);
#else
tds_set_param_type(conn, curcol, dest_type);
/* use binary format for binary to char */
if (sql_src_type == SQL_C_BINARY && is_char_type(dest_type))
curcol->char_conv = NULL;
#endif
}
if (is_numeric_type(curcol->column_type)) {
curcol->column_prec = drec_ipd->sql_desc_precision;
curcol->column_scale = drec_ipd->sql_desc_scale;
}
if (drec_ipd->sql_desc_parameter_type != SQL_PARAM_INPUT)
curcol->column_output = 1;
/* compute destination length */
if (curcol->column_varint_size != 0) {
/* curcol->column_size = drec_apd->sql_desc_octet_length; */
/*
* TODO destination length should come from sql_desc_length,
* however there is the encoding problem to take into account
* we should fill destination length after conversion keeping
* attention to fill correctly blob/fixed type/variable type
*/
/* TODO location of this test is correct here ?? */
if (dest_type != SYBUNIQUE && dest_type != SYBBITN && !is_fixed_type(dest_type)) {
curcol->column_cur_size = 0;
curcol->column_size = drec_ipd->sql_desc_length;
if (curcol->column_size < 0) {
curcol->on_server.column_size = curcol->column_size = 0x7FFFFFFFl;
} else {
if (is_unicode_type(dest_type))
curcol->on_server.column_size = curcol->column_size * 2;
else
curcol->on_server.column_size = curcol->column_size;
}
}
} else if (dest_type != SYBBIT) {
/* TODO only a trick... */
tds_set_param_type(conn, curcol, tds_get_null_type(dest_type));
}
/* test source type */
/* TODO test intervals */
src_type = odbc_c_to_server_type(sql_src_type);
if (!src_type) {
odbc_errs_add(&stmt->errs, "07006", NULL); /* Restricted data type attribute violation */
return SQL_ERROR;
}
/* we have no data to convert, just return */
if (!compute_row)
return SQL_SUCCESS;
src = drec_apd->sql_desc_data_ptr;
if (src && n_row) {
SQLLEN len;
if (axd->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN) {
len = axd->header.sql_desc_bind_type;
if (axd->header.sql_desc_bind_offset_ptr)
src += *axd->header.sql_desc_bind_offset_ptr;
} else {
len = odbc_get_octet_len(sql_src_type, drec_apd);
if (len < 0)
/* TODO sure ? what happen to upper layer ?? */
/* TODO fill error */
return SQL_ERROR;
}
src += len * n_row;
}
/* if only output assume input is NULL */
if (drec_ipd->sql_desc_parameter_type == SQL_PARAM_OUTPUT) {
sql_len = SQL_NULL_DATA;
} else {
sql_len = odbc_get_param_len(drec_apd, drec_ipd, axd, n_row);
/* special case, MS ODBC handle conversion from "\0" to any to NULL, DBD::ODBC require it */
if (src_type == SYBVARCHAR && sql_len == 1 && drec_ipd->sql_desc_parameter_type == SQL_PARAM_INPUT_OUTPUT
&& src && *src == 0) {
sql_len = SQL_NULL_DATA;
}
}
/* compute source length */
switch (sql_len) {
case SQL_NULL_DATA:
len = 0;
break;
case SQL_NTS:
/* check that SQLBindParameter::ParameterValuePtr is not zero for input parameters */
if (!src) {
odbc_errs_add(&stmt->errs, "HY090", NULL);
return SQL_ERROR;
}
if (sql_src_type == SQL_C_WCHAR)
len = sqlwcslen((const SQLWCHAR *) src) * sizeof(SQLWCHAR);
else
len = strlen(src);
break;
case SQL_DEFAULT_PARAM:
odbc_errs_add(&stmt->errs, "07S01", NULL); /* Invalid use of default parameter */
return SQL_ERROR;
break;
case SQL_DATA_AT_EXEC:
default:
len = sql_len;
if (sql_len < 0) {
/* test for SQL_C_CHAR/SQL_C_BINARY */
switch (sql_src_type) {
case SQL_C_CHAR:
case SQL_C_WCHAR:
case SQL_C_BINARY:
break;
default:
odbc_errs_add(&stmt->errs, "HY090", NULL);
return SQL_ERROR;
}
len = SQL_LEN_DATA_AT_EXEC(sql_len);
need_data = 1;
/* dynamic length allowed only for BLOB fields */
switch (drec_ipd->sql_desc_concise_type) {
case SQL_LONGVARCHAR:
case SQL_WLONGVARCHAR:
case SQL_LONGVARBINARY:
break;
default:
odbc_errs_add(&stmt->errs, "HY090", NULL);
return SQL_ERROR;
}
}
}
/* set NULL. For NULLs we don't need to allocate row buffer so avoid it */
if (!need_data) {
assert(drec_ipd->sql_desc_parameter_type != SQL_PARAM_OUTPUT || sql_len == SQL_NULL_DATA);
if (sql_len == SQL_NULL_DATA) {
curcol->column_cur_size = -1;
return SQL_SUCCESS;
}
}
switch (dest_type) {
case SYBCHAR:
case SYBVARCHAR:
case XSYBCHAR:
case XSYBVARCHAR:
case XSYBNVARCHAR:
case XSYBNCHAR:
case SYBNVARCHAR:
case SYBNTEXT:
case SYBTEXT:
if (!need_data && (sql_src_type == SQL_C_CHAR || sql_src_type == SQL_C_WCHAR || sql_src_type == SQL_C_BINARY)) {
if (curcol->column_data && curcol->column_data_free)
curcol->column_data_free(curcol);
curcol->column_data_free = NULL;
if (is_blob_col(curcol)) {
/* trick to set blob without freeing it, _odbc_blob_free does not free TDSBLOB->textvalue */
TDSBLOB *blob = (TDSBLOB *) calloc(1, sizeof(TDSBLOB));
if (!blob) {
odbc_errs_add(&stmt->errs, "HY001", NULL);
return SQL_ERROR;
}
blob->textvalue = src;
curcol->column_data = (TDS_UCHAR*) blob;
curcol->column_data_free = _odbc_blob_free;
} else {
curcol->column_data = (TDS_UCHAR*) src;
}
curcol->column_size = len;
curcol->column_cur_size = len;
return SQL_SUCCESS;
}
}
/* allocate given space */
if (!tds_alloc_param_data(curcol)) {
odbc_errs_add(&stmt->errs, "HY001", NULL);
return SQL_ERROR;
}
/* fill data with SQLPutData */
if (need_data) {
curcol->column_cur_size = 0;
return SQL_NEED_DATA;
}
if (!src) {
odbc_errs_add(&stmt->errs, "HY090", NULL);
return SQL_ERROR;
}
/* convert special parameters (not libTDS compatible) */
switch (src_type) {
case SYBMSDATETIME2:
convert_datetime2server(drec_apd->sql_desc_concise_type, src, &dta);
src = (char *) &dta;
break;
case SYBDECIMAL:
case SYBNUMERIC:
sql_num = (SQL_NUMERIC_STRUCT *) src;
num.precision = sql_num->precision;
num.scale = sql_num->scale;
num.array[0] = sql_num->sign ^ 1;
/* test precision so client do not crash our library */
if (num.precision <= 0 || num.precision > 38 || num.scale > num.precision)
/* TODO add proper error */
return SQL_ERROR;
i = tds_numeric_bytes_per_prec[num.precision];
memcpy(num.array + 1, sql_num->val, i - 1);
tds_swap_bytes(num.array + 1, i - 1);
if (i < sizeof(num.array))
memset(num.array + i, 0, sizeof(num.array) - i);
src = (char *) #
break;
/* TODO intervals */
}
converted_src = NULL;
if (sql_src_type == SQL_C_WCHAR) {
converted_src = src = odbc_wstr2str(stmt, src, &len);
if (!src)
return SQL_ERROR;
src_type = SYBVARCHAR;
}
dest = curcol->column_data;
switch ((TDS_SERVER_TYPE) dest_type) {
case SYBCHAR:
case SYBVARCHAR:
case XSYBCHAR:
case XSYBVARCHAR:
case XSYBNVARCHAR:
case XSYBNCHAR:
case SYBNVARCHAR:
ores.cc.c = (TDS_CHAR*) dest;
ores.cc.len = curcol->column_size;
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, TDS_CONVERT_CHAR, &ores);
if (res > curcol->column_size)
res = curcol->column_size;
break;
case SYBBINARY:
case SYBVARBINARY:
case XSYBBINARY:
case XSYBVARBINARY:
ores.cb.ib = (TDS_CHAR*) dest;
ores.cb.len = curcol->column_size;
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, TDS_CONVERT_BINARY, &ores);
if (res > curcol->column_size)
res = curcol->column_size;
break;
case SYBNTEXT:
dest_type = SYBTEXT;
case SYBTEXT:
case SYBLONGBINARY:
case SYBIMAGE:
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, dest_type, &ores);
if (res >= 0) {
blob = (TDSBLOB *) dest;
free(blob->textvalue);
blob->textvalue = ores.ib;
}
break;
case SYBNUMERIC:
case SYBDECIMAL:
((TDS_NUMERIC *) dest)->precision = drec_ipd->sql_desc_precision;
((TDS_NUMERIC *) dest)->scale = drec_ipd->sql_desc_scale;
case SYBINTN:
case SYBINT1:
case SYBINT2:
case SYBINT4:
case SYBINT8:
case SYBFLT8:
case SYBDATETIME:
case SYBBIT:
case SYBMONEY4:
case SYBMONEY:
case SYBDATETIME4:
case SYBREAL:
case SYBBITN:
case SYBFLTN:
case SYBMONEYN:
case SYBDATETIMN:
case SYBSINT1:
case SYBUINT2:
case SYBUINT4:
case SYBUINT8:
case SYBUNIQUE:
case SYBMSTIME:
case SYBMSDATE:
case SYBMSDATETIME2:
case SYBMSDATETIMEOFFSET:
res = tds_convert(dbc->env->tds_ctx, src_type, src, len, dest_type, (CONV_RESULT*) dest);
break;
default:
case SYBVOID:
case SYBVARIANT:
/* TODO ODBC 3.5 */
assert(0);
res = -1;
break;
}
free(converted_src);
if (res < 0) {
odbc_convert_err_set(&stmt->errs, res);
return SQL_ERROR;
}
curcol->column_cur_size = res;
return SQL_SUCCESS;
}