oracle.c

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

									break;
								}
								
								if (ret_len <= 0) {
									break;
								}
								
								offset += ret_len;
							}
						}
						if (cursor->columns[i].buf && offset) {
							Z_STRLEN_P(tmp) = offset;
						} else {
							Z_STRLEN_P(tmp) = 0;
						}
					}
					break;
				default:
					Z_STRLEN_P(tmp) = min(cursor->columns[i].col_retlen,
											 cursor->columns[i].dsize);
					break;
			}
			Z_STRVAL_P(tmp) = estrndup(cursor->columns[i].buf,Z_STRLEN_P(tmp));
		}

		if (flags&ORA_FETCHINTO_ASSOC){
			zend_hash_update(Z_ARRVAL_PP(arr), cursor->columns[i].cbuf, cursor->columns[i].cbufl+1, (void *) &tmp, sizeof(pval*), NULL);
		} else {
			zend_hash_index_update(Z_ARRVAL_PP(arr), i, (void *) &tmp, sizeof(pval*), NULL);
		}

	}

	RETURN_LONG(cursor->ncols); 
}
/* }}} */

/* {{{ proto string ora_columnname(int cursor, int column)
   Get the name of an Oracle result column */
PHP_FUNCTION(ora_columnname)
{								/* cursor_index, column_index */
	pval **curs, **col;
	oraCursor *cursor = NULL;

	if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &curs, &col) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if ((cursor = ora_get_cursor(&EG(regular_list), curs TSRMLS_CC)) == NULL) {
		RETURN_FALSE;
	}

	convert_to_long_ex(col);
	
	if (cursor->ncols == 0){
		php_error(E_WARNING, "No tuples available at this cursor index");
		RETURN_FALSE;
	}
        
	if (Z_LVAL_PP(col) >= cursor->ncols){
		php_error(E_WARNING, "Column index larger than number of columns");
		RETURN_FALSE;
	}

	if (Z_LVAL_PP(col) < 0){
		php_error(E_WARNING, "Column numbering starts at 0");
		RETURN_FALSE;
	}
        
	RETURN_STRINGL(cursor->columns[Z_LVAL_PP(col)].cbuf,
				   cursor->columns[Z_LVAL_PP(col)].cbufl,1);
}
/* }}} */

/* {{{ proto string ora_columntype(int cursor, int column) 
   Get the type of an Oracle result column */
PHP_FUNCTION(ora_columntype)
{								/* cursor_index, column_index */
	pval **curs, **col;
	int colno;
	oraCursor *cursor = NULL;

	if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &curs, &col) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if ((cursor = ora_get_cursor(&EG(regular_list), curs TSRMLS_CC)) == NULL) {
		RETURN_FALSE;
	}

	convert_to_long_ex(col);
	colno = Z_LVAL_PP(col);

	if (cursor->ncols == 0){
		php_error(E_WARNING, "No tuples available at this cursor index");
		RETURN_FALSE;
	}
        
	if (colno >= cursor->ncols){
		php_error(E_WARNING, "Column index larger than number of columns");
		RETURN_FALSE;
	}

	if (colno < 0){
		php_error(E_WARNING, "Column numbering starts at 0");
		RETURN_FALSE;
	}

	switch (cursor->columns[colno].dbtype) {
		case SQLT_CHR:
			RETURN_STRINGL("VARCHAR2", 8, 1);
		case SQLT_VCS:
	    case SQLT_AVC:
			RETURN_STRINGL("VARCHAR", 7, 1);
		case SQLT_STR:
	    case SQLT_AFC:
			RETURN_STRINGL("CHAR", 4, 1);
		case SQLT_NUM: case SQLT_INT:
		case SQLT_FLT: case SQLT_UIN:
			RETURN_STRINGL("NUMBER", 6, 1);
		case SQLT_LNG:
			RETURN_STRINGL("LONG", 4, 1);
		case SQLT_LBI:
			RETURN_STRINGL("LONG RAW", 8, 1);
		case SQLT_RID:
			RETURN_STRINGL("ROWID", 5, 1);
		case SQLT_DAT:
			RETURN_STRINGL("DATE", 4, 1);
#ifdef SQLT_CUR
		case SQLT_CUR:
			RETURN_STRINGL("CURSOR", 6, 1);
#endif
		default:
		{
			char numbuf[21];
			snprintf(numbuf, 20, "UNKNOWN(%d)", cursor->columns[colno].dbtype);
			numbuf[20] = '\0';
			RETVAL_STRING(numbuf,1);
		}
	}
}
/* }}} */

