Various bugs fixed

diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 3e0c7e67e27ae830b51a6e3714486b1f073dd377..90ee44f1084733b8efa36974c653e97072330cf5 100644 (file)
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -197,7 +197,7 @@ static PHP_METHOD(PDO, dbh_constructor)
 {
        zval *object = getThis();
        pdo_dbh_t *dbh = NULL;
-       zend_bool is_persistent = FALSE;
+       zend_bool is_persistent = 0;
        char *data_source;
        int data_source_len;
        char *colon;
@@ -277,6 +277,8 @@ static PHP_METHOD(PDO, dbh_constructor)
                zend_resource *le;
                pdo_dbh_t *pdbh = NULL;
 
+               //?? let's delay the persistent supports later
+#if 0
                if ((v = zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_PERSISTENT)) != NULL) {
                        if (Z_TYPE_P(v) == IS_STRING &&
                                !is_numeric_string(Z_STRVAL_P(v), Z_STRLEN_P(v), NULL, NULL, 0) && Z_STRLEN_P(v) > 0) {
@@ -294,6 +296,7 @@ static PHP_METHOD(PDO, dbh_constructor)
                                                password ? password : "");
                        }
                }
+#endif
 
                if (is_persistent) {
                        /* let's see if we have one cached.... */
@@ -448,6 +451,7 @@ static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry
        ZVAL_STRINGL(&z_key, "queryString", sizeof("queryString") - 1);
        std_object_handlers.write_property(object, &z_key, &query_string, -1 TSRMLS_CC);
        zval_ptr_dtor(&query_string);
+       zval_ptr_dtor(&z_key);
 
        if (dbstmt_ce->constructor) {
                zend_fcall_info fci;
@@ -579,7 +583,7 @@ static PHP_METHOD(PDO, prepare)
        php_pdo_dbh_addref(dbh TSRMLS_CC);
        ZVAL_COPY_VALUE(&stmt->database_object_handle, getThis());
        /* we haven't created a lazy object yet */
-       ZVAL_NULL(&stmt->lazy_object_ref);
+       ZVAL_UNDEF(&stmt->lazy_object_ref);
 
        if (dbh->methods->preparer(dbh, statement, statement_len, stmt, options TSRMLS_CC)) {
                pdo_stmt_construct(stmt, return_value, dbstmt_ce, &ctor_args TSRMLS_CC);
@@ -1118,7 +1122,7 @@ static PHP_METHOD(PDO, query)
        php_pdo_dbh_addref(dbh TSRMLS_CC);
        stmt->database_object_handle = *getThis();
        /* we haven't created a lazy object yet */
-       ZVAL_NULL(&stmt->lazy_object_ref);
+       ZVAL_UNDEF(&stmt->lazy_object_ref);
 
        if (dbh->methods->preparer(dbh, statement, statement_len, stmt, NULL TSRMLS_CC)) {
                PDO_STMT_CLEAR_ERR();
@@ -1278,6 +1282,14 @@ const zend_function_entry pdo_dbh_functions[] = {
        {NULL, NULL, NULL}
 };
 
+static void cls_method_dtor(zval *el) {
+       zend_function *func = (zend_function*)Z_PTR_P(el);
+       if (func->common.function_name) {
+               STR_RELEASE(func->common.function_name);
+       }
+       efree(func);
+}
+
 /* {{{ overloaded object handlers for PDO class */
 int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
 {
@@ -1298,7 +1310,7 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
        if (!(dbh->cls_methods[kind] = pemalloc(sizeof(HashTable), dbh->is_persistent))) {
                php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO methods.");
        }
-       zend_hash_init_ex(dbh->cls_methods[kind], 8, NULL, NULL, dbh->is_persistent, 0);
+       zend_hash_init_ex(dbh->cls_methods[kind], 8, NULL, cls_method_dtor, dbh->is_persistent, 0);
 
        while (funcs->fname) {
                ifunc->type = ZEND_INTERNAL_FUNCTION;
@@ -1532,7 +1544,7 @@ static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
                }
        }
 
-       pefree(dbh, dbh->is_persistent);
+       //???pefree(dbh, dbh->is_persistent);
 }
 
 PDO_API void php_pdo_dbh_addref(pdo_dbh_t *dbh TSRMLS_DC)
@@ -1557,6 +1569,7 @@ static void pdo_dbh_free_storage(zend_object *std TSRMLS_DC)
                dbh->methods->persistent_shutdown(dbh TSRMLS_CC);
        }
        zend_object_std_dtor(std TSRMLS_CC);
+       dbh_free(dbh);
 }
 
 zend_object *pdo_dbh_new(zend_class_entry *ce TSRMLS_DC)

diff --git a/ext/pdo/pdo_sqlstate.c b/ext/pdo/pdo_sqlstate.c
index ed81d875b6ecf6eea42f5946719144ba65dfb2d6..4d6a01011c5ffc4a72b09d193bfab04a9c5f4d8b 100644 (file)
--- a/ext/pdo/pdo_sqlstate.c
+++ b/ext/pdo/pdo_sqlstate.c
@@ -319,7 +319,7 @@ int pdo_sqlstate_init_error_table(void)
        for (i = 0; i < sizeof(err_initializer)/sizeof(err_initializer[0]); i++) {
                info = &err_initializer[i];
 
-               zend_hash_str_add_mem(&err_hash, info->state, sizeof(info->state) - 1, &info, sizeof(info));
+               zend_hash_str_add_ptr(&err_hash, info->state, sizeof(info->state), info);
        }
 
        return SUCCESS;
@@ -328,7 +328,7 @@ int pdo_sqlstate_init_error_table(void)
 const char *pdo_sqlstate_state_to_description(char *state)
 {
        const struct pdo_sqlstate_info *info;
-       if ((info = zend_hash_str_find_ptr(&err_hash, state, sizeof(err_initializer[0].state) - 1)) != NULL) {
+       if ((info = zend_hash_str_find_ptr(&err_hash, state, sizeof(err_initializer[0].state))) != NULL) {
                return info->desc;
        }
        return NULL;

diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index fd1c2aff7bfc81572042b5b8d7d09dbdd776b4fb..65ac8a835935018e23947e74c274a255a932088b 100644 (file)
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -256,13 +256,13 @@ int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 
 static void get_lazy_object(pdo_stmt_t *stmt, zval *return_value TSRMLS_DC) /* {{{ */
 {
-       if (Z_TYPE(stmt->lazy_object_ref) == IS_NULL) {
+       if (ZVAL_IS_UNDEF(&stmt->lazy_object_ref)) {
                pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t));
                row->stmt = stmt;
+               zend_object_std_init(&row->std, pdo_row_ce TSRMLS_CC);
                ZVAL_OBJ(&stmt->lazy_object_ref, &row->std);
-               zend_objects_store_put(&row->std TSRMLS_CC);
                row->std.handlers = &pdo_row_object_handlers;
-               stmt->refcount++;
+               stmt->std.gc.refcount++;
        }
        ZVAL_COPY(return_value, &stmt->lazy_object_ref);
 }
@@ -289,6 +289,7 @@ static void param_dtor(zval *el) /* {{{ */
        if (!ZVAL_IS_UNDEF(&param->driver_params)) {
                zval_ptr_dtor(&param->driver_params);
        }
+       efree(param);
 }
 /* }}} */
 
@@ -357,7 +358,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
                if (is_param && param->name->val[0] != ':') {
                        zend_string *temp = STR_ALLOC(param->name->len + 1, 0);
                        temp->val[0] = ':';
-                       memmove(temp->val + 1, param->name->val, param->name->len);
+                       memmove(temp->val + 1, param->name->val, param->name->len + 1);
                        param->name = temp;
                } else {
                        param->name = STR_INIT(param->name->val, param->name->len, 0);
@@ -742,7 +743,7 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
                        zval *val;
 
                        fci->param_count = 0;
-                       fci->params = safe_emalloc(sizeof(zval*), ht->nNumOfElements, 0);
+                       fci->params = safe_emalloc(sizeof(zval), ht->nNumOfElements, 0);
                        ZEND_HASH_FOREACH_VAL(ht, val) {
                                ZVAL_COPY_VALUE(&fci->params[fci->param_count++], val);
                        } ZEND_HASH_FOREACH_END();
@@ -785,7 +786,7 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info *
        }
        
        fci->param_count = num_args; /* probably less */
-       fci->params = safe_emalloc(sizeof(zval**), num_args, 0);
+       fci->params = safe_emalloc(sizeof(zval), num_args, 0);
        
        return 1;
 }
