Changeset 76

Show
Ignore:
Timestamp:
07/22/08 08:48:15 (1 month ago)
Author:
scott
Message:

More refactoring, breaks some tests for the moment

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/php_sqlite3.h

    r74 r76  
    109109        sqlite3 *db; 
    110110        php_sqlite3_func *funcs; 
     111} php_sqlite3_db_object; 
    111112 
    112         zend_llist stmt_list; 
    113 } php_sqlite3_db_object; 
     113/*typedef struct _php_sqlite3_stmt { 
     114        sqlite3_stmt *stmt; 
     115        int initialised; 
     116} php_sqlite3_stmt;*/ 
    114117 
    115118/* sqlite3 objects to be destroyed */ 
     
    124127typedef struct _php_sqlite3_result_object  { 
    125128        zend_object zo; 
    126         sqlite3_stmt **intern_stmt; 
     129        sqlite3_stmt *intern_stmt; 
    127130        php_sqlite3_db_object *db_obj; 
    128131        int initialised; 
     
    130133        int is_prepared_statement; 
    131134        int complete; 
    132         int buffered; 
    133  
    134         long num_rows; 
    135135} php_sqlite3_result; 
    136136 
     
    141141        php_sqlite3_db_object *db_obj; 
    142142        int initialised; 
    143          
     143 
    144144        /* Keep track of the zvals for bound parameters */ 
    145145        HashTable *bound_params; 
  • trunk/sqlite3.c

    r74 r76  
    4040static int php_sqlite3_compare_stmt_free( php_sqlite3_stmt_free_list **stmt_list, sqlite3_stmt *statement ); 
    4141 
     42#define SQLITE3_CHECK_INITIALIZED(member, class_name) \ 
     43        if (!(member)) { \ 
     44                php_error_docref(NULL TSRMLS_CC, E_WARNING, "The " #class_name " object has not been correctly initialised"); \ 
     45                RETURN_FALSE; \ 
     46        } 
     47 
    4248/* {{{ PHP_INI 
    4349 */ 
     
    148154        } 
    149155 
    150         zend_llist_clean(&(db_obj->stmt_list)); 
    151156        if (db_obj->initialised) { 
    152157                errcode = sqlite3_close(db_obj->db); 
     
    173178        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    174179 
     180        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
     181 
    175182        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 
    176183                                &sql, &sql_len)) { 
     
    215222        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    216223 
     224        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
     225 
    217226        if (ZEND_NUM_ARGS() != 0) { 
    218227                WRONG_PARAM_COUNT; 
     
    232241        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    233242 
     243        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
     244 
    234245        if (ZEND_NUM_ARGS() != 0) { 
    235246                WRONG_PARAM_COUNT; 
     
    248259        zval *object = getThis(); 
    249260        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
     261 
     262        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
    250263 
    251264        if (ZEND_NUM_ARGS() != 0) { 
     
    268281        int extension_len, extension_dir_len; 
    269282        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
     283 
     284        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
    270285 
    271286        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 
     
    329344        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    330345 
     346        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
     347 
    331348        if (ZEND_NUM_ARGS() != 0) { 
    332349                WRONG_PARAM_COUNT; 
     
    342359PHP_METHOD(sqlite3, escapeString) 
    343360{ 
    344         php_sqlite3_db_object *db_obj; 
    345         zval *object = getThis(); 
    346361        char *sql, *ret; 
    347362        int sql_len; 
    348         db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    349363 
    350364        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 
     
    371385{ 
    372386        php_sqlite3_db_object *db_obj; 
    373         php_sqlite3_stmt *internp
     387        php_sqlite3_stmt *stmt_obj
    374388        zval *object = getThis(); 
    375389        char *sql; 
     
    377391        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    378392 
     393        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
     394 
    379395        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 
    380396                                &sql, &sql_len)) { 
     
    387403 
    388404        object_init_ex(return_value, php_sqlite3_stmt_entry); 
    389         internp = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC); 
    390         internp->db_obj = db_obj; 
    391  
    392         errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(internp->stmt), NULL); 
     405        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC); 
     406        stmt_obj->db_obj = db_obj; 
     407         
     408        errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL); 
    393409        if (errcode != SQLITE_OK) { 
    394410                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to prepare statement: %d, %s", errcode, sqlite3_errmsg(db_obj->db)); 
     411                zval_dtor(return_value); 
    395412                RETURN_FALSE; 
    396413        } 
     
    409426        int sql_len, return_code; 
    410427        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
     428 
     429        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
    411430 
    412431        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 
     
    432451        result->db_obj = db_obj; 
    433452 
    434         return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, result->intern_stmt, NULL); 
     453        return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(result->intern_stmt), NULL); 
    435454        if (return_code != SQLITE_OK) { 
    436455                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db)); 
    437                 efree(result->intern_stmt); 
    438456                result->intern_stmt = NULL; 
    439457                RETURN_FALSE; 
    440458        } 
    441459 
    442  
    443         return_code = sqlite3_step(*(result->intern_stmt)); 
    444         result->num_rows = 0; 
     460        result->initialised = 1; 
     461        return_code = sqlite3_step(result->intern_stmt); 
    445462 
    446463        switch (return_code) { 
    447464                case SQLITE_ROW: /* Valid Row */ 
    448                 { 
    449 #ifdef scottmac_0 
    450                         /* loop through to fill numRows */ 
    451                         do 
    452                         { 
    453                                 result->num_rows++; 
    454                         } while (sqlite3_step(*(result->intern_stmt)) == SQLITE_ROW); 
    455 #endif 
    456                 } 
    457                 /* No break is intentional */ 
    458465                case SQLITE_DONE: /* Valid but no results */ 
    459466                { 
    460                         php_sqlite3_stmt_free_list *free_item; 
     467                        /*php_sqlite3_stmt_free_list *free_item; 
    461468                        free_item = emalloc(sizeof(php_sqlite3_stmt_free_list)); 
    462                         free_item->stmt = *(result->intern_stmt)
     469                        free_item->stmt = result->intern_stmt
    463470                        free_item->statement_object = NULL; 
    464471                        free_item->result_object = return_value; 
    465                         Z_ADDREF_P(return_value); 
    466                         zend_llist_add_element(&(db_obj->stmt_list), &free_item); 
    467                         sqlite3_reset(*(result->intern_stmt)); 
     472                        //Z_ADDREF_P(return_value); 
     473                        zend_llist_add_element(&(db_obj->stmt_list), &free_item);*/ 
     474                        sqlite3_reset(result->intern_stmt); 
    468475                        break; 
    469476                } 
    470477                default: 
    471478                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db)); 
    472                         sqlite3_finalize(*(result->intern_stmt)); 
     479                        sqlite3_finalize(result->intern_stmt); 
     480                        zval_dtor(return_value); 
    473481                        RETURN_FALSE; 
    474482        } 
     
    519527        sqlite3_stmt *stmt; 
    520528        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
     529 
     530        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
    521531 
    522532        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", 
     
    763773        long sql_func_num_args = -1; 
    764774 
     775        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
     776 
    765777        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
    766778 
     
    813825        zval *step_callback, *fini_callback; 
    814826        long sql_func_num_args = -1; 
    815  
    816827        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); 
     828 
     829        SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) 
    817830 
    818831        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &sql_func, &sql_func_len, &step_callback, &fini_callback, &sql_func_num_args) == FAILURE) { 
     
    868881PHP_METHOD(sqlite3_stmt, paramCount) 
    869882{ 
    870         php_sqlite3_stmt *internp; 
    871         zval *object = getThis(); 
    872  
    873         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     883        php_sqlite3_stmt *stmt_obj; 
     884        zval *object = getThis(); 
     885        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    874886 
    875887        if (ZEND_NUM_ARGS() != 0) { 
     
    877889        } 
    878890 
    879         RETURN_LONG(sqlite3_bind_parameter_count(internp->stmt)); 
     891        RETURN_LONG(sqlite3_bind_parameter_count(stmt_obj->stmt)); 
    880892} 
    881893/* }}} */ 
     
    886898PHP_METHOD(sqlite3_stmt, close) 
    887899{ 
    888         php_sqlite3_stmt *internp; 
    889         zval *object = getThis(); 
    890  
    891         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     900        php_sqlite3_stmt *stmt_obj; 
     901        zval *object = getThis(); 
     902        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    892903 
    893904        if (ZEND_NUM_ARGS() != 0) { 
     
    895906        } 
    896907 
    897         zend_llist_del_element(&(internp->db_obj->stmt_list), internp->stmt, 
    898                                                         (int (*)(void *, void *)) php_sqlite3_compare_stmt_free); 
     908        /*zend_llist_del_element(&(stmt_obj->db_obj->stmt_list), stmt_obj->stmt, 
     909                                                        (int (*)(void *, void *)) php_sqlite3_compare_stmt_free);*/ 
    899910 
    900911        RETURN_TRUE; 
     
    907918PHP_METHOD(sqlite3_stmt, reset) 
    908919{ 
    909         php_sqlite3_stmt *internp; 
    910         zval *object = getThis(); 
    911  
    912         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     920        php_sqlite3_stmt *stmt_obj; 
     921        zval *object = getThis(); 
     922        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    913923 
    914924        if (ZEND_NUM_ARGS() != 0) { 
     
    916926        } 
    917927 
    918         if (sqlite3_reset(internp->stmt) != SQLITE_OK) { 
    919                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(internp->stmt))); 
     928        if (sqlite3_reset(stmt_obj->stmt) != SQLITE_OK) { 
     929                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt))); 
    920930                RETURN_FALSE; 
    921931        } 
     
    929939PHP_METHOD(sqlite3_stmt, clear) 
    930940{ 
    931         php_sqlite3_stmt *internp; 
    932         zval *object = getThis(); 
    933  
    934         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     941        php_sqlite3_stmt *stmt_obj; 
     942        zval *object = getThis(); 
     943        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    935944 
    936945        if (ZEND_NUM_ARGS() != 0) { 
     
    938947        } 
    939948 
    940         if (sqlite3_clear_bindings(internp->stmt) != SQLITE_OK) { 
    941                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(internp->stmt))); 
     949        if (sqlite3_clear_bindings(stmt_obj->stmt) != SQLITE_OK) { 
     950                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt))); 
    942951                RETURN_FALSE; 
    943952        } 
     
    946955} 
    947956/* }}} */ 
    948  
    949 #if scottmac_0 
    950 /* {{{ proto bool SQLite3_stmt::bind_params(string types, mixed variable [,mixed,....]) 
    951         Bind Paramater to a stmt variable 
    952 */ 
    953 PHP_METHOD(sqlite3_stmt, bind_params) 
    954 { 
    955         php_sqlite3_stmt *internp; 
    956         zval *object = getThis(); 
    957         int argc = ZEND_NUM_ARGS(); 
    958         char *types; 
    959         int types_len, num_varargs, i, ofs = 0; 
    960         zval ***varargs = NULL; 
    961  
    962         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    963  
    964         if (argc < 2) { 
    965                 WRONG_PARAM_COUNT; 
    966         } 
    967  
    968         if (zend_parse_parameters(1 TSRMLS_CC, "s", 
    969                                 &types, &types_len) == FAILURE) { 
    970                 return; 
    971         } 
    972  
    973         num_varargs = argc - 1; 
    974  
    975         if (!types_len) { 
    976                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "No parameter types specified"); 
    977                 RETURN_FALSE; 
    978         } 
    979  
    980         if (types_len != num_varargs) { 
    981                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of parameter types specified does not match number of bind variables"); 
    982                 RETURN_FALSE; 
    983         } 
    984  
    985         if (types_len != sqlite3_bind_parameter_count(internp->stmt)) { 
    986                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of bind variables does not match number of parameters in prepared statement"); 
    987                 RETURN_FALSE; 
    988         } 
    989  
    990         varargs = (zval ***)safe_emalloc(argc, sizeof(zval **), 0); 
    991  
    992         if (zend_get_parameters_array_ex(argc, varargs) == FAILURE) { 
    993                 zend_wrong_param_count(TSRMLS_C); 
    994                 efree(varargs); 
    995                 RETURN_FALSE; 
    996         } 
    997  
    998         for (i = 1; i <= sqlite3_bind_parameter_count(internp->stmt); i++) { 
    999                 switch (types[ofs]) { 
    1000                         case 'i': /* Integer */ 
    1001                                 sqlite3_bind_int(internp->stmt, i, Z_LVAL_PP(varargs[i])); 
    1002                         break; 
    1003  
    1004                         case 'd': /* double */ 
    1005                                 sqlite3_bind_double(internp->stmt, i, Z_DVAL_PP(varargs[i])); 
    1006                         break; 
    1007  
    1008                         case 'b': /* blob */ 
    1009                         case 's': /* string */ 
    1010                                 sqlite3_bind_text(internp->stmt, i, Z_STRVAL_PP(varargs[i]), Z_STRLEN_PP(varargs[i]), SQLITE_STATIC); 
    1011                         break; 
    1012  
    1013                         case 'n': /* null */ 
    1014                                 sqlite3_bind_null(internp->stmt, i); 
    1015                         break; 
    1016  
    1017                 } 
    1018                 ofs++; 
    1019         } 
    1020  
    1021         efree(varargs); 
    1022         RETURN_TRUE; 
    1023 } 
    1024 /* }}} */ 
    1025 #endif 
    1026957 
    1027958static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *param, php_sqlite3_stmt *stmt TSRMLS_DC) /* {{{ */ 
     
    10751006PHP_METHOD(sqlite3_stmt, bindParam) 
    10761007{ 
    1077         php_sqlite3_stmt *internp
     1008        php_sqlite3_stmt *stmt_obj
    10781009        zval *object = getThis(); 
    10791010        struct php_sqlite3_bound_param param = {0}; 
    1080         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     1011        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    10811012 
    10821013        param.param_number = -1; 
     
    10931024        Z_ADDREF_P(param.parameter); 
    10941025 
    1095         if (!register_bound_parameter_to_sqlite(&param, internp TSRMLS_CC)) { 
     1026        if (!register_bound_parameter_to_sqlite(&param, stmt_obj TSRMLS_CC)) { 
    10961027                if (param.parameter) { 
    10971028                        zval_ptr_dtor(&(param.parameter)); 
     
    11091040PHP_METHOD(sqlite3_stmt, bindValue) 
    11101041{ 
    1111         php_sqlite3_stmt *internp
     1042        php_sqlite3_stmt *stmt_obj
    11121043        zval *object = getThis(); 
    11131044        struct php_sqlite3_bound_param param = {0}; 
    1114         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     1045        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    11151046 
    11161047        param.param_number = -1; 
     
    11271058        Z_ADDREF_P(param.parameter); 
    11281059 
    1129         if (!register_bound_parameter_to_sqlite(&param, internp TSRMLS_CC)) { 
     1060        if (!register_bound_parameter_to_sqlite(&param, stmt_obj TSRMLS_CC)) { 
    11301061                if (param.parameter) { 
    11311062                        zval_ptr_dtor(&(param.parameter)); 
     
    11431074PHP_METHOD(sqlite3_stmt, execute) 
    11441075{ 
    1145         php_sqlite3_stmt *internp
     1076        php_sqlite3_stmt *stmt_obj
    11461077        php_sqlite3_result *result; 
    11471078        zval *object = getThis(); 
    1148         int return_code = 0, num_rows = 0
     1079        int return_code = 0
    11491080        struct php_sqlite3_bound_param *param; 
    1150         internp = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
     1081        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); 
    11511082 
    11521083        if (ZEND_NUM_ARGS() != 0) { 
     
    11541085        } 
    11551086 
    1156         if (internp->bound_params) { 
    1157                 zend_hash_internal_pointer_reset(internp->bound_params); 
    1158                 while (zend_hash_get_current_data(internp->bound_params, (void **)&param) == SUCCESS) { 
     1087        if (stmt_obj->bound_params) { 
     1088                zend_hash_internal_pointer_reset(stmt_obj->bound_params); 
     1089                while (zend_hash_get_current_data(stmt_obj->bound_params, (void **)&param) == SUCCESS) { 
    11591090                        /* If the ZVAL is null then it should be bound as that */ 
    11601091                        if (Z_TYPE_P(param->parameter) == IS_NULL) { 
    1161                                 sqlite3_bind_null(internp->stmt, param->param_number); 
     1092                                sqlite3_bind_null(stmt_obj->stmt, param->param_number); 
    11621093                                continue; 
    11631094                        } 
     
    11661097                                case SQLITE_INTEGER: 
    11671098                                        convert_to_long(param->parameter); 
    1168                                         sqlite3_bind_int(internp->stmt, param->param_number, Z_LVAL_P(param->parameter)); 
     1099                                        sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter)); 
    11691100                                        break; 
    11701101 
    11711102                                case SQLITE_FLOAT: 
    11721103                                        /* convert_to_double(param->parameter);*/ 
    1173                                         sqlite3_bind_double(internp->stmt, param->param_number, Z_DVAL_P(param->parameter)); 
     1104                                        sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(param->parameter)); 
    11741105                                        break; 
    11751106 
     
    11921123                                        } 
    11931124 
    1194                                         sqlite3_bind_blob(internp->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT); 
     1125                                        sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT); 
    11951126 
    11961127                                        if (stream) { 
     
    12021133                                case SQLITE3_TEXT: 
    12031134                                        convert_to_string(param->parameter); 
    1204                                         sqlite3_bind_text(internp->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC); 
     1135                                        sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC); 
    12051136                                        break; 
    12061137 
    12071138                                case SQLITE_NULL: 
    1208                                         sqlite3_bind_null(internp->stmt, param->param_number); 
     1139                                        sqlite3_bind_null(stmt_obj->stmt, param->param_number); 
    12091140                                        break; 
    12101141 
     
    12131144                                        RETURN_FALSE; 
    12141145                        } 
    1215                         zend_hash_move_forward(internp->bound_params); 
    1216                 } 
    1217         } 
    1218  
    1219         return_code = sqlite3_step(internp->stmt); 
     1146                        zend_hash_move_forward(stmt_obj->bound_params); 
     1147                } 
     1148        } 
     1149 
     1150        return_code = sqlite3_step(stmt_obj->stmt); 
    12201151 
    12211152        switch (return_code) { 
    12221153                case SQLITE_ROW: /* Valid Row */ 
    1223 #ifdef scottmac_0 
    1224                         /* loop through to fill numRows */ 
    1225                         do 
    1226                         { 
    1227                                 num_rows++; 
    1228                         } while (sqlite3_step(internp->stmt) == SQLITE_ROW); 
    1229 #endif 
    12301154                case SQLITE_DONE: /* Valid but no results */ 
    12311155                { 
    1232                         php_sqlite3_stmt_free_list *free_item; 
    1233  
    1234                         sqlite3_reset(internp->stmt); 
     1156                        sqlite3_reset(stmt_obj->stmt); 
    12351157                        object_init_ex(return_value, php_sqlite3_result_entry); 
    12361158                        result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC); 
    12371159 
    1238                         free_item = emalloc(sizeof(php_sqlite3_stmt_free_list)); 
    1239                         free_item->stmt = internp->stmt; 
    1240                         free_item->statement_object = object; 
    1241                         free_item->result_object = return_value; 
    1242                         Z_ADDREF_P(object); 
    1243                         Z_ADDREF_P(return_value); 
    1244  
    1245                         zend_llist_add_element(&(internp->db_obj->stmt_list), &free_item); 
    1246                         /* We don't need the default one that came with it now */ 
    1247  
    1248                         efree(result->intern_stmt); 
     1160                        zend_objects_store_add_ref(object TSRMLS_CC); 
     1161 
    12491162                        result->is_prepared_statement = 1; 
    1250                         result->intern_stmt = &internp->stmt
    1251                         result->num_rows = num_rows
    1252                         result->db_obj = internp->db_obj; 
     1163                        result->initialised = 1
     1164                        result->intern_stmt = stmt_obj->stmt
     1165                        result->db_obj = stmt_obj->db_obj; 
    12531166                        break; 
    12541167                } 
    12551168                case SQLITE_ERROR: 
    1256                         sqlite3_reset(internp->stmt); 
     1169                        sqlite3_reset(stmt_obj->stmt); 
    12571170 
    12581171                default: 
    1259                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(internp->stmt))); 
     1172                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt))); 
     1173                        zval_dtor(return_value); 
    12601174                        RETURN_FALSE; 
    12611175        } 
     
    12701184PHP_METHOD(sqlite3_result, numColumns) 
    12711185{ 
    1272         php_sqlite3_result *internp; 
    1273         zval *object = getThis(); 
    1274         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1186        php_sqlite3_result *result_obj; 
     1187        zval *object = getThis(); 
     1188        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1189 
     1190        SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) 
    12751191 
    12761192        if (ZEND_NUM_ARGS() != 0) { 
     
    12781194        } 
    12791195 
    1280         RETURN_LONG(sqlite3_column_count(*(internp->intern_stmt))); 
     1196        RETURN_LONG(sqlite3_column_count(result_obj->intern_stmt)); 
    12811197} 
    12821198/* }}} */ 
     
    12871203PHP_METHOD(sqlite3_result, columnName) 
    12881204{ 
    1289         php_sqlite3_result *internp
     1205        php_sqlite3_result *result_obj
    12901206        zval *object = getThis(); 
    12911207        int column = 0; 
    1292         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1208        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1209 
     1210        SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) 
    12931211 
    12941212        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) { 
     
    12961214        } 
    12971215 
    1298         RETVAL_STRING((char *)sqlite3_column_name(*(internp->intern_stmt), column), 1); 
     1216        RETVAL_STRING((char *)sqlite3_column_name(result_obj->intern_stmt, column), 1); 
    12991217} 
    13001218/* }}} */ 
     
    13051223PHP_METHOD(sqlite3_result, columnType) 
    13061224{ 
    1307         php_sqlite3_result *internp
     1225        php_sqlite3_result *result_obj
    13081226        zval *object = getThis(); 
    13091227        int column = 0; 
    1310         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1228        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1229 
     1230        SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) 
    13111231 
    13121232        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) { 
     
    13141234        } 
    13151235 
    1316         RETURN_LONG(sqlite3_column_type(*(internp->intern_stmt), column)); 
     1236        RETURN_LONG(sqlite3_column_type(result_obj->intern_stmt, column)); 
    13171237} 
    13181238/* }}} */ 
     
    13231243PHP_METHOD(sqlite3_result, fetchArray) 
    13241244{ 
    1325         php_sqlite3_result *internp
     1245        php_sqlite3_result *result_obj
    13261246        zval *object = getThis(); 
    13271247        int i, ret, mode = PHP_SQLITE3_BOTH; 
    1328         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1248        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1249 
     1250        SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) 
    13291251 
    13301252        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mode) == FAILURE) { 
     
    13321254        } 
    13331255 
    1334         if (internp->complete == 1) { 
    1335                 RETURN_FALSE; 
    1336         } 
    1337  
    1338         ret = sqlite3_step(*(internp->intern_stmt)); 
     1256        if (result_obj->complete == 1) { 
     1257                RETURN_FALSE; 
     1258        } 
     1259 
     1260        ret = sqlite3_step(result_obj->intern_stmt); 
    13391261        switch (ret) { 
    13401262                case SQLITE_ROW: 
     
    13461268                        array_init(return_value); 
    13471269 
    1348                         for (i = 0; i < sqlite3_data_count(*(internp->intern_stmt)); i++) { 
     1270                        for (i = 0; i < sqlite3_data_count(result_obj->intern_stmt); i++) { 
    13491271                                zval *data; 
    13501272 
    1351                                 data = sqlite_value_to_zval(*(internp->intern_stmt), i); 
     1273                                data = sqlite_value_to_zval(result_obj->intern_stmt, i); 
    13521274 
    13531275                                if (mode & PHP_SQLITE3_NUM) { 
     
    13591281                                                Z_ADDREF_P(data); 
    13601282                                        } 
    1361                                         add_assoc_zval(return_value, (char*)sqlite3_column_name(*(internp->intern_stmt), i), data); 
     1283                                        add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->intern_stmt, i), data); 
    13621284                                } 
    13631285                        } 
     
    13651287                case SQLITE_DONE: 
    13661288                        /* Can't call sqlite3_step again, so store the value */ 
    1367                         internp->complete = 1; 
     1289                        result_obj->complete = 1; 
    13681290                        RETURN_FALSE; 
    13691291 
    13701292                default: 
    1371                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(*(internp->intern_stmt)))); 
     1293                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(result_obj->intern_stmt))); 
    13721294        } 
    13731295} 
     
    13791301PHP_METHOD(sqlite3_result, reset) 
    13801302{ 
    1381         php_sqlite3_result *internp; 
    1382         zval *object = getThis(); 
    1383         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1303        php_sqlite3_result *result_obj; 
     1304        zval *object = getThis(); 
     1305        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1306 
     1307        SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) 
    13841308 
    13851309        if (ZEND_NUM_ARGS() != 0) { 
     
    13871311        } 
    13881312 
    1389         if (sqlite3_reset(*(internp->intern_stmt)) != SQLITE_OK) { 
    1390                 RETURN_FALSE; 
    1391         } 
    1392  
    1393         internp->complete = 0; 
     1313        if (sqlite3_reset(result_obj->intern_stmt) != SQLITE_OK) { 
     1314                RETURN_FALSE; 
     1315        } 
     1316 
     1317        result_obj->complete = 0; 
    13941318 
    13951319        RETURN_TRUE; 
     
    13971321/* }}} */ 
    13981322 
    1399 #ifdef scottmac_0 
    1400 /* {{{ proto bool SQLite3_result::numRows() 
    1401         Returns the number of rows in a result set 
    1402 */ 
    1403 PHP_METHOD(sqlite3_result, numRows) 
    1404 
    1405         php_sqlite3_result *internp; 
    1406         zval *object = getThis(); 
    1407         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1323/* {{{ proto bool SQLite3_result::finalize() 
     1324        Closes the result set 
     1325*/ 
     1326PHP_METHOD(sqlite3_result, finalize) 
     1327
     1328        php_sqlite3_result *result_obj; 
     1329        zval *object = getThis(); 
     1330        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
     1331 
     1332        SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) 
    14081333 
    14091334        if (ZEND_NUM_ARGS() != 0) { 
    14101335                WRONG_PARAM_COUNT; 
    14111336        } 
    1412         RETURN_LONG(internp->num_rows); 
    1413 } 
    1414 /* }}} */ 
    1415 #endif 
    1416  
    1417 /* {{{ proto bool SQLite3_result::finalize() 
    1418         Closes the result set 
    1419 */ 
    1420 PHP_METHOD(sqlite3_result, finalize) 
    1421 { 
    1422         php_sqlite3_result *internp; 
    1423         zval *object = getThis(); 
    1424         internp = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); 
    1425  
    1426         if (ZEND_NUM_ARGS() != 0) { 
    1427                 WRONG_PARAM_COUNT; 
    1428         } 
    14291337 
    14301338        /* We need to finalize an internal statement */ 
    1431         if (internp->is_prepared_statement == 0) { 
    1432                 zend_llist_del_element(&(internp->db_obj->stmt_list), *(internp->intern_stmt), 
    1433                                                        (int (*)(void *, void *)) php_sqlite3_compare_stmt_free); 
     1339        if (result_obj->is_prepared_statement == 0) { 
     1340                result_obj->initialised = 0; 
     1341                sqlite3_finalize(result_obj->intern_stmt); 
    14341342        } else { 
    1435                 sqlite3_reset(*(internp->intern_stmt)); 
    1436         } 
    1437  
    1438         /*zval_dtor(object); 
    1439         ZVAL_NULL(object);*/ 
     1343                sqlite3_reset(result_obj->intern_stmt); 
     1344        } 
    14401345 
    14411346        RETURN_TRUE; 
     
    15771482ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_result_reset, 0) 
    15781483ZEND_END_ARG_INFO() 
    1579  
    1580 #ifdef scottmac_0 
    1581 static 
    1582 ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_result_numrows, 0) 
    1583 ZEND_END_ARG_INFO() 
    1584 #endif 
    15851484 
    15861485static 
     
    16201519        PHP_ME(sqlite3_stmt, clear,                     arginfo_sqlite3_stmt_clear, ZEND_ACC_PUBLIC) 
    16211520        PHP_ME(sqlite3_stmt, execute,           arginfo_sqlite3_stmt_execute, ZEND_ACC_PUBLIC) 
    1622 #if scottmac_0 
    1623         PHP_ME(sqlite3_stmt, bind_params,       NULL, ZEND_ACC_PUBLIC) 
    1624 #endif 
    16251521        PHP_ME(sqlite3_stmt, bindParam, arginfo_sqlite3_stmt_bindparam, ZEND_ACC_PUBLIC) 
    16261522        PHP_ME(sqlite3_stmt, bindValue, arginfo_sqlite3_stmt_bindvalue, ZEND_ACC_PUBLIC) 
     
    16361532        PHP_ME(sqlite3_result, fetchArray,              arginfo_sqlite3_result_fetcharray, ZEND_ACC_PUBLIC) 
    16371533        PHP_ME(sqlite3_result, reset,                   arginfo_sqlite3_result_reset, ZEND_ACC_PUBLIC) 
    1638 #ifdef scottmac_0 
    1639         PHP_ME(sqlite3_result, numRows,                 arginfo_sqlite3_result_numrows, ZEND_ACC_PUBLIC) 
    1640 #endif 
    16411534        PHP_ME(sqlite3_result, finalize,                arginfo_sqlite3_result_finalize, ZEND_ACC_PUBLIC) 
    16421535 
     
    17071600                func = intern->funcs; 
    17081601                intern->funcs = func->next; 
    1709                 if (intern->db) { 
     1602                if (intern->initialised && intern->db) { 
    17101603                        sqlite3_create_function(intern->db, func->func_name, func->argc, SQLITE_UTF8, func, NULL, NULL, NULL); 
    17111604                } 
     
    17251618        } 
    17261619 
    1727         zend_llist_clean(&(intern->stmt_list)); 
    1728  
    1729         if (intern->db) { 
     1620        if (intern->initialised && intern->db) { 
    17301621                sqlite3_close(intern->db); 
    1731                 intern->db = NULL
     1622                intern->initialised = 0
    17321623        } 
    17331624 
     
    17681659 
    17691660        if (intern->intern_stmt) { 
    1770                 sqlite3_reset(*(intern->intern_stmt)); 
     1661                sqlite3_reset(intern->intern_stmt); 
    17711662        } 
    17721663 
    17731664        /* The result set occured from a straight execute statement */ 
    17741665        if (intern->intern_stmt && intern->is_prepared_statement == 0) { 
    1775                 sqlite3_finalize(*(intern->intern_stmt)); 
    1776                 efree(intern->intern_stmt); 
     1666                sqlite3_finalize(intern->intern_stmt); 
    17771667        } 
    17781668 
     
    17931683        memset(&intern->zo, 0, sizeof(php_sqlite3_db_object)); 
    17941684 
    1795         /* Non standard stuff, not sure if this is really required still */ 
    1796         zend_llist_init(&(intern->stmt_list),   sizeof(php_sqlite3_stmt_free_list *), (llist_dtor_func_t)php_sqlite3_stmt_free, 0); 
     1685        /* Non standard stuff, not sure if this is really required still 
     1686        zend_llist_init(&(intern->stmt_list),   sizeof(php_sqlite3_stmt_free_list *), (llist_dtor_func_t)php_sqlite3_stmt_free, 0);*/ 
    17971687 
    17981688        zend_object_std_init(&intern->zo, class_type TSRMLS_CC); 
     
    18341724        memset(&intern->zo, 0, sizeof(php_sqlite3_result)); 
    18351725 
    1836         intern->intern_stmt = emalloc(sizeof(sqlite3_stmt *)); 
    1837         intern->buffered = 0; 
     1726        intern->intern_stmt = NULL; 
    18381727        intern->complete = 0; 
    18391728        intern->is_prepared_statement = 0; 
    1840         intern->num_rows = 0; 
    18411729 
    18421730        zend_object_std_init(&intern->zo, class_type TSRMLS_CC);