results.c

关系型数据库 Postgresql 6.5.2

		if ( (NULL == stmt->result) || ((stmt->status != STMT_FINISHED) && (stmt->status != STMT_PREMATURE)) ) {
			stmt->errormsg = "Can't get column attributes: no result found.";
			stmt->errornumber = STMT_SEQUENCE_ERROR;
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}

		cols = QR_NumResultCols(stmt->result);

		/*	Column Count is a special case.  The Column number is ignored
			in this case.
		*/
		if (fDescType == SQL_COLUMN_COUNT) {
			if (pfDesc)
				*pfDesc = cols;

			return SQL_SUCCESS;
		}

		if (icol >= cols) {
			stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
			stmt->errormsg = "Invalid column number in DescribeCol.";
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}

		field_type = QR_get_field_type(stmt->result, icol);
	}

	mylog("colAttr: col %d field_type = %d\n", icol, field_type);

	switch(fDescType) {
	case SQL_COLUMN_AUTO_INCREMENT:
		value  = pgtype_auto_increment(stmt, field_type);
		if (value == -1)  /*  non-numeric becomes FALSE (ODBC Doc) */
			value = FALSE;
				
		break;

	case SQL_COLUMN_CASE_SENSITIVE:
		value = pgtype_case_sensitive(stmt, field_type);
		break;

	/* 	This special case is handled above.

	case SQL_COLUMN_COUNT: 
	*/

    case SQL_COLUMN_DISPLAY_SIZE:
		value = (parse_ok) ? stmt->fi[icol]->display_size : pgtype_display_size(stmt, field_type, icol, unknown_sizes);

		mylog("SQLColAttributes: col %d, display_size= %d\n", icol, value);

        break;

	case SQL_COLUMN_LABEL:
		if (parse_ok && stmt->fi[icol]->alias[0] != '\0') {
			p = stmt->fi[icol]->alias;

			mylog("SQLColAttr: COLUMN_LABEL = '%s'\n", p);
			break;

		}	// otherwise same as column name -- FALL THROUGH!!!

	case SQL_COLUMN_NAME:

		p = (parse_ok) ? stmt->fi[icol]->name : QR_get_fieldname(stmt->result, icol);

		mylog("SQLColAttr: COLUMN_NAME = '%s'\n", p);
		break;

	case SQL_COLUMN_LENGTH:
		value = (parse_ok) ? stmt->fi[icol]->length :  pgtype_length(stmt, field_type, icol, unknown_sizes); 

		mylog("SQLColAttributes: col %d, length = %d\n", icol, value);
        break;

	case SQL_COLUMN_MONEY:
		value = pgtype_money(stmt, field_type);
		break;

	case SQL_COLUMN_NULLABLE:
		value = (parse_ok) ? stmt->fi[icol]->nullable : pgtype_nullable(stmt, field_type);
		break;

	case SQL_COLUMN_OWNER_NAME:
		p = "";
		break;

	case SQL_COLUMN_PRECISION:
		value = (parse_ok) ? stmt->fi[icol]->precision : pgtype_precision(stmt, field_type, icol, unknown_sizes);

		mylog("SQLColAttributes: col %d, precision = %d\n", icol, value);
        break;

	case SQL_COLUMN_QUALIFIER_NAME:
		p = "";
		break;

	case SQL_COLUMN_SCALE:
		value = pgtype_scale(stmt, field_type);
		break;

	case SQL_COLUMN_SEARCHABLE:
		value = pgtype_searchable(stmt, field_type);
		break;

    case SQL_COLUMN_TABLE_NAME:

		p = (parse_ok && stmt->fi[icol]->ti) ? stmt->fi[icol]->ti->name : "";

		mylog("SQLColAttr: TABLE_NAME = '%s'\n", p);
        break;

	case SQL_COLUMN_TYPE:
		value = pgtype_to_sqltype(stmt, field_type);
		break;

	case SQL_COLUMN_TYPE_NAME:
		p = pgtype_to_name(stmt, field_type);
		break;

	case SQL_COLUMN_UNSIGNED:
		value = pgtype_unsigned(stmt, field_type);
		if(value == -1)	/* non-numeric becomes TRUE (ODBC Doc) */
			value = TRUE;

		break;

	case SQL_COLUMN_UPDATABLE:
		/*	Neither Access or Borland care about this.

		if (field_type == PG_TYPE_OID)
			*pfDesc = SQL_ATTR_READONLY;
		else
		*/

		value = SQL_ATTR_WRITE;

		mylog("SQLColAttr: UPDATEABLE = %d\n", value);
		break;
    }

	result = SQL_SUCCESS;

	if (p) {  /* char/binary data */
		len = strlen(p);

		if (rgbDesc) {
			strncpy_null((char *)rgbDesc, p, (size_t)cbDescMax);

			if (len >= cbDescMax)  {
				result = SQL_SUCCESS_WITH_INFO;
				stmt->errornumber = STMT_TRUNCATED;
				stmt->errormsg = "The buffer was too small for the result.";
			}
		}

		if (pcbDesc) 
			*pcbDesc = len;
	}
	else {	/* numeric data */

		if (pfDesc)
			*pfDesc = value;

	}


    return result;
}

