Annotation of embedaddon/php/ext/sqlite3/sqlite3.c, revision 1.1.1.3

1.1       misho       1: /*
                      2:    +----------------------------------------------------------------------+
                      3:    | PHP Version 5                                                        |
                      4:    +----------------------------------------------------------------------+
1.1.1.3 ! misho       5:    | Copyright (c) 1997-2013 The PHP Group                                |
1.1       misho       6:    +----------------------------------------------------------------------+
                      7:    | This source file is subject to version 3.01 of the PHP license,      |
                      8:    | that is bundled with this package in the file LICENSE, and is        |
                      9:    | available through the world-wide-web at the following url:           |
                     10:    | http://www.php.net/license/3_01.txt                                  |
                     11:    | If you did not receive a copy of the PHP license and are unable to   |
                     12:    | obtain it through the world-wide-web, please send a note to          |
                     13:    | license@php.net so we can mail you a copy immediately.               |
                     14:    +----------------------------------------------------------------------+
                     15:    | Authors: Scott MacVicar <scottmac@php.net>                           |
                     16:    +----------------------------------------------------------------------+
                     17: */
                     18: 
1.1.1.2   misho      19: /* $Id$ */
1.1       misho      20: 
                     21: #ifdef HAVE_CONFIG_H
                     22: #include "config.h"
                     23: #endif
                     24: 
                     25: #include "php.h"
                     26: #include "php_ini.h"
                     27: #include "ext/standard/info.h"
                     28: #include "php_sqlite3.h"
                     29: #include "php_sqlite3_structs.h"
                     30: #include "main/SAPI.h"
                     31: 
                     32: #include <sqlite3.h>
                     33: 
                     34: #include "zend_exceptions.h"
                     35: #include "zend_interfaces.h"
                     36: #include "SAPI.h"
                     37: 
                     38: ZEND_DECLARE_MODULE_GLOBALS(sqlite3)
                     39: 
                     40: static PHP_GINIT_FUNCTION(sqlite3);
                     41: static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, const char *arg5, const char *arg6);
                     42: static void sqlite3_param_dtor(void *data);
                     43: static int php_sqlite3_compare_stmt_zval_free(php_sqlite3_free_list **free_list, zval *statement);
                     44: 
                     45: /* {{{ Error Handler
                     46: */
                     47: static void php_sqlite3_error(php_sqlite3_db_object *db_obj, char *format, ...)
                     48: {
                     49:        va_list arg;
                     50:        char    *message;
                     51:        TSRMLS_FETCH();
                     52: 
                     53:        va_start(arg, format); 
                     54:        vspprintf(&message, 0, format, arg);
                     55:        va_end(arg);
                     56: 
                     57:        if (db_obj->exception) {
                     58:                zend_throw_exception(zend_exception_get_default(TSRMLS_C), message, 0 TSRMLS_CC);
                     59:        } else {
                     60:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
                     61:        }
                     62:        
                     63:        if (message) {
                     64:                efree(message);
                     65:        }
                     66: }
                     67: /* }}} */
                     68: 
                     69: #define SQLITE3_CHECK_INITIALIZED(db_obj, member, class_name) \
                     70:        if (!(member)) { \
                     71:                php_sqlite3_error(db_obj, "The " #class_name " object has not been correctly initialised"); \
                     72:                RETURN_FALSE; \
                     73:        }
                     74: 
                     75: /* {{{ PHP_INI
                     76: */
                     77: PHP_INI_BEGIN()
                     78:        STD_PHP_INI_ENTRY("sqlite3.extension_dir",  NULL, PHP_INI_SYSTEM, OnUpdateString, extension_dir, zend_sqlite3_globals, sqlite3_globals)
                     79: PHP_INI_END()
                     80: /* }}} */
                     81: 
                     82: /* Handlers */
                     83: static zend_object_handlers sqlite3_object_handlers;
                     84: static zend_object_handlers sqlite3_stmt_object_handlers;
                     85: static zend_object_handlers sqlite3_result_object_handlers;
                     86: 
                     87: /* Class entries */
                     88: zend_class_entry *php_sqlite3_sc_entry;
                     89: zend_class_entry *php_sqlite3_stmt_entry;
                     90: zend_class_entry *php_sqlite3_result_entry;
                     91: 
                     92: /* {{{ proto void SQLite3::open(String filename [, int Flags [, string Encryption Key]])
                     93:    Opens a SQLite 3 Database, if the build includes encryption then it will attempt to use the key. */
                     94: PHP_METHOD(sqlite3, open)
                     95: {
                     96:        php_sqlite3_db_object *db_obj;
                     97:        zval *object = getThis();
                     98:        char *filename, *encryption_key, *fullpath;
                     99:        int filename_len, encryption_key_len = 0;
                    100:        long flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
                    101:        zend_error_handling error_handling;
                    102: 
                    103:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    104:        zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
                    105: 
1.1.1.2   misho     106:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|ls", &filename, &filename_len, &flags, &encryption_key, &encryption_key_len)) {
1.1       misho     107:                zend_restore_error_handling(&error_handling TSRMLS_CC);
                    108:                return;
                    109:        }
                    110: 
                    111:        zend_restore_error_handling(&error_handling TSRMLS_CC);
                    112: 
                    113:        if (db_obj->initialised) {
                    114:                zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Already initialised DB Object", 0 TSRMLS_CC);
                    115:        }
                    116: 
1.1.1.3 ! misho     117:        if (strlen(filename) != filename_len) {
        !           118:                return;
        !           119:        }
        !           120:        if (memcmp(filename, ":memory:", sizeof(":memory:")) != 0) {
1.1       misho     121:                if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
                    122:                        zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Unable to expand filepath", 0 TSRMLS_CC);
                    123:                        return;
                    124:                }
                    125: 
                    126: #if PHP_API_VERSION < 20100412
                    127:                if (PG(safe_mode) && (!php_checkuid(fullpath, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
                    128:                        zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "safe_mode prohibits opening %s", fullpath);
                    129:                        efree(fullpath);
                    130:                        return;
                    131:                }
                    132: #endif
                    133: 
                    134:                if (php_check_open_basedir(fullpath TSRMLS_CC)) {
                    135:                        zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "open_basedir prohibits opening %s", fullpath);
                    136:                        efree(fullpath);
                    137:                        return;
                    138:                }
                    139:        } else {
                    140:                fullpath = estrdup(filename);
                    141:        }
                    142: 
                    143: #if SQLITE_VERSION_NUMBER >= 3005000
                    144:        if (sqlite3_open_v2(fullpath, &(db_obj->db), flags, NULL) != SQLITE_OK) {
                    145: #else
                    146:        if (sqlite3_open(fullpath, &(db_obj->db)) != SQLITE_OK) {
                    147: #endif
                    148:                zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
                    149:                if (fullpath) {
                    150:                        efree(fullpath);
                    151:                }
                    152:                return;
                    153:        }
                    154: 
                    155: #if SQLITE_HAS_CODEC
                    156:        if (encryption_key_len > 0) {
                    157:                if (sqlite3_key(db_obj->db, encryption_key, encryption_key_len) != SQLITE_OK) {
                    158:                        zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
                    159:                        return;
                    160:                }
                    161:        }
                    162: #endif
                    163: 
                    164:        db_obj->initialised = 1;
                    165: 
                    166: #if PHP_API_VERSION < 20100412
                    167:        if (PG(safe_mode) || (PG(open_basedir) && *PG(open_basedir))) {
                    168: #else
                    169:        if (PG(open_basedir) && *PG(open_basedir)) {
                    170: #endif
                    171:                sqlite3_set_authorizer(db_obj->db, php_sqlite3_authorizer, NULL);
                    172:        }
                    173: 
                    174:        if (fullpath) {
                    175:                efree(fullpath);
                    176:        }
                    177: }
                    178: /* }}} */
                    179: 
                    180: /* {{{ proto bool SQLite3::close()
                    181:    Close a SQLite 3 Database. */
                    182: PHP_METHOD(sqlite3, close)
                    183: {
                    184:        php_sqlite3_db_object *db_obj;
                    185:        zval *object = getThis();
                    186:        int errcode;
                    187:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    188: 
                    189:        if (zend_parse_parameters_none() == FAILURE) {
                    190:                return;
                    191:        }
                    192: 
                    193:        if (db_obj->initialised) {
                    194:                zend_llist_clean(&(db_obj->free_list));
                    195:                errcode = sqlite3_close(db_obj->db);
                    196:                if (errcode != SQLITE_OK) {
                    197:                        php_sqlite3_error(db_obj, "Unable to close database: %d, %s", errcode, sqlite3_errmsg(db_obj->db));
                    198:                        RETURN_FALSE;
                    199:                }
                    200:                db_obj->initialised = 0;
                    201:        }
                    202: 
                    203:        RETURN_TRUE;
                    204: }
                    205: /* }}} */
                    206: 
                    207: /* {{{ proto bool SQLite3::exec(String Query)
                    208:    Executes a result-less query against a given database. */
                    209: PHP_METHOD(sqlite3, exec)
                    210: {
                    211:        php_sqlite3_db_object *db_obj;
                    212:        zval *object = getThis();
                    213:        char *sql, *errtext = NULL;
                    214:        int sql_len;
                    215:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    216: 
                    217:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    218: 
                    219:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
                    220:                return;
                    221:        }
                    222: 
                    223:        if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
                    224:                php_sqlite3_error(db_obj, "%s", errtext);
                    225:                sqlite3_free(errtext);
                    226:                RETURN_FALSE;
                    227:        }
                    228: 
                    229:        RETURN_TRUE;
                    230: }
                    231: /* }}} */
                    232: 
                    233: /* {{{ proto Array SQLite3::version()
                    234:    Returns the SQLite3 Library version as a string constant and as a number. */
                    235: PHP_METHOD(sqlite3, version)
                    236: {
                    237:        if (zend_parse_parameters_none() == FAILURE) {
                    238:                return;
                    239:        }
                    240: 
                    241:        array_init(return_value);
                    242: 
                    243:        add_assoc_string(return_value, "versionString", (char*)sqlite3_libversion(), 1);
                    244:        add_assoc_long(return_value, "versionNumber", sqlite3_libversion_number());
                    245: 
                    246:        return;
                    247: }
                    248: /* }}} */
                    249: 
                    250: /* {{{ proto int SQLite3::lastInsertRowID()
                    251:    Returns the rowid of the most recent INSERT into the database from the database connection. */
                    252: PHP_METHOD(sqlite3, lastInsertRowID)
                    253: {
                    254:        php_sqlite3_db_object *db_obj;
                    255:        zval *object = getThis();
                    256:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    257: 
                    258:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    259: 
                    260:        if (zend_parse_parameters_none() == FAILURE) {
                    261:                return;
                    262:        }
                    263: 
                    264:        RETURN_LONG(sqlite3_last_insert_rowid(db_obj->db));
                    265: }
                    266: /* }}} */
                    267: 
                    268: /* {{{ proto int SQLite3::lastErrorCode()
                    269:    Returns the numeric result code of the most recent failed sqlite API call for the database connection. */
                    270: PHP_METHOD(sqlite3, lastErrorCode)
                    271: {
                    272:        php_sqlite3_db_object *db_obj;
                    273:        zval *object = getThis();
                    274:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    275: 
                    276:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
                    277: 
                    278:        if (zend_parse_parameters_none() == FAILURE) {
                    279:                return;
                    280:        }
                    281: 
                    282:        RETURN_LONG(sqlite3_errcode(db_obj->db));
                    283: }
                    284: /* }}} */
                    285: 
                    286: /* {{{ proto string SQLite3::lastErrorMsg()
                    287:    Returns english text describing the most recent failed sqlite API call for the database connection. */
                    288: PHP_METHOD(sqlite3, lastErrorMsg)
                    289: {
                    290:        php_sqlite3_db_object *db_obj;
                    291:        zval *object = getThis();
                    292:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    293: 
                    294:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
                    295: 
                    296:        if (zend_parse_parameters_none() == FAILURE) {
                    297:                return;
                    298:        }
                    299: 
                    300:        RETVAL_STRING((char *)sqlite3_errmsg(db_obj->db), 1);
                    301: }
                    302: /* }}} */
                    303: 
                    304: /* {{{ proto bool SQLite3::busyTimeout(int msecs)
                    305:    Sets a busy handler that will sleep until database is not locked or timeout is reached. Passing a value less than or equal to zero turns off all busy handlers. */
                    306: PHP_METHOD(sqlite3, busyTimeout)
                    307: {
                    308:        php_sqlite3_db_object *db_obj;
                    309:        zval *object = getThis();
                    310:        long ms;
                    311:        int return_code;
                    312:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    313: 
                    314:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    315: 
                    316:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ms)) {
                    317:                return;
                    318:        }
                    319: 
                    320:        return_code = sqlite3_busy_timeout(db_obj->db, ms);
                    321:        if (return_code != SQLITE_OK) {
                    322:                php_sqlite3_error(db_obj, "Unable to set busy timeout: %d, %s", return_code, sqlite3_errmsg(db_obj->db));
                    323:                RETURN_FALSE;
                    324:        }
                    325: 
                    326:        RETURN_TRUE;
                    327: }
                    328: /* }}} */
                    329: 
                    330: 
                    331: #ifndef SQLITE_OMIT_LOAD_EXTENSION
                    332: /* {{{ proto bool SQLite3::loadExtension(String Shared Library)
                    333:    Attempts to load an SQLite extension library. */
                    334: PHP_METHOD(sqlite3, loadExtension)
                    335: {
                    336:        php_sqlite3_db_object *db_obj;
                    337:        zval *object = getThis();
                    338:        char *extension, *lib_path, *extension_dir, *errtext = NULL;
                    339:        char fullpath[MAXPATHLEN];
                    340:        int extension_len, extension_dir_len;
                    341:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    342: 
                    343:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    344: 
                    345:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension, &extension_len)) {
                    346:                return;
                    347:        }
                    348: 
                    349: #ifdef ZTS
                    350:        if ((strncmp(sapi_module.name, "cgi", 3) != 0) &&
                    351:                (strcmp(sapi_module.name, "cli") != 0) &&
                    352:                (strncmp(sapi_module.name, "embed", 5) != 0)
                    353:        ) {             php_sqlite3_error(db_obj, "Not supported in multithreaded Web servers");
                    354:                RETURN_FALSE;
                    355:        }
                    356: #endif
                    357: 
                    358:        if (!SQLITE3G(extension_dir)) {
                    359:                php_sqlite3_error(db_obj, "SQLite Extension are disabled");
                    360:                RETURN_FALSE;
                    361:        }
                    362: 
                    363:        if (extension_len == 0) {
                    364:                php_sqlite3_error(db_obj, "Empty string as an extension");
                    365:                RETURN_FALSE;
                    366:        }
                    367: 
                    368:        extension_dir = SQLITE3G(extension_dir);
                    369:        extension_dir_len = strlen(SQLITE3G(extension_dir));
                    370: 
                    371:        if (IS_SLASH(extension_dir[extension_dir_len-1])) {
                    372:                spprintf(&lib_path, 0, "%s%s", extension_dir, extension);
                    373:        } else {
                    374:                spprintf(&lib_path, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, extension);
                    375:        }
                    376: 
                    377:        if (!VCWD_REALPATH(lib_path, fullpath)) {
                    378:                php_sqlite3_error(db_obj, "Unable to load extension at '%s'", lib_path);
                    379:                efree(lib_path);
                    380:                RETURN_FALSE;
                    381:        }
                    382: 
                    383:        efree(lib_path);
                    384: 
                    385:        if (strncmp(fullpath, extension_dir, extension_dir_len) != 0) {
                    386:                php_sqlite3_error(db_obj, "Unable to open extensions outside the defined directory");
                    387:                RETURN_FALSE;
                    388:        }
                    389: 
                    390:        /* Extension loading should only be enabled for when we attempt to load */
                    391:        sqlite3_enable_load_extension(db_obj->db, 1);
                    392:        if (sqlite3_load_extension(db_obj->db, fullpath, 0, &errtext) != SQLITE_OK) {
                    393:                php_sqlite3_error(db_obj, "%s", errtext);
                    394:                sqlite3_free(errtext);
                    395:                sqlite3_enable_load_extension(db_obj->db, 0);
                    396:                RETURN_FALSE;
                    397:        }
                    398:        sqlite3_enable_load_extension(db_obj->db, 0);
                    399: 
                    400:        RETURN_TRUE;
                    401: }
                    402: /* }}} */
                    403: #endif
                    404: 
                    405: /* {{{ proto int SQLite3::changes()
                    406:   Returns the number of database rows that were changed (or inserted or deleted) by the most recent SQL statement. */
                    407: PHP_METHOD(sqlite3, changes)
                    408: {
                    409:        php_sqlite3_db_object *db_obj;
                    410:        zval *object = getThis();
                    411:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    412: 
                    413:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    414: 
                    415:        if (zend_parse_parameters_none() == FAILURE) {
                    416:                return;
                    417:        }
                    418: 
                    419:        RETURN_LONG(sqlite3_changes(db_obj->db));
                    420: }
                    421: /* }}} */
                    422: 
                    423: /* {{{ proto String SQLite3::escapeString(String value)
                    424:    Returns a string that has been properly escaped. */
                    425: PHP_METHOD(sqlite3, escapeString)
                    426: {
                    427:        char *sql, *ret;
                    428:        int sql_len;
                    429: 
                    430:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
                    431:                return;
                    432:        }
                    433: 
                    434:        if (sql_len) {
                    435:                ret = sqlite3_mprintf("%q", sql);
                    436:                if (ret) {
                    437:                        RETVAL_STRING(ret, 1);
                    438:                        sqlite3_free(ret);
                    439:                }
                    440:        } else {
                    441:                RETURN_EMPTY_STRING();
                    442:        }
                    443: }
                    444: /* }}} */
                    445: 
                    446: /* {{{ proto SQLite3Stmt SQLite3::prepare(String Query)
                    447:    Returns a prepared SQL statement for execution. */
                    448: PHP_METHOD(sqlite3, prepare)
                    449: {
                    450:        php_sqlite3_db_object *db_obj;
                    451:        php_sqlite3_stmt *stmt_obj;
                    452:        zval *object = getThis();
                    453:        char *sql;
                    454:        int sql_len, errcode;
                    455:        php_sqlite3_free_list *free_item;
                    456: 
                    457:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    458: 
                    459:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    460: 
                    461:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
                    462:                return;
                    463:        }
                    464: 
                    465:        if (!sql_len) {
                    466:                RETURN_FALSE;
                    467:        }
                    468: 
                    469:        object_init_ex(return_value, php_sqlite3_stmt_entry);
                    470:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC);
                    471:        stmt_obj->db_obj = db_obj;
                    472:        stmt_obj->db_obj_zval = getThis();
                    473: 
                    474:        Z_ADDREF_P(object);
                    475: 
                    476:        errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
                    477:        if (errcode != SQLITE_OK) {
                    478:                php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", errcode, sqlite3_errmsg(db_obj->db));
                    479:                zval_dtor(return_value);
                    480:                RETURN_FALSE;
                    481:        }
                    482: 
                    483:        stmt_obj->initialised = 1;
                    484: 
                    485:        free_item = emalloc(sizeof(php_sqlite3_free_list));
                    486:        free_item->stmt_obj = stmt_obj;
                    487:        free_item->stmt_obj_zval = return_value;
                    488: 
                    489:        zend_llist_add_element(&(db_obj->free_list), &free_item);
                    490: }
                    491: /* }}} */
                    492: 
                    493: /* {{{ proto SQLite3Result SQLite3::query(String Query)
                    494:    Returns true or false, for queries that return data it will return a SQLite3Result object. */
                    495: PHP_METHOD(sqlite3, query)
                    496: {
                    497:        php_sqlite3_db_object *db_obj;
                    498:        php_sqlite3_result *result;
                    499:        php_sqlite3_stmt *stmt_obj;
                    500:        zval *object = getThis();
                    501:        zval *stmt = NULL;
                    502:        char *sql, *errtext = NULL;
                    503:        int sql_len, return_code;
                    504:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    505: 
                    506:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    507: 
                    508:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
                    509:                return;
                    510:        }
                    511: 
                    512:        if (!sql_len) {
                    513:                RETURN_FALSE;
                    514:        }
                    515: 
                    516:        /* If there was no return value then just execute the query */
                    517:        if (!return_value_used) {
                    518:                if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
                    519:                        php_sqlite3_error(db_obj, "%s", errtext);
                    520:                        sqlite3_free(errtext);
                    521:                }
                    522:                return;
                    523:        }
                    524: 
                    525:        MAKE_STD_ZVAL(stmt);
                    526: 
                    527:        object_init_ex(stmt, php_sqlite3_stmt_entry);
                    528:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(stmt TSRMLS_CC);
                    529:        stmt_obj->db_obj = db_obj;
                    530:        stmt_obj->db_obj_zval = getThis();
                    531: 
                    532:        Z_ADDREF_P(object);
                    533: 
                    534:        return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
                    535:        if (return_code != SQLITE_OK) {
                    536:                php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db));
                    537:                zval_ptr_dtor(&stmt);
                    538:                RETURN_FALSE;
                    539:        }
                    540: 
                    541:        stmt_obj->initialised = 1;
                    542: 
                    543:        object_init_ex(return_value, php_sqlite3_result_entry);
                    544:        result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
                    545:        result->db_obj = db_obj;
                    546:        result->stmt_obj = stmt_obj;
                    547:        result->stmt_obj_zval = stmt;
                    548: 
                    549:        return_code = sqlite3_step(result->stmt_obj->stmt);
                    550: 
                    551:        switch (return_code) {
                    552:                case SQLITE_ROW: /* Valid Row */
                    553:                case SQLITE_DONE: /* Valid but no results */
                    554:                {
                    555:                        php_sqlite3_free_list *free_item;
                    556:                        free_item = emalloc(sizeof(php_sqlite3_free_list));
                    557:                        free_item->stmt_obj = stmt_obj;
                    558:                        free_item->stmt_obj_zval = stmt;
                    559:                        zend_llist_add_element(&(db_obj->free_list), &free_item);
                    560:                        sqlite3_reset(result->stmt_obj->stmt);
                    561:                        break;
                    562:                }
                    563:                default:
                    564:                        php_sqlite3_error(db_obj, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db));
                    565:                        sqlite3_finalize(stmt_obj->stmt);
                    566:                        stmt_obj->initialised = 0;
                    567:                        zval_dtor(return_value);
                    568:                        RETURN_FALSE;
                    569:        }
                    570: }
                    571: /* }}} */
                    572: 
                    573: static zval* sqlite_value_to_zval(sqlite3_stmt *stmt, int column) /* {{{ */
                    574: {
                    575:        zval *data;
                    576:        MAKE_STD_ZVAL(data);
                    577:        switch (sqlite3_column_type(stmt, column)) {
                    578:                case SQLITE_INTEGER:
                    579:                        if ((sqlite3_column_int64(stmt, column)) >= INT_MAX || sqlite3_column_int64(stmt, column) <= INT_MIN) {
                    580:                                ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column), 1);
                    581:                        } else {
                    582:                                ZVAL_LONG(data, sqlite3_column_int64(stmt, column));
                    583:                        }
                    584:                        break;
                    585: 
                    586:                case SQLITE_FLOAT:
                    587:                        ZVAL_DOUBLE(data, sqlite3_column_double(stmt, column));
                    588:                        break;
                    589: 
                    590:                case SQLITE_NULL:
                    591:                        ZVAL_NULL(data);
                    592:                        break;
                    593: 
                    594:                case SQLITE3_TEXT:
                    595:                        ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column), 1);
                    596:                        break;
                    597: 
                    598:                case SQLITE_BLOB:
                    599:                default:
                    600:                        ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column), 1);
                    601:        }
                    602:        return data;
                    603: }
                    604: /* }}} */
                    605: 
                    606: /* {{{ proto SQLite3Result SQLite3::querySingle(String Query [, bool entire_row = false])
                    607:    Returns a string of the first column, or an array of the entire row. */
                    608: PHP_METHOD(sqlite3, querySingle)
                    609: {
                    610:        php_sqlite3_db_object *db_obj;
                    611:        zval *object = getThis();
                    612:        char *sql, *errtext = NULL;
                    613:        int sql_len, return_code;
                    614:        zend_bool entire_row = 0;
                    615:        sqlite3_stmt *stmt;
                    616:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    617: 
                    618:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    619: 
                    620:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &sql, &sql_len, &entire_row)) {
                    621:                return;
                    622:        }
                    623: 
                    624:        if (!sql_len) {
                    625:                RETURN_FALSE;
                    626:        }
                    627: 
                    628:        /* If there was no return value then just execute the query */
                    629:        if (!return_value_used) {
                    630:                if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
                    631:                        php_sqlite3_error(db_obj, "%s", errtext);
                    632:                        sqlite3_free(errtext);
                    633:                }
                    634:                return;
                    635:        }
                    636: 
                    637:        return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &stmt, NULL);
                    638:        if (return_code != SQLITE_OK) {
                    639:                php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db));
                    640:                RETURN_FALSE;
                    641:        }
                    642: 
                    643:        return_code = sqlite3_step(stmt);
                    644: 
                    645:        switch (return_code) {
                    646:                case SQLITE_ROW: /* Valid Row */
                    647:                {
                    648:                        if (!entire_row) {
                    649:                                zval *data;
                    650:                                data = sqlite_value_to_zval(stmt, 0);
                    651:                                *return_value = *data;
                    652:                                zval_copy_ctor(return_value);
                    653:                                zval_dtor(data);
                    654:                                FREE_ZVAL(data);
                    655:                        } else {
                    656:                                int i = 0;
                    657:                                array_init(return_value);
                    658:                                for (i = 0; i < sqlite3_data_count(stmt); i++) {
                    659:                                        zval *data;
                    660:                                        data = sqlite_value_to_zval(stmt, i);
                    661:                                        add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), data);
                    662:                                }
                    663:                        }
                    664:                        break;
                    665:                }
                    666:                case SQLITE_DONE: /* Valid but no results */
                    667:                {
                    668:                        if (!entire_row) {
                    669:                                RETVAL_NULL();
                    670:                        } else {
                    671:                                array_init(return_value);
                    672:                        }
                    673:                        break;
                    674:                }
                    675:                default:
                    676:                        php_sqlite3_error(db_obj, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db));
                    677:                        RETVAL_FALSE;
                    678:        }
                    679:        sqlite3_finalize(stmt);
                    680: }
                    681: /* }}} */
                    682: 
                    683: static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, sqlite3_value **argv, sqlite3_context *context, int is_agg TSRMLS_DC) /* {{{ */
                    684: {
                    685:        zval ***zargs = NULL;
                    686:        zval *retval = NULL;
                    687:        int i;
                    688:        int ret;
                    689:        int fake_argc;
                    690:        php_sqlite3_agg_context *agg_context = NULL;
                    691: 
                    692:        if (is_agg) {
                    693:                is_agg = 2;
                    694:        }
                    695: 
                    696:        fake_argc = argc + is_agg;
                    697: 
                    698:        fc->fci.size = sizeof(fc->fci);
                    699:        fc->fci.function_table = EG(function_table);
                    700:        fc->fci.function_name = cb;
                    701:        fc->fci.symbol_table = NULL;
                    702:        fc->fci.object_ptr = NULL;
                    703:        fc->fci.retval_ptr_ptr = &retval;
                    704:        fc->fci.param_count = fake_argc;
                    705: 
                    706:        /* build up the params */
                    707: 
                    708:        if (fake_argc) {
                    709:                zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
                    710:        }
                    711: 
                    712:        if (is_agg) {
                    713:                /* summon the aggregation context */
                    714:                agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
                    715: 
                    716:                if (!agg_context->zval_context) {
                    717:                        MAKE_STD_ZVAL(agg_context->zval_context);
                    718:                        ZVAL_NULL(agg_context->zval_context);
                    719:                }
                    720:                zargs[0] = &agg_context->zval_context;
                    721: 
                    722:                zargs[1] = emalloc(sizeof(zval*));
                    723:                MAKE_STD_ZVAL(*zargs[1]);
                    724:                ZVAL_LONG(*zargs[1], agg_context->row_count);
                    725:        }
                    726: 
                    727:        for (i = 0; i < argc; i++) {
                    728:                zargs[i + is_agg] = emalloc(sizeof(zval *));
                    729:                MAKE_STD_ZVAL(*zargs[i + is_agg]);
                    730: 
                    731:                switch (sqlite3_value_type(argv[i])) {
                    732:                        case SQLITE_INTEGER:
1.1.1.3 ! misho     733: #if LONG_MAX > 2147483647
        !           734:                                ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int64(argv[i]));
        !           735: #else
1.1       misho     736:                                ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
1.1.1.3 ! misho     737: #endif
1.1       misho     738:                                break;
                    739: 
                    740:                        case SQLITE_FLOAT:
                    741:                                ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
                    742:                                break;
                    743: 
                    744:                        case SQLITE_NULL:
                    745:                                ZVAL_NULL(*zargs[i + is_agg]);
                    746:                                break;
                    747: 
                    748:                        case SQLITE_BLOB:
                    749:                        case SQLITE3_TEXT:
                    750:                        default:
                    751:                                ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]), 1);
                    752:                                break;
                    753:                }
                    754:        }
                    755: 
                    756:        fc->fci.params = zargs;
                    757: 
                    758:        if ((ret = zend_call_function(&fc->fci, &fc->fcc TSRMLS_CC)) == FAILURE) {
                    759:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
                    760:        }
                    761: 
                    762:        /* clean up the params */
                    763:        if (fake_argc) {
                    764:                for (i = is_agg; i < argc + is_agg; i++) {
                    765:                        zval_ptr_dtor(zargs[i]);
                    766:                        efree(zargs[i]);
                    767:                }
                    768:                if (is_agg) {
                    769:                        zval_ptr_dtor(zargs[1]);
                    770:                        efree(zargs[1]);
                    771:                }
                    772:                efree(zargs);
                    773:        }
                    774: 
                    775:        if (!is_agg || !argv) {
                    776:                /* only set the sqlite return value if we are a scalar function,
                    777:                 * or if we are finalizing an aggregate */
                    778:                if (retval) {
                    779:                        switch (Z_TYPE_P(retval)) {
                    780:                                case IS_LONG:
1.1.1.3 ! misho     781: #if LONG_MAX > 2147483647
        !           782:                                        sqlite3_result_int64(context, Z_LVAL_P(retval));
        !           783: #else
1.1       misho     784:                                        sqlite3_result_int(context, Z_LVAL_P(retval));
1.1.1.3 ! misho     785: #endif
1.1       misho     786:                                        break;
                    787: 
                    788:                                case IS_NULL:
                    789:                                        sqlite3_result_null(context);
                    790:                                        break;
                    791: 
                    792:                                case IS_DOUBLE:
                    793:                                        sqlite3_result_double(context, Z_DVAL_P(retval));
                    794:                                        break;
                    795: 
                    796:                                default:
                    797:                                        convert_to_string_ex(&retval);
                    798:                                        sqlite3_result_text(context, Z_STRVAL_P(retval), Z_STRLEN_P(retval), SQLITE_TRANSIENT);
                    799:                                        break;
                    800:                        }
                    801:                } else {
                    802:                        sqlite3_result_error(context, "failed to invoke callback", 0);
                    803:                }
                    804: 
                    805:                if (agg_context && agg_context->zval_context) {
                    806:                        zval_ptr_dtor(&agg_context->zval_context);
                    807:                }
                    808:        } else {
                    809:                /* we're stepping in an aggregate; the return value goes into
                    810:                 * the context */
                    811:                if (agg_context && agg_context->zval_context) {
                    812:                        zval_ptr_dtor(&agg_context->zval_context);
                    813:                }
                    814:                if (retval) {
                    815:                        agg_context->zval_context = retval;
                    816:                        retval = NULL;
                    817:                } else {
                    818:                        agg_context->zval_context = NULL;
                    819:                }
                    820:        }
                    821: 
                    822:        if (retval) {
                    823:                zval_ptr_dtor(&retval);
                    824:        }
                    825:        return ret;
                    826: }
                    827: /* }}}*/
                    828: 
                    829: static void php_sqlite3_callback_func(sqlite3_context *context, int argc, sqlite3_value **argv) /* {{{ */
                    830: {
                    831:        php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
                    832:        TSRMLS_FETCH();
                    833: 
                    834:        sqlite3_do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
                    835: }
                    836: /* }}}*/
                    837: 
                    838: static void php_sqlite3_callback_step(sqlite3_context *context, int argc, sqlite3_value **argv) /* {{{ */
                    839: {
                    840:        php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
                    841:        php_sqlite3_agg_context *agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
                    842: 
                    843:        TSRMLS_FETCH();
                    844:        agg_context->row_count++;
                    845: 
                    846:        sqlite3_do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
                    847: }
                    848: /* }}} */
                    849: 
                    850: static void php_sqlite3_callback_final(sqlite3_context *context) /* {{{ */
                    851: {
                    852:        php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
                    853:        php_sqlite3_agg_context *agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
                    854: 
                    855:        TSRMLS_FETCH();
                    856:        agg_context->row_count = 0;
                    857: 
                    858:        sqlite3_do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
                    859: }
                    860: /* }}} */
                    861: 
