自学教程：C++ DiscardStatementSvp函数代码示例

RETCODE		SQL_APISQLBindCol(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_APISQLSetPos(		  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;}

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 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, ctName, (SQLSMALLINT) nmlen1,            scName, (SQLSMALLINT) nmlen2, 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;}

RETCODE		SQL_APISQLDescribeParam(HSTMT hstmt,				 SQLUSMALLINT ipar,				 SQLSMALLINT *pfSqlType,				 SQLULEN *pcbParamDef,				 SQLSMALLINT *pibScale,				 SQLSMALLINT *pfNullable){	RETCODE	ret;	StatementClass *stmt = (StatementClass *) hstmt;	mylog("[SQLDescribeParam]");	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	ret = PGAPI_DescribeParam(hstmt, ipar, pfSqlType, pcbParamDef,							   pibScale, pfNullable);	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

/*	SQLBindParameter/SQLSetParam -> SQLBindParam */RETCODE		SQL_APISQLBindParam(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;}

RETCODE  SQL_API SQLSetCursorNameW(HSTMT StatementHandle,           SQLWCHAR *CursorName, SQLSMALLINT NameLength){    CSTR func = "SQLSetCursorNameW";    RETCODE ret;    StatementClass *stmt = (StatementClass *) StatementHandle;    char    *crName;    SQLLEN  nlen;    mylog("[%s]", func);    crName = ucs2_to_utf8(CursorName, NameLength, &nlen, FALSE);    ENTER_STMT_CS(stmt);    SC_clear_error(stmt);    StartRollbackState(stmt);    ret = PGAPI_SetCursorName(StatementHandle, crName, (SQLSMALLINT) nlen);    ret = DiscardStatementSvp(stmt, ret, FALSE);    LEAVE_STMT_CS(stmt);    if (crName)        free(crName);    return ret;}

RETCODE		SQL_APISQLDescribeCol(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_APISQLColAttributes(HSTMT hstmt,				 SQLUSMALLINT icol,				 SQLUSMALLINT fDescType,				 PTR rgbDesc,				 SQLSMALLINT cbDescMax,				 SQLSMALLINT *pcbDesc,				 SQLLEN *pfDesc){	RETCODE	ret;	StatementClass *stmt = (StatementClass *) hstmt;	mylog("[SQLColAttributes]");	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	ret = PGAPI_ColAttributes(hstmt, icol, fDescType, rgbDesc,							   cbDescMax, pcbDesc, pfDesc);	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

RETCODE		SQL_APISQLPrepare(HSTMT StatementHandle,		   SQLCHAR *StatementText, SQLINTEGER TextLength){	CSTR func = "SQLPrepare";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) StatementHandle;	mylog("[SQLPrepare]");	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else	{		StartRollbackState(stmt);		ret = PGAPI_Prepare(StatementHandle, StatementText, TextLength);		ret = DiscardStatementSvp(stmt, ret, FALSE);	}	LEAVE_STMT_CS(stmt);	return ret;}

RETCODE  SQL_API SQLPrepareW(HSTMT StatementHandle,           SQLWCHAR *StatementText, SQLINTEGER TextLength){    CSTR func = "SQLPrepareW";    StatementClass *stmt = (StatementClass *) StatementHandle;    RETCODE ret;    char    *stxt;    SQLLEN  slen;    mylog("[%s]", func);    stxt = ucs2_to_utf8(StatementText, TextLength, &slen, FALSE);    ENTER_STMT_CS(stmt);    SC_clear_error(stmt);    StartRollbackState(stmt);    if (SC_opencheck(stmt, func))        ret = SQL_ERROR;    else        ret = PGAPI_Prepare(StatementHandle, stxt, (SQLINTEGER) slen);    ret = DiscardStatementSvp(stmt, ret, FALSE);    LEAVE_STMT_CS(stmt);    if (stxt)        free(stxt);    return ret;}

RETCODE		SQL_APISQLExecute(HSTMT StatementHandle){	CSTR func = "SQLExecute";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) StatementHandle;	UWORD	flag = 0;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	if (PG_VERSION_GE(SC_get_conn(stmt), 7.4))		flag |= PODBC_WITH_HOLD;	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else	{		StartRollbackState(stmt);		ret = PGAPI_Execute(StatementHandle, flag);		ret = DiscardStatementSvp(stmt, ret, FALSE);	}	LEAVE_STMT_CS(stmt);	return ret;}

//.........这里部分代码省略.........		goto cleanup;	}	if (estmt->data_at_exec > apdopts->allocated)	{		SC_set_error(stmt, STMT_SEQUENCE_ERROR, "Too many execution-time parameters were present", func);		retval = SQL_ERROR;		goto cleanup;	}	/* close the large object */	if (estmt->lobj_fd >= 0)	{		odbc_lo_close(conn, estmt->lobj_fd);		/* commit transaction if needed */		if (!CC_cursor_count(conn) && CC_does_autocommit(conn))		{			if (!CC_commit(conn))			{				SC_set_error(stmt, STMT_EXEC_ERROR, "Could not commit (in-line) a transaction", func);				retval = SQL_ERROR;				goto cleanup;			}		}		estmt->lobj_fd = -1;	}	/* Done, now copy the params and then execute the statement */	ipdopts = SC_get_IPDF(estmt);inolog("ipdopts=%p/n", ipdopts);	if (estmt->data_at_exec == 0)	{		BOOL	exec_end;		UWORD	flag = SC_is_with_hold(stmt) ? PODBC_WITH_HOLD : 0;		retval = Exec_with_parameters_resolved(estmt, &exec_end);		if (exec_end)		{			/**SC_reset_delegate(retval, stmt);**/			retval = dequeueNeedDataCallback(retval, stmt);			goto cleanup;		}		if (retval = PGAPI_Execute(estmt, flag), SQL_NEED_DATA != retval)		{			goto cleanup;		}	}	/*	 * Set beginning param;  if first time SQLParamData is called , start	 * at 0. Otherwise, start at the last parameter + 1.	 */	i = estmt->current_exec_param >= 0 ? estmt->current_exec_param + 1 : 0;	num_p = estmt->num_params;	if (num_p < 0)		PGAPI_NumParams(estmt, &num_p);inolog("i=%d allocated=%d num_p=%d/n", i, apdopts->allocated, num_p);	if (num_p > apdopts->allocated)		num_p = apdopts->allocated;	/* At least 1 data at execution parameter, so Fill in the token value */	for (; i < num_p; i++)	{inolog("i=%d", i);		if (apdopts->parameters[i].data_at_exec)		{inolog(" at exec buffer=%p", apdopts->parameters[i].buffer);			estmt->data_at_exec--;			estmt->current_exec_param = i;			estmt->put_data = FALSE;			if (prgbValue)			{				/* returns token here */				if (stmt->execute_delegate)				{					SQLULEN	offset = apdopts->param_offset_ptr ? *apdopts->param_offset_ptr : 0;					SQLLEN	perrow = apdopts->param_bind_type > 0 ? apdopts->param_bind_type : apdopts->parameters[i].buflen; inolog(" offset=%d perrow=%d", offset, perrow);					*prgbValue = apdopts->parameters[i].buffer + offset + estmt->exec_current_row * perrow;				}				else					*prgbValue = apdopts->parameters[i].buffer;			}			break;		}inolog("/n");	}	retval = SQL_NEED_DATA;inolog("return SQL_NEED_DATA/n");cleanup:#undef	return	SC_setInsertedTable(stmt, retval);	if (stmt->internal)		retval = DiscardStatementSvp(stmt, retval, FALSE);	mylog("%s: returning %d/n", func, retval);	return retval;}

RETCODE		SQL_APISQLProcedures(			  HSTMT hstmt,			  SQLCHAR *szCatalogName,			  SQLSMALLINT cbCatalogName,			  SQLCHAR *szSchemaName,			  SQLSMALLINT cbSchemaName,			  SQLCHAR *szProcName,			  SQLSMALLINT cbProcName){	CSTR func = "SQLProcedures";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) hstmt;	SQLCHAR	*ctName = szCatalogName, *scName = szSchemaName,		*prName = szProcName;	UWORD	flag = 0;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);#if (ODBCVER >= 0x0300)	if (stmt->options.metadata_id)		flag |= PODBC_NOT_SEARCH_PATTERN;#endif	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else		ret = PGAPI_Procedures(hstmt, ctName, cbCatalogName,					 scName, cbSchemaName, prName,					 cbProcName, flag);	if (SQL_SUCCESS == ret && 0 == QR_get_num_total_tuples(SC_get_Result(stmt))) 	{		BOOL	ifallupper = TRUE, reexec = FALSE;		char *newCt = NULL, *newSc = NULL, *newPr = NULL;		ConnectionClass *conn = SC_get_conn(stmt);		if (SC_is_lower_case(stmt, conn)) /* case-insensitive identifier */			ifallupper = FALSE;		if (newCt = make_lstring_ifneeded(conn, szCatalogName, cbCatalogName, ifallupper), NULL != newCt)		{			ctName = newCt;			reexec = TRUE;		}		if (newSc = make_lstring_ifneeded(conn, szSchemaName, cbSchemaName, ifallupper), NULL != newSc)		{			scName = newSc;			reexec = TRUE;		}		if (newPr = make_lstring_ifneeded(conn, szProcName, cbProcName, ifallupper), NULL != newPr)		{			prName = newPr;			reexec = TRUE;		}		if (reexec)		{			ret = PGAPI_Procedures(hstmt, ctName, cbCatalogName,					 scName, cbSchemaName, prName, cbProcName, flag);			if (newCt)				free(newCt);			if (newSc)				free(newSc);			if (newPr)				free(newPr);		}	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