@@ -793,8 +794,8 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info *
 
 static int do_fetch_func_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 {
-       zend_fcall_info * fci = &stmt->fetch.cls.fci;
-       zend_fcall_info_cache * fcc = &stmt->fetch.cls.fcc;
+       zend_fcall_info *fci = &stmt->fetch.cls.fci;
+       zend_fcall_info_cache *fcc = &stmt->fetch.cls.fcc;
 
        if (!make_callable_ex(stmt, &stmt->fetch.func.function, fci, fcc, stmt->column_count TSRMLS_CC)) {
                return 0;
@@ -812,6 +813,7 @@ static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs TSRMLS_DC) /
                efree(stmt->fetch.cls.fci.params);
                stmt->fetch.cls.fci.params = NULL;
        }
+
        stmt->fetch.cls.fci.size = 0;
        if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.ctor_args) && free_ctor_agrs) {
                zval_ptr_dtor(&stmt->fetch.cls.ctor_args);
@@ -1428,7 +1430,11 @@ static PHP_METHOD(PDOStatement, fetchAll)
                        }
                        /* no break */
                case 2:
-                       ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, ctor_args); /* we're not going to free these */
+                       if (ctor_args) {
+                               ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, ctor_args); /* we're not going to free these */
+                       } else {
+                               ZVAL_UNDEF(&stmt->fetch.cls.ctor_args);
+                       }
                        if (Z_TYPE_P(arg2) != IS_STRING) {
                                pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid class name (should be a string)" TSRMLS_CC);
                                error = 1;
@@ -1547,14 +1553,15 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt,
 {
        struct pdo_bound_param_data param = {0};
        long param_type = PDO_PARAM_STR;
+       zval *parameter;
 
        param.paramno = -1;
 
        if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
-                       "lz|llz!", &param.paramno, &param.parameter, &param_type, &param.max_value_len,
+                       "lz|llz!", &param.paramno, &parameter, &param_type, &param.max_value_len,
                        &param.driver_params)) {
                if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|llz!", &param.name,
-                               &param.parameter, &param_type, &param.max_value_len, 
+                               &parameter, &param_type, &param.max_value_len, 
                                &param.driver_params)) {
                        return 0;
                }       
