#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "cursor.h"

#include "microprotocols.h"

#include "module.h"

#include "util.h"

#include "pycore_pyerrors.h" // _PyErr_FormatFromCause()

#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()

typedef enum {

TYPE_LONG,

TYPE_FLOAT,

TYPE_UNICODE,

TYPE_BUFFER,

TYPE_UNKNOWN

} parameter_type;

#define clinic_state() (pysqlite_get_state_by_type(Py_TYPE(self)))

#include "clinic/cursor.c.h"

#undef clinic_state

#define _pysqlite_Cursor_CAST(op) ((pysqlite_Cursor *)(op))

static inline int

check_cursor_locked(pysqlite_Cursor *cur)

{

if (cur->locked) {

PyErr_SetString(cur->connection->ProgrammingError,

"Recursive use of cursors not allowed.");

return 0;

}

return 1;

}

static pysqlite_state *

get_module_state_by_cursor(pysqlite_Cursor *cursor)

{

if (cursor->connection != NULL && cursor->connection->state != NULL) {

return cursor->connection->state;

}

return pysqlite_get_state_by_type(Py_TYPE(cursor));

}

static void

cursor_sqlite3_internal_error(pysqlite_Cursor *cursor,

const char *error_message,

int chain_exceptions)

{

pysqlite_state *state = get_module_state_by_cursor(cursor);

if (chain_exceptions) {

assert(PyErr_Occurred());

PyObject *exc = PyErr_GetRaisedException();

PyErr_SetString(state->InternalError, error_message);

_PyErr_ChainExceptions1(exc);

}

else {

assert(!PyErr_Occurred());

PyErr_SetString(state->InternalError, error_message);

}

}

static void

cursor_cannot_reset_stmt_error(pysqlite_Cursor *cursor, int chain_exceptions)

{

cursor_sqlite3_internal_error(cursor,

"cannot reset statement",

chain_exceptions);

}

static int

pysqlite_cursor_init_impl(pysqlite_Cursor *self,

pysqlite_Connection *connection)

{

if (!check_cursor_locked(self)) {

return -1;

}

Py_INCREF(connection);

Py_XSETREF(self->connection, connection);

Py_CLEAR(self->statement);

Py_CLEAR(self->row_cast_map);

Py_INCREF(Py_None);

Py_XSETREF(self->description, Py_None);

Py_INCREF(Py_None);

Py_XSETREF(self->lastrowid, Py_None);

self->arraysize = 1;

self->closed = 0;

self->rowcount = -1L;

Py_INCREF(Py_None);

Py_XSETREF(self->row_factory, Py_None);

if (!pysqlite_check_thread(self->connection)) {

return -1;

}

self->initialized = 1;

return 0;

}

static inline int

stmt_reset(pysqlite_Statement *self)

{

int rc = SQLITE_OK;

if (self->st != NULL) {

Py_BEGIN_ALLOW_THREADS

rc = sqlite3_reset(self->st);

Py_END_ALLOW_THREADS

}

return rc;

}

static int

cursor_traverse(PyObject *op, visitproc visit, void *arg)

{

pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->connection);

Py_VISIT(self->description);

Py_VISIT(self->row_cast_map);

Py_VISIT(self->lastrowid);

Py_VISIT(self->row_factory);

Py_VISIT(self->statement);

return 0;

}

static int

cursor_clear(PyObject *op)

{

pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);

Py_CLEAR(self->connection);

Py_CLEAR(self->description);

Py_CLEAR(self->row_cast_map);

Py_CLEAR(self->lastrowid);

Py_CLEAR(self->row_factory);

if (self->statement) {

/* Reset the statement if the user has not closed the cursor */

int rc = stmt_reset(self->statement);

Py_CLEAR(self->statement);

if (rc != SQLITE_OK) {

cursor_cannot_reset_stmt_error(self, 0);

PyErr_FormatUnraisable("Exception ignored in cursor_clear()");

}

}

return 0;

}

static void

cursor_dealloc(PyObject *op)

{

pysqlite_Cursor *self = _pysqlite_Cursor_CAST(op);

PyTypeObject *tp = Py_TYPE(self);

PyObject_GC_UnTrack(self);

FT_CLEAR_WEAKREFS(op, self->in_weakreflist);

(void)tp->tp_clear(op);

tp->tp_free(self);

Py_DECREF(tp);

}

static PyObject *