//.........这里部分代码省略.........					SQLSMALLINT FAR * pfNullable){	StatementClass *stmt = (StatementClass *) hstmt;	CSTR func = "PGAPI_DescribeParam";	IPDFields	*ipdopts;	RETCODE		ret = SQL_SUCCESS;	int		num_params;	OID		pgtype;	mylog("%s: entering...%d/n", func, ipar);	if (!stmt)	{		SC_log_error(func, "", NULL);		return SQL_INVALID_HANDLE;	}	SC_clear_error(stmt);	ipdopts = SC_get_IPDF(stmt);	/*if ((ipar < 1) || (ipar > ipdopts->allocated))*/	num_params = stmt->num_params;	if (num_params < 0)	{		SQLSMALLINT	num_p;		PGAPI_NumParams(stmt, &num_p);		num_params = num_p;	}	if ((ipar < 1) || (ipar > num_params))	{inolog("num_params=%d/n", stmt->num_params);		SC_set_error(stmt, STMT_BAD_PARAMETER_NUMBER_ERROR, "Invalid parameter number for PGAPI_DescribeParam.", func);		return SQL_ERROR;	}	extend_iparameter_bindings(ipdopts, stmt->num_params);#define	return	DONT_CALL_RETURN_FROM_HERE???	/* StartRollbackState(stmt); */	if (NOT_YET_PREPARED == stmt->prepared)	{		decideHowToPrepare(stmt, FALSE);inolog("howTo=%d/n", SC_get_prepare_method(stmt));		switch (SC_get_prepare_method(stmt))		{			case NAMED_PARSE_REQUEST:			case PARSE_TO_EXEC_ONCE:			case PARSE_REQ_FOR_INFO:				if (ret = prepareParameters(stmt), SQL_ERROR == ret)					goto cleanup;		}	}	ipar--;	pgtype = PIC_get_pgtype(ipdopts->parameters[ipar]);	/*	 * This implementation is not very good, since it is supposed to	 * describe	 */	/* parameter markers, not bound parameters.  */	if (pfSqlType)	{inolog("[%d].SQLType=%d .PGType=%d/n", ipar, ipdopts->parameters[ipar].SQLType, pgtype);		if (ipdopts->parameters[ipar].SQLType)			*pfSqlType = ipdopts->parameters[ipar].SQLType;		else if (pgtype)			*pfSqlType = pgtype_to_concise_type(stmt, pgtype, PG_STATIC);		else		{			ret = SQL_ERROR;			SC_set_error(stmt, STMT_EXEC_ERROR, "Unfortunatley couldn't get this paramater's info", func);			goto cleanup;		}	}	if (pcbParamDef)	{		*pcbParamDef = 0;		if (ipdopts->parameters[ipar].SQLType)			*pcbParamDef = ipdopts->parameters[ipar].column_size;		if (0 == *pcbParamDef && pgtype)			*pcbParamDef = pgtype_column_size(stmt, pgtype, PG_STATIC, PG_STATIC);	}	if (pibScale)	{		*pibScale = 0;		if (ipdopts->parameters[ipar].SQLType)			*pibScale = ipdopts->parameters[ipar].decimal_digits;		else if (pgtype)			*pibScale = pgtype_scale(stmt, pgtype, -1);	}	if (pfNullable)		*pfNullable = pgtype_nullable(SC_get_conn(stmt), ipdopts->parameters[ipar].paramType);cleanup:#undef	return	if (stmt->internal)		ret = DiscardStatementSvp(stmt, ret, FALSE);	return ret;}

