php_sqlite3.c

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

  ZVAL_TO_STMT (stmt, &z_stmt);

  /* increment reference count on this object, as we do not want sqlite3 to 
   * duplicate it (SQLITE_STATIC flag).
   */
     
  z_val->refcount++;
  
  if (sqlite3_bind_text(stmt->stmt, idx, Z_STRVAL_P(z_val), Z_STRLEN_P(z_val), SQLITE_STATIC) != SQLITE_OK)
    RETURN_FALSE;
    
  RETURN_TRUE; 
}   


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

PHP_FUNCTION(sqlite3_bind_blob)
{
  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;    


  ZVAL_TO_STMT (stmt, &z_stmt);

  /* increment reference count on this object, as we do not want sqlite3 to 
   * duplicate it (SQLITE_STATIC flag).
   */
   
  z_val->refcount++;
  
  if (sqlite3_bind_blob(stmt->stmt, idx, Z_STRVAL_P(z_val), Z_STRLEN_P(z_val), SQLITE_STATIC) != SQLITE_OK)
    RETURN_FALSE;
    
  RETURN_TRUE; 
}   


/* }}}
   {{{ resource sqlite3_query(resource handle, string sql)
   execute a sql query. Returns a result set resource */

PHP_FUNCTION(sqlite3_query)
{
  php_sqlite3_resource* me;
  php_sqlite3_stmt_resource* stmt;
  zval* z_rs;
  char* sql;
  int   sql_len;
  int   err;
  zval* z_stmt;
  const char* pztail;


  if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;

  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rs", &z_rs, &sql, &sql_len)==FAILURE)
    return;
    
  ZVAL_TO_S3_HANDLE (me, &z_rs);  
  
  stmt = (php_sqlite3_stmt_resource*)  emalloc ( sizeof (php_sqlite3_stmt_resource));
  memset(stmt, 0, sizeof (php_sqlite3_stmt_resource));    
  stmt->sqlite3 = me;
  
  err = sqlite3_prepare (me->handle, sql, sql_len, &(stmt->stmt), &pztail);
  if (err) RETURN_FALSE;
  
  
  MAKE_STD_ZVAL(z_stmt);
   stmt->rsrc_id =  ZEND_REGISTER_RESOURCE(z_stmt, stmt, le_sqlite3_stmt_resource);  
  RETURN_RESOURCE(stmt->rsrc_id);
}

/* }}} */
/* {{{ bool sqlite3_query_exec(resource statement, [bool free=TRUE]) 
    execute a SQL statement prepared by sqlite3_query(). 
    If free is TRUE, free the result set
    Return TRUE if all went ok.
 */

PHP_FUNCTION(sqlite3_query_exec)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  int                        err;
  zend_bool                  dofree;

  if(ZEND_NUM_ARGS() <1) WRONG_PARAM_COUNT;
  if(ZEND_NUM_ARGS() == 1) dofree=1;
  
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r|b", &z_stmt, &dofree)==FAILURE)
    return; 
    
  ZVAL_TO_STMT (stmt, &z_stmt);
  
  err = sqlite3_step(stmt->stmt);
  if (dofree)
    zend_list_delete(stmt->rsrc_id);
  
  if ((err==SQLITE_DONE) || (err==SQLITE_ROW))
    RETURN_TRUE;
    
  RETURN_FALSE;    
}
/* }}} */


static void
php_sqlite_fetch_result(php_sqlite3_stmt_resource* stmt, zval* return_value, int mode)
{
  int                        col;
  zval*                      col_val;
  
  array_init(return_value);
  
  for (col=0; col < sqlite3_column_count(stmt->stmt); col++)
  {
    MAKE_STD_ZVAL(col_val); 
    
    switch (sqlite3_column_type(stmt->stmt, col))
    {
    
      case SQLITE_INTEGER:
        ZVAL_LONG(col_val, sqlite3_column_int (stmt->stmt, col));
        break;
        
      case SQLITE_FLOAT:
        ZVAL_DOUBLE(col_val, sqlite3_column_double(stmt->stmt, col));
        break;
        
      case SQLITE_TEXT:
        ZVAL_STRING(col_val, estrdup(sqlite3_column_text(stmt->stmt, col)), 0);
        break;
      
      case SQLITE_BLOB:
        ZVAL_STRINGL(col_val, estrdup(sqlite3_column_blob(stmt->stmt, col)), 
          sqlite3_column_bytes(stmt->stmt, col), 1);
        break;
      
      case SQLITE_NULL:
        ZVAL_NULL(col_val);
        break;
  
      default:
        zend_error(E_WARNING, "Unexpected column type %i", sqlite3_column_type(stmt->stmt, col));
    }    
    
    switch (mode)
    {
      case PHP_SQLITE3_FETCH_ASSOC:      
        add_assoc_zval (return_value, estrdup(sqlite3_column_name(stmt->stmt, col)), col_val);  
        break;
        
      case PHP_SQLITE3_FETCH_INDEX:
        add_next_index_zval (return_value, col_val);
        break;
    }
  }  
}