//      Returns result data for a single column in the current row.

RETCODE SQL_API SQLGetData(
        HSTMT      hstmt,
        UWORD      icol,
        SWORD      fCType,
        PTR        rgbValue,
        SDWORD     cbValueMax,
        SDWORD FAR *pcbValue)
{
static char *func="SQLGetData";
QResultClass *res;
StatementClass *stmt = (StatementClass *) hstmt;
int num_cols, num_rows;
Int4 field_type;
void *value;
int result;
char get_bookmark = FALSE;

mylog("SQLGetData: enter, stmt=%u\n", stmt);

    if( ! stmt) {
		SC_log_error(func, "", NULL);
        return SQL_INVALID_HANDLE;
    }
	res = stmt->result;

    if (STMT_EXECUTING == stmt->status) {
        stmt->errormsg = "Can't get data while statement is still executing.";
        stmt->errornumber = STMT_SEQUENCE_ERROR;
		SC_log_error(func, "", stmt);
        return SQL_ERROR;
    }

    if (stmt->status != STMT_FINISHED) {
        stmt->errornumber = STMT_STATUS_ERROR;
        stmt->errormsg = "GetData can only be called after the successful execution on a SQL statement";
		SC_log_error(func, "", stmt);
        return SQL_ERROR;
    }

    if (icol == 0) {

		if (stmt->options.use_bookmarks == SQL_UB_OFF) {
			stmt->errornumber = STMT_COLNUM_ERROR;
			stmt->errormsg = "Attempt to retrieve bookmark with bookmark usage disabled";
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}

		/*	Make sure it is the bookmark data type */
		if (fCType != SQL_C_BOOKMARK) {
			stmt->errormsg = "Column 0 is not of type SQL_C_BOOKMARK";
			stmt->errornumber = STMT_PROGRAM_TYPE_OUT_OF_RANGE;
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}
		
		get_bookmark = TRUE;

    }

	else {

		// use zero-based column numbers
		icol--;

		// make sure the column number is valid
		num_cols = QR_NumResultCols(res);
		if (icol >= num_cols) {
			stmt->errormsg = "Invalid column number.";
			stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}
	}

	if ( stmt->manual_result || ! globals.use_declarefetch) {
		// make sure we're positioned on a valid row
		num_rows = QR_get_num_tuples(res);
		if((stmt->currTuple < 0) ||
		   (stmt->currTuple >= num_rows)) {
			stmt->errormsg = "Not positioned on a valid row for GetData.";
			stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}
		mylog("     num_rows = %d\n", num_rows);

		if ( ! get_bookmark) {
			if ( stmt->manual_result) {
				value = QR_get_value_manual(res, stmt->currTuple, icol);
			}
			else {
				value = QR_get_value_backend_row(res, stmt->currTuple, icol);
			}
			mylog("     value = '%s'\n", value);
		}
	}
	else { /* its a SOCKET result (backend data) */
		if (stmt->currTuple == -1 || ! res || ! res->tupleField) {
			stmt->errormsg = "Not positioned on a valid row for GetData.";
			stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
			SC_log_error(func, "", stmt);
			return SQL_ERROR;
		}

		if ( ! get_bookmark)
			value = QR_get_value_backend(res, icol);

		mylog("  socket: value = '%s'\n", value);
	}

	if ( get_bookmark) {
		*((UDWORD *) rgbValue) = SC_get_bookmark(stmt);

		if (pcbValue)
			*pcbValue = 4;

		return SQL_SUCCESS;
	}

	field_type = QR_get_field_type(res, icol);

	mylog("**** SQLGetData: icol = %d, fCType = %d, field_type = %d, value = '%s'\n", icol, fCType, field_type, value);

	stmt->current_col = icol;

    result = copy_and_convert_field(stmt, field_type, value, 
                                    fCType, rgbValue, cbValueMax, pcbValue);

	stmt->current_col = -1;

	switch(result) {
	case COPY_OK:
		return SQL_SUCCESS;

	case COPY_UNSUPPORTED_TYPE:
		stmt->errormsg = "Received an unsupported type from Postgres.";
		stmt->errornumber = STMT_RESTRICTED_DATA_TYPE_ERROR;
		SC_log_error(func, "", stmt);
		return SQL_ERROR;

	case COPY_UNSUPPORTED_CONVERSION:
		stmt->errormsg = "Couldn't handle the necessary data type conversion.";
		stmt->errornumber = STMT_RESTRICTED_DATA_TYPE_ERROR;
		SC_log_error(func, "", stmt);
		return SQL_ERROR;

	case COPY_RESULT_TRUNCATED:
		stmt->errornumber = STMT_TRUNCATED;
		stmt->errormsg = "The buffer was too small for the result.";
		return SQL_SUCCESS_WITH_INFO;

	case COPY_GENERAL_ERROR:	/* error msg already filled in */
		SC_log_error(func, "", stmt);
		return SQL_ERROR;

	case COPY_NO_DATA_FOUND:
		/* SC_log_error(func, "no data found", stmt); */
		return SQL_NO_DATA_FOUND;

    default:
        stmt->errormsg = "Unrecognized return value from copy_and_convert_field.";
        stmt->errornumber = STMT_INTERNAL_ERROR;
		SC_log_error(func, "", stmt);
        return SQL_ERROR;
    }
}



