ii.c

php-4.4.7学习linux时下载的源代码

	
		default:
			RETURN_FALSE;
	}
}

/* Return the name of a field in a query result
*/
static char *php_ii_field_name(II_LINK *ii_link, int index TSRMLS_DC)
{
	if (index < 1 || index > ii_link->fieldCount) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Ingres II:  php_ii_field_name() called with wrong index (%d)", index);
		return NULL;
	}

	return (ii_link->descriptor[index - 1]).ds_columnName;
}

/* {{{ proto string ingres_field_name(int index [, resource link])
   Return the name of a field in a query result index must be >0 and <= ingres_num_fields() */
PHP_FUNCTION(ingres_field_name)
{
	php_ii_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, II_FIELD_INFO_NAME);
}
/* }}} */

/* {{{ proto string ingres_field_type(int index [, resource link])
   Return the type of a field in a query result index must be >0 and <= ingres_num_fields() */
PHP_FUNCTION(ingres_field_type)
{
	php_ii_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, II_FIELD_INFO_TYPE);
}
/* }}} */

/* {{{ proto string ingres_field_nullable(int index [, resource link])
   Return true if the field is nullable and false otherwise index must be >0 and <= ingres_num_fields() */
PHP_FUNCTION(ingres_field_nullable)
{
	php_ii_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, II_FIELD_INFO_NULLABLE);
}
/* }}} */

/* {{{ proto string ingres_field_length(int index [, resource link])
   Return the length of a field in a query result index must be >0 and <= ingres_num_fields() */
PHP_FUNCTION(ingres_field_length)
{
	php_ii_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, II_FIELD_INFO_LENGTH);
}
/* }}} */

/* {{{ proto string ingres_field_precision(int index [, resource link])
   Return the precision of a field in a query result index must be >0 and <= ingres_num_fields() */
PHP_FUNCTION(ingres_field_precision)
{
	php_ii_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, II_FIELD_INFO_PRECISION);
}
/* }}} */

/* {{{ proto string ingres_field_scale(int index [, resource link])
   Return the scale of a field in a query result index must be >0 and <= ingres_num_fields() */
PHP_FUNCTION(ingres_field_scale)
{
	php_ii_field_info(INTERNAL_FUNCTION_PARAM_PASSTHRU, II_FIELD_INFO_SCALE);
}
/* }}} */


/* Convert complex Ingres data types to php-usable ones
*/
#define IIAPI_CONVERT(destType, destSize, precision) {\
      convertParm.cv_srcDesc.ds_dataType = (ii_link->descriptor[i+k-2]).ds_dataType;\
      convertParm.cv_srcDesc.ds_nullable = (ii_link->descriptor[i+k-2]).ds_nullable;\
      convertParm.cv_srcDesc.ds_length = (ii_link->descriptor[i+k-2]).ds_length;\
      convertParm.cv_srcDesc.ds_precision = (ii_link->descriptor[i+k-2]).ds_precision;\
      convertParm.cv_srcDesc.ds_scale = (ii_link->descriptor[i+k-2]).ds_scale;\
      convertParm.cv_srcDesc.ds_columnType = (ii_link->descriptor[i+k-2]).ds_columnType;\
      convertParm.cv_srcDesc.ds_columnName = (ii_link->descriptor[i+k-2]).ds_columnName;\
      convertParm.cv_srcValue.dv_null = columnData[k-1].dv_null;\
      convertParm.cv_srcValue.dv_length = columnData[k-1].dv_length;\
      convertParm.cv_srcValue.dv_value = columnData[k-1].dv_value;\
      convertParm.cv_dstDesc.ds_dataType = destType;\
      convertParm.cv_dstDesc.ds_nullable = FALSE;\
      convertParm.cv_dstDesc.ds_length = destSize;\
      convertParm.cv_dstDesc.ds_precision = precision;\
      convertParm.cv_dstDesc.ds_scale = 0;\
      convertParm.cv_dstDesc.ds_columnType = IIAPI_COL_TUPLE;\
      convertParm.cv_dstDesc.ds_columnName = NULL;\
      convertParm.cv_dstValue.dv_null = FALSE;\
      convertParm.cv_dstValue.dv_length = convertParm.cv_dstDesc.ds_length;\
      convertParm.cv_dstValue.dv_value = emalloc(convertParm.cv_dstDesc.ds_length+1);\
\
      IIapi_convertData(&convertParm);\
\
      if(ii_success(&(getColParm.gc_genParm))!=II_OK) {\
          RETURN_FALSE;\
      }\
\
      columnData[k-1].dv_length = convertParm.cv_dstValue.dv_length;\
      columnData[k-1].dv_value = convertParm.cv_dstValue.dv_value;\
      efree(convertParm.cv_srcValue.dv_value);\
}


/* Fetch a row of result
*/
static void php_ii_fetch(INTERNAL_FUNCTION_PARAMETERS, II_LINK *ii_link, int result_type)
{
	IIAPI_GETCOLPARM getColParm;
	IIAPI_DATAVALUE *columnData;
	IIAPI_CONVERTPARM convertParm;
	int i, j, k;
	int more;
	double value_double = 0;
	long value_long = 0;
	char *value_char_p;
	int len, should_copy, correct_length;

	/* array initialization */
	array_init(return_value);

	/* going through all fields */
	for (i = 1; i <= ii_link->fieldCount;) {
		j = 1;

		/* as long as there are no long byte or long varchar fields,
		   Ingres is able to fetch many fields at a time, so try to find
		   these types and stop if they're found.
		   variable j will get number of fields to fetch */
		if ((ii_link->descriptor[i]).ds_dataType != IIAPI_LBYTE_TYPE &&
			(ii_link->descriptor[i]).ds_dataType != IIAPI_LVCH_TYPE) {
			while (	(ii_link->descriptor[i + j - 1]).ds_dataType != IIAPI_LBYTE_TYPE &&
					(ii_link->descriptor[i + j - 1]).ds_dataType != IIAPI_LVCH_TYPE && 
					i + j <= ii_link->fieldCount) {
				j++;
			}
		}

		/* allocate memory for j fields */
		columnData = (IIAPI_DATAVALUE *) emalloc(j * sizeof(IIAPI_DATAVALUE));
		for (k = 1; k <= j; k++) {
			columnData[k - 1].dv_value = (II_PTR) emalloc((ii_link->descriptor[i + k - 2]).ds_length);
		}

		more = 1;				/* this is for multi segment LBYTE and LVCH elements */

		while (more) {
			getColParm.gc_genParm.gp_callback = NULL;
			getColParm.gc_genParm.gp_closure = NULL;
			getColParm.gc_rowCount = 1;
			getColParm.gc_columnCount = j;
			getColParm.gc_columnData = columnData;
			getColParm.gc_stmtHandle = ii_link->stmtHandle;
			getColParm.gc_moreSegments = 0;

			IIapi_getColumns(&getColParm);
			ii_sync(&(getColParm.gc_genParm));

			if (ii_success(&(getColParm.gc_genParm)) != II_OK) {
				RETURN_FALSE;
			}

			more = getColParm.gc_moreSegments;

			if (more) {			/* more segments of LBYTE or LVCH element to come */

				/* Multi segment LBYTE and LVCH elements not supported yet */
				php_error_docref(NULL TSRMLS_CC, E_ERROR, "Ingres II:  Multi segment LBYTE and LVCH elements not supported yet");

			} else {

				for (k = 1; k <= j; k++) {
					if (columnData[k - 1].dv_null) {	/* NULL value ? */

						if (result_type & II_NUM) {
							add_index_null(return_value, i + k - 1);
						}
						if (result_type & II_ASSOC) {
							add_assoc_null(return_value, php_ii_field_name(ii_link, i + k - 1 TSRMLS_CC));
						}

					} else {	/* non NULL value */
						correct_length = 0;

						switch ((ii_link->descriptor[i + k - 2]).ds_dataType) {
	
							case IIAPI_DEC_TYPE:	/* decimal (fixed point number) */
							case IIAPI_MNY_TYPE:	/* money */
								/* convert to floating point number */
								IIAPI_CONVERT(IIAPI_FLT_TYPE, sizeof(II_FLOAT8), 53);
								/* NO break */
	
							case IIAPI_FLT_TYPE:	/* floating point number */
								switch (columnData[k - 1].dv_length) {

									case 4:
										value_double = (double) *((II_FLOAT4 *) columnData[k - 1].dv_value);
										break;

									case 8:
										value_double = (double) *((II_FLOAT8 *) columnData[k - 1].dv_value);
										break;

									default:
										php_error_docref(NULL TSRMLS_CC, E_WARNING, "Ingres II:  Invalid size for IIAPI_FLT_TYPE data (%d)", columnData[k - 1].dv_length);
										break;
								}

								if (result_type & II_NUM) {
									add_index_double(return_value, i + k - 1, value_double);
								}

								if (result_type & II_ASSOC) {
									add_assoc_double(return_value, php_ii_field_name(ii_link, i + k - 1 TSRMLS_CC), value_double);
								}
								break;

							case IIAPI_INT_TYPE:	/* integer */
								switch (columnData[k - 1].dv_length) {

									case 1:
										value_long = (long) *((II_INT1 *) columnData[k - 1].dv_value);
										break;

									case 2:
										value_long = (long) *((II_INT2 *) columnData[k - 1].dv_value);
										break;
			
									case 4:
										value_long = (long) *((II_INT4 *) columnData[k - 1].dv_value);
										break;
		
									default:
										php_error_docref(NULL TSRMLS_CC, E_WARNING, "Ingres II:  Invalid size for IIAPI_INT_TYPE data (%d)", columnData[k - 1].dv_length);
										break;
								}

								if (result_type & II_NUM) {
									add_index_long(return_value, i + k - 1, value_long);
								}
	
								if (result_type & II_ASSOC) {
									add_assoc_long(return_value, php_ii_field_name(ii_link, i + k - 1 TSRMLS_CC), value_long);
								}
								break;

							case IIAPI_TXT_TYPE:	/* variable length character string */
							case IIAPI_VBYTE_TYPE:	/* variable length binary string */
							case IIAPI_VCH_TYPE:	/* variable length character string */
								/* real length is stored in first 2 bytes of data, so adjust
								   length variable and data pointer */
								columnData[k - 1].dv_length = *((II_INT2 *) columnData[k - 1].dv_value);
								((II_INT2 *) columnData[k - 1].dv_value)++;
								correct_length = 1;
								/* NO break */
	
							case IIAPI_BYTE_TYPE:	/* fixed length binary string */
							case IIAPI_CHA_TYPE:	/* fixed length character string */
							case IIAPI_CHR_TYPE:	/* fixed length character string */
							case IIAPI_LOGKEY_TYPE:	/* value unique to database */
							case IIAPI_TABKEY_TYPE:	/* value unique to table */
							case IIAPI_DTE_TYPE:	/* date */
								/* eventualy convert date to string */
								if ((ii_link->descriptor[i + k - 2]).
									ds_dataType == IIAPI_DTE_TYPE) {
									IIAPI_CONVERT(IIAPI_CHA_TYPE, 32, 0);
								}
	
								/* use php_addslashes if asked to */
								if (PG(magic_quotes_runtime)) {
									value_char_p = php_addslashes((char *) columnData[k - 1].dv_value, columnData[k - 1].dv_length, &len, 0 TSRMLS_CC);
									should_copy = 0;
								} else {
									value_char_p = (char *) columnData[k - 1].dv_value;
									len = columnData[k - 1].dv_length;
									should_copy = 1;
								}

								if (result_type & II_NUM) {
									add_index_stringl(return_value, i + k - 1, value_char_p, len, should_copy);
								}

								if (result_type & II_ASSOC) {
									add_assoc_stringl(return_value, php_ii_field_name(ii_link, i + k - 1 TSRMLS_CC), value_char_p, len, should_copy);
								}

								/* eventualy restore data pointer state for
							 	   variable length data types */
								if (correct_length) {
									((II_INT2 *) columnData[k - 1].dv_value)--;
								}
								break;
			
							default:
								php_error_docref(NULL TSRMLS_CC, E_WARNING, "Ingres II:  Invalid SQL data type in fetched field (%d -- length : %d)", (ii_link->descriptor[i + k - 2]).ds_dataType, columnData[k - 1].dv_length);
								break;
						}
					}
				}
			}
		}

		/* free the memory buffers */
		for (k = 1; k <= j; k++) {
			efree(columnData[k - 1].dv_value);
		}
		efree(columnData);

		/* increase field pointer by number of fetched fields */
		i += j;
	}
}