/* {{{ array sqlite3_fetch(resource resultset)
   move the result set cursor to the next item and returns an array of the retrived row .*/

PHP_FUNCTION(sqlite3_fetch)
{

  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  int                        err;

  if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_stmt)==FAILURE)
    return; 
    
  ZVAL_TO_STMT (stmt, &z_stmt);

  err = sqlite3_step(stmt->stmt);
  if (err != SQLITE_ROW) 
    RETURN_FALSE;  
    
   php_sqlite_fetch_result(stmt, return_value,PHP_SQLITE3_FETCH_INDEX);   
     
   return;
}

/* }}}
   {{{ array sqlite3_fetch(resource resultset)
   move the result set cursor to the next item and returns an associative array of the retrived row. */

PHP_FUNCTION(sqlite3_fetch_array)
{

  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  int                        err;

  if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_stmt)==FAILURE)
    return;    

  ZVAL_TO_STMT (stmt, &z_stmt);    

  err = sqlite3_step(stmt->stmt);
  if (err != SQLITE_ROW) 
    RETURN_FALSE;
          
  php_sqlite_fetch_result(stmt, return_value,PHP_SQLITE3_FETCH_ASSOC);   
     
  return;
}

/* }}}
   {{{ integer sqlite3_column_count(resource resultset)   
   Returns the number of column in the specified result set. */
   
PHP_FUNCTION(sqlite3_column_count)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;

  if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_stmt)==FAILURE)
    return;    

  ZVAL_TO_STMT (stmt, &z_stmt);

  RETURN_LONG (sqlite3_column_count (stmt->stmt));
}

/* }}}
   {{{ array sqlite3_column_name(resource resultset, integer colum}
   return the name of the column #column */

PHP_FUNCTION(sqlite3_column_name)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  int                        col;

  if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rl", &z_stmt, &col)==FAILURE)
    return;    
    
  ZVAL_TO_STMT (stmt, &z_stmt);    
  
  RETURN_STRING (estrdup(sqlite3_column_name(stmt->stmt, col)), 0);
}

/* }}}
   {{{ constant sqlite3_column_type(resource resultset, integer colum}
   return the type of the column #column */

PHP_FUNCTION(sqlite3_column_type)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  int                        col;

  if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rl", &z_stmt, &col)==FAILURE)
    return;    
    
  ZVAL_TO_STMT (stmt, &z_stmt);    
  
  RETURN_LONG (sqlite3_column_type(stmt->stmt, col));
}

/* }}}
   {{{ bool sqlite3_querry_close(resource resultset)
   close (and free) a result set handle */
   
PHP_FUNCTION(sqlite3_query_close)
{
  php_sqlite3_stmt_resource* stmt;
  zval*                      z_stmt;
  int                        err;


  if(ZEND_NUM_ARGS() != 1) WRONG_PARAM_COUNT;
  if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"r", &z_stmt)==FAILURE)
    return;    

  ZVAL_TO_STMT (stmt, &z_stmt);

  err = sqlite3_finalize ( stmt->stmt);  

	zend_list_delete(Z_RESVAL_P(z_stmt));

  if (err) RETURN_FALSE ;  
  RETURN_TRUE;
}

/* }}}
   {{{ integer sqlite3_last_insert_rowid(resource sqlite3)
   return the last inserted row id */

PHP_FUNCTION(sqlite3_last_insert_rowid)
{
  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_last_insert_rowid (me->handle));
}

/* }}} 
   {{{ integer sqlite3_changes(resource sqlite3)
   return  the number of database rows that were changed (or inserted or deleted) by the most recently completed INSERT, UPDATE, or DELETE statement.
*/