_pysqlite_get_converter(pysqlite_state *state, const char *keystr,

Py_ssize_t keylen)

{

PyObject *key;

PyObject *upcase_key;

PyObject *retval;

key = PyUnicode_FromStringAndSize(keystr, keylen);

if (!key) {

return NULL;

}

upcase_key = PyObject_CallMethodNoArgs(key, state->str_upper);

Py_DECREF(key);

if (!upcase_key) {

return NULL;

}

int rc = PyDict_GetItemRef(state->converters, upcase_key, &retval);

Py_DECREF(upcase_key);

if (rc < 0) {

return NULL;

}

return retval;

}

static int

pysqlite_build_row_cast_map(pysqlite_Cursor* self)

{

int i;

const char* pos;

const char* decltype;

PyObject* converter;

if (!self->connection->detect_types) {

return 0;

}

Py_XSETREF(self->row_cast_map, PyList_New(0));

if (!self->row_cast_map) {

return -1;

}

for (i = 0; i < sqlite3_column_count(self->statement->st); i++) {

converter = NULL;

if (self->connection->detect_types & PARSE_COLNAMES) {

const char *colname = sqlite3_column_name(self->statement->st, i);

if (colname == NULL) {

PyErr_NoMemory();

Py_CLEAR(self->row_cast_map);

return -1;

}

const char *type_start = NULL;

for (pos = colname; *pos != 0; pos++) {

if (*pos == '[') {

type_start = pos + 1;

}

else if (*pos == ']' && type_start != NULL) {

pysqlite_state *state = self->connection->state;

converter = _pysqlite_get_converter(state, type_start,

pos - type_start);

if (!converter && PyErr_Occurred()) {

Py_CLEAR(self->row_cast_map);

return -1;

}

break;

}

}

}

if (!converter && self->connection->detect_types & PARSE_DECLTYPES) {

decltype = sqlite3_column_decltype(self->statement->st, i);

if (decltype) {

for (pos = decltype;;pos++) {

/* Converter names are split at '(' and blanks.

if (*pos == ' ' || *pos == '(' || *pos == 0) {

pysqlite_state *state = self->connection->state;

converter = _pysqlite_get_converter(state, decltype,

pos - decltype);

if (!converter && PyErr_Occurred()) {

Py_CLEAR(self->row_cast_map);

return -1;

}

break;

}

}

}

}

int rc = PyList_Append(self->row_cast_map,

converter ? converter : Py_None);

Py_XDECREF(converter);

if (rc != 0) {

Py_CLEAR(self->row_cast_map);

return -1;

}

}

return 0;

}

static PyObject *

_pysqlite_build_column_name(pysqlite_Cursor *self, const char *colname)

{

const char* pos;

Py_ssize_t len;

if (self->connection->detect_types & PARSE_COLNAMES) {

for (pos = colname; *pos; pos++) {

if (*pos == '[') {

if ((pos != colname) && (*(pos-1) == ' ')) {

pos--;

}

break;

}

}

len = pos - colname;

}

else {

len = strlen(colname);

}

return PyUnicode_FromStringAndSize(colname, len);

}

static PyObject *

_pysqlite_fetch_one_row(pysqlite_Cursor* self)

{

int i, numcols;

PyObject* row;

int coltype;

PyObject* converter;

PyObject* converted;

Py_ssize_t nbytes;

char buf[200];

const char* colname;

PyObject* error_msg;

Py_BEGIN_ALLOW_THREADS

numcols = sqlite3_data_count(self->statement->st);

Py_END_ALLOW_THREADS

row = PyTuple_New(numcols);

if (!row)

return NULL;

sqlite3 *db = self->connection->db;

for (i = 0; i < numcols; i++) {

if (self->connection->detect_types

&& self->row_cast_map != NULL

&& i < PyList_GET_SIZE(self->row_cast_map))

{

converter = PyList_GET_ITEM(self->row_cast_map, i);

}

else {

converter = Py_None;

}

/*

if (converter != Py_None) {

const void *blob = sqlite3_column_blob(self->statement->st, i);

if (blob == NULL) {

if (sqlite3_errcode(db) == SQLITE_NOMEM) {

PyErr_NoMemory();

goto error;

}

converted = Py_NewRef(Py_None);

}

else {

nbytes = sqlite3_column_bytes(self->statement->st, i);

PyObject *item = PyBytes_FromStringAndSize(blob, nbytes);

if (item == NULL) {

goto error;

}

converted = PyObject_CallOneArg(converter, item);

Py_DECREF(item);

}

} else {

Py_BEGIN_ALLOW_THREADS

coltype = sqlite3_column_type(self->statement->st, i);

Py_END_ALLOW_THREADS

if (coltype == SQLITE_NULL) {

converted = Py_NewRef(Py_None);

} else if (coltype == SQLITE_INTEGER) {

converted = PyLong_FromLongLong(sqlite3_column_int64(self->statement->st, i));

} else if (coltype == SQLITE_FLOAT) {

converted = PyFloat_FromDouble(sqlite3_column_double(self->statement->st, i));

} else if (coltype == SQLITE_TEXT) {

const char *text = (const char*)sqlite3_column_text(self->statement->st, i);

if (text == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {

PyErr_NoMemory();

goto error;

}

nbytes = sqlite3_column_bytes(self->statement->st, i);

if (self->connection->text_factory == (PyObject*)&PyUnicode_Type) {

converted = PyUnicode_FromStringAndSize(text, nbytes);

if (!converted && PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {

PyErr_Clear();

colname = sqlite3_column_name(self->statement->st, i);

if (colname == NULL) {

PyErr_NoMemory();

goto error;

}

PyOS_snprintf(buf, sizeof(buf) - 1, "Could not decode to UTF-8 column '%s' with text '%s'",

colname , text);

error_msg = PyUnicode_Decode(buf, strlen(buf), "ascii", "replace");

PyObject *exc = self->connection->OperationalError;

if (!error_msg) {

PyErr_SetString(exc, "Could not decode to UTF-8");

} else {

PyErr_SetObject(exc, error_msg);

Py_DECREF(error_msg);

}

}

} else if (self->connection->text_factory == (PyObject*)&PyBytes_Type) {

converted = PyBytes_FromStringAndSize(text, nbytes);

} else if (self->connection->text_factory == (PyObject*)&PyByteArray_Type) {

converted = PyByteArray_FromStringAndSize(text, nbytes);

} else {

converted = PyObject_CallFunction(self->connection->text_factory, "y#", text, nbytes);

}

} else {

/* coltype == SQLITE_BLOB */

const void *blob = sqlite3_column_blob(self->statement->st, i);

if (blob == NULL && sqlite3_errcode(db) == SQLITE_NOMEM) {

PyErr_NoMemory();

goto error;

}

nbytes = sqlite3_column_bytes(self->statement->st, i);

converted = PyBytes_FromStringAndSize(blob, nbytes);

}

}

if (!converted) {

goto error;

}

PyTuple_SET_ITEM(row, i, converted);

}

if (PyErr_Occurred())

goto error;

return row;

error:

Py_DECREF(row);

return NULL;

}

static int check_cursor(pysqlite_Cursor* cur)

{

if (!cur->initialized) {

pysqlite_state *state = pysqlite_get_state_by_type(Py_TYPE(cur));

PyErr_SetString(state->ProgrammingError,

"Base Cursor.__init__ not called.");

return 0;

}

assert(cur->connection != NULL);

assert(cur->connection->state != NULL);

if (cur->closed) {

PyErr_SetString(cur->connection->state->ProgrammingError,

"Cannot operate on a closed cursor.");

return 0;

}

return (pysqlite_check_thread(cur->connection)

&& pysqlite_check_connection(cur->connection)

&& check_cursor_locked(cur));

}

static int

begin_transaction(pysqlite_Connection *self)

{

assert(self->isolation_level != NULL);

int rc;

Py_BEGIN_ALLOW_THREADS

sqlite3_stmt *statement;

char begin_stmt[16] = "BEGIN ";

#ifdef Py_DEBUG

size_t len = strlen(self->isolation_level);

assert(len <= 9);

(void)strcat(begin_stmt, self->isolation_level);

rc = sqlite3_prepare_v2(self->db, begin_stmt, -1, &statement, NULL);

if (rc == SQLITE_OK) {

(void)sqlite3_step(statement);

rc = sqlite3_finalize(statement);

}

Py_END_ALLOW_THREADS

if (rc != SQLITE_OK) {

set_error_from_db(self->state, self->db);

return -1;

}

return 0;

}

static PyObject *

get_statement_from_cache(pysqlite_Cursor *self, PyObject *operation)

{

PyObject *args[] = { NULL, operation, }; // Borrowed ref.

PyObject *cache = self->connection->statement_cache;

size_t nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;

return PyObject_Vectorcall(cache, args + 1, nargsf, NULL);

}

static inline int

stmt_step(sqlite3_stmt *statement)

{

int rc;

Py_BEGIN_ALLOW_THREADS

rc = sqlite3_step(statement);

Py_END_ALLOW_THREADS

return rc;

}

static int

bind_param(pysqlite_state *state, pysqlite_Statement *self, int pos,

PyObject *parameter)

{

int rc = SQLITE_OK;

const char *string;

Py_ssize_t buflen;

parameter_type paramtype;

if (parameter == Py_None) {

rc = sqlite3_bind_null(self->st, pos);

goto final;

}

if (PyLong_CheckExact(parameter)) {

paramtype = TYPE_LONG;

} else if (PyFloat_CheckExact(parameter)) {

paramtype = TYPE_FLOAT;

} else if (PyUnicode_CheckExact(parameter)) {

paramtype = TYPE_UNICODE;

} else if (PyLong_Check(parameter)) {

paramtype = TYPE_LONG;

} else if (PyFloat_Check(parameter)) {

paramtype = TYPE_FLOAT;

} else if (PyUnicode_Check(parameter)) {

paramtype = TYPE_UNICODE;

} else if (PyObject_CheckBuffer(parameter)) {

paramtype = TYPE_BUFFER;

} else {

paramtype = TYPE_UNKNOWN;

}

switch (paramtype) {

case TYPE_LONG: {

sqlite_int64 value = _pysqlite_long_as_int64(parameter);

rc = (value == -1 && PyErr_Occurred())

? SQLITE_ERROR

: sqlite3_bind_int64(self->st, pos, value);

break;

}

case TYPE_FLOAT: {

double value = PyFloat_AsDouble(parameter);

rc = (value == -1 && PyErr_Occurred())

? SQLITE_ERROR

: sqlite3_bind_double(self->st, pos, value);

break;

}

case TYPE_UNICODE:

string = PyUnicode_AsUTF8AndSize(parameter, &buflen);

if (string == NULL) {

return SQLITE_ERROR;

}

if (buflen > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"string longer than INT_MAX bytes");

return SQLITE_ERROR;

}

rc = sqlite3_bind_text(self->st, pos, string, (int)buflen, SQLITE_TRANSIENT);

break;

case TYPE_BUFFER: {

Py_buffer view;

if (PyObject_GetBuffer(parameter, &view, PyBUF_SIMPLE) != 0) {

return SQLITE_ERROR;

}

if (view.len > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"BLOB longer than INT_MAX bytes");

PyBuffer_Release(&view);

return SQLITE_ERROR;

}

rc = sqlite3_bind_blob(self->st, pos, view.buf, (int)view.len, SQLITE_TRANSIENT);

PyBuffer_Release(&view);

break;

}

case TYPE_UNKNOWN:

PyErr_Format(state->ProgrammingError,

"Error binding parameter %d: type '%s' is not supported",

pos, Py_TYPE(parameter)->tp_name);

rc = SQLITE_ERROR;

}