//      Returns data for bound columns in the current row ("hstmt->iCursor"),
//      advances the cursor.

RETCODE SQL_API SQLFetch(
        HSTMT   hstmt)
{
static char *func = "SQLFetch";
StatementClass *stmt = (StatementClass *) hstmt;   
QResultClass *res;

mylog("SQLFetch: stmt = %u, stmt->result= %u\n", stmt, stmt->result);

	if ( ! stmt) {
		SC_log_error(func, "", NULL);
		return SQL_INVALID_HANDLE;
	}

	SC_clear_error(stmt);

	if ( ! (res = stmt->result)) {
		stmt->errormsg = "Null statement result in SQLFetch.";
		stmt->errornumber = STMT_SEQUENCE_ERROR;
		SC_log_error(func, "", stmt);
		return SQL_ERROR;
	}

	/*	Not allowed to bind a bookmark column when using SQLFetch. */
	if ( stmt->bookmark.buffer) {
		stmt->errornumber = STMT_COLNUM_ERROR;
		stmt->errormsg = "Not allowed to bind a bookmark column when using SQLFetch";
		SC_log_error(func, "", stmt);
		return SQL_ERROR;
	}

	if (stmt->status == STMT_EXECUTING) {
		stmt->errormsg = "Can't fetch while statement is still executing.";
		stmt->errornumber = STMT_SEQUENCE_ERROR;
		SC_log_error(func, "", stmt);
		return SQL_ERROR;
	}


	if (stmt->status != STMT_FINISHED) {
		stmt->errornumber = STMT_STATUS_ERROR;
		stmt->errormsg = "Fetch can only be called after the successful execution on a SQL statement";
		SC_log_error(func, "", stmt);
		return SQL_ERROR;
	}

	if (stmt->bindings == NULL) {
		// just to avoid a crash if the user insists on calling this
		// function even if SQL_ExecDirect has reported an Error
		stmt->errormsg = "Bindings were not allocated properly.";
		stmt->errornumber = STMT_SEQUENCE_ERROR;
		SC_log_error(func, "", stmt);
		return SQL_ERROR;
	}

	QR_set_rowset_size(res, 1);
	QR_inc_base(res, stmt->last_fetch_count);	

	return SC_fetch(stmt);
}

//      This fetchs a block of data (rowset).

RETCODE SQL_API SQLExtendedFetch(
        HSTMT      hstmt,
        UWORD      fFetchType,
        SDWORD     irow,
        UDWORD FAR *pcrow,
        UWORD  FAR *rgfRowStatus)
{
static char *func = "SQLExtendedFetch";
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;
int num_tuples, i, save_rowset_size;
RETCODE result;
char truncated, error;