PHP_FUNCTION(sqlite3_changes)
{
  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_changes (me->handle));
}
/* }}} */


/* {{{ void void php_sqlite3_user_function_cb(sqlite3_context*,int nargs,sqlite3_value**)
 * callback function, for user-defined SQL functions. Get called by sqlite3 library
 */

void php_sqlite3_user_function_cb(sqlite3_context* ctxt,int nargs,sqlite3_value** vals) 
{
  int err; 
  zval***  z_cb_params;
  zval**   z_param;
  zval*    z_retval;
  zval*    z_cb_name;
  int  n;
  php_sqlite3_func_t* func;
  
  
  func = (php_sqlite3_func_t*) sqlite3_user_data(ctxt);
  
  MAKE_STD_ZVAL(z_cb_name);
  ZVAL_STRING  (z_cb_name, func->cb_name, 0);
  
  
  /*
   * fill in callback parameters
   */

  z_cb_params = (zval***) emalloc (sizeof(zval**) * nargs);

  for (n=0; n < nargs; n++)
  {
    z_param = (zval**) emalloc( sizeof(zval*));
    MAKE_STD_ZVAL(*z_param);
            
    switch (sqlite3_value_type (vals[n]))
    {
       case  SQLITE_INTEGER:
        ZVAL_LONG(*z_param,   sqlite3_value_int(vals[n]));
        break;
      
      case SQLITE_FLOAT:
        ZVAL_DOUBLE(*z_param, sqlite3_value_double(vals[n]));
        break;
      
      case SQLITE_TEXT:
        ZVAL_STRING(*z_param, (char*) sqlite3_value_text(vals[n]), 1);
				break;
          
      case SQLITE_NULL:
      default:      
        ZVAL_NULL(*z_param);
    }
    
    z_cb_params[n] = z_param;    
  }
  
  /*
   * now call the user function ...
   */
  
  err = call_user_function_ex (CG(function_table), NULL, z_cb_name, &z_retval, nargs, z_cb_params, 0,  NULL TSRMLS_CC );
  
  if (err != SUCCESS)
  {
    if (z_retval) zval_dtor(z_retval);
    sqlite3_result_error(ctxt, "function called failed.", -1);
    return;
  }
    
  /*
   * ... and parse the output
   */

  switch (z_retval->type)
  {
    case IS_NULL:
      sqlite3_result_null(ctxt);
      break;
      
    case IS_LONG:
      sqlite3_result_int(ctxt, Z_LVAL_P(z_retval));
      break;
    
   case IS_DOUBLE:
       sqlite3_result_double(ctxt, Z_DVAL_P(z_retval));
      break;
      
   case IS_STRING:
       sqlite3_result_text(ctxt, Z_STRVAL_P(z_retval), Z_STRLEN_P(z_retval),SQLITE_TRANSIENT);
      break;

  default:
      sqlite3_result_error(ctxt, "invalid return type.", -1);
      break;
  }
  
   zval_dtor(z_retval);
}
 
/* }}}
   {{{ bool sqlite3_create_function(resource sqlite3, string function_name, int nb_args)
*/

PHP_FUNCTION(sqlite3_create_function)
{
  php_sqlite3_resource* me;
  php_sqlite3_func_t*   func;  
  
  zval*  z_rs;
  char*  func_name;
  int    func_name_len;
  char*  cb_name;
  int    cb_name_len;
  int    cb_num_args;
  int    err;
  
 if(ZEND_NUM_ARGS() != 4) WRONG_PARAM_COUNT;
 
 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,"rsls", &z_rs, 
    &func_name, &func_name_len, 
    &cb_num_args,
    &cb_name, &cb_name_len)==FAILURE)
    return;

  ZVAL_TO_S3_HANDLE (me, &z_rs);
  
  func = (php_sqlite3_func_t*) emalloc (sizeof(php_sqlite3_func_t));
  
  func->func_name   = estrdup(func_name);
  func->cb_name     = estrdup(cb_name);  
  func->cb_num_args = cb_num_args;
  func->me          = me;

  err = sqlite3_create_function(me->handle, func_name, cb_num_args, SQLITE_ANY, func, php_sqlite3_user_function_cb, NULL, NULL);
  
  if (err == SQLITE_ERROR)
    RETURN_FALSE;
    
  RETURN_TRUE;
}
/* }}} */