final:

return rc;

}

static inline int

need_adapt(pysqlite_state *state, PyObject *obj)

{

if (state->BaseTypeAdapted) {

return 1;

}

if (PyLong_CheckExact(obj) || PyFloat_CheckExact(obj)

|| PyUnicode_CheckExact(obj) || PyByteArray_CheckExact(obj)) {

return 0;

} else {

return 1;

}

}

static void

bind_parameters(pysqlite_state *state, pysqlite_Statement *self,

PyObject *parameters)

{

PyObject* current_param;

PyObject* adapted;

const char* binding_name;

int i;

int rc;

int num_params_needed;

Py_ssize_t num_params;

Py_BEGIN_ALLOW_THREADS

num_params_needed = sqlite3_bind_parameter_count(self->st);

Py_END_ALLOW_THREADS

if (PyTuple_CheckExact(parameters) || PyList_CheckExact(parameters) || (!PyDict_Check(parameters) && PySequence_Check(parameters))) {

/* parameters passed as sequence */

if (PyTuple_CheckExact(parameters)) {

num_params = PyTuple_GET_SIZE(parameters);

} else if (PyList_CheckExact(parameters)) {

num_params = PyList_GET_SIZE(parameters);

} else {

num_params = PySequence_Size(parameters);

if (num_params == -1) {

return;

}

}

if (num_params != num_params_needed) {

PyErr_Format(state->ProgrammingError,

"Incorrect number of bindings supplied. The current "

"statement uses %d, and there are %zd supplied.",

num_params_needed, num_params);

return;

}

for (i = 0; i < num_params; i++) {

const char *name = sqlite3_bind_parameter_name(self->st, i+1);

if (name != NULL && name[0] != '?') {

PyErr_Format(state->ProgrammingError,

"Binding %d ('%s') is a named parameter, but you "

"supplied a sequence which requires nameless (qmark) "

"placeholders.",

i+1, name);

return;

}

if (PyTuple_CheckExact(parameters)) {

PyObject *item = PyTuple_GET_ITEM(parameters, i);

current_param = Py_NewRef(item);

} else if (PyList_CheckExact(parameters)) {

PyObject *item = PyList_GetItem(parameters, i);

current_param = Py_XNewRef(item);

} else {

current_param = PySequence_GetItem(parameters, i);

}

if (!current_param) {

return;

}

if (!need_adapt(state, current_param)) {

adapted = current_param;

} else {

PyObject *protocol = (PyObject *)state->PrepareProtocolType;

adapted = pysqlite_microprotocols_adapt(state, current_param,

protocol,

current_param);

Py_DECREF(current_param);

if (!adapted) {

return;

}

}

rc = bind_param(state, self, i + 1, adapted);

Py_DECREF(adapted);

if (rc != SQLITE_OK) {

PyObject *exc = PyErr_GetRaisedException();

sqlite3 *db = sqlite3_db_handle(self->st);

set_error_from_db(state, db);

_PyErr_ChainExceptions1(exc);

return;

}

}

} else if (PyDict_Check(parameters)) {

/* parameters passed as dictionary */

for (i = 1; i <= num_params_needed; i++) {

Py_BEGIN_ALLOW_THREADS

binding_name = sqlite3_bind_parameter_name(self->st, i);

Py_END_ALLOW_THREADS

if (!binding_name) {

PyErr_Format(state->ProgrammingError,

"Binding %d has no name, but you supplied a "

"dictionary (which has only names).", i);

return;

}

binding_name++; /* skip first char (the colon) */

PyObject *current_param = NULL;

int found = PyMapping_GetOptionalItemString(parameters,

binding_name,

&current_param);

if (found == -1) {

return;

}

else if (found == 0) {

PyErr_Format(state->ProgrammingError,

"You did not supply a value for binding "

"parameter :%s.", binding_name);

return;

}

if (!need_adapt(state, current_param)) {

adapted = current_param;

} else {

PyObject *protocol = (PyObject *)state->PrepareProtocolType;

adapted = pysqlite_microprotocols_adapt(state, current_param,

protocol,

current_param);

Py_DECREF(current_param);

if (!adapted) {

return;

}

}

rc = bind_param(state, self, i, adapted);

Py_DECREF(adapted);

if (rc != SQLITE_OK) {

PyObject *exc = PyErr_GetRaisedException();

sqlite3 *db = sqlite3_db_handle(self->st);

set_error_from_db(state, db);

_PyErr_ChainExceptions1(exc);

return;

}

}

} else {

PyErr_SetString(state->ProgrammingError,

"parameters are of unsupported type");

}

}