@@ -1569,9 +1576,7 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt,
                return 0;
        }
 
-       if (Z_REFCOUNTED(param.parameter)) {
-               Z_ADDREF(param.parameter);
-       }
+       ZVAL_COPY(&param.parameter, parameter);
        if (!really_register_bound_param(&param, stmt, is_param TSRMLS_CC)) {
                if (!ZVAL_IS_UNDEF(&param.parameter)) {
                        zval_ptr_dtor(&(param.parameter));
@@ -1588,14 +1593,15 @@ static PHP_METHOD(PDOStatement, bindValue)
 {
        struct pdo_bound_param_data param = {0};
        long param_type = PDO_PARAM_STR;
+       zval *parameter;
        PHP_STMT_GET_OBJ;
 
        param.paramno = -1;
        
        if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
-                       "lz/|l", &param.paramno, &param.parameter, &param_type)) {
+                       "lz/|l", &param.paramno, &parameter, &param_type)) {
                if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz/|l", &param.name,
-                               &param.parameter, &param_type)) {
+                               &parameter, &param_type)) {
                        RETURN_FALSE;
                }
        }
@@ -1609,9 +1615,7 @@ static PHP_METHOD(PDOStatement, bindValue)
                RETURN_FALSE;
        }
        
-       if (Z_REFCOUNTED(param.parameter)) {
-               Z_ADDREF(param.parameter);
-       }
+       ZVAL_COPY(&param.parameter, parameter);
        if (!really_register_bound_param(&param, stmt, TRUE TSRMLS_CC)) {
                if (!ZVAL_IS_UNDEF(&param.parameter)) {
                        zval_ptr_dtor(&(param.parameter));
@@ -1867,7 +1871,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
                return SUCCESS;
        }
 
-       args = safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval*), 0);
+       args = safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval), 0);
 
        retval = zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args);
        