1.1.1.2   misho     862: static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, int b_len, const void* b) /* {{{ */
                    863: {
                    864:        php_sqlite3_collation *collation = (php_sqlite3_collation*)coll;
                    865:        zval ***zargs = NULL;
                    866:        zval *retval = NULL;
                    867:        int ret;
                    868: 
                    869:        TSRMLS_FETCH();
                    870: 
                    871:        collation->fci.fci.size = (sizeof(collation->fci.fci));
                    872:        collation->fci.fci.function_table = EG(function_table);
                    873:        collation->fci.fci.function_name = collation->cmp_func;
                    874:        collation->fci.fci.symbol_table = NULL;
                    875:        collation->fci.fci.object_ptr = NULL;
                    876:        collation->fci.fci.retval_ptr_ptr = &retval;
                    877:        collation->fci.fci.param_count = 2;
                    878: 
                    879:        zargs = (zval***)safe_emalloc(2, sizeof(zval**), 0);
                    880:        zargs[0] = emalloc(sizeof(zval*));
                    881:        zargs[1] = emalloc(sizeof(zval*));
                    882: 
                    883:        MAKE_STD_ZVAL(*zargs[0]);
                    884:        ZVAL_STRINGL(*zargs[0], a, a_len, 1);
                    885: 
                    886:        MAKE_STD_ZVAL(*zargs[1]);
                    887:        ZVAL_STRINGL(*zargs[1], b, b_len, 1);
                    888:  
                    889:        collation->fci.fci.params = zargs;
                    890: 
                    891:        if ((ret = zend_call_function(&collation->fci.fci, &collation->fci.fcc TSRMLS_CC)) == FAILURE) {
                    892:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback");
                    893:        }
                    894: 
                    895:        zval_ptr_dtor(zargs[0]);
                    896:        zval_ptr_dtor(zargs[1]);
                    897:        efree(zargs[0]);
                    898:        efree(zargs[1]);
                    899:        efree(zargs);
                    900: 
                    901:        //retval ought to contain a ZVAL_LONG by now
                    902:        // (the result of a comparison, i.e. most likely -1, 0, or 1)
                    903:        //I suppose we could accept any scalar return type, though.
                    904:        if (Z_TYPE_P(retval) != IS_LONG){
                    905:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback (invalid return type).  Collation behaviour is undefined.");
                    906:        }else{
                    907:                ret = Z_LVAL_P(retval);
                    908:        }
                    909: 
                    910:        zval_ptr_dtor(&retval);
                    911: 
                    912:        return ret;
                    913: }
                    914: /* }}} */
                    915: 