PyObject *

_pysqlite_query_execute(pysqlite_Cursor* self, int multiple, PyObject* operation, PyObject* second_argument)

{

PyObject* parameters_list = NULL;

PyObject* parameters_iter = NULL;

PyObject* parameters = NULL;

int i;

int rc;

int numcols;

PyObject* column_name;

if (!check_cursor(self)) {

goto error;

}

self->locked = 1;

if (multiple) {

if (PyIter_Check(second_argument)) {

/* iterator */

parameters_iter = Py_NewRef(second_argument);

} else {

/* sequence */

parameters_iter = PyObject_GetIter(second_argument);

if (!parameters_iter) {

goto error;

}

}

} else {

parameters_list = PyList_New(0);

if (!parameters_list) {

goto error;

}

if (second_argument == NULL) {

second_argument = PyTuple_New(0);

if (!second_argument) {

goto error;

}

} else {

Py_INCREF(second_argument);

}

if (PyList_Append(parameters_list, second_argument) != 0) {

Py_DECREF(second_argument);

goto error;

}

Py_DECREF(second_argument);

parameters_iter = PyObject_GetIter(parameters_list);

if (!parameters_iter) {

goto error;

}

}

/* reset description */

Py_INCREF(Py_None);

Py_SETREF(self->description, Py_None);

if (self->statement) {

// Reset pending statements on this cursor.

if (stmt_reset(self->statement) != SQLITE_OK) {

goto reset_failure;

}

}

PyObject *stmt = get_statement_from_cache(self, operation);

Py_XSETREF(self->statement, (pysqlite_Statement *)stmt);

if (!self->statement) {

goto error;

}

pysqlite_state *state = self->connection->state;

if (multiple && sqlite3_stmt_readonly(self->statement->st)) {

PyErr_SetString(state->ProgrammingError,

"executemany() can only execute DML statements.");

goto error;

}

if (sqlite3_stmt_busy(self->statement->st)) {

Py_SETREF(self->statement,

pysqlite_statement_create(self->connection, operation));

if (self->statement == NULL) {

goto error;

}

}

if (stmt_reset(self->statement) != SQLITE_OK) {

goto reset_failure;

}

self->rowcount = self->statement->is_dml ? 0L : -1L;

/* We start a transaction implicitly before a DML statement.

if (self->connection->autocommit == AUTOCOMMIT_LEGACY

&& self->connection->isolation_level

&& self->statement->is_dml

&& sqlite3_get_autocommit(self->connection->db))

{

if (begin_transaction(self->connection) < 0) {

goto error;

}

}

assert(!sqlite3_stmt_busy(self->statement->st));

while (1) {

parameters = PyIter_Next(parameters_iter);

if (!parameters) {

break;

}

bind_parameters(state, self->statement, parameters);

if (PyErr_Occurred()) {

goto error;

}

rc = stmt_step(self->statement->st);

if (rc != SQLITE_DONE && rc != SQLITE_ROW) {

if (PyErr_Occurred()) {

/* there was an error that occurred in a user-defined callback */

if (state->enable_callback_tracebacks) {

PyErr_Print();

} else {

PyErr_Clear();

}

}

