2001-07-06 00:04:03 +00:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| PHP version 4.0 |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| This source file is subject to version 2.02 of the PHP license, |
|
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
|
|
| available at through the world-wide-web at |
|
|
|
|
| http://www.php.net/license/2_02.txt. |
|
|
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Authors: Hartmut Holzgraefe <hartmut@six.de> |
|
|
|
|
| |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "php.h"
|
|
|
|
#include "php_ini.h"
|
|
|
|
#include "php_dbplus.h"
|
|
|
|
|
|
|
|
|
|
|
|
#define _STRING(x) ((*x)->value.str.val)
|
|
|
|
#define _INT(x) ((*x)->value.lval)
|
|
|
|
#define _HASH(x) ((*x)->value.ht)
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
#define DBPLUS_FETCH_RESOURCE(r, z) ZEND_FETCH_RESOURCE(r, relf *, z, -1, "dbplus_relation", le_dbplus_relation); \
|
|
|
|
if(!r) RETURN_LONG(ERR_UNKNOWN);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
var2tuple(relf *r, zval **zv, tuple *t)
|
|
|
|
{
|
|
|
|
register attribute *ap ;
|
|
|
|
unsigned deg ;
|
|
|
|
zval **element;
|
|
|
|
|
|
|
|
if ((*zv)->type!=IS_ARRAY)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
rtupinit(r, t);
|
|
|
|
|
|
|
|
ap = r->r_atts;
|
|
|
|
deg = r->r_rel.rel_deg;
|
|
|
|
do {
|
2001-08-11 16:39:07 +00:00
|
|
|
if(SUCCESS!=zend_hash_find((*zv)->value.ht, ap->att_name, strlen(ap->att_name)+1, (void **)&element))
|
2001-07-06 00:04:03 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (! *element) return 1;
|
|
|
|
|
|
|
|
switch(ap->att_type) {
|
|
|
|
case FT_SHORT:
|
|
|
|
convert_to_long_ex(element);
|
|
|
|
AFFIX(ap, t)->f_short = (short) (*element)->value.lval;
|
|
|
|
break;
|
|
|
|
case FT_UNSIGNED:
|
|
|
|
convert_to_long_ex(element);
|
|
|
|
AFFIX(ap, t)->f_unsigned = (unsigned) (*element)->value.lval;
|
|
|
|
break;
|
|
|
|
case FT_SEQUENCE:
|
|
|
|
case FT_LONG:
|
|
|
|
convert_to_long_ex(element);
|
|
|
|
AFFIX(ap, t)->f_long = (long) (*element)->value.lval;
|
|
|
|
break;
|
|
|
|
case FT_DATE:
|
|
|
|
convert_to_long_ex(element);
|
|
|
|
AFFIX(ap, t)->f_date = (long) (*element)->value.lval;
|
|
|
|
break;
|
|
|
|
case FT_FLOAT:
|
|
|
|
convert_to_double_ex(element);
|
|
|
|
AFFIX(ap, t)->f_float = (float) (*element)->value.dval;
|
|
|
|
break;
|
|
|
|
case FT_DOUBLE:
|
|
|
|
convert_to_double_ex(element);
|
|
|
|
AFFIX(ap, t)->f_double = (double) (*element)->value.dval;
|
|
|
|
break;
|
|
|
|
case FT_STRING: case FT_DEUTSCH: case FT_CHAR:
|
|
|
|
convert_to_string_ex(element);
|
|
|
|
afput(ap, t, (field *)0, (*element)->value.str.val);
|
|
|
|
break;
|
|
|
|
case FT_TIMESTAMP:
|
|
|
|
/* TODO
|
|
|
|
str2timestamp(SvPV(sv, na), (timestamp *)AFFIX(ap, t));
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
case FT_BINARY:
|
|
|
|
case FT_BLOB:
|
|
|
|
case FT_MEMO:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (ap++, --deg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
tuple2var(relf * r, tuple * t, zval **zv)
|
|
|
|
{
|
|
|
|
register attribute *ap ;
|
|
|
|
unsigned deg ;
|
|
|
|
char buf[20];
|
|
|
|
zval *element;
|
|
|
|
|
|
|
|
zval_dtor(*zv);
|
|
|
|
if (array_init(*zv) == FAILURE) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ap = r->r_atts;
|
|
|
|
deg = r->r_rel.rel_deg;
|
|
|
|
do {
|
|
|
|
MAKE_STD_ZVAL(element); element->type=IS_NULL;
|
|
|
|
|
|
|
|
switch(ap->att_type) {
|
|
|
|
case FT_SHORT:
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_LONG(element, AFFIX(ap, t)->f_short);
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FT_UNSIGNED:
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_LONG(element, AFFIX(ap, t)->f_unsigned);
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FT_LONG:
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_LONG(element, AFFIX(ap, t)->f_long);
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FT_FLOAT:
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_DOUBLE(element, AFFIX(ap, t)->f_float);
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FT_DOUBLE:
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_DOUBLE(element, AFFIX(ap, t)->f_double);
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FT_STRING: case FT_DEUTSCH: case FT_CHAR:
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_STRING(element, AFVAR(ap, t)->f_string, 1);
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
case FT_P_SHORT: return "FT_P_SHORT";
|
|
|
|
case FT_P_LONG: return "FT_P_LONG";
|
|
|
|
case FT_DATE: return "FT_DATE";
|
|
|
|
case FT_TIME: return "FT_TIME";
|
|
|
|
case FT_BINARY: return "FT_BINARY";
|
|
|
|
case FT_BLOB: return "FT_BLOB";
|
|
|
|
case FT_ANSI: return "FT_ANSI";
|
|
|
|
case FT_TIMESTAMP: return "FT_TIMESTAMP";
|
|
|
|
case FT_SEQUENCE: return "FT_SEQUENCE";
|
|
|
|
case FT_MEMO: return "FT_MEMO";
|
|
|
|
case FT_ISO: return "FT_ISO";
|
|
|
|
case FT_ISOL: return "FT_ISOL";
|
|
|
|
case FT_ANON: return "FT_ANON";
|
|
|
|
case FT_TUPID: return "FT_TUPID";
|
|
|
|
case FT_INVALID: return "FT_INVALID";
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
if(element->type!=IS_NULL)
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_update((*zv)->value.ht,
|
|
|
|
ap->att_name,
|
|
|
|
strlen(ap->att_name)+1,
|
|
|
|
(void *)&element,
|
|
|
|
sizeof(zval*),
|
|
|
|
NULL);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
} while (ap++, --deg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static constraint *
|
|
|
|
ary2constr(relf * r, zval** constr)
|
|
|
|
{
|
|
|
|
attribute *ap;
|
|
|
|
static constraint c;
|
|
|
|
int len;
|
|
|
|
int alen;
|
|
|
|
field *f;
|
|
|
|
enum scalop sop;
|
|
|
|
int n_elems;
|
|
|
|
int n;
|
|
|
|
char * dom;
|
|
|
|
char * val;
|
|
|
|
char * op;
|
|
|
|
zval **zdata;
|
|
|
|
|
|
|
|
/* init first */
|
|
|
|
db_coninit(r, &c);
|
|
|
|
|
|
|
|
if ((*constr)->type != IS_ARRAY) {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Constraint is not an array");
|
2001-07-06 00:04:03 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
zend_hash_internal_pointer_reset(_HASH(constr));
|
2001-08-11 16:39:07 +00:00
|
|
|
if(zend_hash_get_current_data(_HASH(constr), (void **)&zdata)!=SUCCESS) {
|
|
|
|
php_error(E_WARNING, "Constraint array is empty");
|
2001-07-06 00:04:03 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch((*zdata)->type) {
|
|
|
|
case IS_STRING: /* constraints in plain string array */
|
|
|
|
if (_HASH(constr)->nNumOfElements%3) {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Constraint array has to have triples of strings");
|
2001-07-06 00:04:03 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
|
|
|
convert_to_string_ex(zdata);
|
|
|
|
dom = _STRING(zdata);
|
|
|
|
zend_hash_move_forward(_HASH(constr));
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_get_current_data(_HASH(constr), (void **)&zdata);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_string_ex(zdata);
|
|
|
|
op = _STRING(zdata);
|
|
|
|
zend_hash_move_forward(_HASH(constr));
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_get_current_data(_HASH(constr), (void **)&zdata);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_string_ex(zdata);
|
|
|
|
val = _STRING(zdata);
|
|
|
|
zend_hash_move_forward(_HASH(constr));
|
|
|
|
|
|
|
|
if (!(ap = (attribute *) attno (r, dom))) {
|
|
|
|
fprintf(stderr, "Invalid domain \"%s\"\n", dom);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* operator */
|
|
|
|
string_to_scalop(op, &sop);
|
|
|
|
|
|
|
|
/* value */
|
|
|
|
f = string_to_field(val, ap, 0);
|
|
|
|
|
|
|
|
(void) db_constrain(r, &c, dom, sop, f ? f : (field *) val);
|
2001-08-11 16:39:07 +00:00
|
|
|
} while(SUCCESS==zend_hash_get_current_data(_HASH(constr), (void **)&zdata));
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
case IS_ARRAY:
|
|
|
|
{
|
|
|
|
zval **entry;
|
|
|
|
for(zend_hash_internal_pointer_reset(_HASH(constr));
|
2001-08-11 16:39:07 +00:00
|
|
|
SUCCESS==zend_hash_get_current_data(_HASH(constr), (void **)&zdata);
|
2001-07-06 00:04:03 +00:00
|
|
|
zend_hash_move_forward(_HASH(constr))) {
|
|
|
|
if(!((*zdata)->type==IS_ARRAY)) {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Constraint array element not an array");
|
2001-07-06 00:04:03 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if(_HASH(zdata)->nNumOfElements!=3) {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Constraint array element not an array of size 3");
|
2001-07-06 00:04:03 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
zend_hash_internal_pointer_reset(_HASH(zdata));
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_get_current_data(_HASH(zdata), (void **)&entry);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_string_ex(entry);
|
|
|
|
dom=_STRING(entry);
|
|
|
|
|
|
|
|
zend_hash_move_forward(_HASH(zdata));
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_get_current_data(_HASH(zdata), (void **)&entry);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_string_ex(entry);
|
|
|
|
op=_STRING(entry);
|
|
|
|
|
|
|
|
zend_hash_move_forward(_HASH(zdata));
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_get_current_data(_HASH(zdata), (void **)&entry);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_string_ex(entry);
|
|
|
|
val=_STRING(entry);
|
|
|
|
|
|
|
|
if (!(ap = (attribute *) attno (r, dom))) {
|
|
|
|
fprintf(stderr, "Invalid domain \"%s\"\n", dom);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* operator */
|
|
|
|
string_to_scalop(op, &sop);
|
|
|
|
|
|
|
|
/* value */
|
|
|
|
f = string_to_field(val, ap, 0);
|
|
|
|
|
|
|
|
(void) db_constrain(r, &c, dom, sop, f ? f : (field *) val);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* TODO error-handling */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return &c;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_add(int relation, array tuple)
|
|
|
|
Add a tuple to a relation */
|
|
|
|
PHP_FUNCTION(dbplus_add)
|
|
|
|
{
|
|
|
|
zval **relation, **data, **element;
|
|
|
|
enum errorcond stat = ERR_UNKNOWN;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &data) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_array_ex(data);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(var2tuple(r, data, &t))
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat=cdb_add(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_aql(string query [, string server [, string dbpath]])
|
|
|
|
Perform AQL query */
|
|
|
|
PHP_FUNCTION(dbplus_aql)
|
|
|
|
{
|
|
|
|
int argc;
|
|
|
|
zval **query, **server, **dbpath;
|
|
|
|
relf *r;
|
|
|
|
|
|
|
|
argc = ZEND_NUM_ARGS();
|
|
|
|
if (argc < 1 || argc > 3 || zend_get_parameters_ex(argc, &query, &server, &dbpath) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (argc) {
|
|
|
|
case 3:
|
|
|
|
convert_to_string_ex(dbpath);
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Arg dbpath: %s", _STRING(dbpath));
|
2001-07-06 00:04:03 +00:00
|
|
|
/* Fall-through. */
|
|
|
|
case 2:
|
|
|
|
convert_to_string_ex(server);
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Arg server: %s", _STRING(server));
|
2001-07-06 00:04:03 +00:00
|
|
|
/* Fall-through. */
|
|
|
|
case 1:
|
|
|
|
convert_to_string_ex(query);
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Arg query: %s", _STRING(query));
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
r = cdb_aql((argc>=2)?_STRING(server):"localhost",
|
|
|
|
_STRING(query),
|
|
|
|
(argc==3)?_STRING(dbpath):NULL);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(r == NULL) {
|
|
|
|
/* TODO error handling */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, r, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto string dbplus_chdir([string newdir])
|
|
|
|
Get/Set database virtual current directory */
|
|
|
|
PHP_FUNCTION(dbplus_chdir)
|
|
|
|
{
|
|
|
|
int argc;
|
|
|
|
zval **newdir;
|
|
|
|
|
|
|
|
argc = ZEND_NUM_ARGS();
|
|
|
|
if (argc > 1 || zend_get_parameters_ex(1, &newdir) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_string_ex(newdir);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_STRING(cdb_chdir((argc==1)?_STRING(newdir):NULL), 1);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_close(int relation)
|
|
|
|
Close a relation */
|
|
|
|
PHP_FUNCTION(dbplus_close)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
zend_list_delete((*relation)->value.lval);
|
|
|
|
|
|
|
|
RETURN_TRUE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_curr(int relation, array tuple)
|
|
|
|
Get current tuple from relation */
|
|
|
|
PHP_FUNCTION(dbplus_curr)
|
|
|
|
{
|
|
|
|
zval **relation, **tname;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat = cdb_current(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(stat==ERR_NOERR) {
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, tname);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto string dbplus_errcode(int err)
|
|
|
|
Get error string for given errorcode or last error */
|
|
|
|
PHP_FUNCTION(dbplus_errcode)
|
|
|
|
{
|
|
|
|
zval **err;
|
|
|
|
int errno;
|
|
|
|
|
|
|
|
switch (ZEND_NUM_ARGS()) {
|
|
|
|
case 0:
|
|
|
|
errno=-1;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
if( zend_get_parameters_ex(1, &err) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
convert_to_long_ex(err);
|
|
|
|
errno = _INT(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(errno==-1) errno = Acc_error;
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_STRING(dbErrorMsg(errno, NULL), 1);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto string dbplus_errno(void)
|
|
|
|
Get error code for last operation */
|
|
|
|
PHP_FUNCTION(dbplus_errno)
|
|
|
|
{
|
|
|
|
RETURN_LONG(Acc_error);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_find(int relation, array constr, array tuple)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_find)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **constr, **data;
|
|
|
|
constraint *c;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &relation, &constr, &data) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if ((*constr)->type != IS_ARRAY) {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Constraint is not an array");
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_array_ex(data);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
c = ary2constr(r, constr);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if (!c){
|
|
|
|
RETURN_LONG(ERR_USER);
|
|
|
|
}
|
|
|
|
|
|
|
|
stat = cdb_find(r, &t, c);
|
|
|
|
|
|
|
|
if(stat==ERR_NOERR)
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, data);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_first(int relation, array tuple)
|
|
|
|
Get first tuple from relation */
|
|
|
|
PHP_FUNCTION(dbplus_first)
|
|
|
|
{
|
|
|
|
zval **relation, **tname;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat = cdb_first(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(stat==ERR_NOERR) {
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, tname);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_flush(int relation)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_flush)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_flush(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_freealllocks(void)
|
|
|
|
Free all locks held by this client */
|
|
|
|
PHP_FUNCTION(dbplus_freealllocks)
|
|
|
|
{
|
|
|
|
RETURN_LONG(cdbFreeAllLocks());
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_freelock(int relation, array tuple)
|
|
|
|
Give up lock on tuple */
|
|
|
|
PHP_FUNCTION(dbplus_freelock)
|
|
|
|
{
|
|
|
|
zval **relation, **data, **element;
|
|
|
|
enum errorcond stat = ERR_UNKNOWN;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &data) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_array_ex(data);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(var2tuple(r, data, &t))
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat=cdb_freelock(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_freerlocks(int relation)
|
|
|
|
Free all locks on given relation */
|
|
|
|
PHP_FUNCTION(dbplus_freerlocks)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_freerlocks(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_getlock(int relation, array tuple)
|
|
|
|
Request locking of tuple */
|
|
|
|
PHP_FUNCTION(dbplus_getlock)
|
|
|
|
{
|
|
|
|
zval **relation, **data, **element;
|
|
|
|
enum errorcond stat = ERR_UNKNOWN;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &data) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_array_ex(data);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(var2tuple(r, data, &t))
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat=cdb_getlock(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_getunique(int handle, int uniqueid, int flush)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_getunique)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **uniqueid, **flush;
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &relation, &uniqueid, &flush) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
convert_to_long_ex(uniqueid);
|
|
|
|
convert_to_long_ex(flush);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_LONG(cdb_getunique(r, &(_INT(uniqueid)), _INT(flush)));
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_info(int relation, string key, array &result)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_info)
|
|
|
|
{
|
|
|
|
zval **relation, **key, **result, *element;
|
|
|
|
relf *r;
|
|
|
|
register attribute *ap;
|
|
|
|
unsigned deg;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &relation, &key, &result) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
ap = r->r_atts;
|
|
|
|
deg = r->r_rel.rel_deg;
|
|
|
|
|
|
|
|
convert_to_string_ex(key);
|
|
|
|
|
|
|
|
zval_dtor(*result);
|
|
|
|
if (array_init(*result) == FAILURE)
|
|
|
|
RETURN_LONG(ERR_USER);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(!strcmp("atts", (*key)->value.str.val)) {
|
2001-07-06 00:04:03 +00:00
|
|
|
do {
|
|
|
|
MAKE_STD_ZVAL(element);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZVAL_STRING(element, ap->att_name, 1);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
zend_hash_update((*result)->value.ht,
|
|
|
|
ap->att_name,
|
|
|
|
strlen(ap->att_name)+1,
|
|
|
|
(void *)&element,
|
|
|
|
sizeof(zval*),
|
|
|
|
NULL);
|
|
|
|
} while (ap++, deg--);
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_NOERR);
|
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(ERR_USER);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_last(int relation, array tuple)
|
|
|
|
Get last tuple from relation */
|
|
|
|
PHP_FUNCTION(dbplus_last)
|
|
|
|
{
|
|
|
|
zval **relation, **tname;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat = cdb_last(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(stat==ERR_NOERR) {
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, tname);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_lockrel(int relation)
|
|
|
|
Request read-lock on relation */
|
|
|
|
PHP_FUNCTION(dbplus_lockrel)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_lockrel(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_next(int relation, array &tname)
|
|
|
|
Get next tuple from relation */
|
|
|
|
PHP_FUNCTION(dbplus_next)
|
|
|
|
{
|
|
|
|
zval **relation, **tname, *element;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat = cdb_next(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(stat==ERR_NOERR) {
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, tname);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_open(string name)
|
|
|
|
Open a relation file */
|
|
|
|
PHP_FUNCTION(dbplus_open)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **tname;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_string_ex(tname);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
r = cdb_open((*tname)->value.str.val, 1, 1);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(r == NULL) {
|
|
|
|
/* TODO error handling */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, r, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_prev(int relation, array tuple)
|
|
|
|
Get previous tuple from relation */
|
|
|
|
PHP_FUNCTION(dbplus_prev)
|
|
|
|
{
|
|
|
|
zval **relation, **tname;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat = cdb_previous(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(stat==ERR_NOERR) {
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, tname);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_rchperm(int relation, int mask, string user, string group)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_rchperm)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **mask, **user, **group;
|
|
|
|
if (ZEND_NUM_ARGS() != 4 || zend_get_parameters_ex(4, &relation, &mask, &user, &group) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_long_ex(mask);
|
|
|
|
convert_to_string_ex(user);
|
|
|
|
convert_to_string_ex(group);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_LONG(cdbRchperm(r, _INT(mask), _STRING(user), _STRING(group)));
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_restorepos(int relation, array tuple)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_restorepos)
|
|
|
|
{
|
|
|
|
zval **relation, **tname;
|
|
|
|
relf *r;
|
|
|
|
tuple t;
|
|
|
|
int stat;
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat = cdb_next(r, &t);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(stat==ERR_NOERR) {
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &t, tname);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_rkeys(int relation, [string|array] domlist)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_rkeys)
|
|
|
|
{
|
2001-08-11 16:39:07 +00:00
|
|
|
relf *r, *rnew;
|
2001-07-06 00:04:03 +00:00
|
|
|
zval **relation, **domlist, **zdata;
|
|
|
|
int nkeys=0;
|
|
|
|
char *p, *name=NULL, *keys[40]; /* TODO hardcoded magic number ??? */
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &domlist) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if((*domlist)->type == IS_ARRAY) {
|
|
|
|
convert_to_array_ex(domlist);
|
|
|
|
for(zend_hash_internal_pointer_reset(_HASH(domlist));
|
2001-08-11 16:39:07 +00:00
|
|
|
SUCCESS==zend_hash_get_current_data(_HASH(domlist), (void **)&zdata);
|
2001-07-06 00:04:03 +00:00
|
|
|
zend_hash_move_forward(_HASH(domlist))) {
|
|
|
|
if((*zdata)->type==IS_STRING)
|
|
|
|
keys[nkeys++] = _STRING(zdata);
|
|
|
|
else {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Domlist array contains non-string value(s)");
|
2001-07-06 00:04:03 +00:00
|
|
|
Acc_error = ERR_USER;
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
convert_to_string_ex(domlist);
|
|
|
|
name = estrdup(_STRING(domlist));
|
|
|
|
while (p = strtok(nkeys ? 0 : name, " "))
|
|
|
|
keys[nkeys++] = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
rnew = cdbRkeys(r, nkeys, keys);
|
|
|
|
if(name) efree(name);
|
|
|
|
|
|
|
|
if(rnew) {
|
|
|
|
/* TODO realy delete old relation resource ? */
|
|
|
|
zend_list_delete((*relation)->value.lval);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, rnew, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
} else {
|
|
|
|
/* TODO error reporting */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_ropen(string name)
|
|
|
|
Open relation file ... ??? */
|
|
|
|
PHP_FUNCTION(dbplus_ropen)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **tname;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &tname) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_string_ex(tname);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
r = ropen((*tname)->value.str.val, 0, 0);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(r == NULL) {
|
|
|
|
/* TODO error handling */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, r, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_rquery(string name, string dbpath)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_rquery)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **name, **dbpath;
|
|
|
|
int argc;
|
|
|
|
|
|
|
|
if (argc <1 || argc>2 || zend_get_parameters_ex(1, &name, &dbpath) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
r = aql_exec(_STRING(name), (argc==2)?_STRING(dbpath):NULL);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if(!r) {
|
|
|
|
/* TODO error handling */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, r, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_rrename(int relation, string name, int flag)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_rrename)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **name, **flag;
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &relation, &name, &flag) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_string_ex(name);
|
|
|
|
convert_to_long_ex(flag);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_LONG(cdbRrename(r, _STRING(name), (*flag)->value.lval));
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_rsecindex(int relation, string domlist, int compact)
|
|
|
|
*/
|
|
|
|
PHP_FUNCTION(dbplus_rsecindex)
|
|
|
|
{
|
2001-08-11 16:39:07 +00:00
|
|
|
relf *r, *rnew;
|
2001-07-06 00:04:03 +00:00
|
|
|
zval **relation, **domlist, **compact, **zdata;
|
|
|
|
int nkeys=0;
|
|
|
|
char *p, *name=NULL, *keys[40]; /* TODO hardcoded magic number ??? */
|
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &relation, &domlist, &compact) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if((*domlist)->type == IS_ARRAY) {
|
|
|
|
convert_to_array_ex(domlist);
|
|
|
|
for(zend_hash_internal_pointer_reset(_HASH(domlist));
|
2001-08-11 16:39:07 +00:00
|
|
|
SUCCESS==zend_hash_get_current_data(_HASH(domlist), (void **)&zdata);
|
2001-07-06 00:04:03 +00:00
|
|
|
zend_hash_move_forward(_HASH(domlist))) {
|
|
|
|
if((*zdata)->type==IS_STRING)
|
|
|
|
keys[nkeys++] = _STRING(zdata);
|
|
|
|
else {
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Domlist array contains non-string value(s)");
|
2001-07-06 00:04:03 +00:00
|
|
|
Acc_error = ERR_USER;
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
convert_to_string_ex(domlist);
|
|
|
|
name = estrdup(_STRING(domlist));
|
|
|
|
while (p = strtok(nkeys ? 0 : name, " "))
|
|
|
|
keys[nkeys++] = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_long_ex(compact);
|
|
|
|
|
|
|
|
rnew = cdbRsecindex(r, nkeys, keys, _INT(compact));
|
|
|
|
if(name) efree(name);
|
|
|
|
|
|
|
|
if(rnew) {
|
|
|
|
/* TODO realy delete old relation resource ? */
|
|
|
|
zend_list_delete((*relation)->value.lval);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, rnew, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
} else {
|
|
|
|
/* TODO error reporting */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_runlink(int relation)
|
|
|
|
Remove relation from filesystem */
|
|
|
|
PHP_FUNCTION(dbplus_runlink)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdbRunlink(&r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_rzap(int relation, int truncate)
|
|
|
|
Remove all tuples from relation */
|
|
|
|
PHP_FUNCTION(dbplus_rzap)
|
|
|
|
{
|
|
|
|
|
|
|
|
/* todo: optional argument */
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **truncate;
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &truncate) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
convert_to_long_ex(truncate);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_LONG(cdbRzap(r, (*truncate)->value.lval));
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_savepos(int relation)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_savepos)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_savepos(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_setindex(int relation, string idx_name)
|
|
|
|
???? */
|
|
|
|
PHP_FUNCTION(dbplus_setindex)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **idx_name;
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &idx_name) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_string_ex(idx_name);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_LONG(cdb_setindex(r, _STRING(idx_name)));
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_setindexbynumber(int relation, int idx_number)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_setindexbynumber)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation, **idx_number;
|
|
|
|
if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &relation, &idx_number) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_long_ex(idx_number);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
RETURN_LONG(cdb_setindexbynumber(r, (*idx_number)->value.lval));
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_sql(string query, string server, string dbpath)
|
|
|
|
Perform SQL query */
|
|
|
|
PHP_FUNCTION(dbplus_sql)
|
|
|
|
{
|
|
|
|
int argc;
|
|
|
|
zval **query, **server, **dbpath;
|
|
|
|
relf *r;
|
|
|
|
|
|
|
|
argc = ZEND_NUM_ARGS();
|
|
|
|
if (argc < 1 || argc > 3 || zend_get_parameters_ex(argc, &query, &server, &dbpath) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (argc) {
|
|
|
|
case 3:
|
|
|
|
convert_to_string_ex(dbpath);
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Arg dbpath: %s", _STRING(dbpath));
|
2001-07-06 00:04:03 +00:00
|
|
|
/* Fall-through. */
|
|
|
|
case 2:
|
|
|
|
convert_to_string_ex(server);
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Arg server: %s", _STRING(server));
|
2001-07-06 00:04:03 +00:00
|
|
|
/* Fall-through. */
|
|
|
|
case 1:
|
|
|
|
convert_to_string_ex(query);
|
2001-08-11 16:39:07 +00:00
|
|
|
php_error(E_WARNING, "Arg query: %s", _STRING(query));
|
2001-07-06 00:04:03 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
r = cdb_sql((argc>=2)?_STRING(server):"localhost",
|
|
|
|
_STRING(query),
|
|
|
|
(argc==3)?_STRING(dbpath):NULL);
|
2001-07-06 00:04:03 +00:00
|
|
|
if(r == NULL) {
|
|
|
|
/* TODO error handling */
|
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
ZEND_REGISTER_RESOURCE(return_value, r, le_dbplus_relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_tremove(int relation, array old [, array current])
|
|
|
|
Remove tuple and return new current tuple */
|
|
|
|
PHP_FUNCTION(dbplus_tremove)
|
|
|
|
{
|
|
|
|
zval **relation, **old, **current;
|
|
|
|
enum errorcond stat = ERR_UNKNOWN;
|
|
|
|
relf *r;
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple told, tcurr;
|
2001-07-06 00:04:03 +00:00
|
|
|
int argc;
|
|
|
|
|
|
|
|
argc = ZEND_NUM_ARGS();
|
|
|
|
if ( argc<2 || argc>3 || zend_get_parameters_ex(2, &relation, &old, ¤t) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_array_ex(old);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(var2tuple(r, old, &told))
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat=cdbTremove(r, &told, &tcurr);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if((stat==ERR_NOERR) && (argc==3))
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple2var(r, &tcurr, current);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_undo(int relation)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_undo)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_undo(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_undoprepare(int relation)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_undoprepare)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_undoprepare(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_unlockrel(int relation)
|
|
|
|
Give up read-lock on relation */
|
|
|
|
PHP_FUNCTION(dbplus_unlockrel)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_unlockrel(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_unselect(int relation)
|
|
|
|
??? */
|
|
|
|
PHP_FUNCTION(dbplus_unselect)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_unselect(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_update(int relation, array old, array new)
|
|
|
|
Update specified tuple in relation */
|
|
|
|
PHP_FUNCTION(dbplus_update)
|
|
|
|
{
|
|
|
|
zval **relation, **old, **new;
|
|
|
|
enum errorcond stat = ERR_UNKNOWN;
|
|
|
|
relf *r;
|
2001-08-11 16:39:07 +00:00
|
|
|
tuple told, tnew;
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
if (ZEND_NUM_ARGS() != 3 || zend_get_parameters_ex(3, &relation, &old, &new) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
convert_to_array_ex(old);
|
|
|
|
convert_to_array_ex(new);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(var2tuple(r, old, &told))
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
if(var2tuple(r, new, &tnew))
|
2001-07-06 00:04:03 +00:00
|
|
|
RETURN_LONG(ERR_UNKNOWN);
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
stat=cdb_update(r, &told, &tnew);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(stat);
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_xlockrel(int relation)
|
|
|
|
Request exclusive write lock on relation */
|
|
|
|
PHP_FUNCTION(dbplus_xlockrel)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_xlockrel(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int dbplus_xunlockrel(int relation)
|
|
|
|
Free exclusive write lock on relation */
|
|
|
|
PHP_FUNCTION(dbplus_xunlockrel)
|
|
|
|
{
|
|
|
|
relf *r;
|
|
|
|
zval **relation;
|
|
|
|
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &relation) == FAILURE){
|
|
|
|
WRONG_PARAM_COUNT;
|
|
|
|
}
|
|
|
|
|
2001-08-11 16:39:07 +00:00
|
|
|
DBPLUS_FETCH_RESOURCE(r, relation);
|
2001-07-06 00:04:03 +00:00
|
|
|
|
|
|
|
RETURN_LONG(cdb_xunlockrel(r));
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* tab-width: 2
|
|
|
|
* c-basic-offset: 2
|
|
|
|
* End:
|
|
|
|
*/
|