php_sqlite3.c

使PHP直接支持sqlite3数据库操作的扩展DLL

#include "php.h"
#include "php_sqlite3.h"

#define COMPILE_DL_SQLITE3

static function_entry sqlite3_functions[] = {


    PHP_FE(sqlite3_libversion, NULL)
    PHP_FE(sqlite3_open,    NULL)
    PHP_FE(sqlite3_close,   NULL)    
    PHP_FE(sqlite3_errcode,   NULL)
    PHP_FE(sqlite3_errmsg,   NULL)
    PHP_FE(sqlite3_exec,    NULL)
    PHP_FE(sqlite3_query,   NULL)
    PHP_FE(sqlite3_changes, NULL)
    
    PHP_FE(sqlite3_bind_int,    NULL)
    PHP_FE(sqlite3_bind_double, NULL)    
    PHP_FE(sqlite3_bind_text,   NULL)
    PHP_FE(sqlite3_bind_blob,   NULL)   
    PHP_FE(sqlite3_bind_null,   NULL)
    
    PHP_FE(sqlite3_query_exec,  NULL)

    PHP_FE(sqlite3_fetch,        NULL)    
    PHP_FE(sqlite3_fetch_array,  NULL)
    PHP_FE(sqlite3_column_count, NULL)
    PHP_FE(sqlite3_column_name,  NULL)        
    PHP_FE(sqlite3_column_type,  NULL)            
    PHP_FE(sqlite3_query_close,  NULL)
        
    PHP_FE(sqlite3_last_insert_rowid, NULL)
    PHP_FE(sqlite3_create_function,   NULL)    

    {NULL, NULL, NULL}
};

zend_module_entry sqlite3_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
    STANDARD_MODULE_HEADER,
#endif
    PHP_SQLITE3_EXTNAME,
    sqlite3_functions,
    PHP_MINIT(sqlite3),
    NULL,
    NULL,
    NULL,
    PHP_MINFO(sqlite3),
#if ZEND_MODULE_API_NO >= 20010901
    PHP_SQLITE3_VERSION,
#endif
    STANDARD_MODULE_PROPERTIES
};


/*
 * SQLite handler resource definition 
 */
 
static int   le_sqlite3_resource;
static char* le_sqlite3_resource_name="SQLITE3";

  
typedef struct 
{
  sqlite3* handle;
  char*    user_cb; /* user supplied function name for sqlite3_exec() */
} php_sqlite3_resource;


/*
 * SQLite statment handler resource definition 
 */
 
static int   le_sqlite3_stmt_resource;
static char* le_sqlite3_stmt_resource_name="SQLITE3-QUERY";

  
typedef struct 
{
  php_sqlite3_resource* sqlite3;
  sqlite3_stmt*         stmt;
  int                   rsrc_id;
} php_sqlite3_stmt_resource; 


/* 
 * a structure which hold a user defined SQL function
 *
 */
 
typedef struct
{
  char*                func_name;     /* SQL function name */
  char*                cb_name;       /* PHP Callback name */
  int                  cb_num_args;   /* # arguments */
  php_sqlite3_resource *me;
} php_sqlite3_func_t;

/*
 * resource destruction callbacks
 */
 
void 
php_sqlite3_resource_destruction ( zend_rsrc_list_entry *rsrc TSRMLS_DC)
{
  php_sqlite3_resource *me = (php_sqlite3_resource*) rsrc->ptr;
  
  sqlite3_close (me->handle);
  
  if (me->user_cb) efree (me->user_cb);
  
  efree (me);
 
}

void 
php_sqlite3_stmt_resource_destruction ( zend_rsrc_list_entry *rsrc TSRMLS_DC)
{
  php_sqlite3_stmt_resource *me = (php_sqlite3_stmt_resource*) rsrc->ptr;
  
   sqlite3_finalize(me->stmt);
  efree (me);  
}



/*  zval to php_sqlite3_resource conversion macro  */
#define ZVAL_TO_S3_HANDLE(me,zvalpp)  ZEND_FETCH_RESOURCE(me, php_sqlite3_resource*, zvalpp, -1, le_sqlite3_resource_name, le_sqlite3_resource)

/* zval to php_sqlite3_stmt_resource conversion macro */
#define ZVAL_TO_STMT(me,zvalpp)  ZEND_FETCH_RESOURCE(me, php_sqlite3_stmt_resource*, zvalpp, -1, le_sqlite3_stmt_resource_name, le_sqlite3_stmt_resource)