set_error_from_db(state, self->connection->db);

goto error;

}

if (pysqlite_build_row_cast_map(self) != 0) {

_PyErr_FormatFromCause(state->OperationalError,

"Error while building row_cast_map");

goto error;

}

assert(rc == SQLITE_ROW || rc == SQLITE_DONE);

Py_BEGIN_ALLOW_THREADS

numcols = sqlite3_column_count(self->statement->st);

Py_END_ALLOW_THREADS

if (self->description == Py_None && numcols > 0) {

Py_SETREF(self->description, PyTuple_New(numcols));

if (!self->description) {

goto error;

}

for (i = 0; i < numcols; i++) {

const char *colname;

colname = sqlite3_column_name(self->statement->st, i);

if (colname == NULL) {

PyErr_NoMemory();

goto error;

}

column_name = _pysqlite_build_column_name(self, colname);

if (column_name == NULL) {

goto error;

}

PyObject *descriptor = PyTuple_Pack(7, column_name,

Py_None, Py_None, Py_None,

Py_None, Py_None, Py_None);

Py_DECREF(column_name);

if (descriptor == NULL) {

goto error;

}

PyTuple_SET_ITEM(self->description, i, descriptor);

}

}

if (rc == SQLITE_DONE) {

if (self->statement->is_dml) {

self->rowcount += (long)sqlite3_changes(self->connection->db);

}

if (stmt_reset(self->statement) != SQLITE_OK) {

goto reset_failure;

}

}

Py_XDECREF(parameters);

}

if (!multiple) {

sqlite_int64 lastrowid;

Py_BEGIN_ALLOW_THREADS

lastrowid = sqlite3_last_insert_rowid(self->connection->db);

Py_END_ALLOW_THREADS

Py_SETREF(self->lastrowid, PyLong_FromLongLong(lastrowid));

// Fall through on error.

}

error:

Py_XDECREF(parameters);

Py_XDECREF(parameters_iter);

Py_XDECREF(parameters_list);

self->locked = 0;

if (PyErr_Occurred()) {

if (self->statement) {

sqlite3 *db = sqlite3_db_handle(self->statement->st);

int sqlite3_state = sqlite3_errcode(db);

// stmt_reset() may return a previously set exception,

// either triggered because of Python or sqlite3.

rc = stmt_reset(self->statement);

Py_CLEAR(self->statement);

if (sqlite3_state == SQLITE_OK && rc != SQLITE_OK) {

cursor_cannot_reset_stmt_error(self, 1);

}