Hugging Face's logo

Datasets:
meddyrat
/
dis-bench

Modalities:
Tabular
Text
Formats:
parquet
Size:
1K - 10K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
1
dis-bench / src /php /php-src /ext /pdo_sqlite /sqlite_statement.c
meddyrat's picture
meddyrat
Replace repository contents with the original corrected artifact
1e94262
Raw History Blame Contribute Delete
12 kB
/*
+----------------------------------------------------------------------+
| Copyright (c) The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| https://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Wez Furlong <wez@php.net> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "ext/pdo/php_pdo.h"
#include "ext/pdo/php_pdo_driver.h"
#include "php_pdo_sqlite.h"
#include "php_pdo_sqlite_int.h"
#if defined(__APPLE__)
// If more than one usage, a Zend macro could be created
// around this runtime check
#include <Availability.h>
#endif
static int pdo_sqlite_stmt_dtor(pdo_stmt_t *stmt)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
if (S->stmt) {
sqlite3_finalize(S->stmt);
S->stmt = NULL;
}
efree(S);
return 1;
}
static int pdo_sqlite_stmt_execute(pdo_stmt_t *stmt)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
if (stmt->executed && !S->done) {
sqlite3_reset(S->stmt);
}
S->done = 0;
switch (sqlite3_step(S->stmt)) {
case SQLITE_ROW:
S->pre_fetched = 1;
php_pdo_stmt_set_column_count(stmt, sqlite3_data_count(S->stmt));
return 1;
case SQLITE_DONE:
php_pdo_stmt_set_column_count(stmt, sqlite3_column_count(S->stmt));
stmt->row_count = sqlite3_changes(S->H->db);
sqlite3_reset(S->stmt);
S->done = 1;
return 1;
case SQLITE_ERROR:
sqlite3_reset(S->stmt);
ZEND_FALLTHROUGH;
case SQLITE_MISUSE:
case SQLITE_BUSY:
default:
pdo_sqlite_error_stmt(stmt);
return 0;
}
}
static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,
enum pdo_param_event event_type)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
zval *parameter;
switch (event_type) {
case PDO_PARAM_EVT_EXEC_PRE:
if (stmt->executed && !S->done) {
sqlite3_reset(S->stmt);
S->done = 1;
}
if (param->is_param) {
if (param->paramno == -1) {
param->paramno = sqlite3_bind_parameter_index(S->stmt, ZSTR_VAL(param->name)) - 1;
}
switch (PDO_PARAM_TYPE(param->param_type)) {
case PDO_PARAM_STMT:
return 0;
case PDO_PARAM_NULL:
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
pdo_sqlite_error_stmt(stmt);
return 0;
case PDO_PARAM_INT:
case PDO_PARAM_BOOL:
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = &param->parameter;
}
if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
} else {
convert_to_long(parameter);
#if ZEND_LONG_MAX > 2147483647
if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
return 1;
}
#else
if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
return 1;
}
#endif
}
pdo_sqlite_error_stmt(stmt);
return 0;
case PDO_PARAM_LOB:
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = &param->parameter;
}
if (Z_TYPE_P(parameter) == IS_RESOURCE) {
php_stream *stm = NULL;
php_stream_from_zval_no_verify(stm, parameter);
if (stm) {
zend_string *mem = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
zval_ptr_dtor(parameter);
ZVAL_STR(parameter, mem ? mem : ZSTR_EMPTY_ALLOC());
} else {
pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");
return 0;
}
} else if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
pdo_sqlite_error_stmt(stmt);
return 0;
} else {
if (!try_convert_to_string(parameter)) {
return 0;
}
}
if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
Z_STRVAL_P(parameter),
Z_STRLEN_P(parameter),
SQLITE_STATIC)) {
return 1;
}
return 0;
case PDO_PARAM_STR:
default:
if (Z_ISREF(param->parameter)) {
parameter = Z_REFVAL(param->parameter);
} else {
parameter = &param->parameter;
}
if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
} else {
if (!try_convert_to_string(parameter)) {
return 0;
}
if (SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
Z_STRVAL_P(parameter),
Z_STRLEN_P(parameter),
SQLITE_STATIC)) {
return 1;
}
}
pdo_sqlite_error_stmt(stmt);
return 0;
}
}
break;
default:
;
}
return 1;
}
static int pdo_sqlite_stmt_fetch(pdo_stmt_t *stmt,
enum pdo_fetch_orientation ori, zend_long offset)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
int i;
if (!S->stmt) {
return 0;
}
if (S->pre_fetched) {
S->pre_fetched = 0;
return 1;
}
if (S->done) {
return 0;
}
i = sqlite3_step(S->stmt);
switch (i) {
case SQLITE_ROW:
return 1;
case SQLITE_DONE:
S->done = 1;
sqlite3_reset(S->stmt);
return 0;
case SQLITE_ERROR:
sqlite3_reset(S->stmt);
ZEND_FALLTHROUGH;
default:
pdo_sqlite_error_stmt(stmt);
return 0;
}
}
static int pdo_sqlite_stmt_describe(pdo_stmt_t *stmt, int colno)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
const char *str;
if(colno >= sqlite3_column_count(S->stmt)) {
/* error invalid column */
pdo_sqlite_error_stmt(stmt);
return 0;
}
str = sqlite3_column_name(S->stmt, colno);
stmt->columns[colno].name = zend_string_init(str, strlen(str), 0);
stmt->columns[colno].maxlen = SIZE_MAX;
stmt->columns[colno].precision = 0;
return 1;
}
static int pdo_sqlite_stmt_get_col(
pdo_stmt_t *stmt, int colno, zval *result, enum pdo_param_type *type)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
if (!S->stmt) {
return 0;
}
if(colno >= sqlite3_data_count(S->stmt)) {
/* error invalid column */
pdo_sqlite_error_stmt(stmt);
return 0;
}
switch (sqlite3_column_type(S->stmt, colno)) {
case SQLITE_NULL:
ZVAL_NULL(result);
return 1;
case SQLITE_INTEGER: {
int64_t i = sqlite3_column_int64(S->stmt, colno);
#if SIZEOF_ZEND_LONG < 8
if (i > ZEND_LONG_MAX || i < ZEND_LONG_MIN) {
ZVAL_STRINGL(result,
(char *) sqlite3_column_text(S->stmt, colno),
sqlite3_column_bytes(S->stmt, colno));
return 1;
}
#endif
ZVAL_LONG(result, i);
return 1;
}
case SQLITE_FLOAT:
ZVAL_DOUBLE(result, sqlite3_column_double(S->stmt, colno));
return 1;
case SQLITE_BLOB:
ZVAL_STRINGL_FAST(result,
sqlite3_column_blob(S->stmt, colno), sqlite3_column_bytes(S->stmt, colno));
return 1;
default:
ZVAL_STRINGL_FAST(result,
(char *) sqlite3_column_text(S->stmt, colno), sqlite3_column_bytes(S->stmt, colno));
return 1;
}
}
static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
const char *str;
zval flags;
if (!S->stmt || !stmt->executed) {
return FAILURE;
}
if(colno >= sqlite3_column_count(S->stmt)) {
/* error invalid column */
pdo_sqlite_error_stmt(stmt);
return FAILURE;
}
array_init(return_value);
array_init(&flags);
switch (sqlite3_column_type(S->stmt, colno)) {
case SQLITE_NULL:
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_NULL_LOWERCASE));
add_assoc_long(return_value, "pdo_type", PDO_PARAM_NULL);
break;
case SQLITE_FLOAT:
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_DOUBLE));
add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR);
break;
case SQLITE_BLOB:
add_next_index_string(&flags, "blob");
/* TODO Check this is correct */
ZEND_FALLTHROUGH;
case SQLITE_TEXT:
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_STRING));
add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR);
break;
case SQLITE_INTEGER:
add_assoc_str(return_value, "native_type", ZSTR_KNOWN(ZEND_STR_INTEGER));
add_assoc_long(return_value, "pdo_type", PDO_PARAM_INT);
break;
}
str = sqlite3_column_decltype(S->stmt, colno);
if (str) {
add_assoc_string(return_value, "sqlite:decl_type", (char *)str);
}
#ifdef HAVE_SQLITE3_COLUMN_TABLE_NAME
str = sqlite3_column_table_name(S->stmt, colno);
if (str) {
add_assoc_string(return_value, "table", (char *)str);
}
#endif
add_assoc_zval(return_value, "flags", &flags);
return SUCCESS;
}
static int pdo_sqlite_stmt_cursor_closer(pdo_stmt_t *stmt)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
sqlite3_reset(S->stmt);
return 1;
}
static int pdo_sqlite_stmt_get_attribute(pdo_stmt_t *stmt, zend_long attr, zval *val)
{
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
switch (attr) {
case PDO_SQLITE_ATTR_READONLY_STATEMENT:
ZVAL_FALSE(val);
if (sqlite3_stmt_readonly(S->stmt)) {
ZVAL_TRUE(val);
}
break;
case PDO_SQLITE_ATTR_BUSY_STATEMENT:
ZVAL_FALSE(val);
if (sqlite3_stmt_busy(S->stmt)) {
ZVAL_TRUE(val);
}
break;
case PDO_SQLITE_ATTR_EXPLAIN_STATEMENT:
#if SQLITE_VERSION_NUMBER >= 3043000
#if defined(__APPLE__)
if (__builtin_available(macOS 14.2, *)) {
#endif
ZVAL_LONG(val, (zend_long)sqlite3_stmt_isexplain(S->stmt));
return 1;
#if defined(__APPLE__)
} else {
zend_value_error("explain statement unsupported");
return 0;
}
#endif
#else
zend_value_error("explain statement unsupported");
return 0;
#endif
default:
return 0;
}
return 1;
}
static int pdo_sqlite_stmt_set_attribute(pdo_stmt_t *stmt, zend_long attr, zval *zval)
{
switch (attr) {
case PDO_SQLITE_ATTR_EXPLAIN_STATEMENT:
#if SQLITE_VERSION_NUMBER >= 3043000
#if defined(__APPLE__)
if (__builtin_available(macOS 14.2, *)) {
#endif
if (Z_TYPE_P(zval) != IS_LONG) {
zend_type_error("explain mode must be of type int, %s given", zend_zval_value_name(zval));
return 0;
}
if (Z_LVAL_P(zval) < 0 || Z_LVAL_P(zval) > 2) {
zend_value_error("explain mode must be one of the Pdo\\Sqlite::EXPLAIN_MODE_* constants");
return 0;
}
pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
if (sqlite3_stmt_explain(S->stmt, (int)Z_LVAL_P(zval)) != SQLITE_OK) {
return 0;
}
return 1;
#if defined(__APPLE__)
} else {
zend_value_error("explain statement unsupported");
return 0;
}
#endif
#else
zend_value_error("explain statement unsupported");
return 0;
#endif
default:
return 0;
}
return 1;
}
const struct pdo_stmt_methods sqlite_stmt_methods = {
pdo_sqlite_stmt_dtor,
pdo_sqlite_stmt_execute,
pdo_sqlite_stmt_fetch,
pdo_sqlite_stmt_describe,
pdo_sqlite_stmt_get_col,
pdo_sqlite_stmt_param_hook,
pdo_sqlite_stmt_set_attribute, /* set_attr */
pdo_sqlite_stmt_get_attribute, /* get_attr */
pdo_sqlite_stmt_col_meta,
NULL, /* next_rowset */
pdo_sqlite_stmt_cursor_closer
};