PHP_MINIT_FUNCTION(sqlite3)
{
  /* register resource destructors */
  le_sqlite3_resource =zend_register_list_destructors_ex(php_sqlite3_resource_destruction, NULL, le_sqlite3_resource_name, module_number);  
  le_sqlite3_stmt_resource =zend_register_list_destructors_ex(php_sqlite3_stmt_resource_destruction, NULL, le_sqlite3_stmt_resource_name, module_number);    
  
  /* register some constants... */
  REGISTER_LONG_CONSTANT("SQLITE3_INTEGER", SQLITE_INTEGER, CONST_CS | CONST_PERSISTENT);
  REGISTER_LONG_CONSTANT("SQLITE3_FLOAT"  , SQLITE_FLOAT,   CONST_CS | CONST_PERSISTENT);  
  REGISTER_LONG_CONSTANT("SQLITE3_TEXT",    SQLITE_TEXT,    CONST_CS | CONST_PERSISTENT);
  REGISTER_LONG_CONSTANT("SQLITE3_BLOB",    SQLITE_BLOB,    CONST_CS | CONST_PERSISTENT);
  REGISTER_LONG_CONSTANT("SQLITE3_NULL",    SQLITE_NULL,    CONST_CS | CONST_PERSISTENT);
  
}


#ifdef COMPILE_DL_SQLITE3
ZEND_GET_MODULE(sqlite3)
#endif


/* {{{ PHP_MINFO_FUNCTION */

PHP_MINFO_FUNCTION(sqlite3)
{

  php_info_print_table_start();
  php_info_print_table_row(2, "SQLite3 support", "enabled");
  php_info_print_table_row(2, "sqlite3 library version", sqlite3_libversion());
  php_info_print_table_end();
}

/* }}} 
/* {{{ string sqlite3_libersion()
   Returns the SQLite3 library version (such as "3.2.27").  */
   
PHP_FUNCTION(sqlite3_libversion)
{
  RETURN_STRING(estrdup(sqlite3_libversion()), 0);
}

/* }}}
   {{{ bool sqlite3_close(resource handle)
   Close (and free) a Sqlite3 resource handle */

PHP_FUNCTION(sqlite3_close)
{
  php_sqlite3_resource* me;
  zval* z_rs;
  int err;
  
 if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;


  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_rs)==FAILURE)
    return;
    
  ZVAL_TO_S3_HANDLE (me, &z_rs);  

  switch (sqlite3_close (me->handle))
  {
    case SQLITE_OK:
      RETURN_TRUE;
      break;
      
    case SQLITE_BUSY:
      zend_error(E_WARNING, "Closing a SQLite database with active query(ies) is not safe.");
      break;
      
    default:
      RETURN_FALSE;      
  }
}

/* }}}
   {{{ resource sqlite3_open(string path_to_database)
   Open (or create) a SQLite3 database */
  
PHP_FUNCTION(sqlite3_open)
{
  int r_id ; /* resource ID */
  php_sqlite3_resource* me;
  zval* res;
  int err;
  char* dbpath;
  int dbpath_len;
  
  if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;
  
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"s", &dbpath, &dbpath_len) == FAILURE) {
    return;
  }
  
  MAKE_STD_ZVAL(res);
  
  me = (php_sqlite3_resource*)  emalloc ( sizeof (php_sqlite3_resource));
  memset(me, 0, sizeof (php_sqlite3_resource));    
  err = sqlite3_open(dbpath, &(me->handle));
  
  if (err)
  {
    zend_error (E_ERROR, "Could not open database %s: %s", dbpath, sqlite3_errmsg (me->handle));
    sqlite3_close(me->handle);
    RETURN_NULL();
  }

  r_id = ZEND_REGISTER_RESOURCE(res, me, le_sqlite3_resource);  
  RETURN_RESOURCE(r_id);
}

/* }}}
   {{{ string sqlite3_errmsg(resource handle)
   Returns the last error message */

PHP_FUNCTION(sqlite3_errmsg)
{
  php_sqlite3_resource* me;
  zval* z_rs;
  
 if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;

  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_rs)==FAILURE)
    return;
  
  ZVAL_TO_S3_HANDLE (me, &z_rs);    
  
  RETURN_STRING (estrdup(sqlite3_errmsg(me->handle)), 0);
}

PHP_FUNCTION(sqlite3_errcode)
{
  php_sqlite3_resource* me;
  zval* z_rs;
  
 if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;

  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_rs)==FAILURE)
    return;
  
  ZVAL_TO_S3_HANDLE (me, &z_rs);    
  
  RETURN_LONG (sqlite3_errcode(me->handle), 0);
}
/* }}} */


/*
 * callback function called by sqlite3_exec
 */