RETCODE		SQL_APISQLForeignKeys(			   HSTMT hstmt,			   SQLCHAR *szPkCatalogName,			   SQLSMALLINT cbPkCatalogName,			   SQLCHAR *szPkSchemaName,			   SQLSMALLINT cbPkSchemaName,			   SQLCHAR *szPkTableName,			   SQLSMALLINT cbPkTableName,			   SQLCHAR *szFkCatalogName,			   SQLSMALLINT cbFkCatalogName,			   SQLCHAR *szFkSchemaName,			   SQLSMALLINT cbFkSchemaName,			   SQLCHAR *szFkTableName,			   SQLSMALLINT cbFkTableName){	CSTR func = "SQLForeignKeys";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) hstmt;	SQLCHAR *pkctName = szPkCatalogName, *pkscName = szPkSchemaName,		*pktbName = szPkTableName, *fkctName = szFkCatalogName,		*fkscName = szFkSchemaName, *fktbName = szFkTableName;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else		ret = PGAPI_ForeignKeys(hstmt, pkctName, cbPkCatalogName,			pkscName, cbPkSchemaName, pktbName, cbPkTableName,			fkctName, cbFkCatalogName, fkscName, cbFkSchemaName,			fktbName, cbFkTableName);	if (SQL_SUCCESS == ret && 0 == QR_get_num_total_tuples(SC_get_Result(stmt))) 	{		BOOL	ifallupper = TRUE, reexec = FALSE;		char *newPkct = NULL, *newPksc = NULL, *newPktb = NULL,			*newFkct = NULL, *newFksc = NULL, *newFktb = NULL;		ConnectionClass *conn = SC_get_conn(stmt);		if (SC_is_lower_case(stmt, conn)) /* case-insensitive identifier */			ifallupper = FALSE;		if (newPkct = make_lstring_ifneeded(conn, szPkCatalogName, cbPkCatalogName, ifallupper), NULL != newPkct)		{			pkctName = newPkct;			reexec = TRUE;		}		if (newPksc = make_lstring_ifneeded(conn, szPkSchemaName, cbPkSchemaName, ifallupper), NULL != newPksc)		{			pkscName = newPksc;			reexec = TRUE;		}		if (newPktb = make_lstring_ifneeded(conn, szPkTableName, cbPkTableName, ifallupper), NULL != newPktb)		{			pktbName = newPktb;			reexec = TRUE;		}		if (newFkct = make_lstring_ifneeded(conn, szFkCatalogName, cbFkCatalogName, ifallupper), NULL != newFkct)		{			fkctName = newFkct;			reexec = TRUE;		}		if (newFksc = make_lstring_ifneeded(conn, szFkSchemaName, cbFkSchemaName, ifallupper), NULL != newFksc)		{			fkscName = newFksc;			reexec = TRUE;		}		if (newFktb = make_lstring_ifneeded(conn, szFkTableName, cbFkTableName, ifallupper), NULL != newFktb)		{			fktbName = newFktb;			reexec = TRUE;		}		if (reexec)		{			ret = PGAPI_ForeignKeys(hstmt, pkctName, cbPkCatalogName,			pkscName, cbPkSchemaName, pktbName, cbPkTableName,			fkctName, cbFkCatalogName, fkscName, cbFkSchemaName,			fktbName, cbFkTableName);			if (newPkct)				free(newPkct);			if (newPksc)				free(newPksc);			if (newPktb)				free(newPktb);			if (newFkct)				free(newFkct);			if (newFksc)				free(newFksc);			if (newFktb)				free(newFktb);		}	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

RETCODE		SQL_APISQLPrimaryKeys(			   HSTMT hstmt,			   SQLCHAR *szCatalogName,			   SQLSMALLINT cbCatalogName,			   SQLCHAR *szSchemaName,			   SQLSMALLINT cbSchemaName,			   SQLCHAR *szTableName,			   SQLSMALLINT cbTableName){	CSTR func = "SQLPrimaryKeys";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) hstmt;	SQLCHAR	*ctName = szCatalogName, *scName = szSchemaName,		*tbName = szTableName;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else		ret = PGAPI_PrimaryKeys(hstmt, ctName, cbCatalogName,			scName, cbSchemaName, tbName, cbTableName, 0);	if (SQL_SUCCESS == ret && 0 == QR_get_num_total_tuples(SC_get_Result(stmt))) 	{		BOOL	ifallupper = TRUE, reexec = FALSE;		char *newCt = NULL, *newSc = NULL, *newTb = NULL;		ConnectionClass *conn = SC_get_conn(stmt);		if (SC_is_lower_case(stmt, conn)) /* case-insensitive identifier */			ifallupper = FALSE;		if (newCt = make_lstring_ifneeded(conn, szCatalogName, cbCatalogName, ifallupper), NULL != newCt)		{			ctName = newCt;			reexec = TRUE;		}		if (newSc = make_lstring_ifneeded(conn, szSchemaName, cbSchemaName, ifallupper), NULL != newSc)		{			scName = newSc;			reexec = TRUE;		}		if (newTb = make_lstring_ifneeded(conn, szTableName, cbTableName, ifallupper), NULL != newTb)		{			tbName = newTb;			reexec = TRUE;		}		if (reexec)		{			ret = PGAPI_PrimaryKeys(hstmt, ctName, cbCatalogName,			scName, cbSchemaName, tbName, cbTableName, 0);			if (newCt)				free(newCt);			if (newSc)				free(newSc);			if (newTb)				free(newTb);		}	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

/*		Perform a Prepare on the SQL statement */RETCODE		SQL_APIPGAPI_Prepare(HSTMT hstmt,			  const SQLCHAR FAR * szSqlStr,			  SQLINTEGER cbSqlStr){	CSTR func = "PGAPI_Prepare";	StatementClass *self = (StatementClass *) hstmt;	RETCODE	retval = SQL_SUCCESS;	mylog("%s: entering.../n", func);#define	return	DONT_CALL_RETURN_FROM_HERE???	/* StartRollbackState(self); */	if (!self)	{		SC_log_error(func, "", NULL);		retval = SQL_INVALID_HANDLE;		goto cleanup;	}	/*	 * According to the ODBC specs it is valid to call SQLPrepare multiple	 * times. In that case, the bound SQL statement is replaced by the new	 * one	 */	SC_set_prepared(self, NOT_YET_PREPARED);	switch (self->status)	{		case STMT_PREMATURE:			mylog("**** PGAPI_Prepare: STMT_PREMATURE, recycle/n");			SC_recycle_statement(self); /* recycle the statement, but do										 * not remove parameter bindings */			break;		case STMT_FINISHED:			mylog("**** PGAPI_Prepare: STMT_FINISHED, recycle/n");			SC_recycle_statement(self); /* recycle the statement, but do										 * not remove parameter bindings */			break;		case STMT_ALLOCATED:			mylog("**** PGAPI_Prepare: STMT_ALLOCATED, copy/n");			self->status = STMT_READY;			break;		case STMT_READY:			mylog("**** PGAPI_Prepare: STMT_READY, change SQL/n");			break;		case STMT_EXECUTING:			mylog("**** PGAPI_Prepare: STMT_EXECUTING, error!/n");			SC_set_error(self, STMT_SEQUENCE_ERROR, "PGAPI_Prepare(): The handle does not point to a statement that is ready to be executed", func);			retval = SQL_ERROR;			goto cleanup;		default:			SC_set_error(self, STMT_INTERNAL_ERROR, "An Internal Error has occured -- Unknown statement status.", func);			retval = SQL_ERROR;			goto cleanup;	}	SC_initialize_stmts(self, TRUE);	if (!szSqlStr)	{		SC_set_error(self, STMT_NO_MEMORY_ERROR, "the query is NULL", func);		retval = SQL_ERROR;		goto cleanup;	}	if (!szSqlStr[0])		self->statement = strdup("");	else		self->statement = make_string(szSqlStr, cbSqlStr, NULL, 0);	if (!self->statement)	{		SC_set_error(self, STMT_NO_MEMORY_ERROR, "No memory available to store statement", func);		retval = SQL_ERROR;		goto cleanup;	}	self->prepare = PREPARE_STATEMENT;	self->statement_type = statement_type(self->statement);	/* Check if connection is onlyread (only selects are allowed) */	if (CC_is_onlyread(SC_get_conn(self)) && STMT_UPDATE(self))	{		SC_set_error(self, STMT_EXEC_ERROR, "Connection is readonly, only select statements are allowed.", func);		retval = SQL_ERROR;		goto cleanup;	}cleanup:#undef	returninolog("SQLPrepare return=%d/n", retval);	if (self->internal)		retval = DiscardStatementSvp(self, retval, FALSE);//.........这里部分代码省略.........

//.........这里部分代码省略.........next_param_row:#if (ODBCVER >= 0x0300)	if (apdopts->param_operation_ptr)	{		while (apdopts->param_operation_ptr[stmt->exec_current_row] == SQL_PARAM_IGNORE)		{			if (stmt->exec_current_row >= end_row)			{				stmt->exec_current_row = -1;				retval = SQL_SUCCESS;				goto cleanup;			}			++stmt->exec_current_row;		}	}	/*	 *	Initialize the current row status 	 */	if (ipdopts->param_status_ptr)		ipdopts->param_status_ptr[stmt->exec_current_row] = SQL_PARAM_ERROR;#endif /* ODBCVER */	/*	 * Check if statement has any data-at-execute parameters when it is	 * not in SC_pre_execute.	 */	if (!stmt->pre_executing)	{		/*		 * The bound parameters could have possibly changed since the last		 * execute of this statement?  Therefore check for params and		 * re-copy.		 */		SQLULEN	offset = apdopts->param_offset_ptr ? *apdopts->param_offset_ptr : 0;		SQLINTEGER	bind_size = apdopts->param_bind_type;		SQLLEN		current_row = stmt->exec_current_row < 0 ? 0 : stmt->exec_current_row;		Int4	num_p = num_params < apdopts->allocated ? num_params : apdopts->allocated;		/*		 *	Increment the  number of currently processed rows 		 */		if (ipdopts->param_processed_ptr)			(*ipdopts->param_processed_ptr)++;		stmt->data_at_exec = -1;		for (i = 0; i < num_p; i++)		{			SQLLEN	   *pcVal = apdopts->parameters[i].used;			apdopts->parameters[i].data_at_exec = FALSE;			if (pcVal)			{				if (bind_size > 0)					pcVal = LENADDR_SHIFT(pcVal, offset + bind_size * current_row);				else					pcVal = LENADDR_SHIFT(pcVal, offset) + current_row;				if (*pcVal == SQL_DATA_AT_EXEC || *pcVal <= SQL_LEN_DATA_AT_EXEC_OFFSET)					apdopts->parameters[i].data_at_exec = TRUE;			}			/* Check for data at execution parameters */			if (apdopts->parameters[i].data_at_exec)			{				mylog("The %dth parameter of %d-row is data at exec(%d)/n", i, current_row, *pcVal);				if (stmt->data_at_exec < 0)					stmt->data_at_exec = 1;				else					stmt->data_at_exec++;			}		}		/*		 * If there are some data at execution parameters, return need		 * data		 */		/*		 * SQLParamData and SQLPutData will be used to send params and		 * execute the statement.		 */		if (stmt->data_at_exec > 0)		{			retval = SQL_NEED_DATA;			goto cleanup;		}	}	if (0 != (flag & PODBC_WITH_HOLD))		SC_set_with_hold(stmt);	retval = Exec_with_parameters_resolved(stmt, &exec_end);	if (!exec_end)	{		stmt->curr_param_result = 0;		goto next_param_row;	}cleanup:mylog("retval=%d/n", retval);	SC_setInsertedTable(stmt, retval);#undef	return	if (stmt->internal)		retval = DiscardStatementSvp(stmt, retval, FALSE);	return retval;}

RETCODE		SQL_APISQLSpecialColumns(HSTMT StatementHandle,				  SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,				  SQLSMALLINT NameLength1, SQLCHAR *SchemaName,				  SQLSMALLINT NameLength2, SQLCHAR *TableName,				  SQLSMALLINT NameLength3, SQLUSMALLINT Scope,				  SQLUSMALLINT Nullable){	CSTR func = "SQLSpecialColumns";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) StatementHandle;	SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else		ret = PGAPI_SpecialColumns(StatementHandle, IdentifierType, ctName,			NameLength1, scName, NameLength2, tbName, NameLength3,							Scope, Nullable);	if (SQL_SUCCESS == ret && 0 == QR_get_num_total_tuples(SC_get_Result(stmt))) 	{		BOOL	ifallupper = TRUE, reexec = FALSE;		char *newCt =NULL, *newSc = NULL, *newTb = NULL;		ConnectionClass *conn = SC_get_conn(stmt);		if (SC_is_lower_case(stmt, conn)) /* case-insensitive identifier */			ifallupper = FALSE;		if (newCt = make_lstring_ifneeded(conn, CatalogName, NameLength1, ifallupper), NULL != newCt)		{			ctName = newCt;			reexec = TRUE;		}		if (newSc = make_lstring_ifneeded(conn, SchemaName, NameLength2, ifallupper), NULL != newSc)		{			scName = newSc;			reexec = TRUE;		}		if (newTb = make_lstring_ifneeded(conn, TableName, NameLength3, ifallupper), NULL != newTb)		{			tbName = newTb;			reexec = TRUE;		}		if (reexec)		{			ret = PGAPI_SpecialColumns(StatementHandle, IdentifierType, ctName,			NameLength1, scName, NameLength2, tbName, NameLength3,							Scope, Nullable);			if (newCt)				free(newCt);			if (newSc)				free(newSc);			if (newTb)				free(newTb);		}	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

//.........这里部分代码省略.........			switch (fCType)			{				case SQL_C_BOOKMARK:#if (ODBCVER >= 0x0300)				case SQL_C_VARBOOKMARK:#endif /* ODBCVER */					break;				default:					SC_set_error(stmt, STMT_PROGRAM_TYPE_OUT_OF_RANGE, "Bind column 0 is not of type SQL_C_BOOKMARK", func);inolog("Bind column 0 is type %d not of type SQL_C_BOOKMARK", fCType);					ret = SQL_ERROR;					goto cleanup;			}			bookmark = ARD_AllocBookmark(opts);			bookmark->buffer = rgbValue;			bookmark->used =			bookmark->indicator = pcbValue;			bookmark->buflen = cbValueMax;			bookmark->returntype = fCType;		}		goto cleanup;	}	/*	 * Allocate enough bindings if not already done. Most likely,	 * execution of a statement would have setup the necessary bindings.	 * But some apps call BindCol before any statement is executed.	 */	if (icol > opts->allocated)		extend_column_bindings(opts, icol);	gdata_info = SC_get_GDTI(stmt);	if (icol > gdata_info->allocated)		extend_getdata_info(gdata_info, icol, FALSE);	/* check to see if the bindings were allocated */	if (!opts->bindings)	{		SC_set_error(stmt, STMT_NO_MEMORY_ERROR, "Could not allocate memory for bindings.", func);		ret = SQL_ERROR;		goto cleanup;	}	/* use zero based col numbers from here out */	icol--;	/* Reset for SQLGetData */	gdata_info->gdata[icol].data_left = -1;	if (rgbValue == NULL)	{		/* we have to unbind the column */		opts->bindings[icol].buflen = 0;		opts->bindings[icol].buffer = NULL;		opts->bindings[icol].used =		opts->bindings[icol].indicator = NULL;		opts->bindings[icol].returntype = SQL_C_CHAR;		opts->bindings[icol].precision = 0;		opts->bindings[icol].scale = 0;		if (gdata_info->gdata[icol].ttlbuf)			free(gdata_info->gdata[icol].ttlbuf);		gdata_info->gdata[icol].ttlbuf = NULL;		gdata_info->gdata[icol].ttlbuflen = 0;		gdata_info->gdata[icol].ttlbufused = 0;	}	else	{		/* ok, bind that column */		opts->bindings[icol].buflen = cbValueMax;		opts->bindings[icol].buffer = rgbValue;		opts->bindings[icol].used =		opts->bindings[icol].indicator = pcbValue;		opts->bindings[icol].returntype = fCType;		opts->bindings[icol].precision = 0;#if (ODBCVER >= 0x0300)		switch (fCType)		{			case SQL_C_NUMERIC:				opts->bindings[icol].precision = 32;				break;			case SQL_C_TIMESTAMP:			case SQL_C_INTERVAL_DAY_TO_SECOND:			case SQL_C_INTERVAL_HOUR_TO_SECOND:			case SQL_C_INTERVAL_MINUTE_TO_SECOND:			case SQL_C_INTERVAL_SECOND:				opts->bindings[icol].precision = 6;				break;		}#endif /* ODBCVER */		opts->bindings[icol].scale = 0;		mylog("       bound buffer[%d] = %p/n", icol, opts->bindings[icol].buffer);	}cleanup:#undef	return	if (stmt->internal)		ret = DiscardStatementSvp(stmt, ret, FALSE);	return ret;}

//.........这里部分代码省略.........	RETCODE		ret = SQL_SUCCESS;	BOOL	entered_cs = FALSE;	mylog("%s: entering.../n", func);	/* Check if this can handle canceling in the middle of a SQLPutData? */	if (!stmt)	{		SC_log_error(func, "", NULL);		return SQL_INVALID_HANDLE;	}	conn = SC_get_conn(stmt);#define	return	DONT_CALL_RETURN_FROM_HERE???	/* StartRollbackState(stmt); */	if (stmt->execute_delegate)		estmt = stmt->execute_delegate;	else		estmt = stmt;	/*	 * Not in the middle of SQLParamData/SQLPutData so cancel like a	 * close.	 */	if (estmt->data_at_exec < 0)	{		/*		 * Tell the Backend that we're cancelling this request		 */		if (estmt->status == STMT_EXECUTING)		{			if (!CC_send_cancel_request(conn))			{				ret = SQL_ERROR;			}			goto cleanup;		}		/*		 * MAJOR HACK for Windows to reset the driver manager's cursor		 * state: Because of what seems like a bug in the Odbc driver		 * manager, SQLCancel does not act like a SQLFreeStmt(CLOSE), as		 * many applications depend on this behavior.  So, this brute		 * force method calls the driver manager's function on behalf of		 * the application.		 */		if (conn->driver_version < 0x0350)		{#ifdef WIN32		ConnInfo   *ci = &(conn->connInfo);		if (ci->drivers.cancel_as_freestmt)		{	typedef SQLRETURN (SQL_API *SQLAPIPROC)();			HMODULE		hmodule;			SQLAPIPROC	addr;			hmodule = GetModuleHandle("ODBC32");			addr = (SQLAPIPROC) GetProcAddress(hmodule, "SQLFreeStmt");			ret = addr((char *) (stmt->phstmt) - 96, SQL_CLOSE);		}		else#endif /* WIN32 */		{			ENTER_STMT_CS(stmt);			entered_cs = TRUE;			SC_clear_error(hstmt);			ret = PGAPI_FreeStmt(hstmt, SQL_CLOSE);		}		mylog("PGAPI_Cancel:  PGAPI_FreeStmt returned %d/n", ret);		}		goto cleanup;	}	/* In the middle of SQLParamData/SQLPutData, so cancel that. */	/*	 * Note, any previous data-at-exec buffers will be freed in the	 * recycle	 */	/* if they call SQLExecDirect or SQLExecute again. */	ENTER_STMT_CS(stmt);	entered_cs = TRUE;	SC_clear_error(stmt);	estmt->data_at_exec = -1;	estmt->current_exec_param = -1;	estmt->put_data = FALSE;	cancelNeedDataState(estmt);cleanup:#undef	return	if (entered_cs)	{		if (stmt->internal)			ret = DiscardStatementSvp(stmt, ret, FALSE);		LEAVE_STMT_CS(stmt);	}	return ret;}

SQLRETURN SQL_API SQLColAttributeW(	SQLHSTMT	hstmt,	SQLUSMALLINT	iCol,	SQLUSMALLINT	iField,	SQLPOINTER	pCharAttr,	SQLSMALLINT	cbCharAttrMax,		SQLSMALLINT	*pcbCharAttr,#if defined(WITH_UNIXODBC) || (defined(WIN32) && ! defined(_WIN64))	SQLPOINTER	pNumAttr#else	SQLLEN		*pNumAttr#endif	){	CSTR func = "SQLColAttributeW";	RETCODE	ret;	StatementClass	*stmt = (StatementClass *) hstmt;	SQLSMALLINT	*rgbL, blen = 0, bMax;        char    *rgbD = NULL;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	switch (iField)	{ 		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:		case SQL_COLUMN_NAME:			bMax = cbCharAttrMax * 3 / WCLEN;			rgbD = malloc(bMax);			rgbL = &blen;			for (;; bMax = blen + 1, rgbD = realloc(rgbD, bMax))			{				ret = PGAPI_ColAttributes(hstmt, iCol, iField, rgbD,					bMax, rgbL, pNumAttr);				if (SQL_SUCCESS_WITH_INFO != ret || blen < bMax)					break;			}			if (SQL_SUCCEEDED(ret))			{				blen = (SQLSMALLINT) utf8_to_ucs2(rgbD, blen, (SQLWCHAR *) pCharAttr, cbCharAttrMax / WCLEN);				if (SQL_SUCCESS == ret && blen * WCLEN >= cbCharAttrMax)				{					ret = SQL_SUCCESS_WITH_INFO;					SC_set_error(stmt, STMT_TRUNCATED, "The buffer was too small for the pCharAttr.", func);				}				if (pcbCharAttr)					*pcbCharAttr = blen * WCLEN;			}			if (rgbD)				free(rgbD);			break;		default:			rgbD = pCharAttr;			bMax = cbCharAttrMax;			rgbL = pcbCharAttr;			ret = PGAPI_ColAttributes(hstmt, iCol, iField, rgbD,					bMax, rgbL, pNumAttr);			break;	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

			SQLPOINTER NumericAttribute#endif			){	CSTR	func = "SQLColAttribute";	RETCODE	ret;	StatementClass	*stmt = (StatementClass *) StatementHandle;	mylog("[[%s]]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);	ret = PGAPI_ColAttributes(StatementHandle, ColumnNumber,					   FieldIdentifier, CharacterAttribute, BufferLength,							   StringLength, NumericAttribute);	ret = DiscardStatementSvp(stmt,ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}/*	new function */RETCODE		SQL_APISQLCopyDesc(SQLHDESC SourceDescHandle,			SQLHDESC TargetDescHandle){	CSTR	func = "SQLCopyDesc";	RETCODE	ret;	mylog("[[%s]]/n", func);	ret = PGAPI_CopyDesc(SourceDescHandle, TargetDescHandle);	return ret;

RETCODE		SQL_APISQLColumnPrivileges(HSTMT hstmt,					SQLCHAR *szCatalogName,					SQLSMALLINT cbCatalogName,					SQLCHAR *szSchemaName,					SQLSMALLINT cbSchemaName,					SQLCHAR *szTableName,					SQLSMALLINT cbTableName,					SQLCHAR *szColumnName,					SQLSMALLINT cbColumnName){	CSTR func = "SQLColumnPrivileges";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) hstmt;	SQLCHAR	*ctName = szCatalogName, *scName = szSchemaName,		*tbName = szTableName, *clName = szColumnName;	UWORD	flag = 0;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);#if (ODBCVER >= 0x0300)	if (stmt->options.metadata_id)		flag |= PODBC_NOT_SEARCH_PATTERN;#endif	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else		ret = PGAPI_ColumnPrivileges(hstmt, ctName, cbCatalogName,				scName, cbSchemaName, tbName, cbTableName,						clName, cbColumnName, flag);	if (SQL_SUCCESS == ret && theResultIsEmpty(stmt))	{		BOOL	ifallupper = TRUE, reexec = FALSE;		SQLCHAR *newCt = NULL, *newSc = NULL, *newTb = NULL, *newCl = NULL;		ConnectionClass *conn = SC_get_conn(stmt);		if (SC_is_lower_case(stmt, conn)) /* case-insensitive identifier */			ifallupper = FALSE;		if (newCt = make_lstring_ifneeded(conn, szCatalogName, cbCatalogName, ifallupper), NULL != newCt)		{			ctName = newCt;			reexec = TRUE;		}		if (newSc = make_lstring_ifneeded(conn, szSchemaName, cbSchemaName, ifallupper), NULL != newSc)		{			scName = newSc;			reexec = TRUE;		}		if (newTb = make_lstring_ifneeded(conn, szTableName, cbTableName, ifallupper), NULL != newTb)		{			tbName = newTb;			reexec = TRUE;		}		if (newCl = make_lstring_ifneeded(conn, szColumnName, cbColumnName, ifallupper), NULL != newCl)		{			clName = newCl;			reexec = TRUE;		}		if (reexec)		{			ret = PGAPI_ColumnPrivileges(hstmt, ctName, cbCatalogName,				scName, cbSchemaName, tbName, cbTableName,						clName, cbColumnName, flag);			if (newCt)				free(newCt);			if (newSc)				free(newSc);			if (newTb)				free(newTb);			if (newCl)				free(newCl);		}	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

RETCODE		SQL_APISQLTables(HSTMT StatementHandle,		  SQLCHAR *CatalogName, SQLSMALLINT NameLength1,		  SQLCHAR *SchemaName, SQLSMALLINT NameLength2,		  SQLCHAR *TableName, SQLSMALLINT NameLength3,		  SQLCHAR *TableType, SQLSMALLINT NameLength4){	CSTR func = "SQLTables";	RETCODE	ret;	StatementClass *stmt = (StatementClass *) StatementHandle;	SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;	UWORD	flag = 0;	mylog("[%s]", func);	ENTER_STMT_CS(stmt);	SC_clear_error(stmt);	StartRollbackState(stmt);#if (ODBCVER >= 0x0300)	if (stmt->options.metadata_id)		flag |= PODBC_NOT_SEARCH_PATTERN;#endif	if (SC_opencheck(stmt, func))		ret = SQL_ERROR;	else		ret = PGAPI_Tables(StatementHandle, ctName, NameLength1,				scName, NameLength2, tbName, NameLength3,					TableType, NameLength4, flag);	if (SQL_SUCCESS == ret && 0 == QR_get_num_total_tuples(SC_get_Result(stmt))) 	{		BOOL	ifallupper = TRUE, reexec = FALSE;		char *newCt =NULL, *newSc = NULL, *newTb = NULL;		ConnectionClass *conn = SC_get_conn(stmt);		if (SC_is_lower_case(stmt, conn)) /* case-insensitive identifier */			ifallupper = FALSE;		if (newCt = make_lstring_ifneeded(conn, CatalogName, NameLength1, ifallupper), NULL != newCt)		{			ctName = newCt;			reexec = TRUE;		}		if (newSc = make_lstring_ifneeded(conn, SchemaName, NameLength2, ifallupper), NULL != newSc)		{			scName = newSc;			reexec = TRUE;		}		if (newTb = make_lstring_ifneeded(conn, TableName, NameLength3, ifallupper), NULL != newTb)		{			tbName = newTb;			reexec = TRUE;		}		if (reexec)		{			ret = PGAPI_Tables(StatementHandle, ctName, NameLength1,				scName, NameLength2, tbName, NameLength3,						TableType, NameLength4, flag);			if (newCt)				free(newCt);			if (newSc)				free(newSc);			if (newTb)				free(newTb);		}	}	ret = DiscardStatementSvp(stmt, ret, FALSE);	LEAVE_STMT_CS(stmt);	return ret;}

//.........这里部分代码省略.........			/* store the oid */			current_pdata->lobj_oid = odbc_lo_creat(conn, INV_READ | INV_WRITE);			if (current_pdata->lobj_oid == 0)			{				SC_set_error(stmt, STMT_EXEC_ERROR, "Couldnt create large object.", func);				retval = SQL_ERROR;				goto cleanup;			}			/*			 * major hack -- to allow convert to see somethings there have			 * to modify convert to handle this better			 */			/***current_param->EXEC_buffer = (char *) &current_param->lobj_oid;***/			/* store the fd */			estmt->lobj_fd = odbc_lo_open(conn, current_pdata->lobj_oid, INV_WRITE);			if (estmt->lobj_fd < 0)			{				SC_set_error(stmt, STMT_EXEC_ERROR, "Couldnt open large object for writing.", func);				retval = SQL_ERROR;				goto cleanup;			}			retval = odbc_lo_write(conn, estmt->lobj_fd, putbuf, (Int4) putlen);			mylog("lo_write: cbValue=%d, wrote %d bytes/n", putlen, retval);		}		else		{			current_pdata->EXEC_buffer = malloc(putlen + 1);			if (!current_pdata->EXEC_buffer)			{				SC_set_error(stmt, STMT_NO_MEMORY_ERROR, "Out of memory in PGAPI_PutData (2)", func);				retval = SQL_ERROR;				goto cleanup;			}			memcpy(current_pdata->EXEC_buffer, putbuf, putlen);			current_pdata->EXEC_buffer[putlen] = '/0';		}	}	else	{		/* calling SQLPutData more than once */		mylog("PGAPI_PutData: (>1) cbValue = %d/n", cbValue);		/* if (current_iparam->SQLType == SQL_LONGVARBINARY) */		if (handling_lo)		{			/* the large object fd is in EXEC_buffer */			retval = odbc_lo_write(conn, estmt->lobj_fd, putbuf, (Int4) putlen);			mylog("lo_write(2): cbValue = %d, wrote %d bytes/n", putlen, retval);			*current_pdata->EXEC_used += putlen;		}		else		{			buffer = current_pdata->EXEC_buffer;			old_pos = *current_pdata->EXEC_used;			if (putlen > 0)			{				SQLLEN	used = *current_pdata->EXEC_used + putlen, allocsize;				for (allocsize = (1 << 4); allocsize <= used; allocsize <<= 1) ;				mylog("        cbValue = %d, old_pos = %d, *used = %d/n", putlen, old_pos, used);				/* dont lose the old pointer in case out of memory */				buffer = realloc(current_pdata->EXEC_buffer, allocsize);				if (!buffer)				{					SC_set_error(stmt, STMT_NO_MEMORY_ERROR,"Out of memory in PGAPI_PutData (3)", func);					retval = SQL_ERROR;					goto cleanup;				}				memcpy(&buffer[old_pos], putbuf, putlen);				buffer[used] = '/0';				/* reassign buffer incase realloc moved it */				*current_pdata->EXEC_used = used;				current_pdata->EXEC_buffer = buffer;			}			else			{				SC_set_error(stmt, STMT_INTERNAL_ERROR, "bad cbValue", func);				retval = SQL_ERROR;				goto cleanup;			}		}	}	retval = SQL_SUCCESS;cleanup:#undef	return	if (allocbuf)		free(allocbuf);	if (stmt->internal)		retval = DiscardStatementSvp(stmt, retval, TRUE);	return retval;}