@@ -2133,7 +2137,8 @@ static PHP_METHOD(PDOStatement, debugDumpParams)
                        }
 
                        php_stream_printf(out TSRMLS_CC, "paramno=%ld\nname=[%d] \"%.*s\"\nis_param=%d\nparam_type=%d\n",
-                                       param->paramno, param->name->len, param->name->len, param->name ? param->name->val : "",
+                                       param->paramno, param->name? param->name->len : 0, param->name? param->name->len : 0,
+                                       param->name ? param->name->val : "",
                                        param->is_param,
                                        param->param_type);
 
@@ -2192,7 +2197,7 @@ static void dbstmt_prop_write(zval *object, zval *member, zval *value, zend_uint
 
        convert_to_string(member);
 
-       if(strcmp(Z_STRVAL_P(member), "queryString") == 0) {
+       if (strcmp(Z_STRVAL_P(member), "queryString") == 0) {
                pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only" TSRMLS_CC);
        } else {
                std_object_handlers.write_property(object, member, value, cache_slot TSRMLS_CC);
@@ -2261,7 +2266,6 @@ static zend_object *dbstmt_clone_obj(zval *zobject TSRMLS_DC)
        stmt = ecalloc(1, sizeof(pdo_stmt_t) + sizeof(zval) * (Z_OBJCE_P(zobject)->default_properties_count - 1));
        zend_object_std_init(&stmt->std, Z_OBJCE_P(zobject) TSRMLS_CC);
        object_properties_init(&stmt->std, Z_OBJCE_P(zobject));
-       stmt->refcount = 1;
 
        old_stmt = Z_PDO_STMT_P(zobject);
        
@@ -2353,25 +2357,12 @@ static void free_statement(pdo_stmt_t *stmt TSRMLS_DC)
                php_pdo_dbh_delref(stmt->dbh TSRMLS_CC);
        }
        zend_object_std_dtor(&stmt->std TSRMLS_CC);
-       efree(stmt);
-}
-
-PDO_API void php_pdo_stmt_addref(pdo_stmt_t *stmt TSRMLS_DC)
-{
-       stmt->refcount++;
-}
-
-PDO_API void php_pdo_stmt_delref(pdo_stmt_t *stmt TSRMLS_DC)
-{
-       if (--stmt->refcount == 0) {
-               free_statement(stmt TSRMLS_CC);
-       }
 }
 
 void pdo_dbstmt_free_storage(zend_object *std TSRMLS_DC)
 {
        pdo_stmt_t *stmt = php_pdo_stmt_fetch_object(std);
-       php_pdo_stmt_delref(stmt TSRMLS_CC);
+       free_statement(stmt TSRMLS_CC);
 }
 
 zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC)
@@ -2381,7 +2372,6 @@ zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC)
        stmt = ecalloc(1, sizeof(pdo_stmt_t) + sizeof(zval) * (ce->default_properties_count - 1));
        zend_object_std_init(&stmt->std, ce TSRMLS_CC);
        object_properties_init(&stmt->std, ce);
-       stmt->refcount = 1;
 
        stmt->std.handlers = &pdo_dbstmt_object_handlers;
 