1.1       misho     916: /* {{{ proto bool SQLite3::createFunction(string name, mixed callback [, int argcount])
                    917:    Allows registration of a PHP function as a SQLite UDF that can be called within SQL statements. */
                    918: PHP_METHOD(sqlite3, createFunction)
                    919: {
                    920:        php_sqlite3_db_object *db_obj;
                    921:        zval *object = getThis();
                    922:        php_sqlite3_func *func;
                    923:        char *sql_func, *callback_name;
                    924:        int sql_func_len;
                    925:        zval *callback_func;
                    926:        long sql_func_num_args = -1;
                    927:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    928: 
                    929:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    930: 
                    931:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &sql_func, &sql_func_len, &callback_func, &sql_func_num_args) == FAILURE) {
                    932:                return;
                    933:        }
                    934: 
                    935:        if (!sql_func_len) {
                    936:                RETURN_FALSE;
                    937:        }
                    938: 
                    939:        if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
                    940:                php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
                    941:                efree(callback_name);
                    942:                RETURN_FALSE;
                    943:        }
                    944:        efree(callback_name);
                    945: 
                    946:        func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
                    947: 
                    948:        if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, php_sqlite3_callback_func, NULL, NULL) == SQLITE_OK) {
                    949:                func->func_name = estrdup(sql_func);
                    950: 
                    951:                MAKE_STD_ZVAL(func->func);
                    952:                MAKE_COPY_ZVAL(&callback_func, func->func);
                    953: 
                    954:                func->argc = sql_func_num_args;
                    955:                func->next = db_obj->funcs;
                    956:                db_obj->funcs = func;
                    957: 
                    958:                RETURN_TRUE;
                    959:        }
                    960:        efree(func);
                    961: 
                    962:        RETURN_FALSE;
                    963: }
                    964: /* }}} */
                    965: 
                    966: /* {{{ proto bool SQLite3::createAggregate(string name, mixed step, mixed final [, int argcount])
                    967:    Allows registration of a PHP function for use as an aggregate. */
                    968: PHP_METHOD(sqlite3, createAggregate)
                    969: {
                    970:        php_sqlite3_db_object *db_obj;
                    971:        zval *object = getThis();
                    972:        php_sqlite3_func *func;
                    973:        char *sql_func, *callback_name;
                    974:        int sql_func_len;
                    975:        zval *step_callback, *fini_callback;
                    976:        long sql_func_num_args = -1;
                    977:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                    978: 
                    979:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                    980: 
                    981:        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) {
                    982:                return;
                    983:        }
                    984: 
                    985:        if (!sql_func_len) {
                    986:                RETURN_FALSE;
                    987:        }
                    988: 
                    989:        if (!zend_is_callable(step_callback, 0, &callback_name TSRMLS_CC)) {
                    990:                php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
                    991:                efree(callback_name);
                    992:                RETURN_FALSE;
                    993:        }
                    994:        efree(callback_name);
                    995: 
                    996:        if (!zend_is_callable(fini_callback, 0, &callback_name TSRMLS_CC)) {
                    997:                php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
                    998:                efree(callback_name);
                    999:                RETURN_FALSE;
                   1000:        }
                   1001:        efree(callback_name);
                   1002: 
                   1003:        func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
                   1004: 
                   1005:        if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, NULL, php_sqlite3_callback_step, php_sqlite3_callback_final) == SQLITE_OK) {
                   1006:                func->func_name = estrdup(sql_func);
                   1007: 
                   1008:                MAKE_STD_ZVAL(func->step);
                   1009:                MAKE_COPY_ZVAL(&step_callback, func->step);
                   1010: 
                   1011:                MAKE_STD_ZVAL(func->fini);
                   1012:                MAKE_COPY_ZVAL(&fini_callback, func->fini);
                   1013: 
                   1014:                func->argc = sql_func_num_args;
                   1015:                func->next = db_obj->funcs;
                   1016:                db_obj->funcs = func;
                   1017: 
                   1018:                RETURN_TRUE;
                   1019:        }
                   1020:        efree(func);
                   1021: 
                   1022:        RETURN_FALSE;
                   1023: }
                   1024: /* }}} */
                   1025: 