/* {{{ proto int ora_columnsize(int cursor, int column)
   Return the size of the column */
PHP_FUNCTION(ora_columnsize)
{								/* cursor_index, column_index */
	pval **curs, **col;
	oraCursor *cursor = NULL;

	if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &curs, &col) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	/* Find the cursor */
	if ((cursor = ora_get_cursor(&EG(regular_list), curs TSRMLS_CC)) == NULL) {
		RETURN_FALSE;
	}

	convert_to_long_ex(col);
	
	if (cursor->ncols == 0){
		php_error(E_WARNING, "No tuples available at this cursor index");
		RETURN_FALSE;
	}
        
	if (Z_LVAL_PP(col) >= cursor->ncols){
		php_error(E_WARNING, "Column index larger than number of columns");
		RETURN_FALSE;
	}

	if (Z_LVAL_PP(col) < 0){
		php_error(E_WARNING, "Column numbering starts at 0");
		RETURN_FALSE;
	}
        
	RETURN_LONG(cursor->columns[Z_LVAL_PP(col)].dbsize);
}
/* }}} */

/* {{{ proto mixed ora_getcolumn(int cursor, int column)
   Get data from a fetched row */
PHP_FUNCTION(ora_getcolumn)
{								/* cursor_index, column_index */
	pval **curs,**col;
	int colno;
	oraCursor *cursor = NULL;
	oraColumn *column = NULL;
	int len;
	sb2 type;

	if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &curs, &col) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if ((cursor = ora_get_cursor(&EG(regular_list), curs TSRMLS_CC)) == NULL) {
		RETURN_FALSE;
	}

	if (cursor->ncols == 0){
		php_error(E_WARNING, "No tuples available at this cursor index");
		RETURN_FALSE;
	}

	convert_to_long_ex(col);
	colno = Z_LVAL_PP(col);        

	if (colno >= cursor->ncols){
		php_error(E_WARNING, "Column index larger than number of columns");
		RETURN_FALSE;
	}

	if (colno < 0){
		php_error(E_WARNING, "Column numbering starts at 0");
		RETURN_FALSE;
	}

	if (cursor->fetched == 0){
		if (ofetch(&cursor->cda)) {
			if (cursor->cda.rc != NO_DATA_FOUND) {
				php_error(E_WARNING, "Ora_Fetch failed (%s)",
						   ora_error(&cursor->cda));
			}
			RETURN_FALSE;
		}
		cursor->fetched++;		
	}

 	column = &cursor->columns[colno]; 

 	type = column->dbtype; 

	if (column->col_retcode == 1405) {
		RETURN_NULL();
	}

	if (column->col_retcode != 0 && column->col_retcode != 1406) {
		/* So error fetching column.  The most common is 1405, a NULL
		 * was retreived.  1406 is ASCII or string buffer data was
		 * truncated. The converted data from the database did not fit
		 * into the buffer.  Since we allocated the buffer to be large
		 * enough, this should not occur.  Anyway, we probably want to
		 * return what we did get, in that case
		 */
		RETURN_FALSE;
	} else {
		switch(type) {
		case SQLT_CHR:
		case SQLT_NUM:
		case SQLT_INT: 
		case SQLT_FLT:
		case SQLT_STR:
		case SQLT_UIN:
		case SQLT_AFC:
		case SQLT_AVC:
		case SQLT_DAT:
			len = min(column->col_retlen, column->dsize);
			RETURN_STRINGL(column->buf,len,1);

		case SQLT_LNG:
		case SQLT_LBI:
			{ 
				ub4 ret_len;
				int offset = column->col_retlen;
				sb2 result;
				
				if (column->col_retcode == 1406) { /* truncation -> get the rest! */
					while (1) {
						column->buf = erealloc(column->buf,offset + DB_SIZE + 1);
						
						if (! column->buf) {
							offset = 0;
							break;
						}
						
						result = oflng(&cursor->cda, 
									   (sword)(colno + 1),
									   column->buf + offset, 
									   DB_SIZE, 
									   1,
									   &ret_len, 
									   offset);
						if (result) {
							break;
						}
						
						if (ret_len <= 0) {
							break;
						}
						
						offset += ret_len;
					}
				}
				if (column->buf && offset) {
					RETURN_STRINGL(column->buf, offset, 1);
				} else {
					RETURN_FALSE;
				}
			}
		default:
			php_error(E_WARNING,"Ora_GetColumn found invalid type (%d)", type);
			RETURN_FALSE;
		}
	}
}
/* }}} */

/* {{{ proto string ora_error(int cursor_or_connection)
   Get an Oracle error message */