@@ -2393,36 +2383,31 @@ zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC)
 
 struct php_pdo_iterator {
        zend_object_iterator iter;
-       pdo_stmt_t *stmt;
        ulong key;
        zval fetch_ahead;
 };
 
 static void pdo_stmt_iter_dtor(zend_object_iterator *iter TSRMLS_DC)
 {
-       struct php_pdo_iterator *I = (struct php_pdo_iterator*)Z_PTR(iter->data);
+       struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
-       if (--I->stmt->refcount == 0) {
-               free_statement(I->stmt TSRMLS_CC);
-       }
+       zval_ptr_dtor(&I->iter.data);
                
        if (!ZVAL_IS_UNDEF(&I->fetch_ahead)) {
                zval_ptr_dtor(&I->fetch_ahead);
        }
-
-       efree(I);
 }
 
 static int pdo_stmt_iter_valid(zend_object_iterator *iter TSRMLS_DC)
 {
-       struct php_pdo_iterator *I = (struct php_pdo_iterator*)Z_PTR(iter->data);
+       struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
        return ZVAL_IS_UNDEF(&I->fetch_ahead) ? FAILURE : SUCCESS;
 }
 
 static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
 {
-       struct php_pdo_iterator *I = (struct php_pdo_iterator*)Z_PTR(iter->data);
+       struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
        /* sanity */
        if (ZVAL_IS_UNDEF(&I->fetch_ahead)) {
@@ -2434,7 +2419,7 @@ static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
 
 static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 {
-       struct php_pdo_iterator *I = (struct php_pdo_iterator*)Z_PTR(iter->data);
+       struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
        if (I->key == (ulong)-1) {
                ZVAL_NULL(key);
@@ -2445,19 +2430,19 @@ static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_D
 
 static void pdo_stmt_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC)
 {
-       struct php_pdo_iterator *I = (struct php_pdo_iterator*)Z_PTR(iter->data);
+       struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
+       pdo_stmt_t *stmt = Z_PDO_STMT_P(&I->iter.data); /* for PDO_HANDLE_STMT_ERR() */
 
        if (!ZVAL_IS_UNDEF(&I->fetch_ahead)) {
                zval_ptr_dtor(&I->fetch_ahead);
        }
 
-       if (!do_fetch(I->stmt, TRUE, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
+       if (!do_fetch(stmt, TRUE, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
                        PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)) {
-               pdo_stmt_t *stmt = I->stmt; /* for PDO_HANDLE_STMT_ERR() */
 
                PDO_HANDLE_STMT_ERR();
                I->key = (ulong)-1;
-               ZVAL_UNREF(&I->fetch_ahead);
+               ZVAL_UNDEF(&I->fetch_ahead);
 
                return;
        }
@@ -2484,12 +2469,11 @@ zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int
        }
 
        I = ecalloc(1, sizeof(struct php_pdo_iterator));
+       zend_iterator_init(&I->iter TSRMLS_CC);
        I->iter.funcs = &pdo_stmt_iter_funcs;
-       ZVAL_PTR(&I->iter.data, I);
-       I->stmt = stmt;
-       stmt->refcount++;
+       ZVAL_COPY(&I->iter.data, object);
 
-       if (!do_fetch(I->stmt, 1, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
+       if (!do_fetch(stmt, 1, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
                        PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)) {
                PDO_HANDLE_STMT_ERR();
                I->key = (ulong)-1;
@@ -2509,8 +2493,10 @@ const zend_function_entry pdo_row_functions[] = {
 
 static zval *row_prop_read(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
-       pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
+       pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object);
+       pdo_stmt_t *stmt = row->stmt;
        int colno = -1;
+       zval zobj;
 
        ZVAL_NULL(rv);
        if (stmt) {
@@ -2532,8 +2518,9 @@ static zval *row_prop_read(zval *object, zval *member, int type, zend_uint cache
                                }
                        }
                        if (strcmp(Z_STRVAL_P(member), "queryString") == 0) {
-                               zval_ptr_dtor(rv);
-                               return std_object_handlers.read_property(object, member, type, cache_slot, rv TSRMLS_CC);
+                               ZVAL_OBJ(&zobj, &stmt->std);
+                               //zval_ptr_dtor(rv);
+                               return std_object_handlers.read_property(&zobj, member, type, cache_slot, rv TSRMLS_CC);
                        }
                }
        }
@@ -2562,7 +2549,8 @@ static void row_dim_write(zval *object, zval *member, zval *value TSRMLS_DC)
 
 static int row_prop_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)
 {
-       pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
+       pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object);
+       pdo_stmt_t *stmt = row->stmt;
        int colno = -1;
 
        if (stmt) {
@@ -2601,7 +2589,8 @@ static void row_dim_delete(zval *object, zval *offset TSRMLS_DC)
 
 static HashTable *row_get_properties(zval *object TSRMLS_DC)
 {
-       pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
+       pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object);
+       pdo_stmt_t *stmt = row->stmt;
        int i;
 
        if (stmt == NULL) {
@@ -2706,20 +2695,17 @@ zend_object_handlers pdo_row_object_handlers = {
 
 void pdo_row_free_storage(zend_object *std TSRMLS_DC)
 {
-       pdo_stmt_t *stmt = php_pdo_stmt_fetch_object(std);
-       if (stmt) {
-               ZVAL_NULL(&stmt->lazy_object_ref);
-               
-               if (--stmt->refcount == 0) {
-                       free_statement(stmt TSRMLS_CC);
-               }
+       pdo_row_t *row = (pdo_row_t *)std;
+       if (row->stmt) {
+               ZVAL_UNDEF(&row->stmt->lazy_object_ref);
+               OBJ_RELEASE(&row->stmt->std);
        }
 }
 
 zend_object *pdo_row_new(zend_class_entry *ce TSRMLS_DC)
 {
        pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t));
-       zend_objects_store_put(&row->std TSRMLS_CC);
+       zend_object_std_init(&row->std, ce TSRMLS_CC);
        row->std.handlers = &pdo_row_object_handlers;
 
        return &row->std;

diff --git a/ext/pdo/php_pdo_driver.h b/ext/pdo/php_pdo_driver.h
index 1112a9ee95064db8c3c21f90deea3e61e9844c33..6a0faaa121dd7830eb1d02423ff44ac5f0f60922 100644 (file)
--- a/ext/pdo/php_pdo_driver.h
+++ b/ext/pdo/php_pdo_driver.h
@@ -606,6 +606,7 @@ struct _pdo_stmt_t {
                int column;
                struct {
                        zend_class_entry *ce;   
+                       void *_reserved;
                        zval ctor_args;            /* freed */
                        zval retval; 
                        zend_fcall_info fci;

diff --git a/ext/pdo_sqlite/sqlite_statement.c b/ext/pdo_sqlite/sqlite_statement.c
index 83d2a3f238572081cf722bce4d6c50fbde19877e..5f18c8a0cf3a4d9bb7702e886bc10d7f5e10c297 100644 (file)
--- a/ext/pdo_sqlite/sqlite_statement.c
+++ b/ext/pdo_sqlite/sqlite_statement.c
@@ -79,6 +79,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                enum pdo_param_event event_type TSRMLS_DC)
 {
        pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+       zval *parameter;
 
        switch (event_type) {
                case PDO_PARAM_EVT_EXEC_PRE:
@@ -106,18 +107,23 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                                        
                                        case PDO_PARAM_INT:
                                        case PDO_PARAM_BOOL:
-                                               if (Z_TYPE(param->parameter) == IS_NULL) {
+                                               if (Z_ISREF(param->parameter)) {
+                                                       parameter = Z_REFVAL(param->parameter);
+                                               } else {
+                                                       parameter = &param->parameter;
+                                               }
+                                               if (Z_TYPE_P(parameter) == IS_NULL) {
                                                        if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
                                                                return 1;
                                                        }
                                                } else {
-                                                       convert_to_long(&param->parameter);
+                                                       convert_to_long(parameter);
 #if LONG_MAX > 2147483647
-                                                       if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL(param->parameter))) {
+                                                       if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
                                                                return 1;
                                                        }
 #else
-                                                       if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL(param->parameter))) {
+                                                       if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
                                                                return 1;
                                                        }
 #endif
@@ -126,46 +132,55 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
                                                return 0;
                                        
                                        case PDO_PARAM_LOB:
-                                               if (Z_TYPE(param->parameter) == IS_RESOURCE) {
+                                               if (Z_ISREF(param->parameter)) {
+                                                       parameter = Z_REFVAL(param->parameter);
+                                               } else {
+                                                       parameter = &param->parameter;
+                                               }
+                                               if (Z_TYPE_P(parameter) == IS_RESOURCE) {
                                                        php_stream *stm;
-                                                       php_stream_from_zval_no_verify(stm, &param->parameter);
+                                                       php_stream_from_zval_no_verify(stm, parameter);
                                                        if (stm) {
-                                                               zval_ptr_dtor(&param->parameter);
-                                                               ZVAL_STR(&param->parameter, php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0));
+                                                               zval_ptr_dtor(parameter);
+                                                               ZVAL_STR(parameter, php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0));
                                                        } else {
                                                                pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
                                                                return 0;
                                                        }
-                                               } else if (Z_TYPE(param->parameter) == IS_NULL) {
+                                               } else if (Z_TYPE_P(parameter) == IS_NULL) {
                                                        if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
                                                                return 1;
                                                        }
                                                        pdo_sqlite_error_stmt(stmt);
                                                        return 0;
                                                } else {
-                                                       convert_to_string(&param->parameter);
+                                                       convert_to_string(parameter);
                                                }
                                                
                                                if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
-                                                               Z_STRVAL(param->parameter),
-                                                               Z_STRLEN(param->parameter),
+                                                               Z_STRVAL_P(parameter),
+                                                               Z_STRLEN_P(parameter),
                                                                SQLITE_STATIC)) {
                                                        return 1;       
                                                }
-                                               pdo_sqlite_error_stmt(stmt);
                                                return 0;
                                                        
                                        case PDO_PARAM_STR:
                                        default:
-                                               if (Z_TYPE(param->parameter) == IS_NULL) {
+                                               if (Z_ISREF(param->parameter)) {
+                                                       parameter = Z_REFVAL(param->parameter);
+                                               } else {
+                                                       parameter = &param->parameter;
+                                               }
+                                               if (Z_TYPE_P(parameter) == IS_NULL) {
                                                        if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
                                                                return 1;
                                                        }
                                                } else {
-                                                       convert_to_string(&param->parameter);
-                                                       if(SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
-                                                                       Z_STRVAL(param->parameter),
-                                                                       Z_STRLEN(param->parameter),
+                                                       convert_to_string(parameter);
+                                                       if (SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
+                                                                       Z_STRVAL_P(parameter),
+                                                                       Z_STRLEN_P(parameter),
                                                                        SQLITE_STATIC)) {
                                                                return 1;       
                                                        }

diff --git a/ext/sqlite3/sqlite3.c b/ext/sqlite3/sqlite3.c
index f5449ca9439889127d44b94bebb03b287e0ed5ef..bfbb3fbdd11d69fdc8e57190d66322e2f00e0717 100644 (file)
--- a/ext/sqlite3/sqlite3.c
+++ b/ext/sqlite3/sqlite3.c
@@ -1455,48 +1455,49 @@ PHP_METHOD(sqlite3stmt, execute)
 
        if (stmt_obj->bound_params) {
                ZEND_HASH_FOREACH_PTR(stmt_obj->bound_params, param) {
-                       zval parameter;
-                       ZVAL_COPY_VALUE(&parameter, &param->parameter);
-
-                       if (Z_ISREF_P(&parameter)) {
-                               ZVAL_DUP(&parameter, Z_REFVAL(parameter));
+                       zval *parameter;
+                       /* parameter must be a reference? */
+                       if (Z_ISREF(param->parameter)) {
+                               parameter = Z_REFVAL(param->parameter);
+                       } else {
+                               parameter = &param->parameter;
                        }
 
                        /* If the ZVAL is null then it should be bound as that */
-                       if (Z_TYPE(parameter) == IS_NULL) {
+                       if (Z_TYPE_P(parameter) == IS_NULL) {
                                sqlite3_bind_null(stmt_obj->stmt, param->param_number);
                                continue;
                        }
 
                        switch (param->type) {
                                case SQLITE_INTEGER:
-                                       convert_to_long(&parameter);
+                                       convert_to_long(parameter);
 #if LONG_MAX > 2147483647
-                                       sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL(parameter));
+                                       sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL_P(parameter));
 #else
-                                       sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL(parameter));
+                                       sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(parameter));
 #endif
                                        break;
 
                                case SQLITE_FLOAT:
                                        /* convert_to_double(parameter);*/
-                                       sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL(parameter));
+                                       sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(parameter));
                                        break;
 
                                case SQLITE_BLOB:
                                {
                                        php_stream *stream = NULL;
                                        zend_string *buffer;
-                                       if (Z_TYPE(parameter) == IS_RESOURCE) {
-                                               php_stream_from_zval_no_verify(stream, &parameter);
+                                       if (Z_TYPE_P(parameter) == IS_RESOURCE) {
+                                               php_stream_from_zval_no_verify(stream, parameter);
                                                if (stream == NULL) {
                                                        php_sqlite3_error(stmt_obj->db_obj, "Unable to read stream for parameter %ld", param->param_number);
                                                        RETURN_FALSE;
                                                }
                                                buffer = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
                                        } else {
-                                               convert_to_string(&parameter);
-                                               buffer = Z_STR(parameter);
+                                               convert_to_string(parameter);
+                                               buffer = Z_STR_P(parameter);
                                        }
 
                                        sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer->val, buffer->len, SQLITE_TRANSIENT);
@@ -1508,8 +1509,8 @@ PHP_METHOD(sqlite3stmt, execute)
                                }
 
                                case SQLITE3_TEXT:
-                                       convert_to_string(&parameter);
-                                       sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL(parameter), Z_STRLEN(parameter), SQLITE_STATIC);
+                                       convert_to_string(parameter);
+                                       sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), SQLITE_STATIC);
                                        break;
 
                                case SQLITE_NULL: