static SQLRETURN
SQLBindParameter_Internal (
SQLHSTMT hstmt,
SQLUSMALLINT ipar,
SQLSMALLINT fParamType,
SQLSMALLINT fCType,
SQLSMALLINT fSqlType,
SQLULEN cbColDef,
SQLSMALLINT ibScale,
SQLPOINTER rgbValue,
SQLLEN cbValueMax,
SQLLEN * pcbValue)
{
STMT (pstmt, hstmt);
CONN (pdbc, pstmt->hdbc);
ENVR (penv, pdbc->henv);
HPROC hproc2 = SQL_NULL_HPROC;
HPROC hproc3 = SQL_NULL_HPROC;
SQLSMALLINT nCType;
SQLSMALLINT nSqlType;
sqlstcode_t sqlstat = en_00000;
SQLRETURN retcode = SQL_SUCCESS;
SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver;
SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver;
PPARM newparam;
TPARM parm;
int size;
#if (ODBCVER >= 0x0300)
if (0)
#else
/* check param */
if (fSqlType > SQL_TYPE_MAX ||
(fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START))
/* Note: SQL_TYPE_DRIVER_START is a negative number
* So, we use ">" */
#endif
{
sqlstat = en_S1004;
}
else if (ipar < 1)
{
sqlstat = en_S1093;
}
else if ((rgbValue == NULL && pcbValue == NULL)
&& fParamType != SQL_PARAM_OUTPUT)
{
sqlstat = en_S1009;
/* This means, I allow output to nowhere
* (i.e. * junk output result). But I can't
* allow input from nowhere.
*/
}
/**********
else if( cbValueMax < 0L && cbValueMax != SQL_SETPARAM_VALUE_MAX )
{
sqlstat = en_S1090;
}
**********/
else if (fParamType != SQL_PARAM_INPUT
&& fParamType != SQL_PARAM_OUTPUT
&& fParamType != SQL_PARAM_INPUT_OUTPUT)
{
sqlstat = en_S1105;
}
else
{
switch (fCType)
{
case SQL_C_DEFAULT:
case SQL_C_BINARY:
case SQL_C_BIT:
case SQL_C_CHAR:
case SQL_C_DATE:
case SQL_C_DOUBLE:
case SQL_C_FLOAT:
case SQL_C_LONG:
case SQL_C_SHORT:
case SQL_C_SLONG:
case SQL_C_SSHORT:
case SQL_C_STINYINT:
case SQL_C_TIME:
case SQL_C_TIMESTAMP:
case SQL_C_TINYINT:
case SQL_C_ULONG:
case SQL_C_USHORT:
case SQL_C_UTINYINT:
#if (ODBCVER >= 0x0300)
case SQL_C_GUID:
case SQL_C_INTERVAL_DAY:
case SQL_C_INTERVAL_DAY_TO_HOUR:
case SQL_C_INTERVAL_DAY_TO_MINUTE:
case SQL_C_INTERVAL_DAY_TO_SECOND:
case SQL_C_INTERVAL_HOUR:
case SQL_C_INTERVAL_HOUR_TO_MINUTE:
case SQL_C_INTERVAL_HOUR_TO_SECOND:
case SQL_C_INTERVAL_MINUTE:
case SQL_C_INTERVAL_MINUTE_TO_SECOND:
case SQL_C_INTERVAL_MONTH:
case SQL_C_INTERVAL_SECOND:
case SQL_C_INTERVAL_YEAR:
case SQL_C_INTERVAL_YEAR_TO_MONTH:
case SQL_C_NUMERIC:
case SQL_C_SBIGINT:
case SQL_C_TYPE_DATE:
case SQL_C_TYPE_TIME:
case SQL_C_TYPE_TIMESTAMP:
case SQL_C_UBIGINT:
case SQL_C_WCHAR:
#endif
break;
default:
sqlstat = en_S1003;
break;
}
}
if (sqlstat != en_00000)
{
PUSHSQLERR (pstmt->herr, sqlstat);
return SQL_ERROR;
}
/* check state */
if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc)
{
PUSHSQLERR (pstmt->herr, en_S1010);
retcode = SQL_ERROR;
}
/*
* Convert C type to ODBC version of driver
*/
nCType = _iodbcdm_map_c_type (fCType, penv->dodbc_ver);
/*
* Convert SQL type to ODBC version of driver
*/
nSqlType = _iodbcdm_map_sql_type (fSqlType, penv->dodbc_ver);
hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_BindParameter);
#if (ODBCVER >=0x0300)
hproc3 = _iodbcdm_getproc (pstmt->hdbc, en_BindParam);
#endif
parm.pm_par = ipar;
parm.pm_c_type = nCType;
parm.pm_c_type_orig = nCType;
parm.pm_sql_type = fSqlType;
parm.pm_precision = cbColDef;
parm.pm_scale = ibScale;
parm.pm_data = rgbValue;
parm.pm_pOctetLength = pcbValue;
parm.pm_pInd = pcbValue;
parm.pm_size = size;
parm.pm_usage = fParamType;
parm.pm_cbValueMax = cbValueMax;
#if (ODBCVER >=0x0300)
if (fCType == SQL_C_WCHAR && !penv->unicode_driver
&& pcbValue && *pcbValue != SQL_DATA_AT_EXEC)
nCType = SQL_C_CHAR;
#endif
if (ipar < 1 || ipar > STMT_MAX_PARAM)
{
PUSHSQLERR (pstmt->herr, en_S1093);
return SQL_ERROR;
}
if (ipar > pstmt->st_nparam)
{
size_t newsize = ipar + 10;
if (newsize > STMT_MAX_PARAM)
newsize = STMT_MAX_PARAM;
if ((newparam = calloc (newsize, sizeof (TPARM))) == NULL)
{
PUSHSQLERR (pstmt->herr, en_S1001);
return SQL_ERROR;
}
if (pstmt->st_pparam)
{
memcpy (newparam, pstmt->st_pparam, pstmt->st_nparam * sizeof (TPARM));
free (pstmt->st_pparam);
}
pstmt->st_pparam = newparam;
pstmt->st_nparam = (u_short) newsize;
}
pstmt->st_pparam[ipar-1] = parm;
if (odbc_ver == SQL_OV_ODBC2 &&
( dodbc_ver == SQL_OV_ODBC2
|| (dodbc_ver == SQL_OV_ODBC3 && hproc2 != SQL_NULL_HPROC)))
hproc3 = SQL_NULL_HPROC;
#if (ODBCVER >=0x0300)
if (fParamType == SQL_PARAM_INPUT && hproc3 != SQL_NULL_HPROC)
{
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3,
(pstmt->dhstmt, ipar, nCType, nSqlType, cbColDef,
ibScale, rgbValue, pcbValue));
}
else
#endif
{
if (hproc2 == SQL_NULL_HPROC)
{
PUSHSQLERR (pstmt->herr, en_IM001);
return SQL_ERROR;
}
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc2,
(pstmt->dhstmt, ipar, fParamType, nCType, nSqlType, cbColDef,
ibScale, rgbValue, cbValueMax, pcbValue));
}
return retcode;
}
static SQLRETURN
SQLDescribeParam_Internal (
SQLHSTMT hstmt,
SQLUSMALLINT ipar,
SQLSMALLINT * pfSqlType,
SQLULEN * pcbColDef,
SQLSMALLINT * pibScale,
SQLSMALLINT * pfNullable)
{
STMT (pstmt, hstmt);
CONN (pdbc, pstmt->hdbc);
GENV (genv, pdbc->genv);
HPROC hproc;
SQLRETURN retcode;
/* check argument */
if (ipar == 0)
{
PUSHSQLERR (pstmt->herr, en_S1093);
return SQL_ERROR;
}
/* check state */
if (pstmt->asyn_on == en_NullProc)
{
switch (pstmt->state)
{
case en_stmt_allocated:
case en_stmt_needdata:
case en_stmt_mustput:
case en_stmt_canput:
PUSHSQLERR (pstmt->herr, en_S1010);
return SQL_ERROR;
default:
break;
}
}
else if (pstmt->asyn_on != en_DescribeParam)
{
PUSHSQLERR (pstmt->herr, en_S1010);
return SQL_ERROR;
}
/* call driver */
hproc = _iodbcdm_getproc (pstmt->hdbc, en_DescribeParam);
if (hproc == SQL_NULL_HPROC)
{
PUSHSQLERR (pstmt->herr, en_IM001);
return SQL_ERROR;
}
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc,
(pstmt->dhstmt, ipar, pfSqlType, pcbColDef, pibScale, pfNullable));
/*
* Convert sql type to ODBC version of application
*/
if (SQL_SUCCEEDED(retcode) && pfSqlType)
*pfSqlType = _iodbcdm_map_sql_type (*pfSqlType, genv->odbc_ver);
/* state transition */
if (pstmt->asyn_on == en_DescribeParam)
{
switch (retcode)
{
case SQL_SUCCESS:
case SQL_SUCCESS_WITH_INFO:
case SQL_ERROR:
break;
default:
return retcode;
}
}
if (retcode == SQL_STILL_EXECUTING)
{
pstmt->asyn_on = en_DescribeParam;
}
return retcode;
}