static int
php_sqlite3_callback(void* _me,int ncols ,char** col_vals, char** col_names)
{
  php_sqlite3_resource* me = (php_sqlite3_resource*) _me;
  int n;
  zval**  func_params[2];
  zval*   z_col_vals;
  zval*   z_col_names;
  zval*  func_retval;
  zval*  func_name;
  int    retval;
  
  
  MAKE_STD_ZVAL(func_name);
  
  func_params[0]=&z_col_vals;
  func_params[1]=&z_col_names;
  
  ZVAL_STRING (func_name, me->user_cb, 0);

  MAKE_STD_ZVAL(z_col_vals) ; 
  MAKE_STD_ZVAL(z_col_names);  
  array_init (z_col_vals);
  array_init (z_col_names);
  
  for (n=0; n < ncols; n++)
  {
    /* append column value */    
    add_next_index_string (z_col_names, col_vals[n],  1);
    
    /* append column name */
    add_next_index_string (z_col_vals, col_names[n], 1);        
  }

  /* do we need this ?? - bruno */  
   /*  TSRMSLS_FETCH(); */
  
  if (call_user_function_ex(CG(function_table), NULL, func_name, &func_retval, 2, func_params, 0,  NULL TSRMLS_CC ) != SUCCESS)
  {
      zend_error(E_ERROR, "Function call to '%s' failed", me->user_cb);
  }
  
  /*
   * callback function MUST return an integer.
   *
   * (if this return value is non-zero, pass it back to sqlite3_exec(), to abort the query).
   * 
   */
  
  if (func_retval->type != IS_LONG)
    return -1;
  
  retval = Z_LVAL_P(func_retval);
  zval_dtor(func_retval);
  
  return retval;
}


/* {{{ bool sqlite3_exec(resource handle, string sql [,mixed callback])
   Execute a sql query.  Optionnaly call the callback function for each row retrieved in the result set */

PHP_FUNCTION(sqlite3_exec)
{
  php_sqlite3_resource* me;
  zval* z_rs;
  char* sql;
  int   sql_len;
  
  char*  user_cb;
  int    user_cb_len;
  int   err;

  if (ZEND_NUM_ARGS() < 2) WRONG_PARAM_COUNT;
  
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rs|s", &z_rs, &sql, &sql_len, &user_cb, &user_cb_len)==FAILURE)
    return;
    
  ZVAL_TO_S3_HANDLE (me, &z_rs);  
  switch (ZEND_NUM_ARGS())
  {
  
    case 2:
      
      err = sqlite3_exec (me->handle, sql, NULL, NULL, NULL);      
      if (err) 
        RETURN_FALSE;
        
      RETURN_TRUE;      
      break;
      
     case 3:
      me->user_cb = estrdup (user_cb);
      err = sqlite3_exec (me->handle, sql, php_sqlite3_callback, me, NULL);
      
      if (err)
        RETURN_FALSE;
        
      RETURN_TRUE;
       
      
      break;
      
   default:
     WRONG_PARAM_COUNT;          
  }
}

/* }}}
   {{{ bool sqlite3_bind_int(resource resultset, int index, int value)
    bind an integer value at the index parameter 'index' (starts at 1)
*/

PHP_FUNCTION(sqlite3_bind_int)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  long    idx;
  long    val;

  if(ZEND_NUM_ARGS() != 3) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rll",&z_stmt, &idx, &val)==FAILURE)
    return;    

  ZVAL_TO_STMT (stmt, &z_stmt);

  if (sqlite3_bind_int(stmt->stmt, idx, val) != SQLITE_OK)
    RETURN_FALSE;
    
  RETURN_TRUE; 
}

/* }}}
   {{{ bool sqlite3_bind_double(resource resultset, int index, double value)
    bind an double value at the index parameter 'index' (starts at 1)
*/

PHP_FUNCTION(sqlite3_bind_double)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  long    idx;
  double  val;

  if(ZEND_NUM_ARGS() != 3) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rld",&z_stmt, &idx, &val)==FAILURE)
    return;    

  ZVAL_TO_STMT (stmt, &z_stmt);

  if (sqlite3_bind_double(stmt->stmt, idx, val) != SQLITE_OK)
    RETURN_FALSE;
    
  RETURN_TRUE; 
}


/* }}}
   {{{ bool sqlite3_bind_null(resource resultset, int index)
    bind a NULL value at the index parameter 'index' (starts at 1)
*/

PHP_FUNCTION(sqlite3_bind_null)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  long    idx;

  if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rl",&z_stmt, &idx)==FAILURE)
    return;    

  ZVAL_TO_STMT (stmt, &z_stmt);

  if (sqlite3_bind_null(stmt->stmt, idx) != SQLITE_OK)
    RETURN_FALSE;
    
  RETURN_TRUE; 
}

/* }}}
   {{{ bool sqlite3_bind_text(resource resultset, int index, string text)
    bind a string value at the index parameter 'index' (starts at 1)
*/

PHP_FUNCTION(sqlite3_bind_text)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  long    idx;
  zval*   z_val;


  if(ZEND_NUM_ARGS() != 3) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rlz",&z_stmt, &idx, &z_val)==FAILURE)
    return;