/* new function */ RETCODE SQL_API SQLSetDescFieldW(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, PTR Value, SQLINTEGER BufferLength) { CSTR func = "SQLSetDescFieldW"; RETCODE ret; SQLLEN vallen; char *uval = NULL; BOOL val_alloced = FALSE; mylog("[%s]", func); if (BufferLength > 0 || SQL_NTS == BufferLength) { switch (FieldIdentifier) { case SQL_DESC_BASE_COLUMN_NAME: case SQL_DESC_BASE_TABLE_NAME: case SQL_DESC_CATALOG_NAME: case SQL_DESC_LABEL: case SQL_DESC_LITERAL_PREFIX: case SQL_DESC_LITERAL_SUFFIX: case SQL_DESC_LOCAL_TYPE_NAME: case SQL_DESC_NAME: case SQL_DESC_SCHEMA_NAME: case SQL_DESC_TABLE_NAME: case SQL_DESC_TYPE_NAME: uval = ucs2_to_utf8(Value, BufferLength > 0 ? BufferLength / WCLEN : BufferLength, &vallen, FALSE); val_alloced = TRUE; break; } } if (!val_alloced) { uval = Value; vallen = BufferLength; } ret = PGAPI_SetDescField(DescriptorHandle, RecNumber, FieldIdentifier, uval, (SQLINTEGER) vallen); if (val_alloced) free(uval); return ret; }
RETCODE SQL_API SQLSetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER fAttribute, PTR rgbValue, SQLINTEGER cbValueMax) { CSTR func = "SQLSetStmtAttrW"; RETCODE ret; StatementClass *stmt = (StatementClass *) hstmt; mylog("[%s]", func); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); ret = PGAPI_SetStmtAttr(hstmt, fAttribute, rgbValue, cbValueMax); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); return ret; }
RETCODE SQL_API SQLBindCol(HSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType, PTR TargetValue, SQLLEN BufferLength, SQLLEN *StrLen_or_Ind) { RETCODE ret; StatementClass *stmt = (StatementClass *) StatementHandle; mylog("[SQLBindCol]"); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); ret = PGAPI_BindCol(StatementHandle, ColumnNumber, TargetType, TargetValue, BufferLength, StrLen_or_Ind); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); return ret; }
RETCODE SQL_API SQLError(HENV EnvironmentHandle, HDBC ConnectionHandle, HSTMT StatementHandle, SQLCHAR *Sqlstate, SQLINTEGER *NativeError, SQLCHAR *MessageText, SQLSMALLINT BufferLength, SQLSMALLINT *TextLength) { RETCODE ret; mylog("[SQLError]"); if (NULL != EnvironmentHandle) ENTER_ENV_CS((EnvironmentClass *) EnvironmentHandle); ret = PGAPI_Error(EnvironmentHandle, ConnectionHandle, StatementHandle, Sqlstate, NativeError, MessageText, BufferLength, TextLength); if (NULL != EnvironmentHandle) LEAVE_ENV_CS((EnvironmentClass *) EnvironmentHandle); return ret; }
RETCODE SQL_API SQLSetPos( HSTMT hstmt, SQLSETPOSIROW irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock) { RETCODE ret; StatementClass *stmt = (StatementClass *) hstmt; mylog("[SQLSetPos]"); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); ret = PGAPI_SetPos(hstmt, irow, fOption, fLock); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); return ret; }
/* Sets multiple values (arrays) for the set of parameter markers. */ RETCODE SQL_API PGAPI_ParamOptions( HSTMT hstmt, SQLULEN crow, SQLULEN FAR * pirow) { CSTR func = "PGAPI_ParamOptions"; StatementClass *stmt = (StatementClass *) hstmt; APDFields *apdopts; IPDFields *ipdopts; mylog("%s: entering... %d %p\n", func, crow, pirow); apdopts = SC_get_APDF(stmt); apdopts->paramset_size = crow; ipdopts = SC_get_IPDF(stmt); ipdopts->param_processed_ptr = pirow; return SQL_SUCCESS; }
int append_to_image_cache_by_path_and_name(char *path, char *name){ if(last_cache_index>=LAST_CACHE_POS) return 0; weather_images_cache[last_cache_index].name=malloc(strlen(name)+1); strcpy(weather_images_cache[last_cache_index].name,name); weather_images_cache[last_cache_index].image= gdk_pixbuf_new_from_file(path, NULL); mylog("Loaded: %s, %p, index=%d\n",path, weather_images_cache[last_cache_index].image,last_cache_index); if(weather_images_cache[last_cache_index].image==NULL){ free(weather_images_cache[last_cache_index].name); return 0; } ++last_cache_index; return last_cache_index-1; }
static SQLSMALLINT getIntervalColumnSize(OID type, int atttypmod) { Int4 ttl, leading_precision = 9, scale; mylog("%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod); ttl = leading_precision; switch (get_interval_type(atttypmod, NULL)) { case 0: ttl = 25; break; case SQL_INTERVAL_YEAR: ttl = 16; break; case SQL_INTERVAL_MONTH: ttl = 16; break; case SQL_INTERVAL_DAY: ttl = 16; break; case SQL_INTERVAL_DAY_TO_SECOND: case SQL_INTERVAL_DAY_TO_MINUTE: case SQL_INTERVAL_DAY_TO_HOUR: ttl = 25; break; case SQL_INTERVAL_HOUR_TO_SECOND: case SQL_INTERVAL_HOUR_TO_MINUTE: case SQL_INTERVAL_HOUR: ttl = 17; break; case SQL_INTERVAL_MINUTE_TO_SECOND: case SQL_INTERVAL_MINUTE: ttl = 15; break; case SQL_INTERVAL_YEAR_TO_MONTH: ttl = 24; break; } scale = getIntervalDecimalDigits(type, atttypmod); return (scale > 0) ? ttl + 1 + scale : ttl; }
/* freed content of a cache */ void cache_free(Cache *cache) { int i; mylog("cache_free(%p)\n", cache); /* cache itself */ if (cache->name != NULL) free(cache->name); if (cache->firstblock != NULL) free(cache->firstblock); /* chunks */ for(i=0; i<CACHE_MAX_CHUNK; i++) { cache_chunk_free(cache->chunks[i]); cache->chunks[i] = NULL; } /* connection */ cache_disconnect(&(cache->connection)); if (cache->connection.target != NULL) free(cache->connection.target); cache_zero(cache); }
RETCODE SQL_API SQLPrimaryKeysW(HSTMT hstmt, SQLWCHAR *szCatalogName, SQLSMALLINT cbCatalogName, SQLWCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR *szTableName, SQLSMALLINT cbTableName) { CSTR func = "SQLPrimaryKeysW"; RETCODE ret; char *ctName, *scName, *tbName; SQLLEN nmlen1, nmlen2, nmlen3; StatementClass *stmt = (StatementClass *) hstmt; ConnectionClass *conn; BOOL lower_id; mylog("[%s]", func); conn = SC_get_conn(stmt); lower_id = SC_is_lower_case(stmt, conn); ctName = ucs2_to_utf8(szCatalogName, cbCatalogName, &nmlen1, lower_id); scName = ucs2_to_utf8(szSchemaName, cbSchemaName, &nmlen2, lower_id); tbName = ucs2_to_utf8(szTableName, cbTableName, &nmlen3, lower_id); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); if (SC_opencheck(stmt, func)) ret = SQL_ERROR; else ret = PGAPI_PrimaryKeys(hstmt, (SQLCHAR *) ctName, (SQLSMALLINT) nmlen1, (SQLCHAR *) scName, (SQLSMALLINT) nmlen2, (SQLCHAR *) tbName, (SQLSMALLINT) nmlen3, 0); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); if (ctName) free(ctName); if (scName) free(scName); if (tbName) free(tbName); return ret; }
static Int4 /* PostgreSQL restritiction */ getNumericColumnSize(StatementClass *stmt, OID type, int col) { Int4 atttypmod = -1, default_column_size = 28; QResultClass *result; ColumnInfoClass *flds; mylog("getNumericColumnSize: type=%d, col=%d\n", type, col); if (col < 0) return default_column_size; result = SC_get_Curres(stmt); /* * Manual Result Sets -- use assigned column width (i.e., from * set_tuplefield_string) */ atttypmod = QR_get_atttypmod(result, col); if (atttypmod > -1) return (atttypmod >> 16) & 0xffff; if (stmt->catalog_result) { flds = result->fields; if (flds) { int fsize = CI_get_fieldsize(flds, col); if (fsize > 0) return 2 * fsize; } return default_column_size; } else { Int4 dsp_size = QR_get_display_size(result, col); if (dsp_size <= 0) return default_column_size; dsp_size *= 2; if (dsp_size < 10) dsp_size = 10; return dsp_size; } }
PyObject* f_Color(PyObject* self, PyObject* args, PyObject* kwargs) { static char *kwlist[] = {"r", "g", "b", "a", NULL}; ColorObject* color; int r=0,g=0,b=0,a=255; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "iii|i", kwlist, &r,&g,&b,&a)) { char*s= 0; int mya = -1; PyErr_Clear(); static char *kwlist[] = {"col", "alpha", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i", kwlist, &s, &mya)) return NULL; if(mya>=0) a=mya; sscanf(s, "%02x%02x%02x%02x",&r,&g,&b,&a); } color = PyObject_New(ColorObject, &ColorClass); mylog("+%08x(%d) color_new(%d,%d,%d,%d)\n", (int)color, color->ob_refcnt, r,g,b,a); return f_Color2(r,g,b,a); }
xfont_t * sys_xftcreate(){ JNIEnv * g_env; (*jvm)->AttachCurrentThread(jvm, &g_env, 0); xfont_t * font = (xfont_t *)malloc(sizeof(xfont_t)); if(!font){ return 0; } jclass cls =(*g_env)->FindClass(g_env, "xc/api/Xfont"); jmethodID mid = (*g_env)->GetMethodID(g_env, cls, "<init>", "()V"); jobject obj = (*g_env)->NewObject(g_env, cls, mid); font->fontObject = (*g_env)->NewGlobalRef(g_env, obj); mid = (*g_env)->GetMethodID(g_env, cls, "sys_ftcreate", "()V"); (*g_env)->CallVoidMethod(g_env, font->fontObject, mid); (*g_env)->DeleteLocalRef(g_env, obj); (*g_env)->DeleteLocalRef(g_env, cls); mylog("create 15"); return font; }
RETCODE SQL_API SQLSpecialColumnsW(HSTMT StatementHandle, SQLUSMALLINT IdentifierType, SQLWCHAR *CatalogName, SQLSMALLINT NameLength1, SQLWCHAR *SchemaName, SQLSMALLINT NameLength2, SQLWCHAR *TableName, SQLSMALLINT NameLength3, SQLUSMALLINT Scope, SQLUSMALLINT Nullable) { CSTR func = "SQLSpecialColumnsW"; RETCODE ret; char *ctName, *scName, *tbName; SQLLEN nmlen1, nmlen2, nmlen3; StatementClass *stmt = (StatementClass *) StatementHandle; ConnectionClass *conn; BOOL lower_id; mylog("[%s]", func); conn = SC_get_conn(stmt); lower_id = SC_is_lower_case(stmt, conn); ctName = ucs2_to_utf8(CatalogName, NameLength1, &nmlen1, lower_id); scName = ucs2_to_utf8(SchemaName, NameLength2, &nmlen2, lower_id); tbName = ucs2_to_utf8(TableName, NameLength3, &nmlen3, lower_id); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); if (SC_opencheck(stmt, func)) ret = SQL_ERROR; else ret = PGAPI_SpecialColumns(StatementHandle, IdentifierType, (SQLCHAR *) ctName, (SQLSMALLINT) nmlen1, (SQLCHAR *) scName, (SQLSMALLINT) nmlen2, (SQLCHAR *) tbName, (SQLSMALLINT) nmlen3, Scope, Nullable); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); if (ctName) free(ctName); if (scName) free(scName); if (tbName) free(tbName); return ret; }
static SQLSMALLINT getNumericDecimalDigits(StatementClass *stmt, OID type, int col) { Int4 atttypmod = -1, default_decimal_digits = 6; QResultClass *result; ColumnInfoClass *flds; mylog("getNumericDecimalDigits: type=%d, col=%d\n", type, col); if (col < 0) return default_decimal_digits; result = SC_get_Curres(stmt); /* * Manual Result Sets -- use assigned column width (i.e., from * set_tuplefield_string) */ atttypmod = QR_get_atttypmod(result, col); if (atttypmod > -1) return (atttypmod & 0xffff); if (stmt->catalog_result) { flds = result->fields; if (flds) { int fsize = CI_get_fieldsize(flds, col); if (fsize > 0) return fsize; } return default_decimal_digits; } else { Int4 dsp_size = QR_get_display_size(result, col); if (dsp_size <= 0) return default_decimal_digits; if (dsp_size < 5) dsp_size = 5; return dsp_size; } }
RETCODE SQL_API SQLDescribeParam( HSTMT hstmt, UWORD ipar, SWORD FAR *pfSqlType, SQLULEN *pcbColDef, SWORD FAR *pibScale, SWORD FAR *pfNullable) { StatementClass *stmt = (StatementClass *) hstmt; static char* const func = "SQLDescribeParam"; mylog( "%s: entering...\n", func); if( ! stmt) { SC_log_error(func, "", NULL); return SQL_INVALID_HANDLE; } if( (ipar < 1) || (ipar > stmt->parameters_allocated) ) { SC_set_error(stmt, STMT_BAD_PARAMETER_NUMBER_ERROR, "Invalid parameter number for SQLDescribeParam."); SC_log_error(func, "", stmt); return SQL_ERROR; } ipar--; /* This implementation is not very good, since it is supposed to describe */ /* parameter markers, not bound parameters. */ if(pfSqlType) *pfSqlType = stmt->parameters[ipar].SQLType; if(pcbColDef) *pcbColDef = stmt->parameters[ipar].precision; if(pibScale) *pibScale = stmt->parameters[ipar].scale; if(pfNullable) *pfNullable = pgtype_nullable(stmt, stmt->parameters[ipar].paramType); return SQL_SUCCESS; }
RETCODE SQL_API SQLGetTypeInfoW(SQLHSTMT StatementHandle, SQLSMALLINT DataType) { CSTR func = "SQLGetTypeInfoW"; RETCODE ret; StatementClass * stmt = (StatementClass *) StatementHandle; mylog("[%s]", func); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); if (SC_opencheck(stmt, func)) ret = SQL_ERROR; else ret = PGAPI_GetTypeInfo(StatementHandle, DataType); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); return ret; }
RETCODE SQL_API SQLGetInfoW(HDBC ConnectionHandle, SQLUSMALLINT InfoType, PTR InfoValue, SQLSMALLINT BufferLength, SQLSMALLINT *StringLength) { CSTR func = "SQLGetInfoW"; ConnectionClass *conn = (ConnectionClass *) ConnectionHandle; RETCODE ret; CC_examine_global_transaction(conn); ENTER_CONN_CS(conn); CC_set_in_unicode_driver(conn); CC_clear_error(conn); mylog("[%s]", func); if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength)) == SQL_ERROR) CC_log_error("SQLGetInfoW", "", conn); LEAVE_CONN_CS(conn); return ret; }
void reset_a_iparameter_binding(IPDFields *self, int ipar) { CSTR func = "reset_a_iparameter_binding"; mylog("%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar); if (ipar < 1 || ipar > self->allocated) return; ipar--; NULL_THE_NAME(self->parameters[ipar].paramName); self->parameters[ipar].paramType = 0; self->parameters[ipar].SQLType = 0; self->parameters[ipar].column_size = 0; self->parameters[ipar].decimal_digits = 0; self->parameters[ipar].precision = 0; self->parameters[ipar].scale = 0; PIC_set_pgtype(self->parameters[ipar], 0); }
void reset_a_parameter_binding(APDFields *self, int ipar) { CSTR func = "reset_a_parameter_binding"; mylog("%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar); if (ipar < 1 || ipar > self->allocated) return; ipar--; self->parameters[ipar].buflen = 0; self->parameters[ipar].buffer = NULL; self->parameters[ipar].used = self->parameters[ipar].indicator = NULL; self->parameters[ipar].CType = 0; self->parameters[ipar].data_at_exec = FALSE; self->parameters[ipar].precision = 0; self->parameters[ipar].scale = 0; }
static int color_setattr(PyObject * self, char* attr, PyObject* o) { ColorObject*color = (ColorObject*)self; if(!strcmp(attr, "r")) { if (!PyArg_Parse(o, "d", &color->rgba.r)) goto err; return 0; } else if(!strcmp(attr, "g")) { if (!PyArg_Parse(o, "d", &color->rgba.g)) goto err; return 0; } else if(!strcmp(attr, "b")) { if (!PyArg_Parse(o, "d", &color->rgba.b)) goto err; return 0; } else if(!strcmp(attr, "a")) { if (!PyArg_Parse(o, "d", &color->rgba.a)) goto err; return 0; } err: mylog("swf_setattr %08x(%d) %s = ? (%08x)\n", (int)self, self->ob_refcnt, attr, o); return 1; }
RETCODE SQL_API SQLSetConnectAttrW(HDBC hdbc, SQLINTEGER fAttribute, PTR rgbValue, SQLINTEGER cbValue) { CSTR func = "SQLSetConnectAttrW"; RETCODE ret; ConnectionClass *conn = (ConnectionClass *) hdbc; mylog("[%s]", func); CC_examine_global_transaction(conn); ENTER_CONN_CS(conn); CC_clear_error(conn); CC_set_in_unicode_driver(conn); ret = PGAPI_SetConnectAttr(hdbc, fAttribute, rgbValue, cbValue); LEAVE_CONN_CS(conn); return ret; }
/* Returns the next SQL error information. */ RETCODE SQL_API PGAPI_DescError( SQLHDESC hdesc, SQLSMALLINT RecNumber, SQLCHAR FAR * szSqlState, SQLINTEGER FAR * pfNativeError, SQLCHAR FAR * szErrorMsg, SQLSMALLINT cbErrorMsgMax, SQLSMALLINT FAR * pcbErrorMsg, UWORD flag) { CSTR func = "PGAPI_DescError"; /* CC: return an error of a hdesc */ DescriptorClass *desc = (DescriptorClass *) hdesc; mylog("%s RecN=%d\n", func); desc->pgerror = DC_create_errorinfo(desc); return ER_ReturnError(&(desc->pgerror), RecNumber, szSqlState, pfNativeError, szErrorMsg, cbErrorMsgMax, pcbErrorMsg, flag); }
RETCODE SQL_API SQLBrowseConnect( HDBC hdbc, SQLCHAR *szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR *szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT *pcbConnStrOut) { RETCODE ret; ConnectionClass *conn = (ConnectionClass *) hdbc; mylog("[SQLBrowseConnect]"); ENTER_CONN_CS(conn); CC_clear_error(conn); ret = PGAPI_BrowseConnect(hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut); LEAVE_CONN_CS(conn); return ret; }
/* initialise cache without freeing */ void cache_zero(Cache *cache) { int i; mylog("cache_zero(%p)\n", cache); /* cleanup connection */ cache->connection.target = NULL; cache->connection.type = 0; cache->connection.data = NULL; cache->connection.idata = 0; /* cleanup chunks */ for(i=0; i<CACHE_MAX_CHUNK; i++) { cache->chunks[i] = NULL; } /* cleanup cache itself */ cache->name = NULL; cache->size = 0; cache->created = 0; cache->last_use = 0; cache->firstblock = NULL; }
RETCODE SQL_API SQLNativeSql( HDBC hdbc, SQLCHAR *szSqlStrIn, SQLINTEGER cbSqlStrIn, SQLCHAR *szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER *pcbSqlStr) { RETCODE ret; ConnectionClass *conn = (ConnectionClass *) hdbc; mylog("[SQLNativeSql]"); ENTER_CONN_CS(conn); CC_clear_error(conn); ret = PGAPI_NativeSql(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr); LEAVE_CONN_CS(conn); return ret; }
RETCODE SQL_API SQLGetFunctions(HDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported) { RETCODE ret; ConnectionClass *conn = (ConnectionClass *) ConnectionHandle; mylog("[SQLGetFunctions]"); ENTER_CONN_CS(conn); CC_clear_error(conn); #if (ODBCVER >= 0x0300) if (FunctionId == SQL_API_ODBC3_ALL_FUNCTIONS) ret = PGAPI_GetFunctions30(ConnectionHandle, FunctionId, Supported); else #endif { ret = PGAPI_GetFunctions(ConnectionHandle, FunctionId, Supported); } LEAVE_CONN_CS(conn); return ret; }
RETCODE SQL_API SQLDescribeCol(HSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName, SQLSMALLINT BufferLength, SQLSMALLINT *NameLength, SQLSMALLINT *DataType, SQLULEN *ColumnSize, SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable) { RETCODE ret; StatementClass *stmt = (StatementClass *) StatementHandle; mylog("[SQLDescribeCol]"); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); ret = PGAPI_DescribeCol(StatementHandle, ColumnNumber, ColumnName, BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable); ret = DiscardStatementSvp(stmt, ret, FALSE); LEAVE_STMT_CS(stmt); return ret; }
RETCODE SQL_API SQLDriverConnect(HDBC hdbc, HWND hwnd, SQLCHAR FAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR FAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR * pcbConnStrOut, SQLUSMALLINT fDriverCompletion) { RETCODE ret; ConnectionClass *conn = (ConnectionClass *) hdbc; mylog("[SQLDriverConnect]"); ENTER_CONN_CS(conn); CC_clear_error(conn); ret = PGAPI_DriverConnect(hdbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion); LEAVE_CONN_CS(conn); return ret; }
/* SQLBindParameter/SQLSetParam -> SQLBindParam */ RETCODE SQL_API SQLBindParam(HSTMT StatementHandle, SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType, SQLSMALLINT ParameterType, SQLULEN LengthPrecision, SQLSMALLINT ParameterScale, PTR ParameterValue, SQLLEN *StrLen_or_Ind) { CSTR func = "SQLBindParam"; RETCODE ret; StatementClass *stmt = (StatementClass *) StatementHandle; int BufferLength = 512; /* Is it OK ? */ mylog("[[%s]]", func); ENTER_STMT_CS(stmt); SC_clear_error(stmt); StartRollbackState(stmt); ret = PGAPI_BindParameter(StatementHandle, ParameterNumber, SQL_PARAM_INPUT, ValueType, ParameterType, LengthPrecision, ParameterScale, ParameterValue, BufferLength, StrLen_or_Ind); ret = DiscardStatementSvp(stmt,ret, FALSE); LEAVE_STMT_CS(stmt); return ret; }