Refactor pdo_sqlite (only compilable)

3 files changed, 92 insertions, 113 deletions

diff --git a/ext/pdo_sqlite/php_pdo_sqlite_int.h b/ext/pdo_sqlite/php_pdo_sqlite_int.h
index 288cc6335e..188856a3d1 100644
--- a/ext/pdo_sqlite/php_pdo_sqlite_int.h
+++ b/ext/pdo_sqlite/php_pdo_sqlite_int.h
@@ -38,7 +38,7 @@ struct pdo_sqlite_fci {
 struct pdo_sqlite_func {
 	struct pdo_sqlite_func *next;
 
-	zval *func, *step, *fini;
+	zval func, step, fini;
 	int argc;
 	const char *funcname;
 	
@@ -50,7 +50,7 @@ struct pdo_sqlite_collation {
 	struct pdo_sqlite_collation *next;
 
 	const char *name;
-	zval *callback;
+	zval callback;
 	struct pdo_sqlite_fci fc;
 };
 
diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index bff259e848..24339fa344 100644
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -118,13 +118,13 @@ static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
 		}
 
 		efree((char*)func->funcname);
-		if (func->func) {
+		if (!ZVAL_IS_UNDEF(&func->func)) {
 			zval_ptr_dtor(&func->func);
 		}
-		if (func->step) {
+		if (!ZVAL_IS_UNDEF(&func->step)) {
 			zval_ptr_dtor(&func->step);
 		}
-		if (func->fini) {
+		if (!ZVAL_IS_UNDEF(&func->fini)) {
 			zval_ptr_dtor(&func->fini);
 		}
 		efree(func);
@@ -145,7 +145,7 @@ static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
 		}
 
 		efree((char*)collation->name);
-		if (collation->callback) {
+		if (!ZVAL_IS_UNDEF(&collation->callback)) {
 			zval_ptr_dtor(&collation->callback);
 		}
 		efree(collation);
@@ -285,7 +285,7 @@ static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_valu
 	switch (attr) {
 		case PDO_ATTR_CLIENT_VERSION:
 		case PDO_ATTR_SERVER_VERSION:
-			ZVAL_STRING(return_value, (char *)sqlite3_libversion(), 1);
+			ZVAL_STRING(return_value, (char *)sqlite3_libversion());
 			break;
 		
 		default:
@@ -312,12 +312,12 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 		int argc, sqlite3_value **argv, sqlite3_context *context,
 		int is_agg TSRMLS_DC)
 {
-	zval ***zargs = NULL;
-	zval *retval = NULL;
+	zval *zargs = NULL;
+	zval retval;
 	int i;
 	int ret;
 	int fake_argc;
-	zval **agg_context = NULL;
+	zval *agg_context = NULL;
 	
 	if (is_agg) {
 		is_agg = 2;
@@ -327,55 +327,51 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 	
 	fc->fci.size = sizeof(fc->fci);
 	fc->fci.function_table = EG(function_table);
-	fc->fci.function_name = cb;
+	ZVAL_COPY_VALUE(&fc->fci.function_name, cb);
 	fc->fci.symbol_table = NULL;
-	fc->fci.object_ptr = NULL;
-	fc->fci.retval_ptr_ptr = &retval;
+	fc->fci.object = NULL;
+	fc->fci.retval = &retval;
 	fc->fci.param_count = fake_argc;
 	
 	/* build up the params */
 
 	if (fake_argc) {
-		zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
+		zargs = (zval *)safe_emalloc(fake_argc, sizeof(zval), 0);
 	}
 
 	if (is_agg) {
 		/* summon the aggregation context */
-		agg_context = (zval**)sqlite3_aggregate_context(context, sizeof(zval*));
-		if (!*agg_context) {
+		/* ????
+		agg_context = (zval*)sqlite3_aggregate_context(context, sizeof(zval));
+		if (!agg_context) {
 			MAKE_STD_ZVAL(*agg_context);
 			ZVAL_NULL(*agg_context);
 		}
 		zargs[0] = agg_context;
-
-		zargs[1] = emalloc(sizeof(zval*));
-		MAKE_STD_ZVAL(*zargs[1]);
-		ZVAL_LONG(*zargs[1], sqlite3_aggregate_count(context));
+		*/
+		ZVAL_NULL(&zargs[0]);
+		ZVAL_LONG(&zargs[1], sqlite3_aggregate_count(context));
 	}
 	
 	for (i = 0; i < argc; i++) {
-		zargs[i + is_agg] = emalloc(sizeof(zval *));
-		MAKE_STD_ZVAL(*zargs[i + is_agg]);
-
 		/* get the value */
 		switch (sqlite3_value_type(argv[i])) {
 			case SQLITE_INTEGER:
-				ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
+				ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int(argv[i]));
 				break;
 
 			case SQLITE_FLOAT:
-				ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
+				ZVAL_DOUBLE(&zargs[i + is_agg], sqlite3_value_double(argv[i]));
 				break;
 
 			case SQLITE_NULL:
-				ZVAL_NULL(*zargs[i + is_agg]);
+				ZVAL_NULL(&zargs[i + is_agg]);
 				break;
 
 			case SQLITE_BLOB:
 			case SQLITE3_TEXT:
 			default:
-				ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]),
-						sqlite3_value_bytes(argv[i]), 1);
+				ZVAL_STRINGL(&zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]));
 				break;
 		}
 	}
@@ -391,12 +387,10 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 	/* clean up the params */
 	if (zargs) {
 		for (i = is_agg; i < fake_argc; i++) {
-			zval_ptr_dtor(zargs[i]);
-			efree(zargs[i]);
+			zval_ptr_dtor(&zargs[i]);
 		}
 		if (is_agg) {
-			zval_ptr_dtor(zargs[1]);
-			efree(zargs[1]);
+			zval_ptr_dtor(&zargs[1]);
 		}
 		efree(zargs);
 	}
@@ -404,10 +398,10 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 	if (!is_agg || !argv) {
 		/* only set the sqlite return value if we are a scalar function,
 		 * or if we are finalizing an aggregate */
-		if (retval) {
-			switch (Z_TYPE_P(retval)) {
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			switch (Z_TYPE(retval)) {
 				case IS_LONG:
-					sqlite3_result_int(context, Z_LVAL_P(retval));
+					sqlite3_result_int(context, Z_LVAL(retval));
 					break;
 
 				case IS_NULL:
@@ -415,13 +409,12 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 					break;
 
 				case IS_DOUBLE:
-					sqlite3_result_double(context, Z_DVAL_P(retval));
+					sqlite3_result_double(context, Z_DVAL(retval));
 					break;
 
 				default:
 					convert_to_string_ex(&retval);
-					sqlite3_result_text(context, Z_STRVAL_P(retval),
-						Z_STRLEN_P(retval), SQLITE_TRANSIENT);
+					sqlite3_result_text(context, Z_STRVAL(retval), Z_STRLEN(retval), SQLITE_TRANSIENT);
 					break;
 			}
 		} else {
@@ -436,16 +429,16 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 		 * the context */
 		if (agg_context) {
 			zval_ptr_dtor(agg_context);
-		}
+		}/* ???
 		if (retval) {
 			*agg_context = retval;
 			retval = NULL;
 		} else {
 			*agg_context = NULL;
-		}
+		}*/
 	}
 
-	if (retval) {
+	if (!ZVAL_IS_UNDEF(&retval)) {
 		zval_ptr_dtor(&retval);
 	}
 
@@ -458,7 +451,7 @@ static void php_sqlite3_func_callback(sqlite3_context *context, int argc,
 	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
+	do_callback(&func->afunc, &func->func, argc, argv, context, 0 TSRMLS_CC);
 }
 
 static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
@@ -467,7 +460,7 @@ static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
 	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
+	do_callback(&func->astep, &func->step, argc, argv, context, 1 TSRMLS_CC);
 }
 
 static void php_sqlite3_func_final_callback(sqlite3_context *context)
@@ -475,7 +468,7 @@ static void php_sqlite3_func_final_callback(sqlite3_context *context)
 	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
+	do_callback(&func->afini, &func->fini, 0, NULL, context, 1 TSRMLS_CC);
 }
 
 static int php_sqlite3_collation_callback(void *context,
@@ -483,48 +476,41 @@ static int php_sqlite3_collation_callback(void *context,
 	int string2_len, const void *string2)
 {
 	int ret;
-	zval *zstring1, *zstring2;
-	zval **zargs[2];
-	zval *retval = NULL;
+	zval zargs[2];
+	zval retval;
 	struct pdo_sqlite_collation *collation = (struct pdo_sqlite_collation*) context;
 	TSRMLS_FETCH();
 
 	collation->fc.fci.size = sizeof(collation->fc.fci);
 	collation->fc.fci.function_table = EG(function_table);
-	collation->fc.fci.function_name = collation->callback;
+	ZVAL_COPY_VALUE(&collation->fc.fci.function_name, &collation->callback);
 	collation->fc.fci.symbol_table = NULL;
-	collation->fc.fci.object_ptr = NULL;
-	collation->fc.fci.retval_ptr_ptr = &retval;
+	collation->fc.fci.object = NULL;
+	collation->fc.fci.retval = &retval;
 
 	// Prepare the arguments.
-	MAKE_STD_ZVAL(zstring1);
-	ZVAL_STRINGL(zstring1, (char *) string1, string1_len, 1);
-	zargs[0] = &zstring1;
-	MAKE_STD_ZVAL(zstring2);
-	ZVAL_STRINGL(zstring2, (char *) string2, string2_len, 1);
-	zargs[1] = &zstring2;
+	ZVAL_STRINGL(&zargs[0], (char *) string1, string1_len);
+	ZVAL_STRINGL(&zargs[1], (char *) string2, string2_len);
 	collation->fc.fci.param_count = 2;
 	collation->fc.fci.params = zargs;
 
 	if ((ret = zend_call_function(&collation->fc.fci, &collation->fc.fcc TSRMLS_CC)) == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
-	}
-	else if (retval) {
-		if (Z_TYPE_P(retval) != IS_LONG) {
+	} else if (!ZVAL_IS_UNDEF(&retval)) {
+		if (Z_TYPE(retval) != IS_LONG) {
 			convert_to_long_ex(&retval);
 		}
 		ret = 0;
-		if (Z_LVAL_P(retval) > 0) {
+		if (Z_LVAL(retval) > 0) {
 			ret = 1;
-		}
-		else if (Z_LVAL_P(retval) < 0) {
+		} else if (Z_LVAL(retval) < 0) {
 			ret = -1;
 		}
 		zval_ptr_dtor(&retval);
 	}
 
-	zval_ptr_dtor(zargs[0]);
-	zval_ptr_dtor(zargs[1]);
+	zval_ptr_dtor(&zargs[0]);
+	zval_ptr_dtor(&zargs[1]);
 
 	return ret;
 }
@@ -538,7 +524,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	char *func_name;
 	int func_name_len;
 	long argc = -1;
-	char *cbname = NULL;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -548,15 +534,15 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 		RETURN_FALSE;
 	}
 	
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis() TSRMLS_CC);
 	PDO_CONSTRUCT_CHECK;
 
 	if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 	
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -567,8 +553,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	if (ret == SQLITE_OK) {
 		func->funcname = estrdup(func_name);
 		
-		MAKE_STD_ZVAL(func->func);
-		MAKE_COPY_ZVAL(&callback, func->func);
+		ZVAL_COPY(&func->func, callback);
 		
 		func->argc = argc;
 
@@ -609,7 +594,7 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	char *func_name;
 	int func_name_len;
 	long argc = -1;
-	char *cbname = NULL;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -619,21 +604,21 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 		RETURN_FALSE;
 	}
 	
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis() TSRMLS_CC);
 	PDO_CONSTRUCT_CHECK;
 
 	if (!zend_is_callable(step_callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 	if (!zend_is_callable(fini_callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 	
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -644,11 +629,9 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	if (ret == SQLITE_OK) {
 		func->funcname = estrdup(func_name);
 		
-		MAKE_STD_ZVAL(func->step);
-		MAKE_COPY_ZVAL(&step_callback, func->step);
+		ZVAL_COPY(&func->step, step_callback);
 
-		MAKE_STD_ZVAL(func->fini);
-		MAKE_COPY_ZVAL(&fini_callback, func->fini);
+		ZVAL_COPY(&func->fini, fini_callback);
 		
 		func->argc = argc;
 
@@ -671,7 +654,7 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 	zval *callback;
 	char *collation_name;
 	int collation_name_len;
-	char *cbname = NULL;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -681,15 +664,15 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 		RETURN_FALSE;
 	}
 
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis());
 	PDO_CONSTRUCT_CHECK;
 
 	if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -699,8 +682,7 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 	if (ret == SQLITE_OK) {
 		collation->name = estrdup(collation_name);
 
-		MAKE_STD_ZVAL(collation->callback);
-		MAKE_COPY_ZVAL(&callback, collation->callback);
+		ZVAL_COPY(&collation->callback, callback);
 
 		collation->next = H->collations;
 		H->collations = collation;
diff --git a/ext/pdo_sqlite/sqlite_statement.c b/ext/pdo_sqlite/sqlite_statement.c
index e3ffa3eb0e..83d2a3f238 100644
--- a/ext/pdo_sqlite/sqlite_statement.c
+++ b/ext/pdo_sqlite/sqlite_statement.c
@@ -90,7 +90,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
 			if (param->is_param) {
 				
 				if (param->paramno == -1) {
-					param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name) - 1;
+					param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name->val) - 1;
 				}
 
 				switch (PDO_PARAM_TYPE(param->param_type)) {
@@ -106,18 +106,18 @@ 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_P(param->parameter) == IS_NULL) {
+						if (Z_TYPE(param->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(&param->parameter);
 #if LONG_MAX > 2147483647
-							if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+							if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL(param->parameter))) {
 								return 1;
 							}
 #else
-							if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+							if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL(param->parameter))) {
 								return 1;
 							}
 #endif
@@ -126,31 +126,29 @@ 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_P(param->parameter) == IS_RESOURCE) {
+						if (Z_TYPE(param->parameter) == IS_RESOURCE) {
 							php_stream *stm;
 							php_stream_from_zval_no_verify(stm, &param->parameter);
 							if (stm) {
-								SEPARATE_ZVAL(&param->parameter);
-								Z_TYPE_P(param->parameter) = IS_STRING;
-								Z_STRLEN_P(param->parameter) = php_stream_copy_to_mem(stm,
-									&Z_STRVAL_P(param->parameter), PHP_STREAM_COPY_ALL, 0);
+								zval_ptr_dtor(&param->parameter);
+								ZVAL_STR(&param->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_P(param->parameter) == IS_NULL) {
+						} else if (Z_TYPE(param->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(&param->parameter);
 						}
 						
 						if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
-								Z_STRVAL_P(param->parameter),
-								Z_STRLEN_P(param->parameter),
+								Z_STRVAL(param->parameter),
+								Z_STRLEN(param->parameter),
 								SQLITE_STATIC)) {
 							return 1;	
 						}
@@ -159,15 +157,15 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
 							
 					case PDO_PARAM_STR:
 					default:
-						if (Z_TYPE_P(param->parameter) == IS_NULL) {
+						if (Z_TYPE(param->parameter) == IS_NULL) {
 							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
 								return 1;
 							}
 						} else {
-							convert_to_string(param->parameter);
+							convert_to_string(&param->parameter);
 							if(SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
-									Z_STRVAL_P(param->parameter),
-									Z_STRLEN_P(param->parameter),
+									Z_STRVAL(param->parameter),
+									Z_STRLEN(param->parameter),
 									SQLITE_STATIC)) {
 								return 1;	
 							}
@@ -279,7 +277,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 {
 	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
 	const char *str;
-	zval *flags;
+	zval flags;
 	
 	if (!S->stmt) {
 		return FAILURE;
@@ -291,8 +289,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 	}
 
 	array_init(return_value);
-	MAKE_STD_ZVAL(flags);
-	array_init(flags);
+	array_init(&flags);
 
 	switch (sqlite3_column_type(S->stmt, colno)) {
 		case SQLITE_NULL:
@@ -304,7 +301,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 			break;
 
 		case SQLITE_BLOB:
-			add_next_index_string(flags, "blob");
+			add_next_index_string(&flags, "blob");
 		case SQLITE_TEXT:
 			add_assoc_string(return_value, "native_type", "string");
 			break;
@@ -326,7 +323,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 	}
 #endif
 
-	add_assoc_zval(return_value, "flags", flags);
+	add_assoc_zval(return_value, "flags", &flags);
 
 	return SUCCESS;
 }