/* {{{ proto array ingres_fetch_array([int result_type [, resource link]])
   Fetch a row of result into an array result_type can be II_NUM for enumerated array, II_ASSOC for associative array, or II_BOTH (default) */
PHP_FUNCTION(ingres_fetch_array)
{
	zval **result_type, **link;
	int argc;
	int link_id = -1;
	II_LINK *ii_link;

	argc = ZEND_NUM_ARGS();
	if (argc > 2 || zend_get_parameters_ex(argc, &result_type, &link) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if (argc != 2) {
		link_id = php_ii_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}

	if (argc != 0) {
		convert_to_long_ex(result_type);
	}

	ZEND_FETCH_RESOURCE2(ii_link, II_LINK *, link, link_id, "Ingres II Link", le_ii_link, le_ii_plink);

	php_ii_fetch(INTERNAL_FUNCTION_PARAM_PASSTHRU, ii_link, (argc == 0 ? II_BOTH : Z_LVAL_PP(result_type)));
}
/* }}} */

/* {{{ proto array ingres_fetch_row([resource link])
   Fetch a row of result into an enumerated array */
PHP_FUNCTION(ingres_fetch_row)
{
	zval **link;
	int argc;
	int link_id = -1;
	II_LINK *ii_link;

	argc = ZEND_NUM_ARGS();
	if (argc > 1 || zend_get_parameters_ex(argc, &link) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if (argc != 1) {
		link_id = php_ii_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}

	ZEND_FETCH_RESOURCE2(ii_link, II_LINK *, link, link_id, "Ingres II Link", le_ii_link, le_ii_plink);

	php_ii_fetch(INTERNAL_FUNCTION_PARAM_PASSTHRU, ii_link, II_NUM);
}
/* }}} */

/* {{{ proto array ingres_fetch_object([int result_type [, resource link]])
   Fetch a row of result into an object result_type can be II_NUM for enumerated object, II_ASSOC for associative object, or II_BOTH (default) */
PHP_FUNCTION(ingres_fetch_object)
{
	zval **result_type, **link;
	int argc;
	int link_id = -1;
	II_LINK *ii_link;

	argc = ZEND_NUM_ARGS();
	if (argc > 2 || zend_get_parameters_ex(argc, &result_type, &link) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if (argc != 2) {
		link_id = php_ii_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
	}

	if (argc != 0) {
		convert_to_long_ex(result_type);
	}

	ZEND_FETCH_RESOURCE2(ii_link, II_LINK *, link, link_id, "Ingres II Link", le_ii_link, le_ii_plink);

	php_ii_fetch(INTERNAL_FUNCTION_PARAM_PASSTHRU, ii_link, (argc == 0 ? II_BOTH : Z_LVAL_PP(result_type)));

	if (Z_TYPE_P(return_value) == IS_ARRAY) {
		convert_to_object(return_value);
	}
}
/* }}} */

/* {{{ proto bool ingres_rollback([resource link])
   Roll back a transaction */
PHP_FUNCTION(ingres_rollback)
{
	zval **link;
	int argc;
	int link_id = -1;
	II_LINK *ii_link;

	argc = ZEND_NUM_ARGS();
	if (argc > 1 || (argc && zend_get_parameters_ex(argc, &link) == FAILURE)) {
		WRONG_PARAM_COUNT;
	}

	if (argc == 0) {
		link_id = IIG(default_link);
	}
	ZEND_FETCH_RESOURCE2(ii_link, II_LINK *, link, link_id, "Ingres II Link", le_ii_link, le_ii_plink);

	if (_rollback_transaction(ii_link TSRMLS_CC)) {
		RETURN_FALSE;
	}
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool ingres_commit([resource link])
   Commit a transaction */
PHP_FUNCTION(ingres_commit)
{
	zval **link;
	int argc;
	int link_id = -1;
	II_LINK *ii_link;
	IIAPI_COMMITPARM commitParm;

	argc = ZEND_NUM_ARGS();
	if (argc > 1 || (argc && zend_get_parameters_ex(argc, &link) == FAILURE)) {
		WRONG_PARAM_COUNT;
	}

	if (argc == 0) {
		link_id = IIG(default_link);
	}

	ZEND_FETCH_RESOURCE2(ii_link, II_LINK *, link, link_id, "Ingres II Link", le_ii_link, le_ii_plink);

	if (ii_link->stmtHandle && _close_statement(ii_link)) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Ingres II:  Unable to close statement !!");
		RETURN_FALSE;
	}

	commitParm.cm_genParm.gp_callback = NULL;
	commitParm.cm_genParm.gp_closure = NULL;
	commitParm.cm_tranHandle = ii_link->tranHandle;

	IIapi_commit(&commitParm);
	ii_sync(&(commitParm.cm_genParm));

	if (ii_success(&(commitParm.cm_genParm)) == II_FAIL) {
		RETURN_FALSE;
	}

	ii_link->tranHandle = NULL;
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool ingres_autocommit([resource link])
   Switch autocommit on or off */
PHP_FUNCTION(ingres_autocommit)
{
	zval **link;
	int argc;
	int link_id = -1;
	II_LINK *ii_link;
	IIAPI_AUTOPARM autoParm;

	argc = ZEND_NUM_ARGS();
	if (argc > 1 || (argc && zend_get_parameters_ex(argc, &link) == FAILURE)) {
		WRONG_PARAM_COUNT;
	}

	if (argc == 0) {
		link_id = IIG(default_link);
	}

	ZEND_FETCH_RESOURCE2(ii_link, II_LINK *, link, link_id, "Ingres II Link", le_ii_link, le_ii_plink);

	autoParm.ac_genParm.gp_callback = NULL;
	autoParm.ac_genParm.gp_closure = NULL;
	autoParm.ac_connHandle = ii_link->connHandle;
	autoParm.ac_tranHandle = ii_link->tranHandle;

	IIapi_autocommit(&autoParm);
	ii_sync(&(autoParm.ac_genParm));

	if (ii_success(&(autoParm.ac_genParm)) == II_FAIL) {
		RETURN_FALSE;
	}

	ii_link->autocommit = (ii_link->autocommit ? 0 : 1);
	ii_link->tranHandle = autoParm.ac_tranHandle;
	RETURN_TRUE;
}
/* }}} */

#endif /* HAVE_II */

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: sw=4 ts=4 fdm=marker
 * vim<600: sw=4 ts=4
 */