1.1.1.2   misho    1026: /* {{{ proto bool SQLite3::createCollation(string name, mixed callback)
                   1027:    Registers a PHP function as a comparator that can be used with the SQL COLLATE operator. Callback must accept two strings and return an integer (as strcmp()). */
                   1028: PHP_METHOD(sqlite3, createCollation)
                   1029: {
                   1030:        php_sqlite3_db_object *db_obj;
                   1031:        zval *object = getThis();
                   1032:        php_sqlite3_collation *collation;
                   1033:        char *collation_name, *callback_name;
                   1034:        int collation_name_len;
                   1035:        zval *callback_func;
                   1036:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                   1037: 
                   1038:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                   1039: 
                   1040:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &collation_name, &collation_name_len, &callback_func) == FAILURE) {
                   1041:                RETURN_FALSE;
                   1042:        }
                   1043: 
                   1044:        if (!collation_name_len) {
                   1045:                RETURN_FALSE;
                   1046:        }
                   1047: 
                   1048:        if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
                   1049:                php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
                   1050:                efree(callback_name);
                   1051:                RETURN_FALSE;
                   1052:        }
                   1053:        efree(callback_name);
                   1054: 
                   1055:        collation = (php_sqlite3_collation *)ecalloc(1, sizeof(*collation));
                   1056:        if (sqlite3_create_collation(db_obj->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_callback_compare) == SQLITE_OK) {
                   1057:                collation->collation_name = estrdup(collation_name);
                   1058: 
                   1059:                MAKE_STD_ZVAL(collation->cmp_func);
                   1060:                MAKE_COPY_ZVAL(&callback_func, collation->cmp_func);
                   1061: 
                   1062:                collation->next = db_obj->collations;
                   1063:                db_obj->collations = collation;
                   1064: 
                   1065:                RETURN_TRUE;
                   1066:        }
                   1067:        efree(collation);
                   1068: 
                   1069:        RETURN_FALSE;
                   1070: }
                   1071: /* }}} */
                   1072: 
