int wxSqlitePreparedStatement::GetParameterCount()
{
ResetErrorCodes();
int nReturn = 0;
wxSqliteStatementVector::iterator start = m_Statements.begin();
wxSqliteStatementVector::iterator stop = m_Statements.end();
while (start != stop)
{
nReturn += sqlite3_bind_parameter_count((sqlite3_stmt*)(*start));
start++;
}
return nReturn;
}
static void objv_db_sqlite_bind_data(objv_zone_t * zone,sqlite3_stmt * stmt,objv_object_t * data, sqlite3_destructor_type type) {
int c = sqlite3_bind_parameter_count(stmt);
for(int i=1; i<=c; i++) {
const char * name = sqlite3_bind_parameter_name(stmt, i);
objv_object_t * key = NULL;
objv_object_t * v;
if(name) {
key = (objv_object_t *) objv_string_new(zone, name);
}
else {
key = (objv_object_t *) objv_string_new_format(zone, "@%d",i -1);
}
v = objv_object_objectValueForKey(data, key, NULL);
if(v == NULL) {
sqlite3_bind_null(stmt, i);
}
else if(objv_object_isKindOfClass(v, OBJV_CLASS(Value))) {
{
objv_value_t * value = (objv_value_t *) v;
if(value->type == OBJV_TYPE(int)) {
sqlite3_bind_int(stmt, i, value->intValue);
}
else if(value->type == OBJV_TYPE(uint)) {
sqlite3_bind_int(stmt, i, value->uintValue);
}
else if(value->type == OBJV_TYPE(long)) {
sqlite3_bind_int64(stmt, i, value->longValue);
}
else if(value->type == OBJV_TYPE(ulong)) {
sqlite3_bind_int64(stmt, i, value->ulongValue);
}
else if(value->type == OBJV_TYPE(longLong)) {
sqlite3_bind_int64(stmt, i, value->longLongValue);
}
else if(value->type == OBJV_TYPE(ulongLong)) {
sqlite3_bind_int64(stmt, i, value->ulongLongValue);
}
else if(value->type == OBJV_TYPE(float)) {
sqlite3_bind_double(stmt, i, value->floatValue);
}
else if(value->type == OBJV_TYPE(double)) {
sqlite3_bind_double(stmt, i, value->doubleValue);
}
else if(value->type == OBJV_TYPE(boolean)) {
static int
sqlite3_clear_bindings (sqlite3_stmt *stmt)
{
int n = sqlite3_bind_parameter_count (stmt);
int index;
for (index = 1; index <= n; index++)
{
int result = sqlite3_bind_null (stmt, index);
if (result != SQLITE_OK)
return result;
}
return SQLITE_OK;
}
ECode CStmt::BindParameterCount(
/* [out] */ Int32* count)
{
VALIDATE_NOT_NULL(count);
#if HAVE_SQLITE3 && HAVE_SQLITE_COMPILE
hvm *v = (hvm *)mHandle;
if (v && v->vm && v->h) {
*count = sqlite3_bind_parameter_count((sqlite3_stmt *) v->vm);
} else {
return E_NULL_POINTER_EXCEPTION;
}
#else
return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION;
#endif
return NOERROR;
}
bool SQLiteCommand::bindParameterByIndex(size_t index, shared_ptr<DBValue> value) {
if (index == 0) {
return true;
}
const size_t size = myStatements.size();
int number = index;
for (size_t i = 0; i < size; ++i) {
sqlite3_stmt *statement = myStatements[i];
const int count = sqlite3_bind_parameter_count(statement);
if (number > count) {
number -= count;
continue;
}
return bindParameter(statement, number, value);
}
return true;
}
int CppSQLite3Statement::bindParameterIndex(const char* szParam)
{
checkVM();
int nParam = sqlite3_bind_parameter_index(mpVM, szParam);
int nn = sqlite3_bind_parameter_count(mpVM);
const char* sz1 = sqlite3_bind_parameter_name(mpVM, 1);
const char* sz2 = sqlite3_bind_parameter_name(mpVM, 2);
if (!nParam)
{
char buf[128];
sprintf(buf, "Parameter '%s' is not valid for this statement", szParam);
throw CppSQLite3Exception(CPPSQLITE_ERROR, buf, DONT_DELETE_MSG);
}
return nParam;
}
void Statement::initParameters() {
if (!_stmt) {
return;
}
clearParameters();
_parametersCount = sqlite3_bind_parameter_count(_stmt);
if (_parametersCount <= 0) {
return;
}
for (int i = 1; i <= _parametersCount; ++i) {
const char *name = sqlite3_bind_parameter_name(_stmt, i);
if (name && name[0]) {
_nameParameters[name] = i;
}
}
}
static int dbd_sqlite3_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t *statement, va_list args)
{
const char **values;
int i, nargs;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
nargs = sqlite3_bind_parameter_count(statement->stmt);
values = apr_palloc(pool, sizeof(*values) * nargs);
for (i = 0; i < nargs; i++) {
values[i] = apr_pstrdup(pool, va_arg(args, const char*));
}
return dbd_sqlite3_pquery(pool, sql, nrows, statement, nargs, values);
}
static char *sql_pwdb_lookup(const char *user)
{
sqlite3 *db = srv.db_cxn;
sqlite3_stmt *stmt = NULL;
int rc, step = 0;
char *password = NULL;
if (debugging > 1)
applog(LOG_DEBUG, "pw lookup for %s", user ? user : "******");
if (!user)
return NULL;
step++;
rc = sqlite3_prepare_v2(db, srv.db_stmt_pwdb,
strlen(srv.db_stmt_pwdb), &stmt, NULL);
if (rc != SQLITE_OK)
goto err_out;
step++;
if (sqlite3_bind_parameter_count(stmt)) {
rc = sqlite3_bind_text(stmt, 1, user, strlen(user), SQLITE_STATIC);
if (rc != SQLITE_OK)
goto err_out;
}
step++;
rc = sqlite3_step(stmt);
if (rc == SQLITE_ROW)
password = strdup((char *)sqlite3_column_text(stmt, 0));
else if (rc != SQLITE_DONE)
goto err_out;
sqlite3_finalize(stmt);
return password;
err_out:
applog(LOG_ERR, "pwdb sql step %d failed: %s",
step, sqlite3_errmsg(db));
sqlite3_finalize(stmt);
return NULL;
}
/* ctor */
sqlite_statement::sqlite_statement (
sqlite _database
, char const * _query
)
/*
* index starts at 1 and then
* increments.
*/
: stmt (NULL)
/*
* The following state cannot be set only thrown, and
* signifies a new un-stepped statement.
*/
, state (SQLITE_MISUSE)
, db (_database)
, column_count (0)
, stepped(false)
, bind_parameter_count (0)
// will be set to 1 for when auto binding.
, index (0) {
sqlite_check_error ( sqlite3_prepare_v2 (
_database.get()
, _query
, -1 /* Query must be alawys null terminated. */
, & (this->stmt)
, 0 /* There is never an unused portion of the statement. */
));
if (this->stmt == NULL)
throw sqlite_exception("Null statement", SQLITE_MISUSE);
this->bind_parameter_count
= sqlite3_bind_parameter_count(this->stmt);
/*
* If the statement has no parameters to bind, then step
* right away.
* if step finds a result, the statement will be treated
* like a input statement. otherwise complete.
*/
if (0 == bind_parameter_count) this->step();
}
ECode CStmt::Bind(
/* [in] */ Int32 pos,
/* [in] */ const ArrayOf<Byte>& value)
{
#if HAVE_SQLITE3 && HAVE_SQLITE_COMPILE
hvm *v = (hvm *)mHandle;
if (v && v->vm && v->h) {
Int32 npar = sqlite3_bind_parameter_count((sqlite3_stmt *) v->vm);
Int32 ret = 0;
Int32 len = 0;
if (pos < 1 || pos > npar) {
return E_ILLEGAL_ARGUMENT_EXCEPTION;
}
if (value.GetPayload()) {
len = value.GetLength();
if (len > 0) {
ret = sqlite3_bind_blob((sqlite3_stmt *) v->vm,
pos, value.GetPayload(), len, sqlite3_free);
} else {
ret = sqlite3_bind_blob((sqlite3_stmt *) v->vm,
pos, "", 0, SQLITE_STATIC);
}
} else {
ret = sqlite3_bind_null((sqlite3_stmt *) v->vm, pos);
}
if (ret != SQLITE_OK) {
mError_code = ret;
return E_SQL_EXCEPTION;
}
} else {
return E_NULL_POINTER_EXCEPTION;
}
#else
return E_SQL_FEATURE_NOT_SUPPORTED_EXCEPTION;
#endif
return NOERROR;
}
// doc: The sqlite3_bind_*() routines must be called after sqlite3_prepare() or sqlite3_reset() and before sqlite3_step().
// Bindings are not cleared by the sqlite3_reset() routine. Unbound parameters are interpreted as NULL.
bool SqliteSetupBindings(JSContext *cx, sqlite3_stmt *pStmt, JS::HandleObject argObj, JS::HandleObject curObj) {
JS::RootedValue val(cx);
int anonParamIndex = 0;
const char *name;
int count = sqlite3_bind_parameter_count(pStmt);
for ( int param = 1; param <= count; param++ ) { // The first host parameter has an index of 1, not 0.
// doc: Parameters of the form "?" have no name. ... If the value n is out of range or if the n-th parameter is nameless, then NULL is returned.
name = sqlite3_bind_parameter_name(pStmt, param);
// doc: name is UTF-8 encoding
if ( name == NULL ) {
JL_CHKM(argObj, E_PARAM, E_NUM(anonParamIndex), E_DEFINED);
JL_CHK( JL_GetElement(cx, argObj, anonParamIndex, &val) ); // works with {0:2,1:2,2:2,length:3} and [2,2,2]
anonParamIndex++;
} else
if ( name[0] == '@' ) {
JL_CHKM(argObj, E_PARAM, E_NAME(name), E_DEFINED);
JL_CHK( JS_GetProperty(cx, argObj, name+1, &val) );
} else
if ( name[0] == ':' ) {
JL_CHKM(curObj, E_PARAM, E_NAME(name), E_DEFINED);
JL_CHK( JS_GetProperty(cx, curObj, name+1, &val) );
} else {
JL_ERR(E_PARAM, E_NOTSUPPORTED);
}
JL_CHK( jsvalToSqlite( cx, SqliteTargetBind( pStmt, param ), val ) );
}
return true;
JL_BAD;
}
static int
bindtable(lua_State *T, sqlite3_stmt *stmt)
{
int parameters = sqlite3_bind_parameter_count(stmt);
const char *name;
const char *err;
int i;
for (i = 1; i <= parameters; i++) {
int ret;
name = sqlite3_bind_parameter_name(stmt, i);
lua_settop(T, 2);
if (name == NULL || name[0] == '?')
lua_rawgeti(T, 2, i);
else if (name[0] == '@')
lua_getfield(T, 2, name + 1);
else
lua_getfield(T, 2, name);
ret = _bind_arg(T, 3, stmt, i);
if (ret != SQLITE_OK) {
err = sqlite3_errmsg(sqlite3_db_handle(stmt));
goto error;
}
}
return 0;
error:
(void)sqlite3_clear_bindings(stmt);
luaL_where(T, 1);
if (name == NULL || name[0] == '?')
lua_pushfstring(T, "error binding %d: %s", i, err);
else
lua_pushfstring(T, "error binding '%s': %s", name, err);
lua_concat(T, 2);
return -1;
}
bool insert_record(record_type const& rec) const
{
#ifdef MAPNIK_DEBUG
assert( unsigned(sqlite3_bind_parameter_count(stmt_)) == rec.size());
#endif
record_type::const_iterator itr = rec.begin();
record_type::const_iterator end = rec.end();
int count = 1;
for (; itr!=end;++itr)
{
binder op(stmt_,count++);
if (!boost::apply_visitor(op,*itr))
{
return false;
}
}
sqlite3_step(stmt_);
sqlite3_reset(stmt_);
return true;
}
static GError *
_stmt_apply_GV_parameters(sqlite3_stmt *stmt, GVariant **params)
{
int i;
GVariant *p;
guint count_binds, count_params;
count_binds = sqlite3_bind_parameter_count(stmt);
count_params = g_strv_length((gchar**)params);
if (count_params != count_binds)
return NEWERROR(CODE_INTERNAL_ERROR, "Bad parameters : %u expected, %u received",
count_binds, count_params);
for (i=1; (p=*params) ;i++,params++) {
GError *err = _stmt_apply_GV_parameter(stmt, i, p);
if (NULL != err)
return err;
}
return NULL;
}
int wxSqlitePreparedStatement::FindStatementAndAdjustPositionIndex(int* pPosition)
{
// Don't mess around if there's just one entry in the vector
if (m_Statements.size() == 0)
return 0;
// Go through all the elements in the vector
// Get the number of parameters in each statement
// Adjust the nPosition for the the broken up statements
for (unsigned int i=0; i<m_Statements.size(); i++)
{
int nParametersInThisStatement = sqlite3_bind_parameter_count(m_Statements[i]);
if (*pPosition > nParametersInThisStatement)
{
*pPosition -= nParametersInThisStatement; // Decrement the position indicator by the number of parameters in this statement
}
else
{
// We're in the correct statement, return the index
return i;
}
}
return -1;
}
void SQLiteCommand::prepareBindContext() {
if (myBindContext.size() > 0) {
return;
}
size_t number = 0;
for (size_t i = 0; i < myStatements.size(); ++i) {
sqlite3_stmt *statement = myStatements[i];
const int count = sqlite3_bind_parameter_count(statement);
for (int j = 1; j <= count; ++j) {
++number;
const char *name = sqlite3_bind_parameter_name(statement, j);
if (name == 0) {
myBindContext.push_back(BindParameter(number));
} else {
const std::string namestr(name);
if (std::find_if(myBindContext.begin(), myBindContext.end(), BindParameterComparator(namestr)) == myBindContext.end()) {
myBindContext.push_back(BindParameter(number, namestr));
}
}
}
}
}
int CppSQLite3Statement::bindParameterIndex(const char* szParam)
{
checkVM();
int nParam = sqlite3_bind_parameter_index(mpVM, szParam);
/*int nn =*/ sqlite3_bind_parameter_count(mpVM);
/*const char* sz1 =*/ sqlite3_bind_parameter_name(mpVM, 1);
/*const char* sz2 =*/ sqlite3_bind_parameter_name(mpVM, 2);
if (!nParam)
{
char buf[128];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
sprintf_s(buf, 128, "Parameter '%s' is not valid for this statement", szParam);
#else
sprintf(buf, "Parameter '%s' is not valid for this statement", szParam);
#endif
throw CppSQLite3Exception(CPPSQLITE_ERROR, buf, DONT_DELETE_MSG);
}
return nParam;
}
void SQLiteStatementImpl::bindImpl()
{
_stepCalled = false;
_nextResponse = 0;
if (_pStmt == 0) return;
sqlite3_reset(_pStmt);
int paramCount = sqlite3_bind_parameter_count(_pStmt);
if (0 == paramCount)
{
_canBind = false;
return;
}
BindIt bindEnd = bindings().end();
std::size_t availableCount = 0;
Bindings::difference_type bindCount = 0;
Bindings::iterator it = _bindBegin;
for (; it != bindEnd; ++it)
{
availableCount += (*it)->numOfColumnsHandled();
if (availableCount <= paramCount) ++bindCount;
else break;
}
if (availableCount < paramCount)
throw ParameterCountMismatchException();
Bindings::difference_type remainingBindCount = bindEnd - _bindBegin;
if (bindCount < remainingBindCount)
{
bindEnd = _bindBegin + bindCount;
_canBind = true;
}
else if (bindCount > remainingBindCount)
throw ParameterCountMismatchException();
std::size_t boundRowCount;
if (_bindBegin != bindings().end())
{
boundRowCount = (*_bindBegin)->numOfRowsHandled();
Bindings::iterator oldBegin = _bindBegin;
for (std::size_t pos = 1; _bindBegin != bindEnd && (*_bindBegin)->canBind(); ++_bindBegin)
{
if (boundRowCount != (*_bindBegin)->numOfRowsHandled())
throw BindingException("Size mismatch in Bindings. All Bindings MUST have the same size");
(*_bindBegin)->bind(pos);
pos += (*_bindBegin)->numOfColumnsHandled();
}
if ((*oldBegin)->canBind())
{
//container binding will come back for more, so we must rewind
_bindBegin = oldBegin;
_canBind = true;
}
else _canBind = false;
}
}
int Database::Statement::parametersCount(void) const
{
return sqlite3_bind_parameter_count(mStmt);
}
__declspec(dllexport) int WINAPI sqlite3_bind_parameter_count_interop(sqlite3_stmt *stmt)
{
return sqlite3_bind_parameter_count(stmt);
}
static tb_bool_t tb_database_sqlite3_statement_bind(tb_database_sql_impl_t* database, tb_database_sql_statement_ref_t statement, tb_database_sql_value_t const* list, tb_size_t size)
{
// check
tb_database_sqlite3_t* sqlite = tb_database_sqlite3_cast(database);
tb_assert_and_check_return_val(sqlite && sqlite->database && statement && list && size, tb_false);
// the param count
tb_size_t param_count = (tb_size_t)sqlite3_bind_parameter_count((sqlite3_stmt*)statement);
tb_assert_and_check_return_val(size == param_count, tb_false);
// walk
tb_size_t i = 0;
for (i = 0; i < size; i++)
{
// the value
tb_database_sql_value_t const* value = &list[i];
// done
tb_int_t ok = SQLITE_ERROR;
tb_byte_t* data = tb_null;
switch (value->type)
{
case TB_DATABASE_SQL_VALUE_TYPE_TEXT:
tb_trace_i("sqlite3: test %lu %s", i, value->u.text.data);
ok = sqlite3_bind_text((sqlite3_stmt*)statement, (tb_int_t)(i + 1), value->u.text.data, (tb_int_t)tb_database_sql_value_size(value), tb_null);
break;
case TB_DATABASE_SQL_VALUE_TYPE_INT64:
case TB_DATABASE_SQL_VALUE_TYPE_UINT64:
ok = sqlite3_bind_int64((sqlite3_stmt*)statement, (tb_int_t)(i + 1), tb_database_sql_value_int64(value));
break;
case TB_DATABASE_SQL_VALUE_TYPE_INT32:
case TB_DATABASE_SQL_VALUE_TYPE_INT16:
case TB_DATABASE_SQL_VALUE_TYPE_INT8:
case TB_DATABASE_SQL_VALUE_TYPE_UINT32:
case TB_DATABASE_SQL_VALUE_TYPE_UINT16:
case TB_DATABASE_SQL_VALUE_TYPE_UINT8:
ok = sqlite3_bind_int((sqlite3_stmt*)statement, (tb_int_t)(i + 1), (tb_int_t)tb_database_sql_value_int32(value));
break;
case TB_DATABASE_SQL_VALUE_TYPE_BLOB16:
case TB_DATABASE_SQL_VALUE_TYPE_BLOB8:
ok = sqlite3_bind_blob((sqlite3_stmt*)statement, (tb_int_t)(i + 1), value->u.blob.data, (tb_int_t)value->u.blob.size, tb_null);
break;
case TB_DATABASE_SQL_VALUE_TYPE_BLOB32:
{
if (value->u.blob.stream)
{
// done
do
{
// the stream size
tb_hong_t size = tb_stream_size(value->u.blob.stream);
tb_assert_and_check_break(size >= 0);
// make data
data = tb_malloc0_bytes((tb_size_t)size);
tb_assert_and_check_break(data);
// read data
if (!tb_stream_bread(value->u.blob.stream, data, (tb_size_t)size)) break;
// bind it
ok = sqlite3_bind_blob((sqlite3_stmt*)statement, (tb_int_t)(i + 1), data, (tb_int_t)size, tb_database_sqlite3_statement_bind_exit);
} while (0);
}
else ok = sqlite3_bind_blob((sqlite3_stmt*)statement, (tb_int_t)(i + 1), value->u.blob.data, (tb_int_t)value->u.blob.size, tb_null);
}
break;
#ifdef TB_CONFIG_TYPE_HAVE_FLOAT
case TB_DATABASE_SQL_VALUE_TYPE_FLOAT:
case TB_DATABASE_SQL_VALUE_TYPE_DOUBLE:
ok = sqlite3_bind_double((sqlite3_stmt*)statement, (tb_int_t)(i + 1), (tb_double_t)tb_database_sql_value_double(value));
break;
#endif
case TB_DATABASE_SQL_VALUE_TYPE_NULL:
ok = sqlite3_bind_null((sqlite3_stmt*)statement, (tb_int_t)(i + 1));
break;
default:
tb_trace_e("statement: bind: unknown value type: %lu", value->type);
break;
}
// failed?
if (SQLITE_OK != ok)
{
// exit data
if (data) tb_free(data);
data = tb_null;
// save state
sqlite->base.state = tb_database_sqlite3_state_from_errno(sqlite3_errcode(sqlite->database));
// trace
tb_trace_e("statement: bind value[%lu] failed, error[%d]: %s", i, sqlite3_errcode(sqlite->database), sqlite3_errmsg(sqlite->database));
break;
}
}
// ok?
return (i == size)? tb_true : tb_false;
}
unsigned SQLiteStatement::bindParameterCount() const {
ASSERT(m_isPrepared);
if (!m_statement)
return 0;
return sqlite3_bind_parameter_count(m_statement);
}
bool QSpatiaLiteResult::exec()
{
const QVector<QVariant> values = boundValues();
d->skippedStatus = false;
d->skipRow = false;
d->rInf.clear();
clearValues();
setLastError(QSqlError());
int res = sqlite3_reset(d->stmt);
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult",
"Unable to reset statement"), QSqlError::StatementError, res));
d->finalize();
return false;
}
int paramCount = sqlite3_bind_parameter_count(d->stmt);
if (paramCount == values.count()) {
for (int i = 0; i < paramCount; ++i) {
res = SQLITE_OK;
const QVariant value = values.at(i);
if (value.isNull()) {
res = sqlite3_bind_null(d->stmt, i + 1);
} else {
switch (value.type()) {
case QVariant::ByteArray: {
const QByteArray *ba = static_cast<const QByteArray*>(value.constData());
res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(),
ba->size(), SQLITE_STATIC);
break; }
case QVariant::Int:
res = sqlite3_bind_int(d->stmt, i + 1, value.toInt());
break;
case QVariant::Double:
res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble());
break;
case QVariant::UInt:
case QVariant::LongLong:
res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong());
break;
case QVariant::String: {
// lifetime of string == lifetime of its qvariant
const QString *str = static_cast<const QString*>(value.constData());
res = sqlite3_bind_text16(d->stmt, i + 1, str->utf16(),
(str->size()) * sizeof(QChar), SQLITE_STATIC);
break; }
default: {
QString str = value.toString();
// SQLITE_TRANSIENT makes sure that sqlite buffers the data
res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(),
(str.size()) * sizeof(QChar), SQLITE_TRANSIENT);
break; }
}
}
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult",
"Unable to bind parameters"), QSqlError::StatementError, res));
d->finalize();
return false;
}
}
} else {
setLastError(QSqlError(QCoreApplication::translate("QSpatiaLiteResult",
"Parameter count mismatch"), QString(), QSqlError::StatementError));
return false;
}
d->skippedStatus = d->fetchNext(d->firstRow, 0, true);
if (lastError().isValid()) {
setSelect(false);
setActive(false);
return false;
}
setSelect(!d->rInf.isEmpty());
setActive(true);
return true;
}
int main(int argc, char *argv[]) {
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
int flags = SQLITE_OPEN_READWRITE;
int rc = 0;
int idx = -1;
/* Stringa SQL con i parametri nominativi - named parameters.
A ogni stringa alfanumerica, usata nelle tre versioni supportate, viene
associato dalla funzione sqlite3_prepare_v2() un indice numerico. */
char *sql_str = "INSERT INTO addressbook (fullname, alias, email)"
"VALUES(:name, @aka, $mail)";
if (argc != 5) {
fprintf(stderr, "Usage: %s <DB>,<name>,<alias>,<email>\n", argv[0]);
exit(EXIT_FAILURE);
}
/* Le stringhe ricevute in input diventano costanti */
const char *const str_fullname = (argc && argv[2]) ? argv[2] : "";
const char *const str_alias = (argc && argv[3]) ? argv[3] : "";
const char *const str_email = (argc && argv[4]) ? argv[4] : "";
// Library initialization
if (sqlite3_initialize() != SQLITE_OK) {
fprintf(stderr, "Err. Unable to initialize the library.\n");
exit(EXIT_FAILURE);
}
// Open database connection
rc = sqlite3_open_v2(argv[1], &db, flags, NULL);
if (rc != SQLITE_OK) {
fprintf(stderr, "Err. can't create database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
exit(EXIT_FAILURE);
}
// Prepare the statement
rc = sqlite3_prepare_v2(db, sql_str,-1, &stmt, NULL);
if (rc != SQLITE_OK) {
fprintf(stderr, "Err. Can't prepare the statement.\n");
sqlite3_close(db);
exit(EXIT_FAILURE);
}
/* Bind del primo parametro
Si utilizza la funzione sqlite3_bind_text() per associare il parametro al
valore che in questo caso e' 'text', poiche' trattasi di stringa.
L'indice del parametro viene salvato nella variabile intera 'idx', ottenuto
dal valore di ritorno della funzione sqlite3_bind_parameter_index(): */
idx = sqlite3_bind_parameter_index(stmt, ":name");
rc = sqlite3_bind_text(stmt, idx, str_fullname, -1, SQLITE_STATIC);
if (rc != SQLITE_OK) {
fprintf(stderr, "Err. Binding the value (%i).\n", rc);
return 1;
}
// Bind del secondo parametro
idx = sqlite3_bind_parameter_index(stmt, "@aka");
rc = sqlite3_bind_text(stmt, idx, str_alias, -1, SQLITE_STATIC);
if (rc != SQLITE_OK) {
fprintf(stderr, "Err. Binding the value (%i).\n", rc);
return 1;
}
// Bind del terzo parametro
idx = sqlite3_bind_parameter_index(stmt, "$mail");
rc = sqlite3_bind_text(stmt, idx, str_email, -1, SQLITE_STATIC);
if (rc != SQLITE_OK) {
fprintf(stderr, "Err. Binding the value (%i).\n", rc);
return 1;
}
/* Stampa del totale dei parametri, del nome degli stessi e del
rispettivo indice, mediante le funzioni specifiche */
printf("Total bound parameters: %d\n", sqlite3_bind_parameter_count(stmt));
printf("\'%5s\' index \'%d\'\n", sqlite3_bind_parameter_name(stmt, 1), \
sqlite3_bind_parameter_index(stmt, ":name"));
printf("\'%5s\' index \'%d\'\n", sqlite3_bind_parameter_name(stmt, 2), \
sqlite3_bind_parameter_index(stmt, "@aka"));
printf("\'%5s\' index \'%d\'\n", sqlite3_bind_parameter_name(stmt, 3), \
sqlite3_bind_parameter_index(stmt, "$mail"));
// Execute the statement
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE) {
fprintf(stderr, "Err. Stepping through the statement.\n");
} else
puts("... Statement successfully executed.");
// Release prepared statement resources
sqlite3_finalize(stmt);
// Close database connection
sqlite3_close_v2(db);
// Shutdown library initialization
sqlite3_shutdown();
return(EXIT_SUCCESS);
}
uint32 Statement::neededParameters()
{
return sqlite3_bind_parameter_count(m_statement);
}
CAMLprim value caml_sqlite3_bind_parameter_count(value v_stmt)
{
sqlite3_stmt *stmt = safe_get_stmtw("bind_parameter_count", v_stmt)->stmt;
return Val_int(sqlite3_bind_parameter_count(stmt));
}
CSQLite3Statement::CSQLite3Statement(sqlite3* pDB, sqlite3_stmt* pVM)
{
m_pDB = pDB;
m_pVM = pVM;
m_iCols = sqlite3_bind_parameter_count(m_pVM);
}
static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jlong connectionPtr,
jlong statementPtr) {
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
return sqlite3_bind_parameter_count(statement);
}
int parameters()
{
return sqlite3_bind_parameter_count(this->stmt);
}
