// Executes a single query.
// If transaction = TRUE, the query is assumed to be executed in a transaction
// (which has already been initiated)
// The return path (if any) and lastid (0 if not requested) are stored in *res
// and *lastid. The caller of this function is responsible for sending back the
// final response. If this function returns anything other than SQLITE_DONE,
// the query has failed.
// It is assumed that the first `flags' part of the queue item has already been
// fetched.
static int db_queue_process_one(sqlite3 *db, char *q, gboolean nocache, gboolean transaction, GAsyncQueue **res, gint64 *lastid) {
char *query = darray_get_ptr(q);
*res = NULL;
*lastid = 0;
// Would be nice to have the parameters logged
g_debug("db: Executing \"%s\"", query);
// Get statement handler
int r = SQLITE_ROW;
sqlite3_stmt *s;
if(nocache ? sqlite3_prepare_v2(db, query, -1, &s, NULL) : db_queue_process_prepare(db, query, &s)) {
g_critical("SQLite3 error preparing `%s': %s", query, sqlite3_errmsg(db));
r = SQLITE_ERROR;
}
// Bind parameters
int t, n;
int i = 1;
char *a;
while((t = darray_get_int32(q)) != DBQ_END && t != DBQ_RES) {
if(r == SQLITE_ERROR)
continue;
switch(t) {
case DBQ_NULL:
sqlite3_bind_null(s, i);
break;
case DBQ_INT:
sqlite3_bind_int(s, i, darray_get_int32(q));
break;
case DBQ_INT64:
sqlite3_bind_int64(s, i, darray_get_int64(q));
break;
case DBQ_TEXT:
sqlite3_bind_text(s, i, darray_get_string(q), -1, SQLITE_STATIC);
break;
case DBQ_BLOB:
a = darray_get_dat(q, &n);
sqlite3_bind_blob(s, i, a, n, SQLITE_STATIC);
break;
}
i++;
}
// Fetch information about what results we need to send back
gboolean wantlastid = FALSE;
char columns[20]; // 20 should be enough for everyone
n = 0;
if(t == DBQ_RES) {
*res = darray_get_ptr(q);
while((t = darray_get_int32(q)) != DBQ_END) {
if(t == DBQ_LASTID)
wantlastid = TRUE;
else
columns[n++] = t;
}
}
// Execute query
while(r == SQLITE_ROW) {
// do the step()
if(transaction)
r = sqlite3_step(s);
else
while((r = sqlite3_step(s)) == SQLITE_BUSY)
;
if(r != SQLITE_DONE && r != SQLITE_ROW)
g_critical("SQLite3 error on step() of `%s': %s", query, sqlite3_errmsg(db));
// continue with the next step() if we're not going to do anything with the results
if(r != SQLITE_ROW || !*res || !n)
continue;
// send back a response
GByteArray *rc = g_byte_array_new();
darray_init(rc);
darray_add_int32(rc, r);
for(i=0; i<n; i++) {
switch(columns[i]) {
case DBQ_INT: darray_add_int32( rc, sqlite3_column_int( s, i)); break;
case DBQ_INT64: darray_add_int64( rc, sqlite3_column_int64(s, i)); break;
case DBQ_TEXT: darray_add_string(rc, (char *)sqlite3_column_text( s, i)); break;
case DBQ_BLOB: darray_add_dat( rc, sqlite3_column_blob( s, i), sqlite3_column_bytes(s, i)); break;
default: g_warn_if_reached();
}
}
g_async_queue_push(*res, g_byte_array_free(rc, FALSE));
}
// Fetch last id, if requested
if(r == SQLITE_DONE && wantlastid)
*lastid = sqlite3_last_insert_rowid(db);
sqlite3_reset(s);
if(nocache)
sqlite3_finalize(s);
return r;
}
/* call-seq: stmt.bind_param(key, value)
*
* Binds value to the named (or positional) placeholder. If +param+ is a
* Fixnum, it is treated as an index for a positional placeholder.
* Otherwise it is used as the name of the placeholder to bind to.
*
* See also #bind_params.
*/
static VALUE bind_param(VALUE self, VALUE key, VALUE value)
{
sqlite3StmtRubyPtr ctx;
int status;
int index;
Data_Get_Struct(self, sqlite3StmtRuby, ctx);
REQUIRE_OPEN_STMT(ctx);
switch(TYPE(key)) {
case T_SYMBOL:
key = rb_funcall(key, rb_intern("to_s"), 0);
case T_STRING:
if(RSTRING_PTR(key)[0] != ':') key = rb_str_plus(rb_str_new2(":"), key);
index = sqlite3_bind_parameter_index(ctx->st, StringValuePtr(key));
break;
default:
index = (int)NUM2INT(key);
}
if(index == 0)
rb_raise(rb_path2class("SQLite3::Exception"), "no such bind parameter");
switch(TYPE(value)) {
case T_STRING:
if(CLASS_OF(value) == cSqlite3Blob
#ifdef HAVE_RUBY_ENCODING_H
|| rb_enc_get_index(value) == rb_ascii8bit_encindex()
#endif
) {
status = sqlite3_bind_blob(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
} else {
#ifdef HAVE_RUBY_ENCODING_H
if(!UTF8_P(value)) {
VALUE db = rb_iv_get(self, "@connection");
VALUE encoding = rb_funcall(db, rb_intern("encoding"), 0);
rb_encoding * enc = rb_to_encoding(encoding);
value = rb_str_export_to_enc(value, enc);
}
#endif
status = sqlite3_bind_text(
ctx->st,
index,
(const char *)StringValuePtr(value),
(int)RSTRING_LEN(value),
SQLITE_TRANSIENT
);
}
break;
case T_BIGNUM:
#if SIZEOF_LONG < 8
if (RBIGNUM_LEN(value) * SIZEOF_BDIGITS <= 8) {
status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)NUM2LL(value));
break;
}
#endif
case T_FLOAT:
status = sqlite3_bind_double(ctx->st, index, NUM2DBL(value));
break;
case T_FIXNUM:
status = sqlite3_bind_int64(ctx->st, index, (sqlite3_int64)FIX2LONG(value));
break;
case T_NIL:
status = sqlite3_bind_null(ctx->st, index);
break;
default:
rb_raise(rb_eRuntimeError, "can't prepare %s",
rb_class2name(CLASS_OF(value)));
break;
}
CHECK(sqlite3_db_handle(ctx->st), status);
return self;
}
bool QSQLiteResult::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("QSQLiteResult",
"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("QSQLiteResult",
"Unable to bind parameters"), QSqlError::StatementError, res));
d->finalize();
return false;
}
}
} else {
setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult",
"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 SqliteStatement::bindStatic (int position, const void* data, int length)
{
return sqlite3_bind_blob (statement, position, data, length, SQLITE_STATIC);
}
bool operator()(const sql_blob &value) const
{
return sqlite3_bind_blob(stmt_.get(), index_, value.data(), value.size(), SQLITE_TRANSIENT) ==
SQLITE_OK;
}
// Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const int aIndex, const void* apValue, const int aSize)
{
const int ret = sqlite3_bind_blob(mStmtPtr, aIndex, apValue, aSize, SQLITE_TRANSIENT);
check(ret);
}
static krb5_error_code KRB5_CALLCONV
scc_store_cred(krb5_context context,
krb5_ccache id,
krb5_creds *creds)
{
sqlite_uint64 credid;
krb5_scache *s = SCACHE(id);
krb5_error_code ret;
krb5_data data;
ret = make_database(context, s);
if (ret)
return ret;
ret = encode_creds(context, creds, &data);
if (ret)
return ret;
sqlite3_bind_int(s->icred, 1, s->cid);
{
krb5_enctype etype = 0;
int kvno = 0;
Ticket t;
size_t len;
ret = decode_Ticket(creds->ticket.data,
creds->ticket.length, &t, &len);
if (ret == 0) {
if(t.enc_part.kvno)
kvno = *t.enc_part.kvno;
etype = t.enc_part.etype;
free_Ticket(&t);
}
sqlite3_bind_int(s->icred, 2, kvno);
sqlite3_bind_int(s->icred, 3, etype);
}
sqlite3_bind_blob(s->icred, 4, data.data, data.length, free_data);
sqlite3_bind_int(s->icred, 5, time(NULL));
ret = exec_stmt(context, s->db, "BEGIN IMMEDIATE TRANSACTION", KRB5_CC_IO);
if (ret) return ret;
do {
ret = sqlite3_step(s->icred);
} while (ret == SQLITE_ROW);
sqlite3_reset(s->icred);
if (ret != SQLITE_DONE) {
ret = KRB5_CC_IO;
krb5_set_error_message(context, ret,
N_("Failed to add credential: %s", ""),
sqlite3_errmsg(s->db));
goto rollback;
}
credid = sqlite3_last_insert_rowid(s->db);
{
bind_principal(context, s->db, s->iprincipal, 1, creds->server);
sqlite3_bind_int(s->iprincipal, 2, 1);
sqlite3_bind_int(s->iprincipal, 3, credid);
do {
ret = sqlite3_step(s->iprincipal);
} while (ret == SQLITE_ROW);
sqlite3_reset(s->iprincipal);
if (ret != SQLITE_DONE) {
ret = KRB5_CC_IO;
krb5_set_error_message(context, ret,
N_("Failed to add principal: %s", ""),
sqlite3_errmsg(s->db));
goto rollback;
}
}
{
bind_principal(context, s->db, s->iprincipal, 1, creds->client);
sqlite3_bind_int(s->iprincipal, 2, 0);
sqlite3_bind_int(s->iprincipal, 3, credid);
do {
ret = sqlite3_step(s->iprincipal);
} while (ret == SQLITE_ROW);
sqlite3_reset(s->iprincipal);
if (ret != SQLITE_DONE) {
ret = KRB5_CC_IO;
krb5_set_error_message(context, ret,
N_("Failed to add principal: %s", ""),
sqlite3_errmsg(s->db));
goto rollback;
}
}
ret = exec_stmt(context, s->db, "COMMIT", KRB5_CC_IO);
if (ret) return ret;
return 0;
rollback:
exec_stmt(context, s->db, "ROLLBACK", 0);
return ret;
}
// Bind a binary blob value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bindNoCopy(const int aIndex, const void* apValue, const int aSize)
{
const int ret = sqlite3_bind_blob(mStmtPtr, aIndex, apValue, aSize, SQLITE_STATIC);
check(ret);
}
int
WfipsData::LoadFwas()
{
//assert( poScenario->m_VDispLogic.size() > 0 );
sqlite3_stmt *stmt;
int rc, n, i;
void *pGeom;
/* Clear our lookup */
FwaIndexMap.clear();
poScenario->m_VFWA.clear();
if( pszAnalysisAreaWkt )
{
n = CompileGeometry( pszAnalysisAreaWkt, &pGeom );
if( n > 0 )
{
rc = sqlite3_prepare_v2( db, "SELECT * FROM fwa JOIN reload ON "
"fwa.name=reload.fwa_name JOIN "
"walk_in ON "
"reload.fwa_name=walk_in.fwa_name "
"WHERE ST_Intersects(@geom, geometry) "
"AND name NOT LIKE '%unassigned%' "
"AND substr(fwa.name, 0, 3) NOT IN "
"('EA','SA','AK') "
"AND fwa.ROWID IN "
"(SELECT pkid FROM "
"idx_fwa_geometry WHERE "
"xmin <= MbrMaxX(@geom) AND "
"xmax >= MbrMinX(@geom) AND "
"ymin <= MbrMaxY(@geom) AND "
"ymax >= MbrMinY(@geom))",
-1, &stmt, NULL );
rc = sqlite3_bind_blob( stmt,
sqlite3_bind_parameter_index( stmt, "@geom" ),
pGeom, n, sqlite3_free );
}
else
{
return SQLITE_ERROR;
}
}
else
{
rc = sqlite3_prepare_v2( db, "SELECT * FROM fwa JOIN reload ON "
"fwa.name=reload.fwa_name JOIN "
"walk_in ON "
"reload.fwa_name=walk_in.fwa_name "
"WHERE fwa.name NOT LIKE '%unassigned%' "
"AND substr(fwa.name, 0, 3) NOT IN "
"('EA','SA','AK')",
-1, &stmt, NULL );
}
const char *pszName, *pszFpu;
int nWalkIn, nPumpRoll, nHead, nTail, nPara;
double dfAttDist;
int bWaterDrops, bExcluded;
double dfDiscSize, dfEslSize, dfEslTime, dfAirGrnd;
int nFirstDelay;
const char *pszLogic;
int anReload[5];
int anWalkIn[6];
int iFwa = 0;
std::map<std::string, int>::iterator it;
while( sqlite3_step( stmt ) == SQLITE_ROW )
{
pszName = (const char *)sqlite3_column_text( stmt, 1 );
assert( pszName );
pszFpu = (const char *)sqlite3_column_text( stmt, 2 );
assert( pszFpu );
// FMG 3
nWalkIn = sqlite3_column_int( stmt, 4 );
assert( nWalkIn >= 0 || nWalkIn <= 100 );
nPumpRoll = sqlite3_column_int( stmt, 5 );
assert( nPumpRoll >= 0 || nPumpRoll <= 100 );
nHead = sqlite3_column_int( stmt, 6 );
assert( nHead >= 0 || nHead <= 100 );
nTail = sqlite3_column_int( stmt, 7 );
assert( nTail >= 0 || nTail <= 100 );
nPara = sqlite3_column_int( stmt, 8 );
assert( nPara >= 0 || nPara <= 100 );
assert( nPara + nTail + nHead < 101 );
dfAttDist = sqlite3_column_double( stmt, 9 );
assert( dfAttDist >= 0.0 );
bWaterDrops = sqlite3_column_int( stmt, 10 );
assert( bWaterDrops == 0 || bWaterDrops == 1 );
bExcluded = sqlite3_column_int( stmt, 11 );
assert( bExcluded == 0 || bExcluded == 1 );
dfDiscSize = sqlite3_column_double( stmt, 12 );
assert( dfDiscSize >= 0 );
dfEslTime = sqlite3_column_double( stmt, 13 );
assert( dfEslTime >= 0 );
dfEslSize = sqlite3_column_double( stmt, 14 );
assert( dfEslSize >= 0 );
dfAirGrnd = sqlite3_column_double( stmt, 15 );
assert( dfAirGrnd >= 0 );
nFirstDelay = sqlite3_column_int( stmt, 16 );
assert( nFirstDelay >= 0 );
pszLogic = (const char *)sqlite3_column_text( stmt, 17 );
assert( pszLogic );
memset( anReload, 0, sizeof( int ) * 5 );
for( i = 0; i < 5; i++ )
{
anReload[i] = sqlite3_column_int( stmt, 18+i );
assert( anReload[i] >= 0 );
}
memset( anWalkIn, 0, sizeof( int ) * 6 );
for( i = 0; i < 6; i++ )
{
anWalkIn[i] = sqlite3_column_int( stmt, 18+5+i );
assert( anWalkIn[i] >= 0 );
}
/*
** We use defaults now for some delays: From FPA:
**
** Post Escape Delay 20 minutes for all but smokejumpers, smokejumpers
** 120 minutes.
** Post Unused Delay 10 minutes for all.
** Post Used Delay 30 minutes for all but boats and smokejumpers, boats
** and smokejumpers 120 minutes.
**
** Columns:
** tracked,boat,crew,engine,helitack,smkjmp
**/
int anPostEscape[6] = {20,20, 20,20,20,120};
int anPostUnused[6] = {10,10, 10,10,10,10};
int anPostUsed[6] = {30,120,30,30,30,120};
/* Fixed, no assert */
/*
** These values have also been defaulted.
*/
std::string aoRos[10];
double adfRosCoeff[10];
double adfDiurn[24];
for( i = 0; i < 10; i++ )
{
aoRos[i] = std::string( "NA" );
adfRosCoeff[i] = 1.0;
}
/* Fixed, no assert */
for( i = 0; i < 24; i++ )
{
adfDiurn[i] = 1.;
}
/* Fixed, no assert */
/*
** The value of this is up for discussion...
*/
it = DispLogIndexMap.find( pszLogic );
if( it == DispLogIndexMap.end() )
{
i = 0;
printf("Failed to load logic: %s for fwa: %s\n", pszLogic, pszName);
}
else
{
i = it->second;
}
poScenario->m_VFWA.push_back( CFWA( std::string( pszName ),
std::string( "" ), nWalkIn,
nPumpRoll, nHead, nTail, nPara,
dfAttDist, bWaterDrops, bExcluded,
dfDiscSize, dfEslTime, dfEslSize,
dfAirGrnd, anWalkIn, anPostUsed,
anPostUnused, anPostEscape, anReload,
nFirstDelay, adfDiurn, aoRos,
adfRosCoeff, iFwa,
poScenario->m_VDispLogic[i],
std::string( pszFpu ) ) );
FwaIndexMap.insert( std::pair<std::string, int>( std::string( pszName ),
iFwa ) );
iFwa++;
}
assert( FwaIndexMap.size() == poScenario->m_VFWA.size() );
sqlite3_finalize( stmt );
return 0;
}
ActionItemPtr
ActionLog::AddLocalActionDelete(const std::string& filename)
{
_LOG_DEBUG("Adding local action DELETE");
sqlite3_exec(m_db, "BEGIN TRANSACTION;", 0, 0, 0);
const Block device_name = m_syncLog->GetLocalName().wireEncode();
sqlite3_int64 version;
BufferPtr parent_device_name;
sqlite3_int64 parent_seq_no = -1;
sqlite3_int64 action_time = std::time(0);
tie(version, parent_device_name, parent_seq_no) = GetLatestActionForFile(filename);
if (!parent_device_name) // no records exist or file was already deleted
{
_LOG_DEBUG("Nothing to delete... [" << filename << "]");
// just in case, remove data from FileState
sqlite3_stmt* stmt;
sqlite3_prepare_v2(m_db, "DELETE FROM FileState WHERE filename = ? ", -1, &stmt, 0);
sqlite3_bind_text(stmt, 1, filename.c_str(), filename.size(), SQLITE_STATIC); // file
sqlite3_step(stmt);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));
sqlite3_finalize(stmt);
sqlite3_exec(m_db, "END TRANSACTION;", 0, 0, 0);
return ActionItemPtr();
}
version++;
sqlite3_int64 seq_no = m_syncLog->GetNextLocalSeqNo();
sqlite3_stmt* stmt;
sqlite3_prepare_v2(m_db, "INSERT INTO ActionLog "
"(device_name, seq_no, action, filename, version, action_timestamp, "
"parent_device_name, parent_seq_no, "
"action_name, action_content_object) "
"VALUES(?, ?, ?, ?, ?, datetime(?, 'unixepoch', 'localtime'),"
" ?, ?,"
" ?, ?)",
-1, &stmt, 0);
sqlite3_bind_blob(stmt, 1, device_name.wire(), device_name.size(), SQLITE_STATIC);
sqlite3_bind_int64(stmt, 2, seq_no);
sqlite3_bind_int(stmt, 3, 1);
sqlite3_bind_text(stmt, 4, filename.c_str(), filename.size(), SQLITE_STATIC); // file
sqlite3_bind_int64(stmt, 5, version);
sqlite3_bind_int64(stmt, 6, action_time);
sqlite3_bind_blob(stmt, 7, parent_device_name->buf(), parent_device_name->size(), SQLITE_STATIC);
sqlite3_bind_int64(stmt, 8, parent_seq_no);
ActionItemPtr item = make_shared<ActionItem>();
item->set_action(ActionItem::DELETE);
item->set_filename(filename);
item->set_version(version);
item->set_timestamp(action_time);
item->set_parent_device_name(parent_device_name->buf(), parent_device_name->size());
item->set_parent_seq_no(parent_seq_no);
std::string item_msg;
item->SerializeToString(&item_msg);
// action name: /<device_name>/<appname>/action/<shared-folder>/<action-seq>
Name actionName = Name("/");
actionName.append(m_syncLog->GetLocalName()).append(m_appName).append("action");
actionName.append(m_sharedFolderName).appendNumber(seq_no);
_LOG_DEBUG("ActionName: " << actionName);
shared_ptr<Data> actionData = make_shared<Data>();
actionData->setName(actionName);
actionData->setFreshnessPeriod(time::seconds(60));
actionData->setContent(reinterpret_cast<const uint8_t*>(item_msg.c_str()), item_msg.size());
m_keyChain.sign(*actionData);
sqlite3_bind_blob(stmt, 9, actionName.wireEncode().wire(), actionName.wireEncode().size(),
SQLITE_STATIC);
sqlite3_bind_blob(stmt, 10, actionData->wireEncode().wire(), actionData->wireEncode().size(),
SQLITE_STATIC);
sqlite3_step(stmt);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));
// cout << Name(parent_device_name) << endl;
// assign name to the action, serialize action, and create content object
sqlite3_finalize(stmt);
// I had a problem including directory_name assignment as part of the initial insert.
sqlite3_prepare_v2(m_db,
"UPDATE ActionLog SET directory=directory_name(filename) WHERE device_name=? AND seq_no=?",
-1, &stmt, 0);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_OK, sqlite3_errmsg(m_db));
sqlite3_bind_blob(stmt, 1, device_name.wire(), device_name.size(), SQLITE_STATIC);
sqlite3_bind_int64(stmt, 2, seq_no);
sqlite3_step(stmt);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));
sqlite3_finalize(stmt);
sqlite3_exec(m_db, "END TRANSACTION;", 0, 0, 0);
return item;
}
ActionItemPtr
ActionLog::AddRemoteAction(const Name& deviceName, sqlite3_int64 seqno, shared_ptr<Data> actionData)
{
if (!actionData) {
_LOG_ERROR("actionData is not valid");
return ActionItemPtr();
}
ActionItemPtr action = deserializeMsg<ActionItem>(
Buffer(actionData->getContent().value(), actionData->getContent().value_size()));
if (!action) {
_LOG_ERROR("action cannot be decoded");
return ActionItemPtr();
}
_LOG_DEBUG("AddRemoteAction: [" << deviceName.toUri() << "] seqno: " << seqno);
sqlite3_stmt* stmt;
sqlite3_prepare_v2(m_db,
"INSERT INTO ActionLog "
"(device_name, seq_no, action, filename, version, action_timestamp, "
"file_hash, file_atime, file_mtime, file_ctime, file_chmod, file_seg_num, "
"parent_device_name, parent_seq_no, "
"action_name, action_content_object) "
"VALUES (?, ?, ?, ?, ?, datetime(?, 'unixepoch'),"
" ?, datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), datetime(?, 'unixepoch'), ?,?, "
" ?, ?, "
" ?, ?);",
-1, &stmt, 0);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_OK, sqlite3_errmsg(m_db));
sqlite3_bind_blob(stmt, 1, deviceName.wireEncode().wire(), deviceName.wireEncode().size(),
SQLITE_STATIC);
sqlite3_bind_int64(stmt, 2, seqno);
sqlite3_bind_int(stmt, 3, action->action());
sqlite3_bind_text(stmt, 4, action->filename().c_str(), action->filename().size(), SQLITE_STATIC);
sqlite3_bind_int64(stmt, 5, action->version());
sqlite3_bind_int64(stmt, 6, action->timestamp());
if (action->action() == ActionItem::UPDATE) {
sqlite3_bind_blob(stmt, 7, action->file_hash().c_str(), action->file_hash().size(),
SQLITE_STATIC);
// sqlite3_bind_int64(stmt, 8, atime); // NULL
sqlite3_bind_int64(stmt, 9, action->mtime());
// sqlite3_bind_int64(stmt, 10, ctime); // NULL
sqlite3_bind_int(stmt, 11, action->mode());
sqlite3_bind_int(stmt, 12, action->seg_num());
}
if (action->has_parent_device_name()) {
sqlite3_bind_blob(stmt, 13, action->parent_device_name().c_str(),
action->parent_device_name().size(), SQLITE_STATIC);
sqlite3_bind_int64(stmt, 14, action->parent_seq_no());
}
Name actionName = Name(deviceName);
actionName.append("action").append(m_sharedFolderName).appendNumber(seqno);
sqlite3_bind_blob(stmt, 15, actionName.wireEncode().wire(), actionName.wireEncode().size(),
SQLITE_STATIC);
sqlite3_bind_blob(stmt, 16, actionData->wireEncode().wire(), actionData->wireEncode().size(),
SQLITE_STATIC);
sqlite3_step(stmt);
// if action needs to be applied to file state, the trigger will take care of it
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));
sqlite3_finalize(stmt);
// I had a problem including directory_name assignment as part of the initial insert.
sqlite3_prepare_v2(m_db,
"UPDATE ActionLog SET directory=directory_name(filename) WHERE device_name=? AND seq_no=?",
-1, &stmt, 0);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_OK, sqlite3_errmsg(m_db));
sqlite3_bind_blob(stmt, 1, deviceName.wireEncode().wire(), deviceName.wireEncode().size(),
SQLITE_STATIC);
sqlite3_bind_int64(stmt, 2, seqno);
sqlite3_step(stmt);
_LOG_DEBUG_COND(sqlite3_errcode(m_db) != SQLITE_DONE, sqlite3_errmsg(m_db));
sqlite3_finalize(stmt);
return action;
}
int Statement::Bind(int index, void const * data, int datalen)
{
return IsValid()
? sqlite3_bind_blob(m_st, index+1, data, datalen, SQLITE_TRANSIENT)
: SQLITE_ERROR;
}
void Statement::BindBlob(int col, const void* val, int val_len)
{
CheckOk(sqlite3_bind_blob(GetStatement(), col + 1, val, val_len, SQLITE_TRANSIENT));
}
/**
* \brief apply appropriate tile properties to the sqlite statement */
static void _bind_sqlite_params(mapcache_context *ctx, void *vstmt, mapcache_cache_sqlite *cache, mapcache_tile *tile)
{
sqlite3_stmt *stmt = vstmt;
int paramidx;
/* tile->x */
paramidx = sqlite3_bind_parameter_index(stmt, ":x");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->x);
/* tile->y */
paramidx = sqlite3_bind_parameter_index(stmt, ":y");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->y);
/* tile->y */
paramidx = sqlite3_bind_parameter_index(stmt, ":z");
if (paramidx) sqlite3_bind_int(stmt, paramidx, tile->z);
/* eventual dimensions */
paramidx = sqlite3_bind_parameter_index(stmt, ":dim");
if (paramidx) {
if (tile->dimensions) {
char *dim = mapcache_util_get_tile_dimkey(ctx, tile, NULL, NULL);
sqlite3_bind_text(stmt, paramidx, dim, -1, SQLITE_STATIC);
} else {
sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC);
}
}
/* grid */
paramidx = sqlite3_bind_parameter_index(stmt, ":grid");
if (paramidx) sqlite3_bind_text(stmt, paramidx, tile->grid_link->grid->name, -1, SQLITE_STATIC);
/* tileset */
paramidx = sqlite3_bind_parameter_index(stmt, ":tileset");
if (paramidx) sqlite3_bind_text(stmt, paramidx, tile->tileset->name, -1, SQLITE_STATIC);
/* tile blob data */
paramidx = sqlite3_bind_parameter_index(stmt, ":data");
if (paramidx) {
int written = 0;
if(cache->detect_blank) {
if(!tile->raw_image) {
tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
GC_CHECK_ERROR(ctx);
}
if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
char *buf = apr_palloc(ctx->pool, 5* sizeof(char));
buf[0] = '#';
memcpy(buf+1,tile->raw_image->data,4);
written = 1;
sqlite3_bind_blob(stmt, paramidx, buf, 5, SQLITE_STATIC);
}
}
if(!written) {
if (!tile->encoded_data) {
tile->encoded_data = tile->tileset->format->write(ctx, tile->raw_image, tile->tileset->format);
GC_CHECK_ERROR(ctx);
}
if (tile->encoded_data && tile->encoded_data->size) {
sqlite3_bind_blob(stmt, paramidx, tile->encoded_data->buf, tile->encoded_data->size, SQLITE_STATIC);
} else {
sqlite3_bind_text(stmt, paramidx, "", -1, SQLITE_STATIC);
}
}
}
}
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 = ¶m->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 = ¶m->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 {
convert_to_string(parameter);
}
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 = ¶m->parameter;
}
if (Z_TYPE_P(parameter) == IS_NULL) {
if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
return 1;
}
} else {
convert_to_string(parameter);
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;
}
int
WfipsData::LoadDispatchLocations()
{
sqlite3_stmt *stmt, *astmt, *estmt;
int rc, n, i;
void *pGeom = NULL;
int nFwaCount;
poScenario->m_VDispLoc.clear();
if( pszAnalysisAreaWkt )
{
n = CompileGeometry( pszAnalysisAreaWkt, &pGeom );
if( n > 0 )
{
rc = sqlite3_prepare_v2( db, "SELECT disploc.name,fpu_code,"
"callback,X(disploc.geometry),"
"Y(disploc.geometry) FROM "
"disploc JOIN assoc ON "
"name=disploc_name "
"WHERE fwa_name NOT LIKE '%unassign%' "
"AND substr(fwa_name, 0, 3) NOT IN "
"('EA','SA','AK') "
"AND fwa_name IN "
"(SELECT name FROM fwa WHERE "
"ST_Intersects(@geom, fwa.geometry) AND "
"fwa.ROWID IN(SELECT pkid FROM "
"idx_fwa_geometry WHERE "
"xmin <= MbrMaxX(@geom) AND "
"xmax >= MbrMinX(@geom) AND "
"ymin <= MbrMaxY(@geom) AND "
"ymax >= MbrMinY(@geom))) GROUP BY "
"disploc.name",
-1, &stmt, NULL );
rc = sqlite3_bind_blob( stmt,
sqlite3_bind_parameter_index( stmt, "@geom" ),
pGeom, n, sqlite3_free );
}
else
{
return SQLITE_ERROR;
}
}
else
{
rc = sqlite3_prepare_v2( db, "SELECT name,fpu_code,callback,"
"X(geometry), Y(geometry) FROM disploc "
"JOIN assoc ON name=disploc_name WHERE "
"fwa_name NOT LIKE '%unassign%' "
"AND substr(fwa_name, 0, 3) NOT IN "
"('EA','SA','AK') "
"GROUP BY disploc.name",
-1, &stmt, NULL );
}
rc = sqlite3_prepare_v2( db, "SELECT fwa_name, distance FROM assoc WHERE "
"disploc_name=?",
-1, &astmt, NULL );
rc = sqlite3_prepare_v2( db, "SELECT COUNT(*) FROM resource WHERE disploc=?",
-1, &estmt, NULL );
nFwaCount = poScenario->m_VFWA.size();
const char *pszName, *pszFpu;
const char *pszFwa;
int nCallBack;
double dfX, dfY;
double dfDist;
std::map<std::string, int>::iterator it;
while( sqlite3_step( stmt ) == SQLITE_ROW )
{
pszName = (const char*)sqlite3_column_text( stmt, 0 );
assert( pszName );
rc = sqlite3_bind_text( estmt, 1, pszName, -1, NULL );
if( sqlite3_step( estmt ) != SQLITE_ROW ||
sqlite3_column_int( estmt, 0 ) < 1 )
{
sqlite3_reset( estmt );
continue;
}
pszFpu = (const char*)sqlite3_column_text( stmt, 1 );
assert( pszFpu );
nCallBack = sqlite3_column_int( stmt, 2 );
assert( nCallBack >= 0 );
dfX = sqlite3_column_double( stmt, 3 );
assert( dfX > -180 && dfX < 360 );
dfY = sqlite3_column_double( stmt, 4 );
assert( dfY > -180 && dfY < 360 );
CDispLoc oDispLoc( std::string( pszName ), nCallBack,
std::string( pszFpu ), dfY, dfX );
rc = sqlite3_bind_text( astmt, 1, pszName, -1, NULL );
while( sqlite3_step( astmt ) == SQLITE_ROW )
{
pszFwa = (const char*)sqlite3_column_text( astmt, 0 );
assert( pszFwa );
dfDist = sqlite3_column_double( astmt, 1 );
assert( dfDist >= 0 );
it = FwaIndexMap.find( std::string( pszFwa ) );
if( it != FwaIndexMap.end() )
{
i = it->second;
poScenario->m_VFWA[i].AddAssociation( std::string( pszName ), dfDist );
oDispLoc.AddAssocFWA( &(poScenario->m_VFWA[i]) );
}
}
sqlite3_reset( astmt );
sqlite3_reset( estmt );
poScenario->m_VDispLoc.push_back( oDispLoc );
}
sqlite3_finalize( stmt );
sqlite3_finalize( astmt );
sqlite3_finalize( estmt );
poScenario->CreateRescTypeVectors("C:/wfips/data/");
return 0;
}
int db_share_files(const struct pub_file *files, size_t count, const struct client *owner)
{
/* todo: do it in transaction */
while (count-- > 0) {
sqlite3_stmt *stmt;
const char *ext;
int ext_len;
int i;
uint64_t fid;
if (!files->name_len) {
files++;
continue;
}
fid = MAKE_FID(files->hash);
// find extension
ext = file_extension(files->name, files->name_len);
if (ext)
ext_len = files->name + files->name_len - ext;
else
ext_len = 0;
i = 1;
stmt = s_stmt[SHARE_UPD];
DB_CHECK(SQLITE_OK == sqlite3_reset(stmt));
DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, files->name, files->name_len, SQLITE_STATIC));
DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, ext, ext_len, SQLITE_STATIC));
DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, files->size));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->type));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->media_length));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->media_bitrate));
DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, files->media_codec, files->media_codec_len, SQLITE_STATIC));
DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, fid));
DB_CHECK(SQLITE_DONE == sqlite3_step(stmt));
if (!sqlite3_changes(s_db)) {
i = 1;
stmt = s_stmt[SHARE_INS];
DB_CHECK(SQLITE_OK == sqlite3_reset(stmt));
DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, fid));
DB_CHECK(SQLITE_OK == sqlite3_bind_blob(stmt, i++, files->hash, sizeof(files->hash), SQLITE_STATIC));
DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, files->name, files->name_len, SQLITE_STATIC));
DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, ext, ext_len, SQLITE_STATIC));
DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, files->size));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->type));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->media_length));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->media_bitrate));
DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, files->media_codec, files->media_codec_len, SQLITE_STATIC));
DB_CHECK(SQLITE_DONE == sqlite3_step(stmt));
}
i = 1;
stmt = s_stmt[SHARE_SRC];
DB_CHECK(SQLITE_OK == sqlite3_reset(stmt));
DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, fid));
DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, MAKE_SID(owner)));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->complete));
DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, files->rating));
DB_CHECK(SQLITE_DONE == sqlite3_step(stmt));
files++;
}
return 1;
failed:
ED2KD_LOGERR("failed to add file to db (%s)", sqlite3_errmsg(s_db));
return 0;
}
int
WfipsData::LoadDispatchLogic()
{
sqlite3_stmt *stmt;
sqlite3_stmt *rstmt;
int rc, i, j, n, iLogic;
void *pGeom;
/* Clear our lookup */
DispLogIndexMap.clear();
poScenario->m_VDispLogic.clear();
if( pszAnalysisAreaWkt )
{
n = CompileGeometry( pszAnalysisAreaWkt, &pGeom );
if( n > 0 )
{
rc = sqlite3_prepare_v2( db, "SELECT displog.name,indice,num_lev,bp_1,"
"bp_2,bp_3,bp_4 FROM fwa JOIN displog "
"ON fwa.displogic_name=displog.name "
"JOIN brk_point ON "
"displog.name=brk_point.name "
"WHERE ST_Intersects(@geom, geometry) "
"AND fwa.name NOT LIKE '%unassign%' "
"AND substr(fwa.name, 0, 3) NOT IN "
"('EA','SA','AK') "
"AND fwa.ROWID IN "
"(SELECT pkid FROM "
"idx_fwa_geometry WHERE "
"xmin <= MbrMaxX(@geom) AND "
"xmax >= MbrMinX(@geom) AND "
"ymin <= MbrMaxY(@geom) AND "
"ymax >= MbrMinY(@geom)) "
"group by displog.name",
-1, &stmt, NULL );
rc = sqlite3_bind_blob( stmt,
sqlite3_bind_parameter_index( stmt, "@geom" ),
pGeom, n, sqlite3_free );
}
else
{
/* Geometry is bad */
return SQLITE_ERROR;
}
}
else
{
rc = sqlite3_prepare_v2( db, "SELECT displog.name,indice,"
"num_lev,bp_1,bp_2,bp_3,bp_4 FROM "
"fwa JOIN displog ON "
"fwa.displogic_name=displog.name "
"JOIN brk_point ON "
"displog.name=brk_point.name "
"WHERE fwa.name NOT LIKE '%unassign%' "
"AND substr(fwa.name, 0, 3) NOT IN "
"('EA','SA','AK') "
"GROUP BY displog.name",
-1, &stmt, NULL );
}
rc = sqlite3_prepare_v2( db, "SELECT * FROM num_resc WHERE name=?", -1,
&rstmt, NULL );
const char *pszName, *pszIndice;
int nLevels, anBps[4];
int nBp, anRescCount[13][5];
iLogic = 0;
/* Push a default displogic on so we avoid errors */
poScenario->m_VDispLogic.push_back( CDispLogic() );
DispLogIndexMap.insert( std::pair<std::string, int>( poScenario->m_VDispLogic[0].GetLogicID(), iLogic++ ) );
while( sqlite3_step( stmt ) == SQLITE_ROW )
{
pszName = (const char*)sqlite3_column_text( stmt, 0 );
assert( pszName );
pszIndice = (const char*)sqlite3_column_text( stmt, 1 );
/* No assert currently, but do we assume BI? */
nLevels = sqlite3_column_int( stmt, 2 );
assert( nLevels >= 3 && nLevels <= 5 );
memset( anBps, 0, sizeof( int ) * 4 );
for( i = 0; i < nLevels - 1; i++ )
{
anBps[i] = sqlite3_column_int( stmt, 3 + i );
}
sqlite3_bind_text( rstmt, 1, pszName, -1, NULL );
i = 0;
memset( anRescCount, 0, sizeof( int ) * 13 * 5 );
while( sqlite3_step( rstmt ) == SQLITE_ROW )
{
for( j = 0; j < 13; j++ )
{
anRescCount[j][i] = sqlite3_column_int( rstmt, j+2 );
assert( anRescCount[j][i] >= 0 );
assert( i < 5 );
}
i++;
}
poScenario->m_VDispLogic.push_back( CDispLogic( std::string( pszName ),
std::string( pszIndice ), nLevels,
anBps, anRescCount ) );
DispLogIndexMap.insert( std::pair<std::string, int>( pszName, iLogic++ ) );
sqlite3_reset( rstmt );
}
assert( DispLogIndexMap.size() == poScenario->m_VDispLogic.size() );
sqlite3_finalize( stmt );
sqlite3_finalize( rstmt );
return 0;
}
// Bind a binary blob value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statement
void Statement::bind(const char* apName, const void* apValue, const int aSize)
{
const int index = sqlite3_bind_parameter_index(mStmtPtr, apName);
const int ret = sqlite3_bind_blob(mStmtPtr, index, apValue, aSize, SQLITE_TRANSIENT);
check(ret);
}
void sqlite3_command::bind(int index, const void *data, int datalen, sqlite3_destructor_type p_destructor_type /*= SQLITE_STATIC or SQLITE_TRANSIENT*/ ) {
if(sqlite3_bind_blob(this->stmt, index, data, datalen, p_destructor_type)!=SQLITE_OK)
throw database_error(&m_con);
}
int SqliteStatement::bind (int position, const void* data, int length)
{
return sqlite3_bind_blob (statement, position, data, length, SQLITE_TRANSIENT);
}
/* --------------------------------------------------------------- */
void R_sqlbind( const int func )
{
int col, i;
double d;
char type;
if (!sqldb) Lerror(ERR_DATABASE,1);
if (!sqlstmt) Lerror(ERR_DATABASE,0);
if (ARGN==0) {
Licpy(ARGR, sqlite3_bind_parameter_count(sqlstmt));
return;
}
if (ARGN!=3) Lerror(ERR_INCORRECT_CALL,0);
if (Ldatatype(ARG1,'N'))
col = Lrdint(ARG1);
else {
LASCIIZ(*ARG1);
col = sqlite3_bind_parameter_index(sqlstmt, LSTR(*ARG1));
}
get_pad(2, type);
switch (type) {
case 'b': case 'B': /* blob */
Licpy(ARGR, sqlite3_bind_blob(sqlstmt, col,
LSTR(*ARG3), LLEN(*ARG3), SQLITE_TRANSIENT));
break;
case 'i': case 'I': /* integer */
get_i(3, i);
Licpy(ARGR, sqlite3_bind_int(sqlstmt, col, i));
break;
case 'd': case 'D': /* double */
case 'f': case 'F':
L2REAL(ARG3);
Licpy(ARGR, sqlite3_bind_double(sqlstmt, col, LREAL(*ARG3)));
break;
case 's': case 'S': /* double */
case 't': case 'T':
L2STR(ARG3);
Licpy(ARGR, sqlite3_bind_text(sqlstmt, col,
LSTR(*ARG3), LLEN(*ARG3), SQLITE_TRANSIENT));
break;
case 'n': case 'N': /* null */
Licpy(ARGR, sqlite3_bind_null(sqlstmt, col));
break;
case 'z': case 'Z': /* zero blob */
get_i(3, i);
Licpy(ARGR, sqlite3_bind_zeroblob(sqlstmt, col, i));
break;
default:
Lerror(ERR_INCORRECT_CALL,0);
}
} /* R_sqlbind */
int SqliteStatement::bindStatic (int position, Blob const& value)
{
return sqlite3_bind_blob (statement, position, &value.front (), value.size (), SQLITE_STATIC);
}
void QgsOSMDatabase::exportSpatiaLiteNodes( const QString &tableName, const QStringList &tagKeys, const QStringList ¬NullTagKeys )
{
QString sqlInsertPoint = QStringLiteral( "INSERT INTO %1 VALUES (?" ).arg( quotedIdentifier( tableName ) );
for ( int i = 0; i < tagKeys.count(); ++i )
sqlInsertPoint += QStringLiteral( ",?" );
sqlInsertPoint += QLatin1String( ", GeomFromWKB(?, 4326))" );
sqlite3_stmt *stmtInsert = nullptr;
if ( sqlite3_prepare_v2( mDatabase, sqlInsertPoint.toUtf8().constData(), -1, &stmtInsert, nullptr ) != SQLITE_OK )
{
mError = QStringLiteral( "Prepare SELECT FROM nodes failed." );
return;
}
QgsOSMNodeIterator nodes = listNodes();
QgsOSMNode n;
while ( ( n = nodes.next() ).isValid() )
{
QgsOSMTags t = tags( false, n.id() );
// skip untagged nodes: probably they form a part of ways
if ( t.count() == 0 )
continue;
//check not null tags
bool skipNull = false;
for ( int i = 0; i < notNullTagKeys.count() && !skipNull; ++i )
if ( !t.contains( notNullTagKeys[i] ) )
skipNull = true;
if ( skipNull )
continue;
QgsGeometry geom = QgsGeometry::fromPoint( n.point() );
int col = 0;
sqlite3_bind_int64( stmtInsert, ++col, n.id() );
// tags
for ( int i = 0; i < tagKeys.count(); ++i )
{
if ( t.contains( tagKeys[i] ) )
sqlite3_bind_text( stmtInsert, ++col, t.value( tagKeys[i] ).toUtf8().constData(), -1, SQLITE_TRANSIENT );
else
sqlite3_bind_null( stmtInsert, ++col );
}
QByteArray wkb( geom.exportToWkb() );
sqlite3_bind_blob( stmtInsert, ++col, wkb.constData(), wkb.length(), SQLITE_STATIC );
int insertRes = sqlite3_step( stmtInsert );
if ( insertRes != SQLITE_DONE )
{
mError = QStringLiteral( "Error inserting node %1 [%2]" ).arg( n.id() ).arg( insertRes );
break;
}
sqlite3_reset( stmtInsert );
sqlite3_clear_bindings( stmtInsert );
}
sqlite3_finalize( stmtInsert );
}
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;
}
void QgsOSMDatabase::exportSpatiaLiteWays( bool closed, const QString &tableName,
const QStringList &tagKeys,
const QStringList ¬NullTagKeys )
{
Q_UNUSED( tagKeys );
QString sqlInsertLine = QStringLiteral( "INSERT INTO %1 VALUES (?" ).arg( quotedIdentifier( tableName ) );
for ( int i = 0; i < tagKeys.count(); ++i )
sqlInsertLine += QStringLiteral( ",?" );
sqlInsertLine += QLatin1String( ", GeomFromWKB(?, 4326))" );
sqlite3_stmt *stmtInsert = nullptr;
if ( sqlite3_prepare_v2( mDatabase, sqlInsertLine.toUtf8().constData(), -1, &stmtInsert, nullptr ) != SQLITE_OK )
{
mError = QStringLiteral( "Prepare SELECT FROM ways failed." );
return;
}
QgsOSMWayIterator ways = listWays();
QgsOSMWay w;
while ( ( w = ways.next() ).isValid() )
{
QgsOSMTags t = tags( true, w.id() );
QgsPolyline polyline = wayPoints( w.id() );
if ( polyline.count() < 2 )
continue; // invalid way
bool isArea = ( polyline.first() == polyline.last() ); // closed way?
// filter out closed way that are not areas through tags
if ( isArea && ( t.contains( QStringLiteral( "highway" ) ) || t.contains( QStringLiteral( "barrier" ) ) ) )
{
// make sure tags that indicate areas are taken into consideration when deciding on a closed way is or isn't an area
// and allow for a closed way to be exported both as a polygon and a line in case both area and non-area tags are present
if ( ( t.value( QStringLiteral( "area" ) ) != QLatin1String( "yes" ) && !t.contains( QStringLiteral( "amenity" ) ) && !t.contains( QStringLiteral( "landuse" ) ) && !t.contains( QStringLiteral( "building" ) ) && !t.contains( QStringLiteral( "natural" ) ) && !t.contains( QStringLiteral( "leisure" ) ) && !t.contains( QStringLiteral( "aeroway" ) ) ) || !closed )
isArea = false;
}
if ( closed != isArea )
continue; // skip if it's not what we're looking for
//check not null tags
bool skipNull = false;
for ( int i = 0; i < notNullTagKeys.count() && !skipNull; ++i )
if ( !t.contains( notNullTagKeys[i] ) )
skipNull = true;
if ( skipNull )
continue;
QgsGeometry geom = closed ? QgsGeometry::fromPolygon( QgsPolygon() << polyline ) : QgsGeometry::fromPolyline( polyline );
int col = 0;
sqlite3_bind_int64( stmtInsert, ++col, w.id() );
// tags
for ( int i = 0; i < tagKeys.count(); ++i )
{
if ( t.contains( tagKeys[i] ) )
sqlite3_bind_text( stmtInsert, ++col, t.value( tagKeys[i] ).toUtf8().constData(), -1, SQLITE_TRANSIENT );
else
sqlite3_bind_null( stmtInsert, ++col );
}
if ( !geom.isNull() )
{
QByteArray wkb( geom.exportToWkb() );
sqlite3_bind_blob( stmtInsert, ++col, wkb.constData(), wkb.length(), SQLITE_STATIC );
}
else
sqlite3_bind_null( stmtInsert, ++col );
int insertRes = sqlite3_step( stmtInsert );
if ( insertRes != SQLITE_DONE )
{
mError = QStringLiteral( "Error inserting way %1 [%2]" ).arg( w.id() ).arg( insertRes );
break;
}
sqlite3_reset( stmtInsert );
sqlite3_clear_bindings( stmtInsert );
}
sqlite3_finalize( stmtInsert );
}
/*
* Send an SQL query to the server
*/
static int db_sqlite_submit_query(const db1_con_t* _h, const str* _s)
{
struct sqlite_connection *conn = CON_SQLITE(_h);
sqlite3_stmt *stmt;
const db_val_t *val;
int rc, i;
LM_DBG("submit_query: %.*s\n", _s->len, _s->s);
rc = sqlite3_prepare_v2(conn->conn, _s->s, _s->len, &stmt, NULL);
if (rc != SQLITE_OK) {
LM_ERR("failed to prepare statement: %s\n",
sqlite3_errmsg(conn->conn));
return -1;
}
conn->stmt = stmt;
for (i = 1; i <= conn->bindpos; i++) {
val = conn->bindarg[i-1];
if (VAL_NULL(val)) {
rc = sqlite3_bind_null(stmt, i);
} else switch (VAL_TYPE(val)) {
case DB1_INT:
rc = sqlite3_bind_int(stmt, i, VAL_INT(val));
break;
case DB1_BIGINT:
rc = sqlite3_bind_int64(stmt, i, VAL_BIGINT(val));
break;
case DB1_DOUBLE:
rc = sqlite3_bind_double(stmt, i, VAL_DOUBLE(val));
break;
case DB1_STRING:
rc = sqlite3_bind_text(stmt, i,
VAL_STRING(val), -1, NULL);
break;
case DB1_STR:
rc = sqlite3_bind_text(stmt, i,
VAL_STR(val).s, VAL_STR(val).len, NULL);
break;
case DB1_DATETIME:
rc = sqlite3_bind_double(stmt, i, timet_to_sqlite(VAL_TIME(val)));
break;
case DB1_BLOB:
rc = sqlite3_bind_blob(stmt, i,
VAL_BLOB(val).s, VAL_BLOB(val).len,
NULL);
break;
case DB1_BITMAP:
rc = sqlite3_bind_int(stmt, i, VAL_BITMAP(val));
break;
default:
LM_ERR("unknown bind value type %d\n", VAL_TYPE(val));
return -1;
}
if (rc != SQLITE_OK) {
LM_ERR("Parameter bind failed: %s\n",
sqlite3_errmsg(conn->conn));
return -1;
}
}
return 0;
}
DLL_FUNCTION(int32_t) BU_SQLite_Bind_Blob(sqlite3_stmt* pStmt, int32_t index, void* zData, int32_t nData) {
#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Blob=_BU_SQLite_Bind_Blob@16")
return sqlite3_bind_blob(pStmt, index, zData, nData, nullptr);
}
int machine_bind_blob(Code stmt,int index,void * blob,int size){
return msg_id( sqlite3_bind_blob((sqlite3_stmt*)stmt, index ,blob, size, 0));
}
int
gpgsql_stepx (sqlite3 *db,
sqlite3_stmt **stmtp,
gpgsql_stepx_callback callback,
void *cookie,
char **errmsg,
const char *sql, ...)
{
int rc;
int err = 0;
sqlite3_stmt *stmt = NULL;
va_list va;
int args;
enum gpgsql_arg_type t;
int i;
int cols;
/* Names of the columns. We initialize this lazily to avoid the
overhead in case the query doesn't return any results. */
const char **azColName = 0;
int callback_initialized = 0;
const char **azVals = 0;
callback_initialized = 0;
if (stmtp && *stmtp)
{
stmt = *stmtp;
/* Make sure this statement is associated with the supplied db. */
log_assert (db == sqlite3_db_handle (stmt));
#if DEBUG_TOFU_CACHE
prepares_saved ++;
#endif
}
else
{
const char *tail = NULL;
rc = sqlite3_prepare_v2 (db, sql, -1, &stmt, &tail);
if (rc)
log_fatal ("failed to prepare SQL: %s", sql);
/* We can only process a single statement. */
if (tail)
{
while (*tail == ' ' || *tail == ';' || *tail == '\n')
tail ++;
if (*tail)
log_fatal
("sqlite3_stepx can only process a single SQL statement."
" Second statement starts with: '%s'\n",
tail);
}
if (stmtp)
*stmtp = stmt;
}
#if DEBUG_TOFU_CACHE
queries ++;
#endif
args = sqlite3_bind_parameter_count (stmt);
va_start (va, sql);
if (args)
{
for (i = 1; i <= args; i ++)
{
t = va_arg (va, enum gpgsql_arg_type);
switch (t)
{
case SQLITE_ARG_INT:
{
int value = va_arg (va, int);
err = sqlite3_bind_int (stmt, i, value);
break;
}
case SQLITE_ARG_LONG_LONG:
{
long long value = va_arg (va, long long);
err = sqlite3_bind_int64 (stmt, i, value);
break;
}
case SQLITE_ARG_STRING:
{
char *text = va_arg (va, char *);
err = sqlite3_bind_text (stmt, i, text, -1, SQLITE_STATIC);
break;
}
case SQLITE_ARG_BLOB:
{
char *blob = va_arg (va, void *);
long long length = va_arg (va, long long);
err = sqlite3_bind_blob (stmt, i, blob, length, SQLITE_STATIC);
break;
}
default:
/* Internal error. Likely corruption. */
log_fatal ("Bad value for parameter type %d.\n", t);
}
if (err)
{
log_fatal ("Error binding parameter %d\n", i);
goto out;
}
}
}
t = va_arg (va, enum gpgsql_arg_type);
log_assert (t == SQLITE_ARG_END);
va_end (va);
for (;;)
{
rc = sqlite3_step (stmt);
if (rc != SQLITE_ROW)
/* No more data (SQLITE_DONE) or an error occurred. */
break;
if (! callback)
continue;
if (! callback_initialized)
{
cols = sqlite3_column_count (stmt);
azColName = xmalloc (2 * cols * sizeof (const char *) + 1);
for (i = 0; i < cols; i ++)
azColName[i] = sqlite3_column_name (stmt, i);
callback_initialized = 1;
}
azVals = &azColName[cols];
for (i = 0; i < cols; i ++)
{
azVals[i] = sqlite3_column_text (stmt, i);
if (! azVals[i] && sqlite3_column_type (stmt, i) != SQLITE_NULL)
/* Out of memory. */
{
err = SQLITE_NOMEM;
break;
}
}
if (callback (cookie, cols, (char **) azVals, (char **) azColName, stmt))
/* A non-zero result means to abort. */
{
err = SQLITE_ABORT;
break;
}
}
out:
xfree (azColName);
if (stmtp)
rc = sqlite3_reset (stmt);
else
rc = sqlite3_finalize (stmt);
if (rc == SQLITE_OK && err)
/* Local error. */
{
rc = err;
if (errmsg)
{
const char *e = sqlite3_errstr (err);
size_t l = strlen (e) + 1;
*errmsg = sqlite3_malloc (l);
if (! *errmsg)
log_fatal ("Out of memory.\n");
memcpy (*errmsg, e, l);
}
}
else if (rc != SQLITE_OK && errmsg)
/* Error reported by sqlite. */
{
const char * e = sqlite3_errmsg (db);
size_t l = strlen (e) + 1;
*errmsg = sqlite3_malloc (l);
if (! *errmsg)
log_fatal ("Out of memory.\n");
memcpy (*errmsg, e, l);
}
return rc;
}
