--- /dev/null
+#include <stdio.h>
+#include <string.h>
+
+/* #include <dl/phpdl.h> */
+
+#include <php.h>
+#include <php_globals.h>
+#include <zend_API.h>
+/* #include "ext/standard/php3_standard.h" */
+#include "ext/standard/info.h"
+
+#include <ovrimos.h>
+
+#if !defined(WIN32)
+# define stricmp strcasecmp
+#endif
+
+static longreadlen=0;
+static void column_to_string(SQLS stmt, int i, char *buffer, int *len);
+
+PHP_MINFO_FUNCTION(ovrimos) {
+ php_printf(""Ovrimos" module<br>\n");
+}
+
+/* Main User Functions */
+/* {{{ proto int ovrimos_connect(string host, string db, string user, string password)
+ Connect to an Ovrimos database */
+PHP_FUNCTION(ovrimos_connect) {
+ pval *arg1, *arg2, *arg3, *arg4;
+ SQLH conn=0;
+ if(ARG_COUNT(ht)!=4 || getParameters(ht,4,&arg1,&arg2,&arg3,&arg4)==FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_string(arg1);
+ convert_to_string(arg2);
+ convert_to_string(arg3);
+ convert_to_string(arg4);
+ if(!sqlConnect(arg1->value.str.val,arg2->value.str.val,arg3->value.str.val,
+ arg4->value.str.val,&conn)) {
+ RETURN_LONG(0);
+ }
+ RETURN_LONG((int)conn+1);
+}
+/* }}} */
+
+/* {{{ proto void ovrimos_close(int connection)
+ Close a connection */
+PHP_FUNCTION(ovrimos_close) {
+ pval *arg1;
+ SQLH conn;
+ if(ARG_COUNT(ht)!=1 || getParameters(ht,1,&arg1)==FAILURE || arg1->type!=IS_LONG) {
+ WRONG_PARAM_COUNT;
+ }
+ conn=(SQLH)(arg1->value.lval-1);
+ (void)sqlDisConnect(conn);
+}
+/* }}} */
+
+/* {{{ proto void ovrimos_close_all()
+ Close all connections */
+PHP_FUNCTION(ovrimos_close_all) {
+ pval *arg1;
+ SQLH conn;
+ (void)sqlDisconnectAll();
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_longreadlen(int result_id, int length)
+ Handle LONG columns */
+PHP_FUNCTION(ovrimos_longreadlen) {
+ pval *arg1, *arg2;
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE){
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_long(arg1);
+ convert_to_long(arg2);
+ longreadlen=arg2->value.lval;
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_prepare(int connection_id, string query)
+ Prepares a statement for execution */
+PHP_FUNCTION(ovrimos_prepare) {
+ pval *arg1, *arg2;
+ SQLH conn;
+ char *query;
+ SQLS stmt;
+
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE){
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_long(arg1);
+ convert_to_string(arg2);
+ conn = (SQLH)(arg1->value.lval-1);
+ query = arg2->value.str.val;
+
+ if(!sqlAllocStmt(conn,&stmt)) {
+ RETURN_FALSE;
+ }
+ if(!sqlPrepare(stmt,query)) {
+ sqlFreeStmt(stmt);
+ RETURN_FALSE;
+ }
+ if(!sqlGetOutputColDescr(stmt)) {
+ sqlFreeStmt(stmt);
+ RETURN_FALSE;
+ }
+ if(!sqlGetParamDescr(stmt)) {
+ sqlFreeStmt(stmt);
+ RETURN_FALSE;
+ }
+ RETURN_LONG((int)stmt+1);
+}
+/* }}} */
+
+/*
+ * Execute prepared SQL statement. Supports only input parameters.
+ */
+/* {{{ proto int ovrimos_execute(int result_id [, array parameters_array])
+ Execute a prepared statement */
+PHP_FUNCTION(ovrimos_execute) {
+ pval *arg1, *arg2;
+ SQLS stmt;
+ int numArgs;
+ int icol, colnb;
+ numArgs = ARG_COUNT(ht);
+
+ if (getParameters(ht, numArgs, &arg1, &arg2) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ stmt=(SQLS)(arg1->value.lval-1);
+ colnb=sqlGetParamNb(stmt);
+
+ if(colnb!=0) {
+ pval **tmp;
+ int arr_elem;
+
+ if (arg2->type != IS_ARRAY){
+ php_error(E_WARNING, "Not an array in call to ovrimos_execute()");
+ RETURN_FALSE;
+ }
+ arr_elem=zend_hash_num_elements(arg2->value.ht);
+ if (arr_elem < colnb) {
+ php_error(E_WARNING,"Not enough parameters in call to ovrimos_execute(): %d instead of %d",arr_elem,colnb);
+ RETURN_FALSE;
+ }
+
+ zend_hash_internal_pointer_reset(arg2->value.ht);
+
+ for(icol=0; icol<colnb; icol++) {
+ int len;
+ cvt_error err;
+ bool ret;
+ char *msg;
+ char buffer[10240];
+ sql_type to_type=sqlGetParamSQLType(stmt,icol);
+ sql_type from_type;
+
+ if (zend_hash_get_current_data(arg2->value.ht, (void **) &tmp) == FAILURE) {
+ php_error(E_WARNING,"Error getting parameter %d in call to ovrimos_execute()", icol);
+ RETURN_FALSE;
+ }
+ convert_to_string(*tmp);
+ if ((*tmp)->type != IS_STRING) {
+ php_error(E_WARNING,"Error converting parameter %d to string in call to ovrimos_execute()",icol);
+ RETURN_FALSE;
+ }
+
+ /* PHP data to param type */
+ from_type.type=T_VARCHAR;
+ from_type.u.length=(*tmp)->value.str.len;
+
+ *buffer=0;
+ memcpy(buffer+1,(*tmp)->value.str.val,from_type.u.length);
+ buffer[from_type.u.length+1]=0;
+
+ ret=type_convert(buffer,&from_type,&to_type,0,&err);
+ switch(err) {
+ case cvt_trunc: msg="Data truncated"; break;
+ case cvt_range: msg="Numeric value out of range"; break;
+ case cvt_prec: msg="Precision lost"; break;
+ case cvt_incomp: msg="Restricted data type attribute violation"; break;
+ case cvt_no: msg="Conversion failed"; break;
+ }
+ if(!ret) {
+ php_error(E_WARNING,"Error converting parameter %d: %s in call to ovrimos_execute()",icol, msg);
+ RETURN_FALSE;
+ }
+
+ len=sql_type_size(to_type)-1;
+ if(!sqlPutParam(stmt,icol,buffer+1,len)) {
+ php_error(E_WARNING, "Could send parameter %d (%d bytes) in call to ovrimos_execute()",icol,len);
+ RETURN_FALSE;
+ }
+ }
+ }
+
+ if(!sqlExec(stmt)) {
+ RETURN_FALSE;
+ }
+
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string ovrimos_cursor(int result_id)
+ Get cursor name */
+PHP_FUNCTION(ovrimos_cursor) {
+ char cname[126];
+ pval *arg1;
+ SQLS stmt;
+
+ if ( getParameters(ht, 1, &arg1) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_long(arg1);
+ stmt=(SQLS)(arg1->value.lval-1);
+ if(!sqlGetCursorName(stmt,cname)) {
+ RETURN_FALSE;
+ }
+ RETURN_STRING(cname,1);
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_exec(int connection_id, string query)
+ Prepare and execute an SQL statement */
+PHP_FUNCTION(ovrimos_exec) {
+ pval *arg1, *arg2;
+ SQLH conn;
+ SQLS stmt;
+ int numArgs;
+ char *query;
+ numArgs = ARG_COUNT(ht);
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ convert_to_string(arg2);
+ conn = (SQLH)(arg1->value.lval-1);
+ query = arg2->value.str.val;
+
+ if(!sqlAllocStmt(conn,&stmt)) {
+ RETURN_FALSE;
+ }
+ if(!sqlExecDirect(stmt,query)) {
+ sqlFreeStmt(stmt);
+ RETURN_FALSE;
+ }
+ if(!sqlGetOutputColDescr(stmt)) {
+ sqlFreeStmt(stmt);
+ RETURN_FALSE;
+ }
+ if(!sqlGetParamDescr(stmt)) {
+ sqlFreeStmt(stmt);
+ RETURN_FALSE;
+ }
+ RETURN_LONG((int)stmt+1);
+}
+/* }}} */
+
+static void column_to_string(SQLS stmt, int i, char *buffer, int *len) {
+ const char *bf=sqlColValue(stmt,i,0);
+ switch(sqlGetOutputColType(stmt,i)) {
+ case T_BIGINT:
+ case T_UBIGINT: {
+ switch(sqlGetOutputColType(stmt,i)) {
+ case T_BIGINT:
+ printsint64(Read(sint64,bf),buffer); break;
+ case T_UBIGINT:
+ printuint64(Read(uint64,bf),buffer); break;
+ }
+ *len=strlen(buffer);
+ } break;
+ case T_INTEGER:
+ sprintf(buffer,"%11ld",Read(sint32,bf));
+ *len=strlen(buffer);
+ break;
+ case T_UINTEGER:
+ sprintf(buffer,"%10lu",Read(uint32,bf));
+ *len=strlen(buffer);
+ break;
+ case T_SMALLINT:
+ sprintf(buffer,"%6hd",Read(sint16,bf));
+ *len=strlen(buffer);
+ break;
+ case T_USMALLINT:
+ sprintf(buffer,"%5hu",Read(uint16,bf));
+ *len=strlen(buffer);
+ break;
+ case T_TINYINT:
+ sprintf(buffer,"%4hd",(sint16)Read(sint8,bf));
+ *len=strlen(buffer);
+ break;
+ case T_UTINYINT:
+ sprintf(buffer,"%3hu",(uint16)Read(uint8,bf));
+ *len=strlen(buffer);
+ break;
+ case T_BIT:
+ sprintf(buffer,"%s",(Read(uint8,bf)==0)?"off":"on");
+ *len=strlen(buffer);
+ break;
+ case T_REAL:
+ sprintf(buffer,"%9.7g",(double)Read(float,bf));
+ *len=strlen(buffer);
+ break;
+
+ case T_FLOAT:
+ case T_DOUBLE:
+ sprintf(buffer,"%19.17g",Read(double,bf));
+ *len=strlen(buffer);
+ break;
+ case T_DECIMAL:
+ case T_NUMERIC: {
+ int prec=sqlGetOutputColPrecision(stmt,i);
+ int scale=sqlGetOutputColScale(stmt,i);
+ sprintf(buffer,"%*.*f",prec+2,scale,Read(double,bf));
+ *len=strlen(buffer);
+ } break;
+ case T_CHAR:
+ case T_VARCHAR:
+ strcpy(buffer,bf);
+ *len=strlen(buffer);
+ break;
+ case T_UNI_CHAR:
+ case T_UNI_VARCHAR:
+ uni_strcpy((uni_char*)buffer,(uni_char*)bf);
+ *len=uni_strlen((uni_char*)buffer);
+ break;
+ case T_BINARY: {
+ int sz=sqlGetOutputColLength(stmt,i);
+ memcpy(buffer,bf,sz);
+ *len=sz;
+ } break;
+
+ case T_VARBINARY: {
+ int sz=Read(uint16,bf);
+ memcpy(buffer,bf+2,sz);
+ *len=sz;
+ } break;
+
+ case T_DATE: {
+ char db[11];
+ if(!sql_date_to_str((uint32*)bf,buffer)) {
+ strcpy(buffer,"Error!");
+ }
+ } break;
+
+ case T_TIME: {
+ int prec=sqlGetOutputColPrecision(stmt,i);
+ if(!sql_time_to_str((uint32*)bf,prec,0,buffer)) {
+ strcpy(buffer,"Error!");
+ }
+ } break;
+
+ case T_TIMESTAMP: {
+ int prec=sqlGetOutputColPrecision(stmt,i);
+ if(!sql_timestamp_to_str((uint32*)bf,prec,0,buffer)) {
+ strcpy(buffer,"Error!");
+ }
+
+ } break;
+
+ case T_LONGVARCHAR:
+ case T_LONGVARBINARY: {
+ if(longreadlen==0) {
+ *buffer=0;
+ *len=0;
+ } else if(!sqlColValueLong(stmt,i,0,0,longreadlen,buffer,len)) {
+ strcpy(buffer,"Error!");
+ }
+ } break;
+ }
+}
+
+/* {{{ proto int ovrimos_fetch_into(int result_id, array result_array [, string how, [int rownumber]])
+ Fetch one result row into an array
+ how: 'Next' (default), 'Prev', 'First', 'Last', 'Absolute'
+ */
+PHP_FUNCTION(ovrimos_fetch_into) {
+ int numArgs;
+ char *s_how;
+ typedef enum { h_next=0, h_prev, h_first, h_last, h_absolute } h_type;
+ h_type how=h_next; /* default */
+ sint32 rownum = 0;
+ pval *arg_id, *arg_how=0, *arg_row=0, *arr, *tmp;
+ SQLS stmt;
+ int icol,colnb;
+ bool ret;
+ numArgs = ARG_COUNT(ht);
+
+ switch(numArgs){
+ case 2:
+ if (getParameters(ht, 2, &arg_id, &arr) == FAILURE)
+ WRONG_PARAM_COUNT;
+ break;
+ case 3:
+ if (getParameters(ht, 3, &arg_id, &arr, &arg_how) == FAILURE)
+ WRONG_PARAM_COUNT;
+ break;
+ case 4:
+ if (getParameters(ht, 4, &arg_id, &arr, &arg_how, &arg_row) == FAILURE)
+ WRONG_PARAM_COUNT;
+ break;
+ default:
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg_id);
+ stmt = (SQLS)(arg_id->value.lval-1);
+
+ if(arg_how!=0) {
+ if(arg_how->type!=IS_STRING) {
+ php_error(E_WARNING, "Third argument not string in ovrimos_fetch_into()");
+ RETURN_FALSE;
+ }
+ s_how = arg_how->value.str.val;
+ if(stricmp(s_how,"next")==0) {
+ how=h_next;
+ } else if(stricmp(s_how,"prev")==0) {
+ how=h_prev;
+ } else if(stricmp(s_how,"first")==0) {
+ how=h_first;
+ } else if(stricmp(s_how,"last")==0) {
+ how=h_last;
+ } else if(stricmp(s_how,"absolute")==0) {
+ how=h_absolute;
+ } else {
+ php_error(E_WARNING, "Third argument not valid in ovrimos_fetch_into()");
+ RETURN_FALSE;
+ }
+ if(arg_row==0 && how==h_absolute) {
+ php_error(E_WARNING, "Fourth argument is required for ABSOLUTE in ovrimos_fetch_into()");
+ RETURN_FALSE;
+ }
+ if(arg_row!=0) {
+ convert_to_long(arg_row);
+ rownum = arg_row->value.lval;
+ switch(how) {
+ case h_next:
+ case h_prev:
+ rownum--; /* Next 1 should send FUNC_CURSOR_NEXT(0) */
+ break;
+ }
+ }
+ }
+
+ if (!ParameterPassedByReference(ht, 2)){ /* 1-based?...*/
+ php_error(E_WARNING, "Array not passed by reference in call to ovrimos_fetch_into()");
+ RETURN_FALSE;
+ }
+
+ if (arr->type != IS_ARRAY){
+ if (array_init(arr) == FAILURE){
+ php_error(E_WARNING, "Can't convert to type Array");
+ RETURN_FALSE;
+ }
+ }
+ switch(how) {
+ case h_absolute:
+ case h_first:
+ ret=sqlCursorFirst(stmt,rownum);
+ break;
+ case h_last:
+ ret=sqlCursorLast(stmt,rownum);
+ break;
+ case h_next:
+ ret=sqlCursorNext(stmt,rownum);
+ break;
+ case h_prev:
+ ret=sqlCursorPrev(stmt,rownum);
+ break;
+ }
+ if(!ret) {
+ RETURN_FALSE;
+ }
+ colnb=sqlGetOutputColNb(stmt);
+ for(icol=0; icol<colnb; icol++) {
+ int len;
+ char buffer[10240];
+ tmp = (pval *) emalloc(sizeof(pval));
+ tmp->refcount=1;
+ tmp->type = IS_STRING;
+ tmp->value.str.len = 0;
+
+ /* Produce column value in 'tmp' ...*/
+ column_to_string(stmt, icol, buffer,&len);
+ tmp->value.str.len=len;
+ tmp->value.str.val=estrndup(buffer,len);
+
+ zend_hash_index_update(arr->value.ht, icol, &tmp, sizeof(pval *), NULL);
+ }
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_fetch_row(int result_id [, int how, [int row_number]])
+ how: 'Next' (default), 'Prev', 'First', 'Last', 'Absolute'
+ Fetch a row */
+PHP_FUNCTION(ovrimos_fetch_row) {
+ int numArgs, i;
+ char *s_how;
+ typedef enum { h_next=0, h_prev, h_first, h_last, h_absolute } h_type;
+ h_type how=h_next; /* default */
+ sint32 rownum = 0;
+ pval *arg_id, *arg_how=0, *arg_row=0;
+ SQLS stmt;
+ bool ret;
+ numArgs = ARG_COUNT(ht);
+
+ switch(numArgs){
+ case 1:
+ if (getParameters(ht, 1, &arg_id) == FAILURE)
+ WRONG_PARAM_COUNT;
+ break;
+ case 2:
+ if (getParameters(ht, 2, &arg_id, &arg_how) == FAILURE)
+ WRONG_PARAM_COUNT;
+ break;
+ case 3:
+ if (getParameters(ht, 3, &arg_id, &arg_how, &arg_row) == FAILURE)
+ WRONG_PARAM_COUNT;
+ break;
+ default:
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg_id);
+ stmt = (SQLS)(arg_id->value.lval-1);
+
+ if(arg_how!=0) {
+ if(arg_how->type!=IS_STRING) {
+ php_error(E_WARNING, "Second argument not string in ovrimos_fetch_row()");
+ RETURN_FALSE;
+ }
+ s_how = arg_how->value.str.val;
+ if(stricmp(s_how,"next")==0) {
+ how=h_next;
+ } else if(stricmp(s_how,"prev")==0) {
+ how=h_prev;
+ } else if(stricmp(s_how,"first")==0) {
+ how=h_first;
+ } else if(stricmp(s_how,"last")==0) {
+ how=h_last;
+ } else if(stricmp(s_how,"absolute")==0) {
+ how=h_absolute;
+ } else {
+ php_error(E_WARNING, "Second argument not valid in ovrimos_fetch_row()");
+ RETURN_FALSE;
+ }
+ if(arg_row==0 && how==4) {
+ php_error(E_WARNING, "Third argument is required for ABSOLUTE in ovrimos_fetch_row()");
+ RETURN_FALSE;
+ }
+ if(arg_row!=0) {
+ convert_to_long(arg_row);
+ rownum = arg_row->value.lval;
+ switch(how) {
+ case h_next:
+ case h_prev:
+ rownum--; /* Next 1 should send FUNC_CURSOR_NEXT(0) */
+ break;
+ }
+ }
+ }
+
+ switch(how) {
+ case h_absolute:
+ case h_first:
+ ret=sqlCursorFirst(stmt,rownum);
+ break;
+ case h_last:
+ ret=sqlCursorLast(stmt,rownum);
+ break;
+ case h_next:
+ ret=sqlCursorNext(stmt,rownum);
+ break;
+ case h_prev:
+ ret=sqlCursorPrev(stmt,rownum);
+ break;
+ }
+ if(!ret) {
+ RETURN_FALSE;
+ }
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto string ovrimos_result(int result_id, mixed field)
+ Get result data */
+PHP_FUNCTION(ovrimos_result) {
+ int numArgs = ARG_COUNT(ht);
+ pval *arg_id, *arg_field;
+ int icol, colnb;
+ SQLS stmt;
+ int len;
+ char buffer[1024];
+
+ if (numArgs!=2 || getParameters(ht, 2, &arg_id, &arg_field) == FAILURE)
+ WRONG_PARAM_COUNT;
+
+ convert_to_long(arg_id);
+ stmt = (SQLS)(arg_id->value.lval-1);
+
+ colnb=sqlGetOutputColNb(stmt);
+
+ if(arg_field->type==IS_STRING) {
+ int i;
+ for(i=0; i<colnb; i++) {
+ if(!stricmp(arg_field->value.str.val,sqlGetOutputColName(stmt,i))) {
+ icol=i;
+ break;
+ }
+ }
+ } else if(arg_field->type==IS_LONG) {
+ icol=arg_field->value.lval-1;
+ } else {
+ php_error(E_WARNING, "Second argument neither number nor string in ovrimos_result()");
+ RETURN_FALSE;
+ }
+ if(icol<0 || icol>colnb) {
+ php_error(E_WARNING, "Unknown column in ovrimos_result()");
+ RETURN_FALSE;
+ }
+ column_to_string(stmt, icol, buffer,&len);
+
+ RETURN_STRINGL(buffer,len,1);
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_result_all(int result_id [, string format])
+ Print result as HTML table */
+PHP_FUNCTION(ovrimos_result_all) {
+ long fetched=0;
+ pval *arg1, *arg2;
+ int numArgs;
+ SQLS stmt;
+ int icol, colnb;
+ char buffer[1024];
+ int len;
+
+ numArgs = ARG_COUNT(ht);
+ if (numArgs == 1){
+ if (getParameters(ht, 1, &arg1) == FAILURE)
+ WRONG_PARAM_COUNT;
+ } else {
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE)
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ stmt = (SQLS)(arg1->value.lval-1);
+
+ colnb=sqlGetOutputColNb(stmt);
+
+ /* Start table tag */
+ if (numArgs == 1){
+ php_printf("<table><tr>");
+ } else {
+ convert_to_string(arg2);
+ php_printf("<table %s ><tr>",arg2->value.str.val);
+ }
+
+ for(icol = 0; icol<colnb; icol++) {
+ php_printf("<th>%s</th>", sqlGetOutputColName(stmt,icol));
+ }
+
+ php_printf("</tr>\n");
+
+ if(sqlCursorFirst(stmt,0)) {
+ do {
+ fetched++;
+ php_printf("<tr>");
+ for(icol=0; icol<colnb; icol++) {
+ column_to_string(stmt, icol, buffer,&len);
+ php_printf("<td>%s</td>",buffer);
+ }
+ php_printf("</tr>\n");
+ } while(sqlCursorNext(stmt,0));
+ }
+ php_printf("</table>\n");
+
+ RETURN_LONG(fetched);
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_free_result(int result_id)
+ Free resources associated with a result */
+PHP_FUNCTION(ovrimos_free_result) {
+ pval *arg1;
+ SQLS stmt;
+
+ if ( getParameters(ht, 1, &arg1) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_long(arg1);
+ stmt=(SQLS)(arg1->value.lval-1);
+ sqlCloseCursor(stmt);
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_num_rows(int result_id)
+ Get number of rows in a result */
+PHP_FUNCTION(ovrimos_num_rows) {
+ uint32 rows;
+ pval *arg1;
+ SQLS stmt;
+
+ if ( getParameters(ht, 1, &arg1) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ stmt=(SQLS)(arg1->value.lval-1);
+
+ sqlGetRowCount(stmt, &rows);
+ RETURN_LONG(rows);
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_num_fields(int result_id)
+ Get number of columns in a result */
+PHP_FUNCTION(ovrimos_num_fields) {
+ pval *arg1;
+ SQLS stmt;
+
+ if ( getParameters(ht, 1, &arg1) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ stmt=(SQLS)(arg1->value.lval-1);
+
+ RETURN_LONG(sqlGetOutputColNb(stmt));
+}
+/* }}} */
+
+/* {{{ proto string ovrimos_field_name(int result_id, int field_number)
+ Get a column name */
+PHP_FUNCTION(ovrimos_field_name) {
+ pval *arg1, *arg2;
+ SQLS stmt;
+ int field;
+
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ convert_to_long(arg2);
+ stmt=(SQLS)(arg1->value.lval-1);
+
+ if (arg2->value.lval < 1){
+ php_error(E_WARNING, "Field numbering starts at 1! in call to ovrimos_field_name()");
+ RETURN_FALSE;
+ }
+
+ field=arg2->value.lval-1;
+
+ if (field>=sqlGetOutputColNb(stmt)){
+ php_error(E_WARNING, "No field at this index (%d) in call to ovrimos_field_name()",field);
+ RETURN_FALSE;
+ }
+
+ RETURN_STRING((char*)sqlGetOutputColName(stmt,field),1);
+}
+/* }}} */
+
+/* {{{ proto string ovrimos_field_type(int result_id, int field_number)
+ Get the datatype of a column */
+PHP_FUNCTION(ovrimos_field_type) {
+ pval *arg1, *arg2;
+ SQLS stmt;
+ int field;
+
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ convert_to_long(arg2);
+ stmt=(SQLS)(arg1->value.lval-1);
+
+ if (arg2->value.lval < 1){
+ php_error(E_WARNING, "Field numbering starts at 1! in call to ovrimos_field_type()");
+ RETURN_FALSE;
+ }
+
+ field=arg2->value.lval-1;
+
+ if (field>=sqlGetOutputColNb(stmt)){
+ php_error(E_WARNING, "No field at this index (%d) in call to ovrimos_field_type()",field);
+ RETURN_FALSE;
+ }
+
+ RETURN_LONG(sqlGetOutputColType(stmt,field));
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_field_len(int result_id, int field_number)
+ Get the length of a column */
+PHP_FUNCTION(ovrimos_field_len) {
+ pval *arg1, *arg2;
+ SQLS stmt;
+ int field;
+
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+
+ convert_to_long(arg1);
+ convert_to_long(arg2);
+ stmt=(SQLS)(arg1->value.lval-1);
+
+ if (arg2->value.lval < 1){
+ php_error(E_WARNING, "Field numbering starts at 1! in call to ovrimos_field_len()");
+ RETURN_FALSE;
+ }
+
+ field=arg2->value.lval-1;
+
+ if (field>=sqlGetOutputColNb(stmt)){
+ php_error(E_WARNING, "No field at this index (%d) in call to ovrimos_field_len()",field);
+ RETURN_FALSE;
+ }
+
+ switch(sqlGetOutputColType(stmt,field)) {
+ case T_LONGVARCHAR:
+ case T_LONGVARBINARY:
+ RETURN_LONG(longreadlen);
+ default:
+ RETURN_LONG(sqlGetOutputColLength(stmt,field));
+ }
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_field_num(int result_id, string field_name)
+ Return column number */
+PHP_FUNCTION(ovrimos_field_num) {
+ pval *arg1, *arg2;
+ SQLS stmt;
+ int i,n;
+
+ if (getParameters(ht, 2, &arg1, &arg2) == FAILURE || arg2->type!=IS_STRING) {
+ WRONG_PARAM_COUNT;
+ }
+ convert_to_long(arg1);
+ stmt=(SQLS)(arg1->value.lval-1);
+ n=sqlGetOutputColNb(stmt);
+ for(i=0; i<n; i++) {
+ if(!strcmp(arg2->value.str.val,sqlGetOutputColName(stmt,i))) {
+ RETURN_LONG(i+1);
+ }
+ }
+ RETURN_FALSE;
+}
+/* }}} */
+
+#if 0
+/* {{{ proto int ovrimos_autocommit(int connection_id, int OnOff)
+ Toggle autocommit mode
+ There can be problems with pconnections!*/
+PHP_FUNCTION(ovrimos_autocommit) {
+}
+/* }}} */
+#endif
+
+/* {{{ proto int ovrimos_commit(int connection_id)
+ Commit an ovrimos transaction */
+PHP_FUNCTION(ovrimos_commit) {
+ pval *arg1;
+ SQLH conn;
+ if(ARG_COUNT(ht)!=1 || getParameters(ht,1,&arg1)==FAILURE || arg1->type!=IS_LONG) {
+ WRONG_PARAM_COUNT;
+ }
+ conn=(SQLH)(arg1->value.lval-1);
+ if(!sqlTransactCommit(conn)) {
+ RETURN_FALSE;
+ }
+ RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ proto int ovrimos_rollback(int connection_id)
+ Rollback a transaction */
+PHP_FUNCTION(ovrimos_rollback) {
+ pval *arg1;
+ SQLH conn;
+ if(ARG_COUNT(ht)!=1 || getParameters(ht,1,&arg1)==FAILURE || arg1->type!=IS_LONG) {
+ WRONG_PARAM_COUNT;
+ }
+ conn=(SQLH)(arg1->value.lval-1);
+ if(!sqlTransactRollback(conn)) {
+ RETURN_FALSE;
+ }
+ RETURN_TRUE;
+}
+/* }}} */
+
+#if 0
+/* {{{ proto int ovrimos_setoption(int conn_id|result_id, int which, int option, int value)
+ Sets connection or statement options */
+PHP_FUNCTION(ovrimos_setoption) {
+}
+/* }}} */
+#endif
+
+function_entry ovrimos_functions[] = {
+/* PHP_FE(ovrimos_setoption, NULL)*/
+/* PHP_FE(ovrimos_autocommit, NULL)*/
+ PHP_FE(ovrimos_close, NULL)
+ PHP_FE(ovrimos_close_all, NULL)
+ PHP_FE(ovrimos_commit, NULL)
+ PHP_FE(ovrimos_connect, NULL)
+ PHP_FE(ovrimos_cursor, NULL)
+ PHP_FE(ovrimos_exec, NULL)
+ PHP_FE(ovrimos_prepare, NULL)
+ PHP_FE(ovrimos_execute, NULL)
+ PHP_FE(ovrimos_fetch_row, NULL)
+ PHP_FE(ovrimos_fetch_into, NULL)
+ PHP_FE(ovrimos_field_len, NULL)
+ PHP_FE(ovrimos_field_name, NULL)
+ PHP_FE(ovrimos_field_type, NULL)
+ PHP_FE(ovrimos_field_num, NULL)
+ PHP_FE(ovrimos_free_result, NULL)
+ PHP_FE(ovrimos_num_fields, NULL)
+ PHP_FE(ovrimos_num_rows, NULL)
+ PHP_FE(ovrimos_result, NULL)
+ PHP_FE(ovrimos_result_all, NULL)
+ PHP_FE(ovrimos_rollback, NULL)
+/* PHP_FE(ovrimos_binmode, NULL)*/
+ PHP_FE(ovrimos_longreadlen, NULL)
+ PHP_FALIAS(ovrimos_do, ovrimos_exec, NULL)
+ { NULL, NULL, NULL }
+};
+
+zend_module_entry ovrimos_module_entry = {
+ "Ovrimos",
+ ovrimos_functions,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ PHP_MINFO(ovrimos),
+ STANDARD_MODULE_PROPERTIES
+};
+
+DLEXPORT zend_module_entry *get_module() { return &ovrimos_module_entry; };
projects / php / commitdiff