1.1       misho    1073: typedef struct {
                   1074:        sqlite3_blob *blob;
                   1075:        size_t           position;
                   1076:        size_t       size;
                   1077: } php_stream_sqlite3_data;
                   1078: 
                   1079: static size_t php_sqlite3_stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
                   1080: {
                   1081: /*     php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract; */
                   1082:        
                   1083:        return 0;
                   1084: }
                   1085: 
                   1086: static size_t php_sqlite3_stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
                   1087: {
                   1088:        php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
                   1089: 
                   1090:        if (sqlite3_stream->position + count >= sqlite3_stream->size) {
                   1091:                count = sqlite3_stream->size - sqlite3_stream->position;
                   1092:                stream->eof = 1;
                   1093:        }
                   1094:        if (count) {
                   1095:                if (sqlite3_blob_read(sqlite3_stream->blob, buf, count, sqlite3_stream->position) != SQLITE_OK) {
                   1096:                        return 0;
                   1097:                }
                   1098:                sqlite3_stream->position += count;
                   1099:        }
                   1100:        return count;
                   1101: }
                   1102: 
                   1103: static int php_sqlite3_stream_close(php_stream *stream, int close_handle TSRMLS_DC)
                   1104: {
                   1105:        php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
                   1106:        
                   1107:        if (sqlite3_blob_close(sqlite3_stream->blob) != SQLITE_OK) {
1.1.1.3 ! misho    1108:                /* Error occurred, but it still closed */
1.1       misho    1109:        }
                   1110: 
                   1111:        efree(sqlite3_stream);
                   1112:        
                   1113:        return 0;
                   1114: }
                   1115: 
                   1116: static int php_sqlite3_stream_flush(php_stream *stream TSRMLS_DC)
                   1117: {
                   1118:        /* do nothing */
                   1119:        return 0;
                   1120: }
                   1121: 
                   1122: /* {{{ */
                   1123: static int php_sqlite3_stream_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
                   1124: {
                   1125:        php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
                   1126: 
                   1127:        switch(whence) {
                   1128:                case SEEK_CUR:
                   1129:                        if (offset < 0) {
                   1130:                                if (sqlite3_stream->position < (size_t)(-offset)) {
                   1131:                                        sqlite3_stream->position = 0;
                   1132:                                        *newoffs = -1;
                   1133:                                        return -1;
                   1134:                                } else {
                   1135:                                        sqlite3_stream->position = sqlite3_stream->position + offset;
                   1136:                                        *newoffs = sqlite3_stream->position;
                   1137:                                        stream->eof = 0;
                   1138:                                        return 0;
                   1139:                                }
                   1140:                        } else {
                   1141:                                if (sqlite3_stream->position + (size_t)(offset) > sqlite3_stream->size) {
                   1142:                                        sqlite3_stream->position = sqlite3_stream->size;
                   1143:                                        *newoffs = -1;
                   1144:                                        return -1;
                   1145:                                } else {
                   1146:                                        sqlite3_stream->position = sqlite3_stream->position + offset;
                   1147:                                        *newoffs = sqlite3_stream->position;
                   1148:                                        stream->eof = 0;
                   1149:                                        return 0;
                   1150:                                }
                   1151:                        }
                   1152:                case SEEK_SET:
                   1153:                        if (sqlite3_stream->size < (size_t)(offset)) {
                   1154:                                sqlite3_stream->position = sqlite3_stream->size;
                   1155:                                *newoffs = -1;
                   1156:                                return -1;
                   1157:                        } else {
                   1158:                                sqlite3_stream->position = offset;
                   1159:                                *newoffs = sqlite3_stream->position;
                   1160:                                stream->eof = 0;
                   1161:                                return 0;
                   1162:                        }
                   1163:                case SEEK_END:
                   1164:                        if (offset > 0) {
                   1165:                                sqlite3_stream->position = sqlite3_stream->size;
                   1166:                                *newoffs = -1;
                   1167:                                return -1;
                   1168:                        } else if (sqlite3_stream->size < (size_t)(-offset)) {
                   1169:                                sqlite3_stream->position = 0;
                   1170:                                *newoffs = -1;
                   1171:                                return -1;
                   1172:                        } else {
                   1173:                                sqlite3_stream->position = sqlite3_stream->size + offset;
                   1174:                                *newoffs = sqlite3_stream->position;
                   1175:                                stream->eof = 0;
                   1176:                                return 0;
                   1177:                        }
                   1178:                default:
                   1179:                        *newoffs = sqlite3_stream->position;
                   1180:                        return -1;
                   1181:        }
                   1182: }
                   1183: /* }}} */
                   1184: 
                   1185: 
                   1186: static int php_sqlite3_stream_cast(php_stream *stream, int castas, void **ret TSRMLS_DC)
                   1187: {
                   1188:        return FAILURE;
                   1189: }
                   1190: 
                   1191: static int php_sqlite3_stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
                   1192: {
                   1193:        php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
                   1194:        ssb->sb.st_size = sqlite3_stream->size;
                   1195:        return 0;
                   1196: }
                   1197: 
                   1198: static php_stream_ops php_stream_sqlite3_ops = {
                   1199:        php_sqlite3_stream_write,
                   1200:        php_sqlite3_stream_read,
                   1201:        php_sqlite3_stream_close,
                   1202:        php_sqlite3_stream_flush,
                   1203:        "SQLite3",
                   1204:        php_sqlite3_stream_seek,
                   1205:        php_sqlite3_stream_cast,
                   1206:        php_sqlite3_stream_stat
                   1207: };
                   1208: 
                   1209: /* {{{ proto resource SQLite3::openBlob(string table, string column, int rowid [, string dbname])
                   1210:    Open a blob as a stream which we can read / write to. */
                   1211: PHP_METHOD(sqlite3, openBlob)
                   1212: {
                   1213:        php_sqlite3_db_object *db_obj;
                   1214:        zval *object = getThis();
                   1215:        char *table, *column, *dbname = "main";
                   1216:        int table_len, column_len, dbname_len;
                   1217:        long rowid, flags = 0;
                   1218:        sqlite3_blob *blob = NULL;
                   1219:        php_stream_sqlite3_data *sqlite3_stream;
                   1220:        php_stream *stream;
                   1221: 
                   1222:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                   1223: 
                   1224:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                   1225: 
                   1226:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl|s", &table, &table_len, &column, &column_len, &rowid, &dbname, &dbname_len) == FAILURE) {
                   1227:                return;
                   1228:        }
                   1229: 
                   1230:        if (sqlite3_blob_open(db_obj->db, dbname, table, column, rowid, flags, &blob) != SQLITE_OK) {
                   1231:                php_sqlite3_error(db_obj, "Unable to open blob: %s", sqlite3_errmsg(db_obj->db));
                   1232:                RETURN_FALSE;
                   1233:        }
                   1234: 
                   1235:        sqlite3_stream = emalloc(sizeof(php_stream_sqlite3_data));
                   1236:        sqlite3_stream->blob = blob;
                   1237:        sqlite3_stream->position = 0;
                   1238:        sqlite3_stream->size = sqlite3_blob_bytes(blob);
                   1239:        
                   1240:        stream = php_stream_alloc(&php_stream_sqlite3_ops, sqlite3_stream, 0, "rb");
                   1241: 
                   1242:        if (stream) {
                   1243:                php_stream_to_zval(stream, return_value);
                   1244:        } else {
                   1245:                RETURN_FALSE;
                   1246:        }
                   1247: }
                   1248: /* }}} */
                   1249: 
                   1250: /* {{{ proto bool SQLite3::enableExceptions([bool enableExceptions = false])
                   1251:    Enables an exception error mode. */
                   1252: PHP_METHOD(sqlite3, enableExceptions)
                   1253: {
                   1254:        php_sqlite3_db_object *db_obj;
                   1255:        zval *object = getThis();
                   1256:        zend_bool enableExceptions = 0;
                   1257: 
                   1258:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
                   1259: 
                   1260:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enableExceptions) == FAILURE) {
                   1261:                return;
                   1262:        }
                   1263: 
                   1264:        RETVAL_BOOL(db_obj->exception);
                   1265: 
                   1266:        db_obj->exception = enableExceptions;
                   1267: }
                   1268: /* }}} */
                   1269: 
                   1270: /* {{{ proto int SQLite3Stmt::paramCount()
                   1271:    Returns the number of parameters within the prepared statement. */
                   1272: PHP_METHOD(sqlite3stmt, paramCount)
                   1273: {
                   1274:        php_sqlite3_stmt *stmt_obj;
                   1275:        zval *object = getThis();
                   1276:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1277: 
                   1278:        if (zend_parse_parameters_none() == FAILURE) {
                   1279:                return;
                   1280:        }
                   1281: 
                   1282:        RETURN_LONG(sqlite3_bind_parameter_count(stmt_obj->stmt));
                   1283: }
                   1284: /* }}} */
                   1285: 
                   1286: /* {{{ proto bool SQLite3Stmt::close()
                   1287:    Closes the prepared statement. */
                   1288: PHP_METHOD(sqlite3stmt, close)
                   1289: {
                   1290:        php_sqlite3_stmt *stmt_obj;
                   1291:        zval *object = getThis();
                   1292:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1293: 
                   1294:        if (zend_parse_parameters_none() == FAILURE) {
                   1295:                return;
                   1296:        }
                   1297: 
                   1298:        zend_llist_del_element(&(stmt_obj->db_obj->free_list), object, (int (*)(void *, void *)) php_sqlite3_compare_stmt_zval_free);
                   1299: 
                   1300:        RETURN_TRUE;
                   1301: }
                   1302: /* }}} */
                   1303: 
                   1304: /* {{{ proto bool SQLite3Stmt::reset()
                   1305:    Reset the prepared statement to the state before it was executed, bindings still remain. */
                   1306: PHP_METHOD(sqlite3stmt, reset)
                   1307: {
                   1308:        php_sqlite3_stmt *stmt_obj;
                   1309:        zval *object = getThis();
                   1310:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1311: 
                   1312:        if (zend_parse_parameters_none() == FAILURE) {
                   1313:                return;
                   1314:        }
                   1315: 
                   1316:        if (sqlite3_reset(stmt_obj->stmt) != SQLITE_OK) {
                   1317:                php_sqlite3_error(stmt_obj->db_obj, "Unable to reset statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt)));
                   1318:                RETURN_FALSE;
                   1319:        }
                   1320:        RETURN_TRUE;
                   1321: }
                   1322: /* }}} */
                   1323: 
                   1324: /* {{{ proto bool SQLite3Stmt::clear()
                   1325:    Clear all current bound parameters. */
                   1326: PHP_METHOD(sqlite3stmt, clear)
                   1327: {
                   1328:        php_sqlite3_stmt *stmt_obj;
                   1329:        zval *object = getThis();
                   1330:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1331: 
                   1332:        if (zend_parse_parameters_none() == FAILURE) {
                   1333:                return;
                   1334:        }
                   1335: 
                   1336:        if (sqlite3_clear_bindings(stmt_obj->stmt) != SQLITE_OK) {
                   1337:                php_sqlite3_error(stmt_obj->db_obj, "Unable to clear statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt)));
                   1338:                RETURN_FALSE;
                   1339:        }
                   1340: 
                   1341:        RETURN_TRUE;
                   1342: }
                   1343: /* }}} */
                   1344: 
                   1345: /* {{{ proto bool SQLite3Stmt::readOnly()
                   1346:    Returns true if a statement is definitely read only */
                   1347: PHP_METHOD(sqlite3stmt, readOnly)
                   1348: {
                   1349:        php_sqlite3_stmt *stmt_obj;
                   1350:        zval *object = getThis();
                   1351:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1352: 
                   1353:        if (zend_parse_parameters_none() == FAILURE) {
                   1354:                return;
                   1355:        }
                   1356: 
                   1357: #if SQLITE_VERSION_NUMBER >= 3007004
                   1358:        if (sqlite3_stmt_readonly(stmt_obj->stmt)) {
                   1359:                RETURN_TRUE;
                   1360:        }
                   1361: #endif
                   1362:        RETURN_FALSE;
                   1363: }
                   1364: /* }}} */
                   1365: 
                   1366: static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *param, php_sqlite3_stmt *stmt TSRMLS_DC) /* {{{ */
                   1367: {
                   1368:        HashTable *hash;
                   1369:        hash = stmt->bound_params;
                   1370: 
                   1371:        if (!hash) {
                   1372:                ALLOC_HASHTABLE(hash);
                   1373:                zend_hash_init(hash, 13, NULL, sqlite3_param_dtor, 0);
                   1374:                stmt->bound_params = hash;
                   1375:        }
                   1376: 
                   1377:        /* We need a : prefix to resolve a name to a parameter number */
                   1378:        if (param->name) {
                   1379:                if (param->name[0] != ':') {
                   1380:                        /* pre-increment for character + 1 for null */
                   1381:                        char *temp = emalloc(++param->name_len + 1);
                   1382:                        temp[0] = ':';
                   1383:                        memmove(temp+1, param->name, param->name_len);
                   1384:                        param->name = temp;
                   1385:                } else {
                   1386:                        param->name = estrndup(param->name, param->name_len);
                   1387:                }
                   1388:                /* do lookup*/
                   1389:                param->param_number = sqlite3_bind_parameter_index(stmt->stmt, param->name);
                   1390:        }
                   1391: 
                   1392:        if (param->param_number < 1) {
                   1393:                efree(param->name);
                   1394:                return 0;
                   1395:        }
                   1396: 
                   1397:        if (param->param_number >= 1) {
                   1398:                zend_hash_index_del(hash, param->param_number);
                   1399:        }
                   1400: 
                   1401:        if (param->name) {
                   1402:                zend_hash_update(hash, param->name, param->name_len, param, sizeof(*param), NULL);
                   1403:        } else {
                   1404:                zend_hash_index_update(hash, param->param_number, param, sizeof(*param), NULL);
                   1405:        }
                   1406: 
                   1407:        return 1;
                   1408: }
                   1409: /* }}} */
                   1410: 
                   1411: /* {{{ proto bool SQLite3Stmt::bindParam(int parameter_number, mixed parameter [, int type])
1.1.1.3 ! misho    1412:    Bind Parameter to a stmt variable. */
1.1       misho    1413: PHP_METHOD(sqlite3stmt, bindParam)
                   1414: {
                   1415:        php_sqlite3_stmt *stmt_obj;
                   1416:        zval *object = getThis();
                   1417:        struct php_sqlite3_bound_param param = {0};
                   1418:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1419: 
                   1420:        param.param_number = -1;
                   1421:        param.type = SQLITE3_TEXT;
                   1422: 
                   1423:        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", &param.param_number, &param.parameter, &param.type) == FAILURE) {
                   1424:                if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &param.name, &param.name_len, &param.parameter, &param.type) == FAILURE) {
                   1425:                        return;
                   1426:                }
                   1427:        }
                   1428: 
                   1429:        Z_ADDREF_P(param.parameter);
                   1430: 
                   1431:        if (!register_bound_parameter_to_sqlite(&param, stmt_obj TSRMLS_CC)) {
                   1432:                if (param.parameter) {
                   1433:                        zval_ptr_dtor(&(param.parameter));
                   1434:                        param.parameter = NULL;
                   1435:                }
                   1436:                RETURN_FALSE;
                   1437:        }
                   1438:        RETURN_TRUE;
                   1439: }
                   1440: /* }}} */
                   1441: 
                   1442: /* {{{ proto bool SQLite3Stmt::bindValue(int parameter_number, mixed parameter [, int type])
                   1443:    Bind Value of a parameter to a stmt variable. */
                   1444: PHP_METHOD(sqlite3stmt, bindValue)
                   1445: {
                   1446:        php_sqlite3_stmt *stmt_obj;
                   1447:        zval *object = getThis();
                   1448:        struct php_sqlite3_bound_param param = {0};
                   1449:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1450: 
                   1451:        param.param_number = -1;
                   1452:        param.type = SQLITE3_TEXT;
                   1453: 
                   1454:        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", &param.param_number, &param.parameter, &param.type) == FAILURE) {
                   1455:                if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", &param.name, &param.name_len, &param.parameter, &param.type) == FAILURE) {
                   1456:                        return;
                   1457:                }
                   1458:        }
                   1459: 
                   1460:        Z_ADDREF_P(param.parameter);
                   1461: 
                   1462:        if (!register_bound_parameter_to_sqlite(&param, stmt_obj TSRMLS_CC)) {
                   1463:                if (param.parameter) {
                   1464:                        zval_ptr_dtor(&(param.parameter));
                   1465:                        param.parameter = NULL;
                   1466:                }
                   1467:                RETURN_FALSE;
                   1468:        }
                   1469:        RETURN_TRUE;
                   1470: }
                   1471: /* }}} */
                   1472: 
                   1473: /* {{{ proto SQLite3Result SQLite3Stmt::execute()
                   1474:    Executes a prepared statement and returns a result set object. */
                   1475: PHP_METHOD(sqlite3stmt, execute)
                   1476: {
                   1477:        php_sqlite3_stmt *stmt_obj;
                   1478:        php_sqlite3_result *result;
                   1479:        zval *object = getThis();
                   1480:        int return_code = 0;
                   1481:        struct php_sqlite3_bound_param *param;
                   1482: 
                   1483:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1484: 
                   1485:        if (zend_parse_parameters_none() == FAILURE) {
                   1486:                return;
                   1487:        }
                   1488: 
                   1489:        SQLITE3_CHECK_INITIALIZED(stmt_obj->db_obj, stmt_obj->initialised, SQLite3)
                   1490: 
                   1491:        if (stmt_obj->bound_params) {
                   1492:                zend_hash_internal_pointer_reset(stmt_obj->bound_params);
                   1493:                while (zend_hash_get_current_data(stmt_obj->bound_params, (void **)&param) == SUCCESS) {
                   1494:                        /* If the ZVAL is null then it should be bound as that */
                   1495:                        if (Z_TYPE_P(param->parameter) == IS_NULL) {
                   1496:                                sqlite3_bind_null(stmt_obj->stmt, param->param_number);
                   1497:                                zend_hash_move_forward(stmt_obj->bound_params);
                   1498:                                continue;
                   1499:                        }
                   1500: 
                   1501:                        switch (param->type) {
                   1502:                                case SQLITE_INTEGER:
                   1503:                                        convert_to_long(param->parameter);
1.1.1.3 ! misho    1504: #if LONG_MAX > 2147483647
        !          1505:                                        sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
        !          1506: #else
1.1       misho    1507:                                        sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
1.1.1.3 ! misho    1508: #endif
1.1       misho    1509:                                        break;
                   1510: 
                   1511:                                case SQLITE_FLOAT:
                   1512:                                        /* convert_to_double(param->parameter);*/
                   1513:                                        sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(param->parameter));
                   1514:                                        break;
                   1515: 
                   1516:                                case SQLITE_BLOB:
                   1517:                                {
                   1518:                                        php_stream *stream = NULL;
                   1519:                                        int blength;
                   1520:                                        char *buffer = NULL;
                   1521:                                        if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
                   1522:                                                php_stream_from_zval_no_verify(stream, &param->parameter);
                   1523:                                                if (stream == NULL) {
                   1524:                                                        php_sqlite3_error(stmt_obj->db_obj, "Unable to read stream for parameter %ld", param->param_number);
                   1525:                                                        RETURN_FALSE;
                   1526:                                                }
                   1527:                                                blength = php_stream_copy_to_mem(stream, (void *)&buffer, PHP_STREAM_COPY_ALL, 0);
                   1528:                                        } else {
                   1529:                                                convert_to_string(param->parameter);
                   1530:                                                blength =  Z_STRLEN_P(param->parameter);
                   1531:                                                buffer = Z_STRVAL_P(param->parameter);
                   1532:                                        }
                   1533: 
                   1534:                                        sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT);
                   1535: 
                   1536:                                        if (stream) {
                   1537:                                                pefree(buffer, 0);
                   1538:                                        }
                   1539:                                        break;
                   1540:                                }
                   1541: 
                   1542:                                case SQLITE3_TEXT:
                   1543:                                        convert_to_string(param->parameter);
                   1544:                                        sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC);
                   1545:                                        break;
                   1546: 
                   1547:                                case SQLITE_NULL:
                   1548:                                        sqlite3_bind_null(stmt_obj->stmt, param->param_number);
                   1549:                                        break;
                   1550: 
                   1551:                                default:
                   1552:                                        php_sqlite3_error(stmt_obj->db_obj, "Unknown parameter type: %ld for parameter %ld", param->type, param->param_number);
                   1553:                                        RETURN_FALSE;
                   1554:                        }
                   1555:                        zend_hash_move_forward(stmt_obj->bound_params);
                   1556:                }
                   1557:        }
                   1558: 
                   1559:        return_code = sqlite3_step(stmt_obj->stmt);
                   1560: 
                   1561:        switch (return_code) {
                   1562:                case SQLITE_ROW: /* Valid Row */
                   1563:                case SQLITE_DONE: /* Valid but no results */
                   1564:                {
                   1565:                        sqlite3_reset(stmt_obj->stmt);
                   1566:                        object_init_ex(return_value, php_sqlite3_result_entry);
                   1567:                        result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
                   1568: 
                   1569:                        Z_ADDREF_P(object);
                   1570:        
                   1571:                        result->is_prepared_statement = 1;
                   1572:                        result->db_obj = stmt_obj->db_obj;
                   1573:                        result->stmt_obj = stmt_obj;
                   1574:                        result->stmt_obj_zval = getThis();
                   1575: 
                   1576:                        break;
                   1577:                }
                   1578:                case SQLITE_ERROR:
                   1579:                        sqlite3_reset(stmt_obj->stmt);
                   1580: 
                   1581:                default:
                   1582:                        php_sqlite3_error(stmt_obj->db_obj, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt)));
                   1583:                        zval_dtor(return_value);
                   1584:                        RETURN_FALSE;
                   1585:        }
                   1586: 
                   1587:        return;
                   1588: }
                   1589: /* }}} */
                   1590: 
                   1591: /* {{{ proto int SQLite3Stmt::__construct(SQLite3 dbobject, String Statement)
                   1592:    __constructor for SQLite3Stmt. */
                   1593: PHP_METHOD(sqlite3stmt, __construct)
                   1594: {
                   1595:        php_sqlite3_stmt *stmt_obj;
                   1596:        php_sqlite3_db_object *db_obj;
                   1597:        zval *object = getThis();
                   1598:        zval *db_zval;
                   1599:        char *sql;
                   1600:        int sql_len, errcode;
                   1601:        zend_error_handling error_handling;
                   1602:        php_sqlite3_free_list *free_item;
                   1603: 
                   1604:        stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
                   1605:        zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
                   1606: 
                   1607:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &db_zval, php_sqlite3_sc_entry, &sql, &sql_len) == FAILURE) {
                   1608:                zend_restore_error_handling(&error_handling TSRMLS_CC);
                   1609:                return;
                   1610:        }
                   1611: 
                   1612:        db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(db_zval TSRMLS_CC);
                   1613: 
                   1614:        SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
                   1615: 
                   1616:        zend_restore_error_handling(&error_handling TSRMLS_CC);
                   1617: 
                   1618:        if (!sql_len) {
                   1619:                RETURN_FALSE;
                   1620:        }
                   1621: 
                   1622:        stmt_obj->db_obj = db_obj;
                   1623:        stmt_obj->db_obj_zval = db_zval;
                   1624: 
                   1625:        Z_ADDREF_P(db_zval);
                   1626:        
                   1627:        errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
                   1628:        if (errcode != SQLITE_OK) {
                   1629:                php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", errcode, sqlite3_errmsg(db_obj->db));
                   1630:                zval_dtor(return_value);
                   1631:                RETURN_FALSE;
                   1632:        }
                   1633:        stmt_obj->initialised = 1;
                   1634: 
                   1635:        free_item = emalloc(sizeof(php_sqlite3_free_list));
                   1636:        free_item->stmt_obj = stmt_obj;
                   1637:        free_item->stmt_obj_zval = getThis();
                   1638: 
                   1639:        zend_llist_add_element(&(db_obj->free_list), &free_item);
                   1640: }
                   1641: /* }}} */
                   1642: 
                   1643: /* {{{ proto int SQLite3Result::numColumns()
                   1644:    Number of columns in the result set. */
                   1645: PHP_METHOD(sqlite3result, numColumns)
                   1646: {
                   1647:        php_sqlite3_result *result_obj;
                   1648:        zval *object = getThis();
                   1649:        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
                   1650: 
                   1651:        SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
                   1652: 
                   1653:        if (zend_parse_parameters_none() == FAILURE) {
                   1654:                return;
                   1655:        }
                   1656: 
                   1657:        RETURN_LONG(sqlite3_column_count(result_obj->stmt_obj->stmt));
                   1658: }
                   1659: /* }}} */
                   1660: 
                   1661: /* {{{ proto string SQLite3Result::columnName(int column)
                   1662:    Returns the name of the nth column. */
                   1663: PHP_METHOD(sqlite3result, columnName)
                   1664: {
                   1665:        php_sqlite3_result *result_obj;
                   1666:        zval *object = getThis();
                   1667:        long column = 0;
                   1668:        char *column_name;
                   1669:        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
                   1670: 
                   1671:        SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
                   1672: 
                   1673:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) {
                   1674:                return;
                   1675:        }
                   1676:        column_name = (char*) sqlite3_column_name(result_obj->stmt_obj->stmt, column);
                   1677: 
                   1678:        if (column_name == NULL) {
                   1679:                RETURN_FALSE;
                   1680:        }
                   1681:                
                   1682:        RETVAL_STRING(column_name, 1);
                   1683: }
                   1684: /* }}} */
                   1685: 
                   1686: /* {{{ proto int SQLite3Result::columnType(int column)
                   1687:    Returns the type of the nth column. */
                   1688: PHP_METHOD(sqlite3result, columnType)
                   1689: {
                   1690:        php_sqlite3_result *result_obj;
                   1691:        zval *object = getThis();
                   1692:        long column = 0;
                   1693:        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
                   1694: 
                   1695:        SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
                   1696: 
                   1697:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) {
                   1698:                return;
                   1699:        }
                   1700: 
                   1701:        if (result_obj->complete) {
                   1702:                RETURN_FALSE;
                   1703:        }
                   1704: 
                   1705:        RETURN_LONG(sqlite3_column_type(result_obj->stmt_obj->stmt, column));
                   1706: }
                   1707: /* }}} */
                   1708: 
                   1709: /* {{{ proto array SQLite3Result::fetchArray([int mode])
                   1710:    Fetch a result row as both an associative or numerically indexed array or both. */
                   1711: PHP_METHOD(sqlite3result, fetchArray)
                   1712: {
                   1713:        php_sqlite3_result *result_obj;
                   1714:        zval *object = getThis();
                   1715:        int i, ret;
                   1716:        long mode = PHP_SQLITE3_BOTH;
                   1717:        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
                   1718: 
                   1719:        SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
                   1720: 
                   1721:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mode) == FAILURE) {
                   1722:                return;
                   1723:        }
                   1724: 
                   1725:        ret = sqlite3_step(result_obj->stmt_obj->stmt);
                   1726:        switch (ret) {
                   1727:                case SQLITE_ROW:
                   1728:                        /* If there was no return value then just skip fetching */
                   1729:                        if (!return_value_used) {
                   1730:                                return;
                   1731:                        }
                   1732: 
                   1733:                        array_init(return_value);
                   1734: 
                   1735:                        for (i = 0; i < sqlite3_data_count(result_obj->stmt_obj->stmt); i++) {
                   1736:                                zval *data;
                   1737: 
                   1738:                                data = sqlite_value_to_zval(result_obj->stmt_obj->stmt, i);
                   1739: 
                   1740:                                if (mode & PHP_SQLITE3_NUM) {
                   1741:                                        add_index_zval(return_value, i, data);
                   1742:                                }
                   1743: 
                   1744:                                if (mode & PHP_SQLITE3_ASSOC) {
                   1745:                                        if (mode & PHP_SQLITE3_NUM) {
                   1746:                                                Z_ADDREF_P(data);
                   1747:                                        }
                   1748:                                        add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->stmt_obj->stmt, i), data);
                   1749:                                }
                   1750:                        }
                   1751:                        break;
                   1752: 
                   1753:                case SQLITE_DONE:
                   1754:                        result_obj->complete = 1;
                   1755:                        RETURN_FALSE;
                   1756:                        break;
                   1757: 
                   1758:                default:
                   1759:                        php_sqlite3_error(result_obj->db_obj, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(result_obj->stmt_obj->stmt)));
                   1760:        }
                   1761: }
                   1762: /* }}} */
                   1763: 
                   1764: /* {{{ proto bool SQLite3Result::reset()
                   1765:    Resets the result set back to the first row. */
                   1766: PHP_METHOD(sqlite3result, reset)
                   1767: {
                   1768:        php_sqlite3_result *result_obj;
                   1769:        zval *object = getThis();
                   1770:        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
                   1771: 
                   1772:        SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
                   1773: 
                   1774:        if (zend_parse_parameters_none() == FAILURE) {
                   1775:                return;
                   1776:        }
                   1777: 
                   1778:        if (sqlite3_reset(result_obj->stmt_obj->stmt) != SQLITE_OK) {
                   1779:                RETURN_FALSE;
                   1780:        }
                   1781: 
                   1782:        result_obj->complete = 0;
                   1783: 
                   1784:        RETURN_TRUE;
                   1785: }
                   1786: /* }}} */
                   1787: 
                   1788: /* {{{ proto bool SQLite3Result::finalize()
                   1789:    Closes the result set. */
                   1790: PHP_METHOD(sqlite3result, finalize)
                   1791: {
                   1792:        php_sqlite3_result *result_obj;
                   1793:        zval *object = getThis();
                   1794:        result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
                   1795: 
                   1796:        SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
                   1797: 
                   1798:        if (zend_parse_parameters_none() == FAILURE) {
                   1799:                return;
                   1800:        }
                   1801: 
                   1802:        /* We need to finalize an internal statement */
                   1803:        if (result_obj->is_prepared_statement == 0) {
                   1804:                zend_llist_del_element(&(result_obj->db_obj->free_list), result_obj->stmt_obj_zval,
                   1805:                        (int (*)(void *, void *)) php_sqlite3_compare_stmt_zval_free);
                   1806:        } else {
                   1807:                sqlite3_reset(result_obj->stmt_obj->stmt);
                   1808:        }
                   1809: 
                   1810:        RETURN_TRUE;
                   1811: }
                   1812: /* }}} */
                   1813: 
                   1814: /* {{{ proto int SQLite3Result::__construct()
                   1815:    __constructor for SQLite3Result. */
                   1816: PHP_METHOD(sqlite3result, __construct)
                   1817: {
                   1818:        zend_throw_exception(zend_exception_get_default(TSRMLS_C), "SQLite3Result cannot be directly instantiated", 0 TSRMLS_CC);
                   1819: }
                   1820: /* }}} */
                   1821: 
                   1822: /* {{{ arginfo */
                   1823: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_open, 0)
                   1824:        ZEND_ARG_INFO(0, filename)
                   1825:        ZEND_ARG_INFO(0, flags)
                   1826:        ZEND_ARG_INFO(0, encryption_key)
                   1827: ZEND_END_ARG_INFO()
                   1828: 
                   1829: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_busytimeout, 0)
                   1830:        ZEND_ARG_INFO(0, ms)
                   1831: ZEND_END_ARG_INFO()
                   1832: 
                   1833: #ifndef SQLITE_OMIT_LOAD_EXTENSION
                   1834: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_loadextension, 0)
                   1835:        ZEND_ARG_INFO(0, shared_library)
                   1836: ZEND_END_ARG_INFO()
                   1837: #endif
                   1838: 
                   1839: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_escapestring, 0, 0, 1)
                   1840:        ZEND_ARG_INFO(0, value)
                   1841: ZEND_END_ARG_INFO()
                   1842: 
                   1843: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_query, 0, 0, 1)
                   1844:        ZEND_ARG_INFO(0, query)
                   1845: ZEND_END_ARG_INFO()
                   1846: 
                   1847: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_querysingle, 0, 0, 1)
                   1848:        ZEND_ARG_INFO(0, query)
                   1849:        ZEND_ARG_INFO(0, entire_row)
                   1850: ZEND_END_ARG_INFO()
                   1851: 
                   1852: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createfunction, 0, 0, 2)
                   1853:        ZEND_ARG_INFO(0, name)
                   1854:        ZEND_ARG_INFO(0, callback)
                   1855:        ZEND_ARG_INFO(0, argument_count)
                   1856: ZEND_END_ARG_INFO()
                   1857: 
                   1858: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createaggregate, 0, 0, 3)
                   1859:        ZEND_ARG_INFO(0, name)
                   1860:        ZEND_ARG_INFO(0, step_callback)
                   1861:        ZEND_ARG_INFO(0, final_callback)
                   1862:        ZEND_ARG_INFO(0, argument_count)
                   1863: ZEND_END_ARG_INFO()
                   1864: 