PHP_FUNCTION(ora_error)
{
	pval **arg;
	oraCursor *cursor;
	oraConnection *conn;
	void *res;
	int what;
	int argc = ZEND_NUM_ARGS();

	if (argc < 0 || argc >> 1 || zend_get_parameters_ex(argc, &arg) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if (argc == 1) {
		res = zend_fetch_resource(arg TSRMLS_CC, -1,"Oracle-Connection/Cursor",&what,3,le_conn, le_pconn, le_cursor);
		ZEND_VERIFY_RESOURCE(res);

		if (what == le_cursor) {
			cursor = (oraCursor *) res;
			RETURN_STRING(ora_error(&cursor->cda),1);
		} else {
			conn = (oraConnection *) res;
			RETURN_STRING(ora_error(&conn->lda),1);
		}
	} else {
		RETURN_STRING(ora_error(&ORA(db_err_conn).lda),1);
	}
}
/* }}} */

/* {{{ proto int ora_errorcode(int cursor_or_connection)
   Get an Oracle error code */
PHP_FUNCTION(ora_errorcode)
{
	pval **arg;
	oraCursor *cursor;
	oraConnection *conn;
	void *res;
	int what;
	int argc = ZEND_NUM_ARGS();

	if (argc < 0 || argc >> 1 || zend_get_parameters_ex(argc, &arg) == FAILURE) {
		WRONG_PARAM_COUNT;
	}

	if (argc == 1) {
		res = zend_fetch_resource(arg TSRMLS_CC, -1,"Oracle-Connection/Cursor",&what,3,le_conn, le_pconn, le_cursor);
		ZEND_VERIFY_RESOURCE(res);

		if (what == le_cursor) {
			cursor = (oraCursor *) res;
			RETURN_LONG(cursor->cda.rc);
		} else {
			conn = (oraConnection *) res;
			RETURN_LONG(conn->lda.rc);
		}
	} else {
		RETURN_LONG(ORA(db_err_conn).lda.rc);
	}
}
/* }}} */

/* {{{ PHP_MINFO_FUNCTION
 */
PHP_MINFO_FUNCTION(oracle)
{
	php_info_print_table_start();
	php_info_print_table_row(2, "Oracle Support", "enabled");
#ifndef PHP_WIN32
    php_info_print_table_row(2, "Oracle Version", PHP_ORACLE_VERSION );
    php_info_print_table_row(2, "Compile-time ORACLE_HOME", PHP_ORACLE_DIR );
    php_info_print_table_row(2, "Libraries Used", PHP_ORACLE_SHARED_LIBADD );                                                                                       
#endif
	php_info_print_table_end();
}
/* }}} */

/*
** Functions internal to this module.
*/

/* {{{ ora_get_cursor
 */
static oraCursor *
ora_get_cursor(HashTable *list, pval **ind TSRMLS_DC)
{
	oraCursor *cursor;
	oraConnection *db_conn;

	cursor = (oraCursor *) zend_fetch_resource(ind TSRMLS_CC, -1, "Oracle-Cursor", NULL, 1, le_cursor);
	if (! cursor) {
		return NULL;
	}

	if (zend_hash_find(ORA(conns),(void*)&(cursor->conn_ptr),sizeof(void*),(void **)&db_conn) == FAILURE) {
		php_error(E_WARNING, "Connection already closed for cursor index %d", ind);
		return NULL;
	}

	return cursor;
}
/* }}} */

/* {{{ ora_error
 */
static char *
ora_error(Cda_Def * cda)
{
	sword n, l;
	static text errmsg[ 512 ];

	n = oerhms(cda, cda->rc, errmsg, 400);

	/* remove the last newline */
	l = strlen(errmsg);
	if (l < 400 && errmsg[l - 1] == '\n') {
		errmsg[l - 1] = '\0';
		l--;
	}
	if (cda->fc > 0) {
		strcat(errmsg, " -- while processing OCI function ");
		strncat(errmsg, ora_func_tab[cda->fc], 75);  /* 512 - 400 - 36 */
	}
	return (char *) errmsg;
}
/* }}} */

/* {{{ ora_describe_define
 */
static sword
ora_describe_define(oraCursor * cursor)
{
	long col = 0;
	int i;
	sb2 type;
	sb4 dbsize;

	if (cursor == NULL) {
		return -1;
	}

	if (cursor->columns) {
		for(i = 0; i < cursor->ncols; i++){
			if (cursor->columns[i].buf)
				efree(cursor->columns[i].buf);
		}
		efree(cursor->columns);
	} 

	cursor->ncols = 0;

	while(1){
		if (odescr(&cursor->cda, (sword) cursor->ncols + 1, &dbsize, (sb2 *)0, (sb1 *)0, 
			   (sb4 *)0, (sb4 *)0,	(sb2 *)0, (sb2 *)0, (sb2 *)0)){
			if (cursor->cda.rc == VAR_NOT_IN_LIST) {
				break;
			} else {
				php_error(E_WARNING, "%s", ora_error(&cursor->cda));
				cursor->ncols = 0;
				return -1;
			}
		}
		cursor->ncols++;
	}

	if (cursor->ncols > 0){
		cursor->columns = (oraColumn *) emalloc(sizeof(oraColumn) * cursor->ncols);
		if (cursor->columns == NULL){
			php_error(E_WARNING, "Out of memory");
			return -1;
		}
		memset(cursor->columns,0,sizeof(oraColumn) * cursor->ncols);
	}

	for(col = 0; col < cursor->ncols; col++){
		cursor->columns[col].cbufl = ORANAMELEN;
		
		if (odescr(&cursor->cda, (sword)col + 1, &cursor->columns[col].dbsize,
				   &cursor->columns[col].dbtype, &cursor->columns[col].cbuf[0],
				   &cursor->columns[col].cbufl, &cursor->columns[col].dsize,
				   &cursor->columns[col].prec, &cursor->columns[col].scale,
				   &cursor->columns[col].nullok)) {
			if (cursor->cda.rc == VAR_NOT_IN_LIST) {
				break;
			} else {
				php_error(E_WARNING, "%s", ora_error(&cursor->cda));
				return -1;
			}
		}

		cursor->columns[col].cbuf[cursor->columns[col].cbufl] = '\0';

		switch (cursor->columns[col].dbtype) {
			case SQLT_LBI:
				cursor->columns[col].dsize = DB_SIZE;
				type = SQLT_LBI;
				break;
			case SQLT_LNG: 
				cursor->columns[col].dsize = DB_SIZE;
			default:
				type = SQLT_STR;
				break;
		}
		
		if ((cursor->columns[col].buf = (ub1 *) emalloc(cursor->columns[col].dsize + 1)) == NULL){
			php_error(E_WARNING, "Out of memory");
			return -1;
		}
		/* Define an output variable for the column */
		if (odefin(&cursor->cda, (sword)col + 1, cursor->columns[col].buf, 
				   cursor->columns[col].dsize + 1, type, -1, &cursor->columns[col].indp,
				   (text *) 0, -1, -1, &cursor->columns[col].col_retlen, 
				   &cursor->columns[col].col_retcode)) {
			php_error(E_WARNING, "%s", ora_error(&cursor->cda));
			return -1;
		}
	}
	return 1;
}
/* }}} */

/* {{{ ora_set_param_values
 */
int ora_set_param_values(oraCursor *cursor, int isout TSRMLS_DC)
{
	char *paramname;
	oraParam *param;
	pval **pdata;
	int i, len, plen;

	zend_hash_internal_pointer_reset(cursor->params);

	if(zend_hash_num_elements(cursor->params) != cursor->nparams){
		php_error(E_WARNING, "Mismatch in number of parameters");
		return 0;
	}

	for(i = 0; i < cursor->nparams; i++, zend_hash_move_forward(cursor->params)){
		if(zend_hash_get_current_key(cursor->params, &paramname, NULL, 0) != HASH_KEY_IS_STRING){
			php_error(E_WARNING, "Can't get parameter name");
			return 0;
		}

		if(zend_hash_get_current_data(cursor->params, (void **)&param) == FAILURE){
			php_error(E_WARNING, "Can't get parameter data");
			return 0;
		}

		if(isout){
			SET_VAR_STRINGL(paramname, estrdup(param->progv), strlen(param->progv));
			continue;
		}
		
		/* doing the in-loop */

		if (zend_hash_find(&EG(symbol_table), paramname, strlen(paramname) + 1, (void **)&pdata) == FAILURE){
			php_error(E_WARNING, "Can't find variable for parameter");
			return 0;
		}

		convert_to_string(*pdata);
		plen = Z_STRLEN_PP(pdata);

 		if (param->progvl <= plen){
  			php_error(E_NOTICE, "Input value will be truncated");
  		}

		len = min(param->progvl - 1, plen);

		strncpy(param->progv, Z_STRVAL_PP(pdata), len);
		param->progv[len] = '\0';
	}

	return 1;
}
/* }}} */

#endif							/* HAVE_ORACLE */

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