static int odbc_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,
enum pdo_param_event event_type)
{
pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
RETCODE rc;
SWORD sqltype = 0, ctype = 0, scale = 0, nullable = 0;
SQLULEN precision = 0;
pdo_odbc_param *P;
zval *parameter;
/* we're only interested in parameters for prepared SQL right now */
if (param->is_param) {
switch (event_type) {
case PDO_PARAM_EVT_FETCH_PRE:
case PDO_PARAM_EVT_FETCH_POST:
case PDO_PARAM_EVT_NORMALIZE:
/* Do nothing */
break;
case PDO_PARAM_EVT_FREE:
P = param->driver_data;
if (P) {
efree(P);
}
break;
case PDO_PARAM_EVT_ALLOC:
{
/* figure out what we're doing */
switch (PDO_PARAM_TYPE(param->param_type)) {
case PDO_PARAM_LOB:
break;
case PDO_PARAM_STMT:
return 0;
default:
break;
}
rc = SQLDescribeParam(S->stmt, (SQLUSMALLINT) param->paramno+1, &sqltype, &precision, &scale, &nullable);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
/* MS Access, for instance, doesn't support SQLDescribeParam,
* so we need to guess */
sqltype = PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB ?
SQL_LONGVARBINARY :
SQL_LONGVARCHAR;
precision = 4000;
scale = 5;
nullable = 1;
if (param->max_value_len > 0) {
precision = param->max_value_len;
}
}
if (sqltype == SQL_BINARY || sqltype == SQL_VARBINARY || sqltype == SQL_LONGVARBINARY) {
ctype = SQL_C_BINARY;
} else {
ctype = SQL_C_CHAR;
}
P = emalloc(sizeof(*P));
param->driver_data = P;
P->len = 0; /* is re-populated each EXEC_PRE */
P->outbuf = NULL;
P->is_unicode = pdo_odbc_sqltype_is_unicode(S, sqltype);
if (P->is_unicode) {
/* avoid driver auto-translation: we'll do it ourselves */
ctype = SQL_C_BINARY;
}
if ((param->param_type & PDO_PARAM_INPUT_OUTPUT) == PDO_PARAM_INPUT_OUTPUT) {
P->paramtype = SQL_PARAM_INPUT_OUTPUT;
} else if (param->max_value_len <= 0) {
P->paramtype = SQL_PARAM_INPUT;
} else {
P->paramtype = SQL_PARAM_OUTPUT;
}
if (P->paramtype != SQL_PARAM_INPUT) {
if (PDO_PARAM_TYPE(param->param_type) != PDO_PARAM_NULL) {
/* need an explicit buffer to hold result */
P->len = param->max_value_len > 0 ? param->max_value_len : precision;
if (P->is_unicode) {
P->len *= 2;
}
P->outbuf = emalloc(P->len + (P->is_unicode ? 2:1));
}
}
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB && P->paramtype != SQL_PARAM_INPUT) {
pdo_odbc_stmt_error("Can't bind a lob for output");
return 0;
}
rc = SQLBindParameter(S->stmt, (SQLUSMALLINT) param->paramno+1,
P->paramtype, ctype, sqltype, precision, scale,
P->paramtype == SQL_PARAM_INPUT ?
(SQLPOINTER)param :
P->outbuf,
P->len,
&P->len
);
if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
return 1;
}
pdo_odbc_stmt_error("SQLBindParameter");
return 0;
}
case PDO_PARAM_EVT_EXEC_PRE:
P = param->driver_data;
if (!Z_ISREF(param->parameter)) {
parameter = ¶m->parameter;
} else {
parameter = Z_REFVAL(param->parameter);
}
if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
if (Z_TYPE_P(parameter) == IS_RESOURCE) {
php_stream *stm;
php_stream_statbuf sb;
php_stream_from_zval_no_verify(stm, parameter);
if (!stm) {
return 0;
}
if (0 == php_stream_stat(stm, &sb)) {
if (P->outbuf) {
int len, amount;
char *ptr = P->outbuf;
char *end = P->outbuf + P->len;
P->len = 0;
do {
amount = end - ptr;
if (amount == 0) {
break;
}
if (amount > 8192)
amount = 8192;
len = php_stream_read(stm, ptr, amount);
if (len == 0) {
break;
}
ptr += len;
P->len += len;
} while (1);
} else {
P->len = SQL_LEN_DATA_AT_EXEC(sb.sb.st_size);
}
} else {
if (P->outbuf) {
P->len = 0;
} else {
P->len = SQL_LEN_DATA_AT_EXEC(0);
}
}
} else {
convert_to_string(parameter);
if (P->outbuf) {
P->len = Z_STRLEN_P(parameter);
memcpy(P->outbuf, Z_STRVAL_P(parameter), P->len);
} else {
P->len = SQL_LEN_DATA_AT_EXEC(Z_STRLEN_P(parameter));
}
}
} else if (Z_TYPE_P(parameter) == IS_NULL || PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL) {
P->len = SQL_NULL_DATA;
} else {
convert_to_string(parameter);
if (P->outbuf) {
zend_ulong ulen;
switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode,
Z_STRVAL_P(parameter),
Z_STRLEN_P(parameter),
&ulen)) {
case PDO_ODBC_CONV_FAIL:
case PDO_ODBC_CONV_NOT_REQUIRED:
P->len = Z_STRLEN_P(parameter);
memcpy(P->outbuf, Z_STRVAL_P(parameter), P->len);
break;
case PDO_ODBC_CONV_OK:
P->len = ulen;
memcpy(P->outbuf, S->convbuf, P->len);
break;
}
} else {
P->len = SQL_LEN_DATA_AT_EXEC(Z_STRLEN_P(parameter));
}
}
return 1;
case PDO_PARAM_EVT_EXEC_POST:
P = param->driver_data;
if (P->outbuf) {
zend_ulong ulen;
char *srcbuf;
zend_ulong srclen = 0;
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = ¶m->parameter;
}
zval_ptr_dtor(parameter);
ZVAL_NULL(parameter);
switch (P->len) {
case SQL_NULL_DATA:
break;
default:
switch (pdo_odbc_ucs22utf8(stmt, P->is_unicode, P->outbuf, P->len, &ulen)) {
case PDO_ODBC_CONV_FAIL:
/* something fishy, but allow it to come back as binary */
case PDO_ODBC_CONV_NOT_REQUIRED:
srcbuf = P->outbuf;
srclen = P->len;
break;
case PDO_ODBC_CONV_OK:
srcbuf = S->convbuf;
srclen = ulen;
break;
}
ZVAL_NEW_STR(parameter, zend_string_alloc(srclen, 0));
memcpy(Z_STRVAL_P(parameter), srcbuf, srclen);
Z_STRVAL_P(parameter)[Z_STRLEN_P(parameter)] = '\0';
}
}
return 1;
}
}
return 1;
}
static int odbc_stmt_describe(pdo_stmt_t *stmt, int colno)
{
pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
struct pdo_column_data *col = &stmt->columns[colno];
RETCODE rc;
SWORD colnamelen;
SQLULEN colsize;
SQLLEN displaysize;
rc = SQLDescribeCol(S->stmt, colno+1, S->cols[colno].colname,
sizeof(S->cols[colno].colname)-1, &colnamelen,
&S->cols[colno].coltype, &colsize, NULL, NULL);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLDescribeCol");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
rc = SQLColAttribute(S->stmt, colno+1,
SQL_DESC_DISPLAY_SIZE,
NULL, 0, NULL, &displaysize);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLColAttribute");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
colsize = displaysize;
col->maxlen = S->cols[colno].datalen = colsize;
col->namelen = colnamelen;
col->name = estrdup(S->cols[colno].colname);
S->cols[colno].is_unicode = pdo_odbc_sqltype_is_unicode(S, S->cols[colno].coltype);
/* returning data as a string */
col->param_type = PDO_PARAM_STR;
/* tell ODBC to put it straight into our buffer, but only if it
* isn't "long" data, and only if we haven't already bound a long
* column. */
if (colsize < 256 && !S->going_long) {
S->cols[colno].data = emalloc(colsize+1);
S->cols[colno].is_long = 0;
rc = SQLBindCol(S->stmt, colno+1,
S->cols[colno].is_unicode ? SQL_C_BINARY : SQL_C_CHAR,
S->cols[colno].data,
S->cols[colno].datalen+1, &S->cols[colno].fetched_len);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLBindCol");
return 0;
}
} else {
/* allocate a smaller buffer to keep around for smaller
* "long" columns */
S->cols[colno].data = emalloc(256);
S->going_long = 1;
S->cols[colno].is_long = 1;
}
return 1;
}
static int odbc_stmt_describe(pdo_stmt_t *stmt, int colno)
{
pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data;
struct pdo_column_data *col = &stmt->columns[colno];
RETCODE rc;
SWORD colnamelen;
SQLULEN colsize;
SQLLEN displaysize;
rc = SQLDescribeCol(S->stmt, colno+1, S->cols[colno].colname,
sizeof(S->cols[colno].colname)-1, &colnamelen,
&S->cols[colno].coltype, &colsize, NULL, NULL);
/* This fixes a known issue with SQL Server and (max) lengths,
may affect others as well. If we are SQL_VARCHAR,
SQL_VARBINARY, or SQL_WVARCHAR (or any of the long variations)
and zero is returned from colsize then consider it long */
if (0 == colsize &&
(S->cols[colno].coltype == SQL_VARCHAR ||
S->cols[colno].coltype == SQL_LONGVARCHAR ||
#ifdef SQL_WVARCHAR
S->cols[colno].coltype == SQL_WVARCHAR ||
#endif
#ifdef SQL_WLONGVARCHAR
S->cols[colno].coltype == SQL_WLONGVARCHAR ||
#endif
S->cols[colno].coltype == SQL_VARBINARY ||
S->cols[colno].coltype == SQL_LONGVARBINARY)) {
S->going_long = 1;
}
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLDescribeCol");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
rc = SQLColAttribute(S->stmt, colno+1,
SQL_DESC_DISPLAY_SIZE,
NULL, 0, NULL, &displaysize);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLColAttribute");
if (rc != SQL_SUCCESS_WITH_INFO) {
return 0;
}
}
colsize = displaysize;
col->maxlen = S->cols[colno].datalen = colsize;
col->name = zend_string_init(S->cols[colno].colname, colnamelen, 0);
S->cols[colno].is_unicode = pdo_odbc_sqltype_is_unicode(S, S->cols[colno].coltype);
/* returning data as a string */
col->param_type = PDO_PARAM_STR;
/* tell ODBC to put it straight into our buffer, but only if it
* isn't "long" data, and only if we haven't already bound a long
* column. */
if (colsize < 256 && !S->going_long) {
S->cols[colno].data = emalloc(colsize+1);
S->cols[colno].is_long = 0;
rc = SQLBindCol(S->stmt, colno+1,
S->cols[colno].is_unicode ? SQL_C_BINARY : SQL_C_CHAR,
S->cols[colno].data,
S->cols[colno].datalen+1, &S->cols[colno].fetched_len);
if (rc != SQL_SUCCESS) {
pdo_odbc_stmt_error("SQLBindCol");
return 0;
}
} else {
/* allocate a smaller buffer to keep around for smaller
* "long" columns */
S->cols[colno].data = emalloc(256);
S->going_long = 1;
S->cols[colno].is_long = 1;
}
return 1;
}