1.1.1.2   misho    1865: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createcollation, 0, 0, 2)
                   1866:        ZEND_ARG_INFO(0, name)
                   1867:        ZEND_ARG_INFO(0, callback)
                   1868: ZEND_END_ARG_INFO()
                   1869: 
1.1       misho    1870: ZEND_BEGIN_ARG_INFO_EX(argingo_sqlite3_openblob, 0, 0, 3)
                   1871:        ZEND_ARG_INFO(0, table)
                   1872:        ZEND_ARG_INFO(0, column)
                   1873:        ZEND_ARG_INFO(0, rowid)
                   1874:        ZEND_ARG_INFO(0, dbname)
                   1875: ZEND_END_ARG_INFO()
                   1876: 
                   1877: ZEND_BEGIN_ARG_INFO_EX(argingo_sqlite3_enableexceptions, 0, 0, 1)
                   1878:        ZEND_ARG_INFO(0, enableExceptions)
                   1879: ZEND_END_ARG_INFO()
                   1880: 
                   1881: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3stmt_bindparam, 0, 0, 2)
                   1882:        ZEND_ARG_INFO(0, param_number)
                   1883:        ZEND_ARG_INFO(1, param)
                   1884:        ZEND_ARG_INFO(0, type)
                   1885: ZEND_END_ARG_INFO()
                   1886: 
                   1887: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3stmt_bindvalue, 0, 0, 2)
                   1888:        ZEND_ARG_INFO(0, param_number)
                   1889:        ZEND_ARG_INFO(0, param)
                   1890:        ZEND_ARG_INFO(0, type)
                   1891: ZEND_END_ARG_INFO()
                   1892: 
                   1893: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3stmt_construct, 1)
                   1894:        ZEND_ARG_INFO(0, sqlite3)
                   1895: ZEND_END_ARG_INFO()
                   1896: 
                   1897: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3result_columnname, 0, 0, 1)
                   1898:        ZEND_ARG_INFO(0, column_number)
                   1899: ZEND_END_ARG_INFO()
                   1900: 
                   1901: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3result_columntype, 0, 0, 1)
                   1902:        ZEND_ARG_INFO(0, column_number)
                   1903: ZEND_END_ARG_INFO()
                   1904: 
                   1905: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3result_fetcharray, 0, 0, 1)
                   1906:        ZEND_ARG_INFO(0, mode)
                   1907: ZEND_END_ARG_INFO()
                   1908: 
                   1909: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_void, 0)
                   1910: ZEND_END_ARG_INFO()
                   1911: /* }}} */
                   1912: 
                   1913: /* {{{ php_sqlite3_class_methods */
                   1914: static zend_function_entry php_sqlite3_class_methods[] = {
                   1915:        PHP_ME(sqlite3,         open,                           arginfo_sqlite3_open, ZEND_ACC_PUBLIC)
                   1916:        PHP_ME(sqlite3,         close,                          arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1917:        PHP_ME(sqlite3,         exec,                           arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
                   1918:        PHP_ME(sqlite3,         version,                        arginfo_sqlite3_void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
                   1919:        PHP_ME(sqlite3,         lastInsertRowID,        arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1920:        PHP_ME(sqlite3,         lastErrorCode,          arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1921:        PHP_ME(sqlite3,         lastErrorMsg,           arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1922:        PHP_ME(sqlite3,         busyTimeout,            arginfo_sqlite3_busytimeout, ZEND_ACC_PUBLIC)
                   1923: #ifndef SQLITE_OMIT_LOAD_EXTENSION
                   1924:        PHP_ME(sqlite3,         loadExtension,          arginfo_sqlite3_loadextension, ZEND_ACC_PUBLIC)
                   1925: #endif
                   1926:        PHP_ME(sqlite3,         changes,                        arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1927:        PHP_ME(sqlite3,         escapeString,           arginfo_sqlite3_escapestring, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
                   1928:        PHP_ME(sqlite3,         prepare,                        arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
                   1929:        PHP_ME(sqlite3,         query,                          arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
                   1930:        PHP_ME(sqlite3,         querySingle,            arginfo_sqlite3_querysingle, ZEND_ACC_PUBLIC)
                   1931:        PHP_ME(sqlite3,         createFunction,         arginfo_sqlite3_createfunction, ZEND_ACC_PUBLIC)
                   1932:        PHP_ME(sqlite3,         createAggregate,        arginfo_sqlite3_createaggregate, ZEND_ACC_PUBLIC)
1.1.1.2   misho    1933:        PHP_ME(sqlite3,         createCollation,        arginfo_sqlite3_createcollation, ZEND_ACC_PUBLIC)
1.1       misho    1934:        PHP_ME(sqlite3,         openBlob,                       argingo_sqlite3_openblob, ZEND_ACC_PUBLIC)
                   1935:        PHP_ME(sqlite3,         enableExceptions,       argingo_sqlite3_enableexceptions, ZEND_ACC_PUBLIC)
                   1936:        /* Aliases */
                   1937:        PHP_MALIAS(sqlite3,     __construct, open, arginfo_sqlite3_open, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
                   1938:        PHP_FE_END
                   1939: };
                   1940: /* }}} */
                   1941: 
                   1942: /* {{{ php_sqlite3_stmt_class_methods */
                   1943: static zend_function_entry php_sqlite3_stmt_class_methods[] = {
                   1944:        PHP_ME(sqlite3stmt, paramCount, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1945:        PHP_ME(sqlite3stmt, close,              arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1946:        PHP_ME(sqlite3stmt, reset,              arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1947:        PHP_ME(sqlite3stmt, clear,              arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1948:        PHP_ME(sqlite3stmt, execute,    arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1949:        PHP_ME(sqlite3stmt, bindParam,  arginfo_sqlite3stmt_bindparam, ZEND_ACC_PUBLIC)
                   1950:        PHP_ME(sqlite3stmt, bindValue,  arginfo_sqlite3stmt_bindvalue, ZEND_ACC_PUBLIC)
                   1951:        PHP_ME(sqlite3stmt, readOnly,   arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1952:        PHP_ME(sqlite3stmt, __construct, arginfo_sqlite3stmt_construct, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
                   1953:        PHP_FE_END
                   1954: };
                   1955: /* }}} */
                   1956: 
                   1957: /* {{{ php_sqlite3_result_class_methods */
                   1958: static zend_function_entry php_sqlite3_result_class_methods[] = {
                   1959:        PHP_ME(sqlite3result, numColumns,               arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1960:        PHP_ME(sqlite3result, columnName,               arginfo_sqlite3result_columnname, ZEND_ACC_PUBLIC)
                   1961:        PHP_ME(sqlite3result, columnType,               arginfo_sqlite3result_columntype, ZEND_ACC_PUBLIC)
                   1962:        PHP_ME(sqlite3result, fetchArray,               arginfo_sqlite3result_fetcharray, ZEND_ACC_PUBLIC)
                   1963:        PHP_ME(sqlite3result, reset,                    arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1964:        PHP_ME(sqlite3result, finalize,                 arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
                   1965:        PHP_ME(sqlite3result, __construct,              arginfo_sqlite3_void, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
                   1966:        PHP_FE_END
                   1967: };
                   1968: /* }}} */
                   1969: 
                   1970: /* {{{ Authorization Callback 
                   1971: */
                   1972: static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, const char *arg5, const char *arg6)
                   1973: {
                   1974:        switch (access_type) {
                   1975:                case SQLITE_ATTACH:
                   1976:                {
1.1.1.3 ! misho    1977:                        if (memcmp(arg3, ":memory:", sizeof(":memory:")) && *arg3) {
1.1       misho    1978:                                TSRMLS_FETCH();
                   1979: 
                   1980: #if PHP_API_VERSION < 20100412
                   1981:                                if (PG(safe_mode) && (!php_checkuid(arg3, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
                   1982:                                        return SQLITE_DENY;
                   1983:                                }
                   1984: #endif
                   1985: 
                   1986:                                if (php_check_open_basedir(arg3 TSRMLS_CC)) {
                   1987:                                        return SQLITE_DENY;
                   1988:                                }
                   1989:                        }
                   1990:                        return SQLITE_OK;
                   1991:                }
                   1992: 
                   1993:                default:
                   1994:                        /* access allowed */
                   1995:                        return SQLITE_OK;
                   1996:        }
                   1997: }
                   1998: /* }}} */
                   1999: 
                   2000: /* {{{ php_sqlite3_free_list_dtor
                   2001: */
                   2002: static void php_sqlite3_free_list_dtor(void **item)
                   2003: {
                   2004:        php_sqlite3_free_list *free_item = (php_sqlite3_free_list *)*item;
                   2005: 
                   2006:        if (free_item->stmt_obj && free_item->stmt_obj->initialised) {
                   2007:                sqlite3_finalize(free_item->stmt_obj->stmt);
                   2008:                free_item->stmt_obj->initialised = 0;
                   2009:        }
                   2010:        efree(*item);
                   2011: }
                   2012: /* }}} */
                   2013: 
                   2014: static int php_sqlite3_compare_stmt_zval_free( php_sqlite3_free_list **free_list, zval *statement ) /* {{{ */
                   2015: {
                   2016:        return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj_zval);
                   2017: }
                   2018: /* }}} */
                   2019: 
                   2020: static int php_sqlite3_compare_stmt_free( php_sqlite3_free_list **free_list, sqlite3_stmt *statement ) /* {{{ */
                   2021: {
                   2022:        return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj->stmt);
                   2023: }
                   2024: /* }}} */
                   2025: 
                   2026: static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
                   2027: {
                   2028:        php_sqlite3_db_object *intern = (php_sqlite3_db_object *)object;
                   2029:        php_sqlite3_func *func;
1.1.1.2   misho    2030:        php_sqlite3_collation *collation;
1.1       misho    2031: 
                   2032:        if (!intern) {
                   2033:                return;
                   2034:        }
                   2035: 
                   2036:        while (intern->funcs) {
                   2037:                func = intern->funcs;
                   2038:                intern->funcs = func->next;
                   2039:                if (intern->initialised && intern->db) {
                   2040:                        sqlite3_create_function(intern->db, func->func_name, func->argc, SQLITE_UTF8, func, NULL, NULL, NULL);
                   2041:                }
                   2042: 
                   2043:                efree((char*)func->func_name);
                   2044: 
                   2045:                if (func->func) {
                   2046:                        zval_ptr_dtor(&func->func);
                   2047:                }
                   2048:                if (func->step) {
                   2049:                        zval_ptr_dtor(&func->step);
                   2050:                }
                   2051:                if (func->fini) {
                   2052:                        zval_ptr_dtor(&func->fini);
                   2053:                }
                   2054:                efree(func);
                   2055:        }
                   2056: 
1.1.1.2   misho    2057:        while (intern->collations){
                   2058:                collation = intern->collations;
                   2059:                intern->collations = collation->next;
                   2060:                if (intern->initialised && intern->db){
                   2061:                        sqlite3_create_collation(intern->db, collation->collation_name, SQLITE_UTF8, NULL, NULL);
                   2062:                }
                   2063:                efree((char*)collation->collation_name);
                   2064:                if (collation->cmp_func){
                   2065:                        zval_ptr_dtor(&collation->cmp_func);
                   2066:                }
                   2067:                efree(collation);
                   2068:        }
                   2069: 
1.1       misho    2070:        if (intern->initialised && intern->db) {
                   2071:                sqlite3_close(intern->db);
                   2072:                intern->initialised = 0;
                   2073:        }
                   2074: 
                   2075:        zend_object_std_dtor(&intern->zo TSRMLS_CC);
                   2076:        efree(intern);
                   2077: }
                   2078: /* }}} */
                   2079: 
                   2080: static void php_sqlite3_stmt_object_free_storage(void *object TSRMLS_DC) /* {{{ */
                   2081: {
                   2082:        php_sqlite3_stmt *intern = (php_sqlite3_stmt *)object;
                   2083: 
                   2084:        if (!intern) {
                   2085:                return;
                   2086:        }
                   2087: 
                   2088:        if (intern->bound_params) {
                   2089:                zend_hash_destroy(intern->bound_params);
                   2090:                FREE_HASHTABLE(intern->bound_params);
                   2091:                intern->bound_params = NULL;
                   2092:        }
                   2093: 
                   2094:        if (intern->initialised) {
                   2095:                zend_llist_del_element(&(intern->db_obj->free_list), intern->stmt,
                   2096:                        (int (*)(void *, void *)) php_sqlite3_compare_stmt_free);
                   2097:        }
                   2098: 
                   2099:        if (intern->db_obj_zval) {
                   2100:                zval_ptr_dtor(&intern->db_obj_zval);
                   2101:        }
                   2102: 
                   2103:        zend_object_std_dtor(&intern->zo TSRMLS_CC);
                   2104:        efree(intern);
                   2105: }
                   2106: /* }}} */
                   2107: 
                   2108: static void php_sqlite3_result_object_free_storage(void *object TSRMLS_DC) /* {{{ */
                   2109: {
                   2110:        php_sqlite3_result *intern = (php_sqlite3_result *)object;
                   2111: 
                   2112:        if (!intern) {
                   2113:                return;
                   2114:        }
                   2115: 
                   2116:        if (intern->stmt_obj_zval) {
                   2117:                if (intern->stmt_obj->initialised) {
                   2118:                        sqlite3_reset(intern->stmt_obj->stmt);
                   2119:                }
                   2120: 
                   2121:                if (intern->is_prepared_statement == 0) {
                   2122:                        zval_dtor(intern->stmt_obj_zval);
                   2123:                        FREE_ZVAL(intern->stmt_obj_zval);
                   2124:                } else {
                   2125:                        zval_ptr_dtor(&intern->stmt_obj_zval);
                   2126:                }
                   2127:        }
                   2128: 
                   2129:        zend_object_std_dtor(&intern->zo TSRMLS_CC);
                   2130:        efree(intern);
                   2131: }
                   2132: /* }}} */
                   2133: 
                   2134: static zend_object_value php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
                   2135: {
                   2136:        zend_object_value retval;
                   2137:        php_sqlite3_db_object *intern;
                   2138: 
                   2139:        /* Allocate memory for it */
                   2140:        intern = emalloc(sizeof(php_sqlite3_db_object));
                   2141:        memset(intern, 0, sizeof(php_sqlite3_db_object));
                   2142:        intern->exception = 0;
                   2143: 
                   2144:        /* Need to keep track of things to free */
                   2145:        zend_llist_init(&(intern->free_list),   sizeof(php_sqlite3_free_list *), (llist_dtor_func_t)php_sqlite3_free_list_dtor, 0);
                   2146: 
                   2147:        zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
1.1.1.2   misho    2148:        object_properties_init(&intern->zo, class_type);
1.1       misho    2149: 
                   2150:        retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_object_free_storage, NULL TSRMLS_CC);
                   2151:        retval.handlers = (zend_object_handlers *) &sqlite3_object_handlers;
                   2152: 
                   2153:        return retval;
                   2154: }
                   2155: /* }}} */
                   2156: 
                   2157: static zend_object_value php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
                   2158: {
                   2159:        zend_object_value retval;
                   2160:        php_sqlite3_stmt *intern;
                   2161: 
                   2162:        /* Allocate memory for it */
                   2163:        intern = emalloc(sizeof(php_sqlite3_stmt));
                   2164:        memset(intern, 0, sizeof(php_sqlite3_stmt));
                   2165: 
                   2166:        intern->db_obj_zval = NULL;
                   2167: 
                   2168:        zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
1.1.1.2   misho    2169:        object_properties_init(&intern->zo, class_type);
1.1       misho    2170: 
                   2171:        retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_stmt_object_free_storage, NULL TSRMLS_CC);
                   2172:        retval.handlers = (zend_object_handlers *) &sqlite3_stmt_object_handlers;
                   2173: 
                   2174:        return retval;
                   2175: }
                   2176: /* }}} */
                   2177: 
                   2178: static zend_object_value php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
                   2179: {
                   2180:        zend_object_value retval;
                   2181:        php_sqlite3_result *intern;
                   2182: 
                   2183:        /* Allocate memory for it */
                   2184:        intern = emalloc(sizeof(php_sqlite3_result));
                   2185:        memset(intern, 0, sizeof(php_sqlite3_result));
                   2186: 
                   2187:        intern->complete = 0;
                   2188:        intern->is_prepared_statement = 0;
                   2189:        intern->stmt_obj_zval = NULL;
                   2190: 
                   2191:        zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
1.1.1.2   misho    2192:        object_properties_init(&intern->zo, class_type);
1.1       misho    2193: 
                   2194:        retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_result_object_free_storage, NULL TSRMLS_CC);
                   2195:        retval.handlers = (zend_object_handlers *) &sqlite3_result_object_handlers;
                   2196: 
                   2197:        return retval;
                   2198: }
                   2199: /* }}} */
                   2200: 
                   2201: static void sqlite3_param_dtor(void *data) /* {{{ */
                   2202: {
                   2203:        struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)data;
                   2204: 
                   2205:        if (param->name) {
                   2206:                efree(param->name);
                   2207:        }
                   2208: 
                   2209:        if (param->parameter) {
                   2210:                zval_ptr_dtor(&(param->parameter));
                   2211:                param->parameter = NULL;
                   2212:        }
                   2213: }
                   2214: /* }}} */
                   2215: 
                   2216: /* {{{ PHP_MINIT_FUNCTION
                   2217: */
                   2218: PHP_MINIT_FUNCTION(sqlite3)
                   2219: {
                   2220:        zend_class_entry ce;
                   2221: 
                   2222: #if defined(ZTS)
                   2223:        /* Refuse to load if this wasn't a threasafe library loaded */
                   2224:        if (!sqlite3_threadsafe()) {
                   2225:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "A thread safe version of SQLite is required when using a thread safe version of PHP.");
                   2226:                return FAILURE;
                   2227:        }
                   2228: #endif
                   2229: 
                   2230:        memcpy(&sqlite3_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
                   2231:        memcpy(&sqlite3_stmt_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
                   2232:        memcpy(&sqlite3_result_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
                   2233: 
                   2234:        /* Register SQLite 3 Class */
                   2235:        INIT_CLASS_ENTRY(ce, "SQLite3", php_sqlite3_class_methods);
                   2236:        ce.create_object = php_sqlite3_object_new;
                   2237:        sqlite3_object_handlers.clone_obj = NULL;
                   2238:        php_sqlite3_sc_entry = zend_register_internal_class(&ce TSRMLS_CC);
                   2239: 
                   2240:        /* Register SQLite 3 Prepared Statement Class */
                   2241:        INIT_CLASS_ENTRY(ce, "SQLite3Stmt", php_sqlite3_stmt_class_methods);
                   2242:        ce.create_object = php_sqlite3_stmt_object_new;
                   2243:        sqlite3_stmt_object_handlers.clone_obj = NULL;
                   2244:        php_sqlite3_stmt_entry = zend_register_internal_class(&ce TSRMLS_CC);
                   2245: 
                   2246:        /* Register SQLite 3 Result Class */
                   2247:        INIT_CLASS_ENTRY(ce, "SQLite3Result", php_sqlite3_result_class_methods);
                   2248:        ce.create_object = php_sqlite3_result_object_new;
                   2249:        sqlite3_result_object_handlers.clone_obj = NULL;
                   2250:        php_sqlite3_result_entry = zend_register_internal_class(&ce TSRMLS_CC);
                   2251: 
                   2252:        REGISTER_INI_ENTRIES();
                   2253: 
                   2254:        REGISTER_LONG_CONSTANT("SQLITE3_ASSOC", PHP_SQLITE3_ASSOC, CONST_CS | CONST_PERSISTENT);
                   2255:        REGISTER_LONG_CONSTANT("SQLITE3_NUM", PHP_SQLITE3_NUM, CONST_CS | CONST_PERSISTENT);
                   2256:        REGISTER_LONG_CONSTANT("SQLITE3_BOTH", PHP_SQLITE3_BOTH, CONST_CS | CONST_PERSISTENT);
                   2257: 
                   2258:        REGISTER_LONG_CONSTANT("SQLITE3_INTEGER", SQLITE_INTEGER, CONST_CS | CONST_PERSISTENT);
                   2259:        REGISTER_LONG_CONSTANT("SQLITE3_FLOAT", SQLITE_FLOAT, CONST_CS | CONST_PERSISTENT);
                   2260:        REGISTER_LONG_CONSTANT("SQLITE3_TEXT", SQLITE3_TEXT, CONST_CS | CONST_PERSISTENT);
                   2261:        REGISTER_LONG_CONSTANT("SQLITE3_BLOB", SQLITE_BLOB, CONST_CS | CONST_PERSISTENT);
                   2262:        REGISTER_LONG_CONSTANT("SQLITE3_NULL", SQLITE_NULL, CONST_CS | CONST_PERSISTENT);
                   2263: 
                   2264:        REGISTER_LONG_CONSTANT("SQLITE3_OPEN_READONLY", SQLITE_OPEN_READONLY, CONST_CS | CONST_PERSISTENT);
                   2265:        REGISTER_LONG_CONSTANT("SQLITE3_OPEN_READWRITE", SQLITE_OPEN_READWRITE, CONST_CS | CONST_PERSISTENT);
                   2266:        REGISTER_LONG_CONSTANT("SQLITE3_OPEN_CREATE", SQLITE_OPEN_CREATE, CONST_CS | CONST_PERSISTENT);
                   2267: 
                   2268:        return SUCCESS;
                   2269: }
                   2270: /* }}} */
                   2271: 
                   2272: /* {{{ PHP_MSHUTDOWN_FUNCTION
                   2273: */
                   2274: PHP_MSHUTDOWN_FUNCTION(sqlite3)
                   2275: {
                   2276:        UNREGISTER_INI_ENTRIES();
                   2277: 
                   2278:        return SUCCESS;
                   2279: }
                   2280: /* }}} */
                   2281: 
                   2282: /* {{{ PHP_MINFO_FUNCTION
                   2283: */
                   2284: PHP_MINFO_FUNCTION(sqlite3)
                   2285: {
                   2286:        php_info_print_table_start();
                   2287:        php_info_print_table_header(2, "SQLite3 support", "enabled");
                   2288:        php_info_print_table_row(2, "SQLite3 module version", PHP_SQLITE3_VERSION);
                   2289:        php_info_print_table_row(2, "SQLite Library", sqlite3_libversion());
                   2290:        php_info_print_table_end();
                   2291: 
                   2292:        DISPLAY_INI_ENTRIES();
                   2293: }
                   2294: /* }}} */
                   2295: 
                   2296: /* {{{ PHP_GINIT_FUNCTION
                   2297: */
                   2298: static PHP_GINIT_FUNCTION(sqlite3)
                   2299: {
                   2300:        memset(sqlite3_globals, 0, sizeof(*sqlite3_globals));
                   2301: }
                   2302: /* }}} */
                   2303: 
                   2304: /* {{{ sqlite3_module_entry
                   2305: */
                   2306: zend_module_entry sqlite3_module_entry = {
                   2307:        STANDARD_MODULE_HEADER,
                   2308:        "sqlite3",
                   2309:        NULL,
                   2310:        PHP_MINIT(sqlite3),
                   2311:        PHP_MSHUTDOWN(sqlite3),
                   2312:        NULL,
                   2313:        NULL,
                   2314:        PHP_MINFO(sqlite3),
                   2315:        PHP_SQLITE3_VERSION,
                   2316:        PHP_MODULE_GLOBALS(sqlite3),
                   2317:        PHP_GINIT(sqlite3),
                   2318:        NULL,
                   2319:        NULL,
                   2320:        STANDARD_MODULE_PROPERTIES_EX
                   2321: };
                   2322: /* }}} */
                   2323: 
                   2324: #ifdef COMPILE_DL_SQLITE3
                   2325: ZEND_GET_MODULE(sqlite3)
                   2326: #endif
                   2327: 
                   2328: /*
                   2329:  * Local variables:
                   2330:  * tab-width: 4
                   2331:  * c-basic-offset: 4
                   2332:  * End:
                   2333:  * vim600: sw=4 ts=4 fdm=marker
                   2334:  * vim<600: sw=4 ts=4
                   2335:  */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>