static mrb_value
mrb_sqlite3_database_execute(mrb_state *mrb, mrb_value self) {
  int argc = 0;
  mrb_value* argv = NULL;
  mrb_value b = mrb_nil_value();
  mrb_value value_context;
  mrb_sqlite3_database* db = NULL;
  mrb_value fields;
  int i, r, count;
  sqlite3_stmt* stmt = NULL;
  mrb_value args[2];
  mrb_value query;

  mrb_get_args(mrb, "&S*", &b, &query, &argv, &argc);

  value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context"));
  db = NULL;
  Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db);
  if (!db) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
  }

  r = sqlite3_prepare_v2(db->db, RSTRING_PTR(query), RSTRING_LEN(query),
    &stmt, NULL);
  if (r != SQLITE_OK) {
    if (stmt) {
      sqlite3_finalize(stmt);
      sqlite3_reset(stmt);
    }
    mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
  }
  if (!stmt) {
    return mrb_nil_value();
  }

  if (argc > 0) {
    const char* error = bind_values(mrb, db->db, stmt, argc, argv);
    if (error) {
      mrb_raise(mrb, E_ARGUMENT_ERROR, error);
    }
  }

  fields = mrb_ary_new(mrb);
  count = sqlite3_column_count(stmt);
  for (i = 0; i < count; i++) {
    const char* name = sqlite3_column_name(stmt, i);
    mrb_ary_push(mrb, fields, mrb_str_new_cstr(mrb, name));
  }

  if (mrb_nil_p(b)) {
    struct RClass* _class_sqlite3;
    struct RClass* _class_sqlite3_resultset;
    mrb_value c;
    mrb_sqlite3_resultset* rs = (mrb_sqlite3_resultset*)
      malloc(sizeof(mrb_sqlite3_resultset));
    if (!rs) {
      mrb_raise(mrb, E_RUNTIME_ERROR, "can't memory alloc");
    }
    memset(rs, 0, sizeof(mrb_sqlite3_resultset));
    rs->mrb = mrb;
    rs->stmt = stmt;
    _class_sqlite3 = mrb_class_get(mrb, "SQLite3");
    _class_sqlite3_resultset = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_sqlite3), mrb_intern(mrb, "ResultSet")));
    c = mrb_class_new_instance(mrb, 0, NULL, _class_sqlite3_resultset);
    mrb_iv_set(mrb, c, mrb_intern(mrb, "context"), mrb_obj_value(
      Data_Wrap_Struct(mrb, mrb->object_class,
      &mrb_sqlite3_resultset_type, (void*) rs)));
    mrb_iv_set(mrb, c, mrb_intern(mrb, "fields"), fields);
    mrb_iv_set(mrb, c, mrb_intern(mrb, "db"), self);
    mrb_iv_set(mrb, c, mrb_intern(mrb, "eof"), mrb_false_value());
    return c;
  }
  while ((r = sqlite3_step(stmt)) == SQLITE_ROW) {
    int ai = mrb_gc_arena_save(mrb);
    args[0] = row_to_value(mrb, stmt);
    args[1] = fields;
    mrb_yield_argv(mrb, b, 2, args);
    mrb_gc_arena_restore(mrb, ai);
  }
  sqlite3_finalize(stmt);
  if (r != SQLITE_OK && r != SQLITE_DONE) {
    mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
  }
  return mrb_nil_value();
}
/* 
 Saves in ret the tag action if it exists
 Returns 0 if it doesn't exists
 Returns -1 if it there is an error
*/
int
touchatag_taglist_sqlite3_copy_action (tag_t *tag, char *ret)
{	
	sqlite3_stmt *pStmt;   
	sqlite3 *database;
	int rc, rf, i = 0;
	uid[14] = '\0';
	data[96] = '\0';

	if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){
		printf ("Error sqlite3_open ()\n");
		return -1;
	}
	
	touchatag_sconvert (tag, uid, data);
		
	if ((rf = touchatag_taglist_sqlite3_search (tag)) == -1){
		printf ("Error touchatag_taglist_sqlite3_search ()\n");
		sqlite3_close (database);
		return -1;
	}
	
	if (rf == 0) {
		sqlite3_close (database);
		return 0;
	}
		
	if (rf == 1) {                                          
			
		if ((rc = sqlite3_prepare_v2 (database,"SELECT * from tag WHERE UID=?", -1, &pStmt, NULL)) != SQLITE_OK){   
			printf ("Error sqlite3_prepare_v2 ()\n");
			sqlite3_close (database); 
			return -1;
		}
		
		if ((rc = sqlite3_bind_text (pStmt, 1, uid, -1, NULL)) != SQLITE_OK){               
			printf ("Error sqlite3_bind_text ()\n");
			sqlite3_close (database); 
			return -1;
		}
		
		if ((rc = sqlite3_step (pStmt)) != SQLITE_ROW){                     
			printf ("Error sqlite3_step ()\n");
			return -1;
		}
		
		res = sqlite3_column_text (pStmt, 2);                 
		
		sprintf (ret, "%s", res);
			
		i = sqlite3_clear_bindings (pStmt);                            
		
		if ((rc = sqlite3_reset (pStmt)) != SQLITE_OK){    
			printf ("Error sqlite3_reset ()\n");
			sqlite3_close (database);
			return -1;
		}
			
		sqlite3_close (database); 
		return 1;
	}
}
/*
 Update (plus 1) the counter of the given tag (if it exists in the db)
 Returns 0 if it's not in the db
 Returns -1 if there is a problem
*/
int
touchatag_taglist_sqlite3_update_counter_tag (tag_t *tag)
{
	sqlite3_stmt *pStmt;   
	sqlite3 *database;
	int rc, rf, i = 0;
	
	uid[14] = '\0';
	data[96] = '\0';

	if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){
		printf ("Error sqlite3_open ()\n");
		return -1;
	}
	
	touchatag_sconvert (tag, uid, data);

	if ((rf = touchatag_taglist_sqlite3_counter_tag (tag)) == -1){
		printf ("Error touchatag_taglist_sqlite3_counter_tag () in touchatag_taglist_sqlite3_update_counter_tag ()\n");
		sqlite3_close (database);
		return -1;
	}
	if (rf == -2) {
		sqlite3_close (database);
		return 0;
	}		
			
	rf++;          
		
	if ((rc = sqlite3_prepare_v2 (database,"UPDATE tag SET CONT=? WHERE UID=?", -1, &pStmt, NULL)) != SQLITE_OK){
		printf ("Error sqlite3_prepare_v2 () in touchatag_taglist_sqlite3_update_counter_tag ()\n");
		sqlite3_close (database);
		return -1;
	}
	if ((rc = sqlite3_bind_int (pStmt, 1, rf)) != SQLITE_OK){
		printf ("Error sqlite3_bind_int () in touchatag_taglist_sqlite3_update_counter_tag ()\n");
		sqlite3_close (database);
		return -1;
	}
	if ((rc = sqlite3_bind_text (pStmt, 2, (const char*)uid, -1, NULL)) != SQLITE_OK){
		printf ("Error sqlite3_bind_text () in touchatag_taglist_sqlite3_update_counter_tag ()\n");
		sqlite3_close (database);
		return -1;

	}
	if ((rc = sqlite3_step (pStmt)) != SQLITE_DONE){
		printf ("Error sqlite3_step () in touchatag_taglist_sqlite3_update_counter_tag ()\n");
		sqlite3_close (database);
		return -1;
	}
	
	i = sqlite3_clear_bindings (pStmt);
		
	if ((rc = sqlite3_reset (pStmt))!= SQLITE_OK){
		printf ("Error sqlite3_reset () in touchatag_taglist_sqlite3_update_counter_tag ()\n");
		sqlite3_close (database);
		return -1;
	}
	
	sqlite3_close (database); 
	return 1;
}
void Statement::reset() {
    assert(stmt);
    sqlite3_reset(stmt);
}
Beispiel #5
0
static void print_by_size(void)
{
	int ret;
	int header_printed = 0;
	unsigned char *digest;
	uint64_t count, files_count;

	if (print_all_hashes)
		printf("Print all hashes ");
	else
		printf("Print top %d hashes ", num_to_print);

	printf("(this may take some time)\n");

	while ((ret = sqlite3_step(top_hashes_stmt)) == SQLITE_ROW) {
		digest = (unsigned char *)sqlite3_column_blob(top_hashes_stmt, 0);
		count = sqlite3_column_int64(top_hashes_stmt, 1);

		ret = sqlite3_bind_blob(files_count_stmt, 1, digest, digest_len,
					SQLITE_STATIC);
		if (ret) {
			fprintf(stderr, "Error %d binding digest: %s\n", ret,
				sqlite3_errstr(ret));
			return;
		}

		ret = sqlite3_step(files_count_stmt);
		if (ret != SQLITE_ROW && ret != SQLITE_DONE) {
			fprintf(stderr, "error %d, file count search: %s\n",
				ret, sqlite3_errstr(ret));
			return;
		}

		files_count = sqlite3_column_int64(files_count_stmt, 0);

		if (!header_printed) {
			printf("Hash, # Blocks, # Files\n");
			header_printed = 1;
		}

		debug_print_digest(stdout, digest);
		printf(", %"PRIu64", %"PRIu64"\n", count, files_count);

		sqlite3_reset(files_count_stmt);

		if (print_blocks) {
			ret = print_all_blocks(digest);
			if (ret)
				return;
		}

		if (!print_all_hashes && --num_to_print == 0) {
			ret = SQLITE_DONE;
			break;
		}
	}
	if (ret != SQLITE_DONE) {
		fprintf(stderr, "error %d retrieving hashes from table: %s\n",
			ret, sqlite3_errstr(ret));
	}
}
Beispiel #6
0
/* insert a measurement report into the database */
int meas_db_insert(struct meas_db_state *st, const char *imsi,
		   const char *name, unsigned long timestamp,
		   const char *scenario,
		   const struct gsm_meas_rep *mr)
{
	int rc;
	sqlite3_int64 rowid, ul_rowid, dl_rowid;

	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 1, timestamp));

	if (imsi)
		SCK_OK(st->db, sqlite3_bind_text(st->stmt_ins_mr, 2,
						 imsi, -1, SQLITE_STATIC));
	else
		SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 2));

	if (name)
		SCK_OK(st->db, sqlite3_bind_text(st->stmt_ins_mr, 3,
						 name, -1, SQLITE_STATIC));
	else
		SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 3));

	if (scenario)
		SCK_OK(st->db, sqlite3_bind_text(st->stmt_ins_mr, 4,
						 scenario, -1, SQLITE_STATIC));
	else
		SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 4));


	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 5, mr->nr));
	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 6, mr->bs_power));

	if (mr->flags & MEAS_REP_F_MS_TO)
		SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 7,
						mr->ms_timing_offset));
	else
		SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 7));

	if (mr->flags & MEAS_REP_F_FPC)
		SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 8, 1));
	else
		SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 8, 0));

	if (mr->flags & MEAS_REP_F_MS_L1) {
		SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 9,
						mr->ms_l1.pwr));
		SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 10,
						mr->ms_l1.ta));
	}

	SCK_DONE(st->db, sqlite3_step(st->stmt_ins_mr));
	SCK_OK(st->db, sqlite3_reset(st->stmt_ins_mr));

	rowid = sqlite3_last_insert_rowid(st->db);

	/* insert uplink measurement */
	ul_rowid = _insert_ud(st, rowid, mr->flags & MEAS_REP_F_UL_DTX,
				1, &mr->ul);
	SCK_OK(st->db, sqlite3_bind_int(st->stmt_upd_mr, 1, ul_rowid));

	/* insert downlink measurement, if present */
	if (mr->flags & MEAS_REP_F_DL_VALID) {
		dl_rowid = _insert_ud(st, rowid, mr->flags & MEAS_REP_F_DL_DTX,
			       	      0, &mr->dl);
		SCK_OK(st->db, sqlite3_bind_int(st->stmt_upd_mr, 2, dl_rowid));
	} else
		SCK_OK(st->db, sqlite3_bind_null(st->stmt_upd_mr, 2));

	/* update meas_rep with the id's of the unidirectional
	 * measurements */
	SCK_OK(st->db, sqlite3_bind_int(st->stmt_upd_mr, 3, rowid));
	SCK_DONE(st->db, sqlite3_step(st->stmt_upd_mr));
	SCK_OK(st->db, sqlite3_reset(st->stmt_upd_mr));

	return 0;

err_io:
	return -EIO;
}
Beispiel #7
0
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;
}
Beispiel #8
0
static int unbump_revs(struct revunbump_data_t *unb) {
    int64_t revs[MAX_UNBUMPS];
    sqlite3_stmt *q;
    char *qry = NULL;
    const void *tgt;
    unsigned int i, qlen = 0, qat = 0;
    int64_t unbid;
    const sx_node_t *target, *me;
    int r, err = 0, remote;

    q = unb->quget_hi;
    sqlite3_reset(q);
    if(qbind_blob(q, ":oldtarget", (const void *)&unb->last_target, sizeof(unb->last_target)))
	return -1; /* Error */
    r = qstep(q);
    if(r == SQLITE_DONE) {
	q = unb->quget_lo;
	sqlite3_reset(q);
	if(qbind_blob(q, ":oldtarget", (const void *)&unb->last_target, sizeof(unb->last_target)))
	    return -1; /* Error */
	r = qstep(q);
	if(r == SQLITE_DONE)
	    return 0; /* Work complete */
    }
    if(r != SQLITE_ROW)
	return -1; /* Error */

    unbid = sqlite3_column_int64(q, 0);
    tgt = sqlite3_column_blob(q, 3);
    if(!tgt || sqlite3_column_bytes(q, 3) != sizeof(unb->last_target.binary)) {
	WARN("Removing unbid %lld with bogus target", (long long)unbid);
	sqlite3_reset(q);
	return unbump_unq(unb, unbid);
    }
    uuid_from_binary(&unb->last_target, tgt);

    target = sx_nodelist_lookup(sx_hashfs_all_nodes(unb->hashfs, NL_NEXTPREV), &unb->last_target);
    if(!target) {
	DEBUG("Removing unbid %lld for target node %s which is no longer a member", (long long)unbid, unb->last_target.string);
	sqlite3_reset(q);
	return unbump_unq(unb, unbid);
    }

    if(sx_hashfs_is_node_ignored(unb->hashfs, &unb->last_target)) {
	/* These will be sent once there is a replacement */
	DEBUG("Skipping requests for unbid %lld for target node %s which is no longer a member", (long long)unbid, unb->last_target.string);
	sqlite3_reset(q);
	return 0; /* Work complete */
    }

    me = sx_hashfs_self(unb->hashfs);
    remote = sx_node_cmp(me, target);
    if(!remote && sx_hashfs_revision_op_begin(unb->hashfs)) {
	WARN("Failed to start revision operation: %s", msg_get_reason());
	sqlite3_reset(q);
	return -1; /* Error */
    }
    for(i=0; i<MAX_UNBUMPS;) {
	const sx_hash_t *revid;
	unsigned int bs = sqlite3_column_int(q, 2);

	if(sx_hashfs_check_blocksize(bs))
	    WARN("Removing unbid %lld with invalid block size %u", (long long)unbid, bs);
	else if(!(revid = sqlite3_column_blob(q, 1)) || sqlite3_column_bytes(q, 1) != sizeof(*revid))
	    WARN("Removing unbid %lld with bogus revision ID", (long long)unbid);
	else if(!(tgt = sqlite3_column_blob(q, 3)) || sqlite3_column_bytes(q, 3) != sizeof(unb->last_target.binary))
	    WARN("Removing unbid %lld with bogus target", (long long)unbid);
        else if(memcmp(tgt, &unb->last_target.binary, sizeof(unb->last_target.binary)))
	    break;
	else if(remote) {
	    /* Remote target */
	    if(qlen - qat < sizeof(*revid) * 2 + sizeof(",\"\":") + 32) {
		/* Make room for hex encoded rev, size and json glue */
		qlen += 1024;
		qry = wrap_realloc_or_free(qry, qlen);
		if(!qry) {
		    WARN("Unable to allocate query");
		    err = 1;
		    break;
		}
	    }
	    
	    qry[qat] = qat ? ',' : '{';
	    qry[qat+1] = '"';
	    qat += 2;
	    bin2hex(revid, sizeof(*revid), &qry[qat], qlen - qat);
	    qat += sizeof(*revid)*2;
	    qat += snprintf(&qry[qat], qlen - qat,"\":%u", bs);
	} else {
	    /* Local target */
	    if(sx_hashfs_revision_op(unb->hashfs, bs, revid, -1) != OK) {
		WARN("Failed to unbump local revision");
		err = 1;
		break;
	    }
	}
	revs[i++] = sqlite3_column_int64(q, 0);

	r = qstep(q);
	if(r == SQLITE_ROW)
	    continue;
	else if(r != SQLITE_DONE) {
	    WARN("Failed to retrieve next revision");
	    err = 1;
	}
	break;
    }

    sqlite3_reset(q);

    if(!remote) {
	/* Commit local revision ops... */
	if(!err && sx_hashfs_revision_op_commit(unb->hashfs)) {
	    WARN("Failed to commit revision operation: %s", msg_get_reason());
	    err = 1;
	}
	/* ... or rollback on error */
	if(err)
	    sx_hashfs_revision_op_rollback(unb->hashfs);
    }

    if(err) {
	free(qry);
	return -1; /* Error */
    }

    if(remote && qry) {
	sxi_conns_t *clust = sx_hashfs_conns(unb->hashfs);
	sxc_client_t *sx = sx_hashfs_client(unb->hashfs);
	sxi_hostlist_t hlist;
	int qret;

	sxi_hostlist_init(&hlist);
	if(qlen - qat < 2) {
	    qry = wrap_realloc_or_free(qry, qlen + 2);
	    if(!qry) {
		WARN("Unable to allocate query");
		return -1; /* Error */
	    }
	}
	qry[qat] = '}';
	qry[qat+1] = '\0';

	if(sxi_hostlist_add_host(sx, &hlist, sx_node_internal_addr(target))) {
	    WARN("Unable to allocate hostlist");
	    free(qry);
	    return -1; /* Error */
	}

	qret = sxi_cluster_query(clust, &hlist, REQ_PUT, ".blockrevs/remove", qry, strlen(qry), NULL, NULL, NULL);
	free(qry);
	qry = NULL;
	sxi_hostlist_empty(&hlist);
	if(qret != 200) {
	    WARN("Unbump request failed for %s (%s): HTTP status %d", unb->last_target.string, sx_node_internal_addr(target), qret);
	    return -1;
	}
    }

    free(qry);
    while(i--)
	unbump_unq(unb, revs[i]);

    return 1; /* Some work done */

}
Beispiel #9
0
void RepoStmt::reset() {
  sqlite3_reset(m_stmt);
  sqlite3_clear_bindings(m_stmt);
}
Beispiel #10
0
DWORD
SamDbDeleteObject(
    HANDLE hDirectory,
    PWSTR  pwszObjectDN
)
{
    DWORD dwError = 0;
    PSAM_DIRECTORY_CONTEXT pDirectoryContext = NULL;
    PSTR pszObjectDN = NULL;
    PSAM_DB_DN pDN = NULL;
    BOOLEAN bInLock = FALSE;
    DWORD dwNumDependents = 0;

    pDirectoryContext = (PSAM_DIRECTORY_CONTEXT)hDirectory;

    if (!hDirectory || !pwszObjectDN || !*pwszObjectDN)
    {
        dwError = LW_ERROR_INVALID_PARAMETER;
        BAIL_ON_SAMDB_ERROR(dwError);
    }

    dwError = SamDbParseDN(
                  pwszObjectDN,
                  &pDN);
    BAIL_ON_SAMDB_ERROR(dwError);

    dwError = LwWc16sToMbs(
                  pwszObjectDN,
                  &pszObjectDN);
    BAIL_ON_SAMDB_ERROR(dwError);

    SAMDB_LOCK_RWMUTEX_EXCLUSIVE(bInLock, &gSamGlobals.rwLock);

    dwError = SamDbGetNumberOfDependents_inlock(
                  pDirectoryContext,
                  pszObjectDN,
                  &dwNumDependents);
    BAIL_ON_SAMDB_ERROR(dwError);

    if (dwNumDependents)
    {
        dwError = LW_ERROR_OBJECT_IN_USE;
        BAIL_ON_SAMDB_ERROR(dwError);
    }

    if (!pDirectoryContext->pDbContext->pDelObjectStmt)
    {
        PCSTR pszDelQueryTemplate =
            "DELETE FROM " SAM_DB_OBJECTS_TABLE \
            " WHERE " SAM_DB_COL_DISTINGUISHED_NAME " = ?1;";

        dwError = sqlite3_prepare_v2(
                      pDirectoryContext->pDbContext->pDbHandle,
                      pszDelQueryTemplate,
                      -1,
                      &pDirectoryContext->pDbContext->pDelObjectStmt,
                      NULL);
        BAIL_ON_SAMDB_SQLITE_ERROR_DB(
            dwError,
            pDirectoryContext->pDbContext->pDbHandle);
    }

    dwError = sqlite3_bind_text(
                  pDirectoryContext->pDbContext->pDelObjectStmt,
                  1,
                  pszObjectDN,
                  -1,
                  SQLITE_TRANSIENT);
    BAIL_ON_SAMDB_SQLITE_ERROR_STMT(
        dwError,
        pDirectoryContext->pDbContext->pDelObjectStmt);

    dwError = sqlite3_step(pDirectoryContext->pDbContext->pDelObjectStmt);
    if (dwError == SQLITE_DONE)
    {
        dwError = LW_ERROR_SUCCESS;
    }
    BAIL_ON_SAMDB_SQLITE_ERROR_STMT(
        dwError,
        pDirectoryContext->pDbContext->pDelObjectStmt);

    dwError = SamDbIncrementSequenceNumber_inlock(
                  pDirectoryContext);
    BAIL_ON_SAMDB_ERROR(dwError);

cleanup:

    if (pDirectoryContext->pDbContext->pDelObjectStmt)
    {
        sqlite3_reset(pDirectoryContext->pDbContext->pDelObjectStmt);
    }

    SAMDB_UNLOCK_RWMUTEX(bInLock, &gSamGlobals.rwLock);

    DIRECTORY_FREE_STRING(pszObjectDN);

    if (pDN)
    {
        SamDbFreeDN(pDN);
    }

    return dwError;

error:

    goto cleanup;
}
Beispiel #11
0
static int schedule_blocks_sfq(struct blockmgr_data_t *q) {
    sx_uuid_t target_uuid;
    sqlite3_stmt *qget;
    int ret = 0, r;

    DEBUG("in %s", __func__);
    qget = q->qget_first_hi;
    if(qbind_int64(qget, ":flow", q->last_flowid)) {
	WARN("Error retrieving master block from queue");
	return -1;
    }
    r = qstep(qget);
    if(r == SQLITE_DONE) {
	qget = q->qget_first_lo;
	if(qbind_int64(qget, ":flow", q->last_flowid)) {
	    WARN("Error retrieving master block from queue");
	    return -1;
	}
	r = qstep(qget);
    }
    if(r == SQLITE_DONE) {
	DEBUG("No blocks in the queue");
	return 0;
    }
    if(r != SQLITE_ROW) {
	WARN("Error retrieving master block from queue");
	return -1;
    }

    do {
	int64_t push_id;
	const void *p;
	int i;

	/* SELECT id, flow, block[, size, node] */
	push_id = sqlite3_column_int64(qget, 0);
	q->last_flowid = sqlite3_column_int64(qget, 1);

	if(!ret) {
	    /* First block is the "master" and dictates blocksize and target node */
	    q->blocksize = sqlite3_column_int(qget, 3);
	    if(sx_hashfs_check_blocksize(q->blocksize)) {
		WARN("Removing block with invalid blocksize %u", q->blocksize);
		sqlite3_reset(qget);
		blockmgr_del_xfer(q, push_id);
		return schedule_blocks_sfq(q);
	    }

	    p = sqlite3_column_blob(qget, 4);
	    if(sqlite3_column_bytes(qget, 4) != sizeof(target_uuid.binary)) {
		WARN("Removing block with invalid target node UUID");
		sqlite3_reset(qget);
		blockmgr_del_xfer(q, push_id);
		return schedule_blocks_sfq(q);
	    }
	    uuid_from_binary(&target_uuid, p);
	    if(!(q->target = sx_nodelist_lookup(sx_hashfs_effective_nodes(q->hashfs, NL_NEXT), &target_uuid))) {
		DEBUG("Removing transfer to non existing (possibly ignored) node %s", target_uuid.string);
		sqlite3_reset(qget);
		blockmgr_del_xfer(q, push_id);
		return schedule_blocks_sfq(q);
	    }
	    if(!sx_node_cmp(q->target, sx_hashfs_self(q->hashfs))) {
		WARN("Removing transfer to self");
		sqlite3_reset(qget);
		blockmgr_del_xfer(q, push_id);
		return schedule_blocks_sfq(q);
	    }

	    DEBUG("Selected master block for transfer bs: %u, node: %s", q->blocksize, target_uuid.string);
	}

	p = sqlite3_column_blob(qget, 2);
	if(sqlite3_column_bytes(qget, 2) != SXI_SHA1_BIN_LEN) {
	    if(!ret) {
		/* Remove "master" block from queue */
		WARN("Removing block with invalid hash");
		sqlite3_reset(qget);
		blockmgr_del_xfer(q, push_id);
		return schedule_blocks_sfq(q);
	    } else /* Or silently skip slaves (they'll be pruned in the subsequent loops) */
		continue;
	}

	q->hashlist.ids[ret] = push_id;
	q->hashlist.havehs[ret] = 0;
	memcpy(&q->hashlist.binhs[ret], p, SXI_SHA1_BIN_LEN);
	sqlite3_reset(qget);

	if(!ret && qstep_noret(q->qwipesched)) {
	    sqlite3_reset(qget);
	    WARN("Failed to wipe schedule");
	    return -1;
	}
	if(qbind_int64(q->qaddsched, ":pushid", push_id) ||
	   qstep_noret(q->qaddsched)) {
	    WARN("Failed to schedule block transfer");
	    return -1;
	}

	/*
	do {
	    char hexh[SXI_SHA1_BIN_LEN * 2 + 1];
	    sxi_bin2hex(&q->hashlist.binhs[ret], SXI_SHA1_BIN_LEN, hexh);
	    INFO("Block %s scheduled for transfer", hexh);
	} while(0);
	*/

	ret++;
	if(ret >= DOWNLOAD_MAX_BLOCKS)
	    break;

	for(i = 0; i<2; i++) {
	    /* Failure is not severe here: we just ship what we have scheduled so far and call it a day */
	    qget = (i == 0) ? q->qget_next_hi : q->qget_next_lo;
	    if(qbind_int64(qget, ":flow", q->last_flowid) ||
	       qbind_int(qget, ":size", q->blocksize) ||
	       qbind_blob(qget, ":node", target_uuid.binary, sizeof(target_uuid.binary))) {
		WARN("Error retrieving next slave block from queue");
		r = SQLITE_DONE;
		break;
	    }
	    r = qstep(qget);
	    if(r == SQLITE_ROW)
		break;
	    if(r != SQLITE_DONE) {
		WARN("Error retrieving next slave block from queue");
		break;
	    }
	}
    } while(r == SQLITE_ROW);

    q->hashlist.nblocks = ret;
    DEBUG("Successfully scheduled %d blocks for transfer", ret);
    return ret;
}
Beispiel #12
0
int machine_reset(Pointer stmt) {
  reset_ready_event( EV_Done| EV_Data | EV_Error);
	return msg_id(sqlite3_reset((sqlite3_stmt*)stmt));}
Beispiel #13
0
static tb_bool_t tb_database_sqlite3_statement_done(tb_database_sql_impl_t* database, tb_database_sql_statement_ref_t statement)
{
    // check
    tb_database_sqlite3_t* sqlite = tb_database_sqlite3_cast(database);
    tb_assert_and_check_return_val(sqlite && sqlite->database && statement, tb_false);

    // done
    tb_bool_t ok = tb_false;
    do
    {
        // exit result first if exists
        if (sqlite->result.result) sqlite3_free_table(sqlite->result.result);
        sqlite->result.result = tb_null;

        // clear the last statement first
        sqlite->result.statement = tb_null;

        // clear the result row count first
        sqlite->result.count = 0;

        // clear the result col count first
        sqlite->result.row.count = 0;

        // step statement
        tb_int_t result = sqlite3_step((sqlite3_stmt*)statement);
        tb_assert_and_check_break(result == SQLITE_DONE || result == SQLITE_ROW);

        // exists result?
        if (result == SQLITE_ROW)
        {
            // save the result iterator mode
            sqlite->result.itor.mode = TB_ITERATOR_MODE_FORWARD | TB_ITERATOR_MODE_READONLY;

            // save statement for iterating it
            sqlite->result.statement = (sqlite3_stmt*)statement;

            // save result row count
            sqlite->result.count = (tb_size_t)-1;

            // save result col count
            sqlite->result.row.count = sqlite3_column_count((sqlite3_stmt*)statement);
        }
        else
        {
            // reset it 
            if (SQLITE_OK != sqlite3_reset((sqlite3_stmt*)statement))
            {
                // save state
                sqlite->base.state = tb_database_sqlite3_state_from_errno(sqlite3_errcode(sqlite->database));

                // trace
                tb_trace_e("statement: reset failed, error[%d]: %s", sqlite3_errcode(sqlite->database), sqlite3_errmsg(sqlite->database));

                // failed
                break;
            }
        }

        // ok
        ok = tb_true;

    } while (0);

    // ok?
    return ok;
}
static mrb_value
mrb_sqlite3_database_execute_batch(mrb_state *mrb, mrb_value self) {
  int argc = 0;
  mrb_value *argv;
  mrb_value value_context;
  mrb_sqlite3_database* db = NULL;
  mrb_value query;
  int len;
  char* top;
  const char *tail, *sql;

  mrb_get_args(mrb, "*", &argv, &argc);

  if (argc == 0) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
  }
  value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context"));
  Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db);
  if (!db) {
    mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
  }

  query = argv[0];
  len = RSTRING_LEN(query);
  top = malloc(len + 1);
  if (!top) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "can't memory alloc");
  }
  memcpy(top, RSTRING_PTR(query), len);
  top[len] = 0;
  tail = (const char*) top;

  while (*(sql = tail)) {
    sqlite3_stmt* stmt = NULL;
    int r = sqlite3_prepare_v2(db->db, sql, -1, &stmt, &tail);
    if (argc > 1) {
      const char* error = bind_values(mrb, db->db, stmt, argc-1, &argv[1]);
      argc = 0;
      if (error) {
        free(top);
        mrb_raise(mrb, E_ARGUMENT_ERROR, error);
      }
    }
    if (r != SQLITE_OK) {
      if (stmt) {
        sqlite3_finalize(stmt);
        sqlite3_reset(stmt);
      }
      free(top);
      mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
    }
    if (stmt) {
      r = sqlite3_step(stmt);
      sqlite3_finalize(stmt);
      if (r != SQLITE_OK && r != SQLITE_DONE) {
        free(top);
        mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db));
      }
    }
  }
  free(top);
  return mrb_fixnum_value(sqlite3_changes(db->db));
}
Beispiel #15
0
void Database_SQLite3::saveBlock(MapBlock *block)
{
	DSTACK(__FUNCTION_NAME);
	/*
		Dummy blocks are not written
	*/
	if(block->isDummy())
	{
		/*v3s16 p = block->getPos();
		infostream<<"Database_SQLite3::saveBlock(): WARNING: Not writing dummy block "
				<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
		return;
	}

	// Format used for writing
	u8 version = SER_FMT_VER_HIGHEST;
	// Get destination
	v3s16 p3d = block->getPos();
	
	
#if 0
	v2s16 p2d(p3d.X, p3d.Z);
	std::string sectordir = getSectorDir(p2d);

	createDirs(sectordir);

	std::string fullpath = sectordir+DIR_DELIM+getBlockFilename(p3d);
	std::ofstream o(fullpath.c_str(), std::ios_base::binary);
	if(o.good() == false)
		throw FileNotGoodException("Cannot open block data");
#endif
	/*
		[0] u8 serialization version
		[1] data
	*/
	
	verifyDatabase();
	
	std::ostringstream o(std::ios_base::binary);
	
	o.write((char*)&version, 1);
	
	// Write basic data
	block->serialize(o, version, true);
	
	// Write block to database
	
	std::string tmp = o.str();
	const char *bytes = tmp.c_str();
	
	if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK)
		infostream<<"WARNING: Block position failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
	if(sqlite3_bind_blob(m_database_write, 2, (void *)bytes, o.tellp(), NULL) != SQLITE_OK) // TODO this mught not be the right length
		infostream<<"WARNING: Block data failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
	int written = sqlite3_step(m_database_write);
	if(written != SQLITE_DONE)
		infostream<<"WARNING: Block failed to save ("<<p3d.X<<", "<<p3d.Y<<", "<<p3d.Z<<") "
		<<sqlite3_errmsg(m_database)<<std::endl;
	// Make ready for later reuse
	sqlite3_reset(m_database_write);
	
	// We just wrote it to the disk so clear modified flag
	block->resetModified();
}
Beispiel #16
0
static char *handle_cli_database_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
	char prefix[MAX_DB_FIELD];
	int counter = 0;
	sqlite3_stmt *stmt = gettree_stmt;

	switch (cmd) {
	case CLI_INIT:
		e->command = "database show";
		e->usage =
			"Usage: database show [family [keytree]]\n"
			"   OR: database show [family[/keytree]]\n"
			"       Shows Asterisk database contents, optionally restricted\n"
			"       to a given family, or family and keytree. The two arguments\n"
			"       may be separated either by a space or by a slash.\n";
		return NULL;
	case CLI_GENERATE:
		return NULL;
	}

	if (a->argc == 4) {
		/* Family and key tree */
		snprintf(prefix, sizeof(prefix), "/%s/%s", a->argv[2], a->argv[3]);
	} else if (a->argc == 3) {
		/* Family only */
		snprintf(prefix, sizeof(prefix), "/%s", a->argv[2]);
	} else if (a->argc == 2) {
		/* Neither */
		prefix[0] = '\0';
		stmt = gettree_all_stmt;

	} else {
		return CLI_SHOWUSAGE;
	}

	ast_mutex_lock(&dblock);
	if (!ast_strlen_zero(prefix) && (sqlite3_bind_text(stmt, 1, prefix, -1, SQLITE_STATIC) != SQLITE_OK)) {
		ast_log(LOG_WARNING, "Could bind %s to stmt: %s\n", prefix, sqlite3_errmsg(astdb));
		sqlite3_reset(stmt);
		ast_mutex_unlock(&dblock);
		return NULL;
	}

	while (sqlite3_step(stmt) == SQLITE_ROW) {
		const char *key_s, *value_s;
		if (!(key_s = (const char *) sqlite3_column_text(stmt, 0))) {
			ast_log(LOG_WARNING, "Skipping invalid key!\n");
			continue;
		}
		if (!(value_s = (const char *) sqlite3_column_text(stmt, 1))) {
			ast_log(LOG_WARNING, "Skipping invalid value!\n");
			continue;
		}
		++counter;
		ast_cli(a->fd, "%-50s: %-25s\n", key_s, value_s);
	}

	sqlite3_reset(stmt);
	ast_mutex_unlock(&dblock);

	ast_cli(a->fd, "%d results found.\n", counter);
	return CLI_SUCCESS;
}
Beispiel #17
0
MapBlock* Database_SQLite3::loadBlock(v3s16 blockpos)
{
	v2s16 p2d(blockpos.X, blockpos.Z);
        verifyDatabase();
        
        if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK)
                infostream<<"WARNING: Could not bind block position for load: "
                        <<sqlite3_errmsg(m_database)<<std::endl;
        if(sqlite3_step(m_database_read) == SQLITE_ROW) {
                /*
                        Make sure sector is loaded
                */
                MapSector *sector = srvmap->createSector(p2d);
                
                /*
                        Load block
                */
                const char * data = (const char *)sqlite3_column_blob(m_database_read, 0);
                size_t len = sqlite3_column_bytes(m_database_read, 0);
                
                std::string datastr(data, len);
                
//                srvmap->loadBlock(&datastr, blockpos, sector, false);

		try {
                	std::istringstream is(datastr, std::ios_base::binary);
                     
                   	u8 version = SER_FMT_VER_INVALID;
                     	is.read((char*)&version, 1);

                     	if(is.fail())
                             	throw SerializationError("ServerMap::loadBlock(): Failed"
                                	             " to read MapBlock version");

                     	MapBlock *block = NULL;
                     	bool created_new = false;
                     	block = sector->getBlockNoCreateNoEx(blockpos.Y);
                     	if(block == NULL)
                     	{
                             	block = sector->createBlankBlockNoInsert(blockpos.Y);
                             	created_new = true;
                     	}
                     
                     	// Read basic data
                     	block->deSerialize(is, version, true);
                     
                     	// If it's a new block, insert it to the map
                     	if(created_new)
                             	sector->insertBlock(block);
                     
                     	/*
                             	Save blocks loaded in old format in new format
                     	*/

                     	//if(version < SER_FMT_VER_HIGHEST || save_after_load)
                     	// Only save if asked to; no need to update version
                     	//if(save_after_load)
                        //     	saveBlock(block);
                     
                     	// We just loaded it from, so it's up-to-date.
                     	block->resetModified();

             	}
             	catch(SerializationError &e)
             	{
                     	errorstream<<"Invalid block data in database"
                                     <<" ("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
                                     <<" (SerializationError): "<<e.what()<<std::endl;
                     
                     // TODO: Block should be marked as invalid in memory so that it is
                     // not touched but the game can run

                     	if(g_settings->getBool("ignore_world_load_errors")){
                             errorstream<<"Ignoring block load error. Duck and cover! "
                                             <<"(ignore_world_load_errors)"<<std::endl;
                     	} else {
                             throw SerializationError("Invalid block data in database");
                             //assert(0);
                     	}
             	}


                sqlite3_step(m_database_read);
                // We should never get more than 1 row, so ok to reset
                sqlite3_reset(m_database_read);

                return srvmap->getBlockNoCreateNoEx(blockpos);  // should not be using this here
        }
        sqlite3_reset(m_database_read);
	return(NULL);
}
Beispiel #18
0
bool Sqlite3Connection::Execute() {
	Cancel();
	if(statement.GetLength() == 0) {
		session.SetError("Empty statement", String("Preparing: ") + statement);
		return false;
	}
	String utf8_stmt = ToCharset(CHARSET_UTF8, statement, CHARSET_DEFAULT);
	if (SQLITE_OK != sqlite3_prepare(db,utf8_stmt,utf8_stmt.GetLength(),&current_stmt,NULL)) {
		LLOG("Sqlite3Connection::Compile(" << statement << ") -> error");
		session.SetError(sqlite3_errmsg(db), String("Preparing: ") + statement);
		return false;
	}
	current_stmt_string = statement;
	int nparams = ParseForArgs(current_stmt_string);
	ASSERT(nparams == param.GetCount());
	for (int i = 0; i < nparams; ++i)
		BindParam(i+1,param[i]);
	param.Clear();
	// Make sure that compiling the statement never fails.
	ASSERT(NULL != current_stmt);
	int retcode;
	dword ticks_start = GetTickCount();
	int sleep_ms = 1;
	do{
		retcode = sqlite3_step(current_stmt);
		if(retcode!=SQLITE_BUSY && retcode!=SQLITE_LOCKED) break;
		if(session.busy_timeout == 0) break;
		if(session.busy_timeout>0){
			if((int)(GetTickCount()-ticks_start)>session.busy_timeout){
				break;
			}
		}//else infinite retry
		if(retcode==SQLITE_LOCKED) sqlite3_reset(current_stmt);
		Sleep(sleep_ms);
		if(sleep_ms<128) sleep_ms += sleep_ms;
	}while(1);
	if ((retcode != SQLITE_DONE) && (retcode != SQLITE_ROW)) {
		session.SetError(sqlite3_errmsg(db), current_stmt_string);
		return false;
	}
	got_first_row = got_row_data = (retcode==SQLITE_ROW);
//	if (got_row_data) { // By WebChaot, 2009-01-15
		int numfields = sqlite3_column_count(current_stmt);
		info.SetCount(numfields);
		for (int i = 0; i < numfields; ++i) {
			SqlColumnInfo& field = info[i];
			field.name = sqlite3_column_name(current_stmt,i);
			field.binary = false;
			String coltype = sqlite3_column_decltype(current_stmt,i);
			switch (sqlite3_column_type(current_stmt,i)) {
				case SQLITE_INTEGER:
					field.type = INT_V;
					break;
				case SQLITE_FLOAT:
					field.type = DOUBLE_V;
					break;
				case SQLITE_TEXT:
					if(coltype == "date")
						field.type = DATE_V;
					else
					if(coltype == "datetime")
						field.type = TIME_V;
					else
						field.type = WSTRING_V;
					break;
				case SQLITE_NULL:
					if(coltype == "date")
						field.type = DATE_V;
					else
					if(coltype == "datetime")
						field.type = TIME_V;
					else
					if(coltype.Find("char") >= 0 || coltype.Find("text") >= 0 )
						field.type = WSTRING_V;
					else
					if(coltype.Find("integer") >= 0)
						field.type = INT_V;
					else
					if(coltype.Find("real") >= 0)
						field.type = DOUBLE_V;
					else
						field.type = VOID_V;
					break;
				case SQLITE_BLOB:
					field.type = STRING_V;
					field.binary = true;
					break;
				default:
					NEVER();
					break;
			}
		}
//	}
	return true;
}
Beispiel #19
0
bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch)
{
    int res;
    int i;

    if (skipRow) {
        // already fetched
        Q_ASSERT(!initialFetch);
        skipRow = false;
        for(int i=0;i<firstRow.count();i++)
            values[i]=firstRow[i];
        return skippedStatus;
    }
    skipRow = initialFetch;

    if(initialFetch) {
        firstRow.clear();
        firstRow.resize(sqlite3_column_count(stmt));
    }

    if (!stmt) {
        q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"),
                                  QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError));
        q->setAt(QSql::AfterLastRow);
        return false;
    }
    res = sqlite3_step(stmt);

    switch(res) {
    case SQLITE_ROW:
        // check to see if should fill out columns
        if (rInf.isEmpty())
            // must be first call.
            initColumns(false);
        if (idx < 0 && !initialFetch)
            return true;
        for (i = 0; i < rInf.count(); ++i) {
            switch (sqlite3_column_type(stmt, i)) {
            case SQLITE_BLOB:
                values[i + idx] = QByteArray(static_cast<const char *>(
                            sqlite3_column_blob(stmt, i)),
                            sqlite3_column_bytes(stmt, i));
                break;
            case SQLITE_INTEGER:
                values[i + idx] = sqlite3_column_int64(stmt, i);
                break;
            case SQLITE_FLOAT:
                switch(q->numericalPrecisionPolicy()) {
                    case QSql::LowPrecisionInt32:
                        values[i + idx] = sqlite3_column_int(stmt, i);
                        break;
                    case QSql::LowPrecisionInt64:
                        values[i + idx] = sqlite3_column_int64(stmt, i);
                        break;
                    case QSql::LowPrecisionDouble:
                    case QSql::HighPrecision:
                    default:
                        values[i + idx] = sqlite3_column_double(stmt, i);
                        break;
                };
                break;
            case SQLITE_NULL:
                values[i + idx] = QVariant(QVariant::String);
                break;
            default:
                values[i + idx] = QString(reinterpret_cast<const QChar *>(
                            sqlite3_column_text16(stmt, i)),
                            sqlite3_column_bytes16(stmt, i) / sizeof(QChar));
                break;
            }
        }
        return true;
    case SQLITE_DONE:
        if (rInf.isEmpty())
            // must be first call.
            initColumns(true);
        q->setAt(QSql::AfterLastRow);
        sqlite3_reset(stmt);
        return false;
    case SQLITE_CONSTRAINT:
    case SQLITE_ERROR:
        // SQLITE_ERROR is a generic error code and we must call sqlite3_reset()
        // to get the specific error message.
        res = sqlite3_reset(stmt);
        q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
                        "Unable to fetch row"), QSqlError::ConnectionError, res));
        q->setAt(QSql::AfterLastRow);
        return false;
    case SQLITE_MISUSE:
    case SQLITE_BUSY:
    default:
        // something wrong, don't get col info, but still return false
        q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
                        "Unable to fetch row"), QSqlError::ConnectionError, res));
        sqlite3_reset(stmt);
        q->setAt(QSql::AfterLastRow);
        return false;
    }
    return false;
}
Beispiel #20
0
void Sqlite3Connection::Reset()
{
	if(current_stmt && sqlite3_reset(current_stmt) != SQLITE_OK)
		session.SetError(sqlite3_errmsg(db), "Resetting statement: " + current_stmt_string);
}
Beispiel #21
0
int main(int argc, char **argv){
  sqlite3_int64 iBegin;        /* Start time of this program */
  int quietFlag = 0;           /* True if --quiet or -q */
  int verboseFlag = 0;         /* True if --verbose or -v */
  char *zInsSql = 0;           /* SQL statement for --load-db or --load-sql */
  int iFirstInsArg = 0;        /* First argv[] to use for --load-db or --load-sql */
  sqlite3 *db = 0;             /* The open database connection */
  sqlite3_stmt *pStmt;         /* A prepared statement */
  int rc;                      /* Result code from SQLite interface calls */
  Blob *pSql;                  /* For looping over SQL scripts */
  Blob *pDb;                   /* For looping over template databases */
  int i;                       /* Loop index for the argv[] loop */
  int onlySqlid = -1;          /* --sqlid */
  int onlyDbid = -1;           /* --dbid */
  int nativeFlag = 0;          /* --native-vfs */
  int rebuildFlag = 0;         /* --rebuild */
  int vdbeLimitFlag = 0;       /* --limit-vdbe */
  int timeoutTest = 0;         /* undocumented --timeout-test flag */
  int runFlags = 0;            /* Flags sent to runSql() */
  char *zMsg = 0;              /* Add this message */
  int nSrcDb = 0;              /* Number of source databases */
  char **azSrcDb = 0;          /* Array of source database names */
  int iSrcDb;                  /* Loop over all source databases */
  int nTest = 0;               /* Total number of tests performed */
  char *zDbName = "";          /* Appreviated name of a source database */
  const char *zFailCode = 0;   /* Value of the TEST_FAILURE environment variable */
  int cellSzCkFlag = 0;        /* --cell-size-check */
  int sqlFuzz = 0;             /* True for SQL fuzz testing. False for DB fuzz */
  int iTimeout = 120;          /* Default 120-second timeout */
  int nMem = 0;                /* Memory limit */
  char *zExpDb = 0;            /* Write Databases to files in this directory */
  char *zExpSql = 0;           /* Write SQL to files in this directory */

  iBegin = timeOfDay();
#ifdef __unix__
  signal(SIGALRM, timeoutHandler);
#endif
  g.zArgv0 = argv[0];
  zFailCode = getenv("TEST_FAILURE");
  for(i=1; i<argc; i++){
    const char *z = argv[i];
    if( z[0]=='-' ){
      z++;
      if( z[0]=='-' ) z++;
      if( strcmp(z,"cell-size-check")==0 ){
        cellSzCkFlag = 1;
      }else
      if( strcmp(z,"dbid")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        onlyDbid = integerValue(argv[++i]);
      }else
      if( strcmp(z,"export-db")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        zExpDb = argv[++i];
      }else
      if( strcmp(z,"export-sql")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        zExpSql = argv[++i];
      }else
      if( strcmp(z,"help")==0 ){
        showHelp();
        return 0;
      }else
      if( strcmp(z,"limit-mem")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        nMem = integerValue(argv[++i]);
      }else
      if( strcmp(z,"limit-vdbe")==0 ){
        vdbeLimitFlag = 1;
      }else
      if( strcmp(z,"load-sql")==0 ){
        zInsSql = "INSERT INTO xsql(sqltext) VALUES(CAST(readfile(?1) AS text))";
        iFirstInsArg = i+1;
        break;
      }else
      if( strcmp(z,"load-db")==0 ){
        zInsSql = "INSERT INTO db(dbcontent) VALUES(readfile(?1))";
        iFirstInsArg = i+1;
        break;
      }else
      if( strcmp(z,"m")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        zMsg = argv[++i];
      }else
      if( strcmp(z,"native-vfs")==0 ){
        nativeFlag = 1;
      }else
      if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){
        quietFlag = 1;
        verboseFlag = 0;
      }else
      if( strcmp(z,"rebuild")==0 ){
        rebuildFlag = 1;
      }else
      if( strcmp(z,"result-trace")==0 ){
        runFlags |= SQL_OUTPUT;
      }else
      if( strcmp(z,"sqlid")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        onlySqlid = integerValue(argv[++i]);
      }else
      if( strcmp(z,"timeout")==0 ){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        iTimeout = integerValue(argv[++i]);
      }else
      if( strcmp(z,"timeout-test")==0 ){
        timeoutTest = 1;
#ifndef __unix__
        fatalError("timeout is not available on non-unix systems");
#endif
      }else
      if( strcmp(z,"verbose")==0 || strcmp(z,"v")==0 ){
        quietFlag = 0;
        verboseFlag = 1;
        runFlags |= SQL_TRACE;
      }else
      {
        fatalError("unknown option: %s", argv[i]);
      }
    }else{
      nSrcDb++;
      azSrcDb = safe_realloc(azSrcDb, nSrcDb*sizeof(azSrcDb[0]));
      azSrcDb[nSrcDb-1] = argv[i];
    }
  }
  if( nSrcDb==0 ) fatalError("no source database specified");
  if( nSrcDb>1 ){
    if( zMsg ){
      fatalError("cannot change the description of more than one database");
    }
    if( zInsSql ){
      fatalError("cannot import into more than one database");
    }
  }

  /* Process each source database separately */
  for(iSrcDb=0; iSrcDb<nSrcDb; iSrcDb++){
    rc = sqlite3_open(azSrcDb[iSrcDb], &db);
    if( rc ){
      fatalError("cannot open source database %s - %s",
      azSrcDb[iSrcDb], sqlite3_errmsg(db));
    }
    rc = sqlite3_exec(db,
       "CREATE TABLE IF NOT EXISTS db(\n"
       "  dbid INTEGER PRIMARY KEY, -- database id\n"
       "  dbcontent BLOB            -- database disk file image\n"
       ");\n"
       "CREATE TABLE IF NOT EXISTS xsql(\n"
       "  sqlid INTEGER PRIMARY KEY,   -- SQL script id\n"
       "  sqltext TEXT                 -- Text of SQL statements to run\n"
       ");"
       "CREATE TABLE IF NOT EXISTS readme(\n"
       "  msg TEXT -- Human-readable description of this file\n"
       ");", 0, 0, 0);
    if( rc ) fatalError("cannot create schema: %s", sqlite3_errmsg(db));
    if( zMsg ){
      char *zSql;
      zSql = sqlite3_mprintf(
               "DELETE FROM readme; INSERT INTO readme(msg) VALUES(%Q)", zMsg);
      rc = sqlite3_exec(db, zSql, 0, 0, 0);
      sqlite3_free(zSql);
      if( rc ) fatalError("cannot change description: %s", sqlite3_errmsg(db));
    }
    if( zInsSql ){
      sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
                              readfileFunc, 0, 0);
      rc = sqlite3_prepare_v2(db, zInsSql, -1, &pStmt, 0);
      if( rc ) fatalError("cannot prepare statement [%s]: %s",
                          zInsSql, sqlite3_errmsg(db));
      rc = sqlite3_exec(db, "BEGIN", 0, 0, 0);
      if( rc ) fatalError("cannot start a transaction");
      for(i=iFirstInsArg; i<argc; i++){
        sqlite3_bind_text(pStmt, 1, argv[i], -1, SQLITE_STATIC);
        sqlite3_step(pStmt);
        rc = sqlite3_reset(pStmt);
        if( rc ) fatalError("insert failed for %s", argv[i]);
      }
      sqlite3_finalize(pStmt);
      rc = sqlite3_exec(db, "COMMIT", 0, 0, 0);
      if( rc ) fatalError("cannot commit the transaction: %s", sqlite3_errmsg(db));
      rebuild_database(db);
      sqlite3_close(db);
      return 0;
    }
    if( zExpDb!=0 || zExpSql!=0 ){
      sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
                              writefileFunc, 0, 0);
      if( zExpDb!=0 ){
        const char *zExDb = 
          "SELECT writefile(printf('%s/db%06d.db',?1,dbid),dbcontent),"
          "       dbid, printf('%s/db%06d.db',?1,dbid), length(dbcontent)"
          "  FROM db WHERE ?2<0 OR dbid=?2;";
        rc = sqlite3_prepare_v2(db, zExDb, -1, &pStmt, 0);
        if( rc ) fatalError("cannot prepare statement [%s]: %s",
                            zExDb, sqlite3_errmsg(db));
        sqlite3_bind_text64(pStmt, 1, zExpDb, strlen(zExpDb),
                            SQLITE_STATIC, SQLITE_UTF8);
        sqlite3_bind_int(pStmt, 2, onlyDbid);
        while( sqlite3_step(pStmt)==SQLITE_ROW ){
          printf("write db-%d (%d bytes) into %s\n",
             sqlite3_column_int(pStmt,1),
             sqlite3_column_int(pStmt,3),
             sqlite3_column_text(pStmt,2));
        }
        sqlite3_finalize(pStmt);
      }
      if( zExpSql!=0 ){
        const char *zExSql = 
          "SELECT writefile(printf('%s/sql%06d.txt',?1,sqlid),sqltext),"
          "       sqlid, printf('%s/sql%06d.txt',?1,sqlid), length(sqltext)"
          "  FROM xsql WHERE ?2<0 OR sqlid=?2;";
        rc = sqlite3_prepare_v2(db, zExSql, -1, &pStmt, 0);
        if( rc ) fatalError("cannot prepare statement [%s]: %s",
                            zExSql, sqlite3_errmsg(db));
        sqlite3_bind_text64(pStmt, 1, zExpSql, strlen(zExpSql),
                            SQLITE_STATIC, SQLITE_UTF8);
        sqlite3_bind_int(pStmt, 2, onlySqlid);
        while( sqlite3_step(pStmt)==SQLITE_ROW ){
          printf("write sql-%d (%d bytes) into %s\n",
             sqlite3_column_int(pStmt,1),
             sqlite3_column_int(pStmt,3),
             sqlite3_column_text(pStmt,2));
        }
        sqlite3_finalize(pStmt);
      }
      sqlite3_close(db);
      return 0;
    }
  
    /* Load all SQL script content and all initial database images from the
    ** source db
    */
    blobListLoadFromDb(db, "SELECT sqlid, sqltext FROM xsql", onlySqlid,
                           &g.nSql, &g.pFirstSql);
    if( g.nSql==0 ) fatalError("need at least one SQL script");
    blobListLoadFromDb(db, "SELECT dbid, dbcontent FROM db", onlyDbid,
                       &g.nDb, &g.pFirstDb);
    if( g.nDb==0 ){
      g.pFirstDb = safe_realloc(0, sizeof(Blob));
      memset(g.pFirstDb, 0, sizeof(Blob));
      g.pFirstDb->id = 1;
      g.pFirstDb->seq = 0;
      g.nDb = 1;
      sqlFuzz = 1;
    }
  
    /* Print the description, if there is one */
    if( !quietFlag ){
      int i;
      zDbName = azSrcDb[iSrcDb];
      i = strlen(zDbName) - 1;
      while( i>0 && zDbName[i-1]!='/' && zDbName[i-1]!='\\' ){ i--; }
      zDbName += i;
      sqlite3_prepare_v2(db, "SELECT msg FROM readme", -1, &pStmt, 0);
      if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
        printf("%s: %s\n", zDbName, sqlite3_column_text(pStmt,0));
      }
      sqlite3_finalize(pStmt);
    }

    /* Rebuild the database, if requested */
    if( rebuildFlag ){
      if( !quietFlag ){
        printf("%s: rebuilding... ", zDbName);
        fflush(stdout);
      }
      rebuild_database(db);
      if( !quietFlag ) printf("done\n");
    }
  
    /* Close the source database.  Verify that no SQLite memory allocations are
    ** outstanding.
    */
    sqlite3_close(db);
    if( sqlite3_memory_used()>0 ){
      fatalError("SQLite has memory in use before the start of testing");
    }

    /* Limit available memory, if requested */
    if( nMem>0 ){
      void *pHeap;
      sqlite3_shutdown();
      pHeap = malloc(nMem);
      if( pHeap==0 ){
        fatalError("failed to allocate %d bytes of heap memory", nMem);
      }
      sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMem, 128);
    }
  
    /* Register the in-memory virtual filesystem
    */
    formatVfs();
    inmemVfsRegister();
    
    /* Run a test using each SQL script against each database.
    */
    if( !verboseFlag && !quietFlag ) printf("%s:", zDbName);
    for(pSql=g.pFirstSql; pSql; pSql=pSql->pNext){
      for(pDb=g.pFirstDb; pDb; pDb=pDb->pNext){
        int openFlags;
        const char *zVfs = "inmem";
        sqlite3_snprintf(sizeof(g.zTestName), g.zTestName, "sqlid=%d,dbid=%d",
                         pSql->id, pDb->id);
        if( verboseFlag ){
          printf("%s\n", g.zTestName);
          fflush(stdout);
        }else if( !quietFlag ){
          static int prevAmt = -1;
          int idx = pSql->seq*g.nDb + pDb->id - 1;
          int amt = idx*10/(g.nDb*g.nSql);
          if( amt!=prevAmt ){
            printf(" %d%%", amt*10);
            fflush(stdout);
            prevAmt = amt;
          }
        }
        createVFile("main.db", pDb->sz, pDb->a);
        openFlags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
        if( nativeFlag && pDb->sz==0 ){
          openFlags |= SQLITE_OPEN_MEMORY;
          zVfs = 0;
        }
        rc = sqlite3_open_v2("main.db", &db, openFlags, zVfs);
        if( rc ) fatalError("cannot open inmem database");
#ifdef SQLITE_ENABLE_JSON1
        {
          extern int sqlite3_json_init(sqlite3*);
          sqlite3_json_init(db);
        }
#endif
        if( cellSzCkFlag ) runSql(db, "PRAGMA cell_size_check=ON", runFlags);
        setAlarm(iTimeout);
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
        if( sqlFuzz || vdbeLimitFlag ){
          sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag);
        }
#endif
        do{
          runSql(db, (char*)pSql->a, runFlags);
        }while( timeoutTest );
        setAlarm(0);
        sqlite3_close(db);
        if( sqlite3_memory_used()>0 ) fatalError("memory leak");
        reformatVfs();
        nTest++;
        g.zTestName[0] = 0;

        /* Simulate an error if the TEST_FAILURE environment variable is "5".
        ** This is used to verify that automated test script really do spot
        ** errors that occur in this test program.
        */
        if( zFailCode ){
          if( zFailCode[0]=='5' && zFailCode[1]==0 ){
            fatalError("simulated failure");
          }else if( zFailCode[0]!=0 ){
            /* If TEST_FAILURE is something other than 5, just exit the test
            ** early */
            printf("\nExit early due to TEST_FAILURE being set\n");
            iSrcDb = nSrcDb-1;
            goto sourcedb_cleanup;
          }
        }
      }
    }
    if( !quietFlag && !verboseFlag ){
      printf(" 100%% - %d tests\n", g.nDb*g.nSql);
    }
  
    /* Clean up at the end of processing a single source database
    */
  sourcedb_cleanup:
    blobListFree(g.pFirstSql);
    blobListFree(g.pFirstDb);
    reformatVfs();
 
  } /* End loop over all source databases */

  if( !quietFlag ){
    sqlite3_int64 iElapse = timeOfDay() - iBegin;
    printf("fuzzcheck: 0 errors out of %d tests in %d.%03d seconds\n"
           "SQLite %s %s\n",
           nTest, (int)(iElapse/1000), (int)(iElapse%1000),
           sqlite3_libversion(), sqlite3_sourceid());
  }
  free(azSrcDb);
  return 0;
}
Beispiel #22
0
 int statement::reset()
 {
   return sqlite3_reset(stmt_);
 }
Beispiel #23
0
void Statement::reset() {
    assert(impl);
    sqlite3_reset(impl->stmt);
}
static int import(const char *szTableName, const char *szImportFileName, const char *szRecordSeparator)
{
    sqlite3_stmt *pStmt = NULL;
    int nCol;
    int i, j;
    char *zLine;
    char **azCol;
    char *zCommit;
    FILE *pFileIn;
    int lineno = 0;
    int nSep = strlen30(szRecordSeparator);

    if(0 == nSep)
    {
        LOG("Error: non-null separator required for import.");
        return BWLIST_ERROR;
    }

    char *SqlString = sqlite3_mprintf("SELECT * FROM %s", szTableName);
    if(NULL == SqlString)
    {
        LOG("Error: out of memory.");
        return BWLIST_ERROR;
    }
    int nByte = strlen30(SqlString);

    sqlite3_mutex_enter(db_mutex);
    int rc = sqlite3_prepare_v2(db, SqlString, -1, &pStmt, 0);
    sqlite3_free(SqlString);
    SqlString = NULL;
    if( rc )
    {
        sqlite3_finalize(pStmt);
        sqlite3_mutex_leave(db_mutex);
        LOG("Error: %s.", sqlite3_errmsg(db));
        return BWLIST_ERROR;
    }
    sqlite3_mutex_leave(db_mutex);

    nCol = sqlite3_column_count(pStmt);
    sqlite3_finalize(pStmt);
    pStmt = NULL;

    if(0 == nCol)
    {
        return BWLIST_OK; /* no columns, no error */
    }

    SqlString = malloc( nByte + 20 + nCol*2 );
    if(NULL == SqlString)
    {
        LOG("Error: out of memory!.");
        return BWLIST_ERROR;
    }
    sqlite3_snprintf(nByte+20, SqlString, "INSERT INTO %s VALUES(?", szTableName);
    j = strlen30(SqlString);

    for(i = 1; i < nCol; i++)
    {
        SqlString[j++] = ',';
        SqlString[j++] = '?';
    }
    SqlString[j++] = ')';
    SqlString[j] = 0;

    sqlite3_mutex_enter(db_mutex);
    rc = sqlite3_prepare_v2(db, SqlString, -1, &pStmt, 0);
    free(SqlString);
    SqlString = NULL;
    if(rc)
    {
        LOG("Error: %s.", sqlite3_errmsg(db));
        sqlite3_finalize(pStmt);
        sqlite3_mutex_leave(db_mutex);
        return BWLIST_ERROR;
    }
    sqlite3_mutex_leave(db_mutex);
    pFileIn = fopen(szImportFileName, "rb");
    if( pFileIn==0 )
    {
        LOG("Error: cannot open \"%s\".", szImportFileName);
        sqlite3_finalize(pStmt);
        return BWLIST_ERROR;
    }
    azCol = malloc(sizeof(azCol[0])*(nCol+1) );
    if( azCol==0 )
    {
        LOG("Error: out of memory.");
        fclose(pFileIn);
        sqlite3_finalize(pStmt);
        return BWLIST_ERROR;
    }

    sqlite3_mutex_enter(db_mutex);
    //BEGIN IMMEDIATE avoid deadlock
    if (SQLITE_OK != sqlite3_exec(db, "BEGIN IMMEDIATE", 0, 0, 0))
    {
        LOG("BEGIN TRANSACTION Error:%s", sqlite3_errmsg(db));
        fclose(pFileIn);
        sqlite3_mutex_leave(db_mutex);
        sqlite3_finalize(pStmt);
        return BWLIST_ERROR;
    }
    sqlite3_mutex_leave(db_mutex);

    zCommit = "COMMIT";

    while( (zLine = local_getline(pFileIn, 1))!=0 )
    {
        char *z, c;
        int inQuote = 0;
        lineno++;
        azCol[0] = zLine;

        for(i=0, z=zLine; (c = *z)!=0; z++)
        {
            if(c=='"')
            {
                inQuote = !inQuote;
            }
            if(c=='\n')
            {
                lineno++;
            }
            if(!inQuote && c==szRecordSeparator[0] && strncmp(z,szRecordSeparator,nSep)==0)
            {
                *z = 0;
                i++;
                if(i<nCol)
                {
                    azCol[i] = &z[nSep];
                    z += nSep-1;
                }
            }
        } /* end for */

        *z = 0;
        if( i+1!=nCol )
        {
            LOG("Error: %s line %d: expected %d columns of data bud found %d.", szImportFileName, lineno, nCol, i+1);
            zCommit = "ROLLBACK";
            free(zLine);
            rc = 1;
            break; /* from while */
        }

        for(i=0; i<nCol; i++)
        {
            if( azCol[i][0]=='"' )
            {
                int k;
                for(z=azCol[i], j=1, k=0; z[j]; j++)
                {
                    if( z[j]=='"' )
                    {
                        j++;
                        if(z[j]==0)
                        {
                            break;
                        }
                    }
                    z[k++] = z[j];
                }
                z[k] = 0;
            }
            sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);
        }

        sqlite3_mutex_enter(db_mutex);
        sqlite3_step(pStmt);
        rc = sqlite3_reset(pStmt);
        free(zLine);

        //if(rc!=SQLITE_OK)
        //SQLITE_CONSTRAINT: abort due to constraint violation
        if (SQLITE_OK != rc && SQLITE_CONSTRAINT != rc)
        {
            LOG("Error:%s", sqlite3_errmsg(db));
            sqlite3_mutex_leave(db_mutex);
            zCommit = "ROLLBACK";
            rc = 1;
            break; /* from while */
        }
        sqlite3_mutex_leave(db_mutex);
    } /* end while */

    free(azCol);
    fclose(pFileIn);
    sqlite3_finalize(pStmt);
    if (sqlite3_exec(db, zCommit, 0, 0, 0) != SQLITE_OK)
    {
        return BWLIST_ERROR;
    }
    if (strcmp(zCommit, "COMMIT") == 0)
    {
        return BWLIST_OK;
    }
    else
    {
        return BWLIST_ERROR;
    }
}
Beispiel #25
0
static
int OGR2SQLITEDealWithSpatialColumn(OGRLayer* poLayer,
                                    int iGeomCol,
                                    const LayerDesc& oLayerDesc,
                                    const CPLString& osTableName,
                                    OGRSQLiteDataSource* poSQLiteDS,
                                    sqlite3* hDB,
                                    int bSpatialiteDB,
                                    const std::set<LayerDesc>&
                                        WHEN_SPATIALITE(oSetLayers),
                                    const std::set<CPLString>&
                                        WHEN_SPATIALITE(oSetSpatialIndex)
                                   )
{
    OGRGeomFieldDefn* poGeomField =
        poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeomCol);
    CPLString osGeomColRaw;
    if( iGeomCol == 0 )
        osGeomColRaw = OGR2SQLITE_GetNameForGeometryColumn(poLayer);
    else
        osGeomColRaw = poGeomField->GetNameRef();
    const char* pszGeomColRaw = osGeomColRaw.c_str();

    CPLString osGeomColEscaped(OGRSQLiteEscape(pszGeomColRaw));
    const char* pszGeomColEscaped = osGeomColEscaped.c_str();

    CPLString osLayerNameEscaped(OGRSQLiteEscape(osTableName));
    const char* pszLayerNameEscaped = osLayerNameEscaped.c_str();

    CPLString osIdxNameRaw(CPLSPrintf("idx_%s_%s",
                    oLayerDesc.osLayerName.c_str(), pszGeomColRaw));
    CPLString osIdxNameEscaped(OGRSQLiteEscapeName(osIdxNameRaw));

    /* Make sure that the SRS is injected in spatial_ref_sys */
    OGRSpatialReference* poSRS = poGeomField->GetSpatialRef();
    if( iGeomCol == 0 && poSRS == NULL )
        poSRS = poLayer->GetSpatialRef();
    int nSRSId = poSQLiteDS->GetUndefinedSRID();
    if( poSRS != NULL )
        nSRSId = poSQLiteDS->FetchSRSId(poSRS);

    CPLString osSQL;
#ifdef HAVE_SPATIALITE
    bool bCreateSpatialIndex = false;
#endif
    if( !bSpatialiteDB )
    {
        osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
                    "f_geometry_column, geometry_format, geometry_type, "
                    "coord_dimension, srid) "
                    "VALUES ('%s','%s','SpatiaLite',%d,%d,%d)",
                    pszLayerNameEscaped,
                    pszGeomColEscaped,
                        (int) wkbFlatten(poLayer->GetGeomType()),
                    wkbHasZ( poLayer->GetGeomType() ) ? 3 : 2,
                    nSRSId);
    }
#ifdef HAVE_SPATIALITE
    else
    {
        /* We detect the need for creating a spatial index by 2 means : */

        /* 1) if there's an explicit reference to a 'idx_layername_geometrycolumn' */
        /*   table in the SQL --> old/traditionnal way of requesting spatial indices */
        /*   with spatialite. */

        std::set<LayerDesc>::const_iterator oIter2 = oSetLayers.begin();
        for(; oIter2 != oSetLayers.end(); ++oIter2)
        {
            const LayerDesc& oLayerDescIter = *oIter2;
            if( EQUAL(oLayerDescIter.osLayerName, osIdxNameRaw) )
            {
                    bCreateSpatialIndex = true;
                    break;
            }
        }

        /* 2) or if there's a SELECT FROM SpatialIndex WHERE f_table_name = 'layername' */
        if( !bCreateSpatialIndex )
        {
            std::set<CPLString>::const_iterator oIter3 = oSetSpatialIndex.begin();
            for(; oIter3 != oSetSpatialIndex.end(); ++oIter3)
            {
                const CPLString& osNameIter = *oIter3;
                if( EQUAL(osNameIter, oLayerDesc.osLayerName) )
                {
                    bCreateSpatialIndex = true;
                    break;
                }
            }
        }

        if( poSQLiteDS->HasSpatialite4Layout() )
        {
            int nGeomType = poLayer->GetGeomType();
            int nCoordDimension = 2;
            if( wkbHasZ((OGRwkbGeometryType)nGeomType) )
            {
                nGeomType += 1000;
                nCoordDimension = 3;
            }

            osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
                        "f_geometry_column, geometry_type, coord_dimension, "
                        "srid, spatial_index_enabled) "
                        "VALUES ('%s',Lower('%s'),%d ,%d ,%d, %d)",
                        pszLayerNameEscaped,
                        pszGeomColEscaped, nGeomType,
                        nCoordDimension,
                        nSRSId, bCreateSpatialIndex );
        }
        else
        {
            const char *pszGeometryType = OGRToOGCGeomType(poLayer->GetGeomType());
            if (pszGeometryType[0] == '\0')
                pszGeometryType = "GEOMETRY";

            osSQL.Printf("INSERT INTO geometry_columns (f_table_name, "
                        "f_geometry_column, type, coord_dimension, "
                        "srid, spatial_index_enabled) "
                        "VALUES ('%s','%s','%s','%s',%d, %d)",
                        pszLayerNameEscaped,
                        pszGeomColEscaped, pszGeometryType,
                        wkbHasZ( poLayer->GetGeomType() ) ? "XYZ" : "XY",
                        nSRSId, bCreateSpatialIndex );
        }
    }
#endif // HAVE_SPATIALITE
    int rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );

#ifdef HAVE_SPATIALITE
/* -------------------------------------------------------------------- */
/*      Should we create a spatial index ?.                             */
/* -------------------------------------------------------------------- */
    if( !bSpatialiteDB || !bCreateSpatialIndex )
        return rc == SQLITE_OK;

    CPLDebug("SQLITE", "Create spatial index %s", osIdxNameRaw.c_str());

    /* ENABLE_VIRTUAL_OGR_SPATIAL_INDEX is not defined */
#ifdef ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
    osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING "
                    "VirtualOGRSpatialIndex(%d, '%s', pkid, xmin, xmax, ymin, ymax)",
                    osIdxNameEscaped.c_str(),
                    nExtraDS,
                    OGRSQLiteEscape(oLayerDesc.osLayerName).c_str());

    rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );
    if( rc != SQLITE_OK )
    {
        CPLDebug("SQLITE",
                    "Error occured during spatial index creation : %s",
                    sqlite3_errmsg(hDB));
    }
#else //  ENABLE_VIRTUAL_OGR_SPATIAL_INDEX
    rc = sqlite3_exec( hDB, "BEGIN", NULL, NULL, NULL );

    osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" "
                    "USING rtree(pkid, xmin, xmax, ymin, ymax)",
                    osIdxNameEscaped.c_str());

    if( rc == SQLITE_OK )
        rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL );

    sqlite3_stmt *hStmt = NULL;
    if( rc == SQLITE_OK )
    {
        const char* pszInsertInto = CPLSPrintf(
            "INSERT INTO \"%s\" (pkid, xmin, xmax, ymin, ymax) "
            "VALUES (?,?,?,?,?)", osIdxNameEscaped.c_str());
        rc = sqlite3_prepare(hDB, pszInsertInto, -1, &hStmt, NULL);
    }

    OGRFeature* poFeature;
    OGREnvelope sEnvelope;
    OGR2SQLITE_IgnoreAllFieldsExceptGeometry(poLayer);
    poLayer->ResetReading();

    while( rc == SQLITE_OK &&
            (poFeature = poLayer->GetNextFeature()) != NULL )
    {
        OGRGeometry* poGeom = poFeature->GetGeometryRef();
        if( poGeom != NULL && !poGeom->IsEmpty() )
        {
            poGeom->getEnvelope(&sEnvelope);
            sqlite3_bind_int64(hStmt, 1,
                                (sqlite3_int64) poFeature->GetFID() );
            sqlite3_bind_double(hStmt, 2, sEnvelope.MinX);
            sqlite3_bind_double(hStmt, 3, sEnvelope.MaxX);
            sqlite3_bind_double(hStmt, 4, sEnvelope.MinY);
            sqlite3_bind_double(hStmt, 5, sEnvelope.MaxY);
            rc = sqlite3_step(hStmt);
            if( rc == SQLITE_OK || rc == SQLITE_DONE )
                rc = sqlite3_reset(hStmt);
        }
        delete poFeature;
    }

    poLayer->SetIgnoredFields(NULL);

    sqlite3_finalize(hStmt);

    if( rc == SQLITE_OK )
        rc = sqlite3_exec( hDB, "COMMIT", NULL, NULL, NULL );
    else
    {
        CPLDebug("SQLITE",
                    "Error occured during spatial index creation : %s",
                    sqlite3_errmsg(hDB));
        rc = sqlite3_exec( hDB, "ROLLBACK", NULL, NULL, NULL );
    }
#endif //  ENABLE_VIRTUAL_OGR_SPATIAL_INDEX

#endif // HAVE_SPATIALITE

    return rc == SQLITE_OK;
}
Beispiel #26
0
bool QgsOracleTableCache::saveToCache( const QString& connName, CacheFlags flags, const QVector<QgsOracleLayerProperty>& layers )
{
  sqlite3* db = _openCacheDatabase();
  if ( !db )
    return false;

  QString tblNameRaw = "oracle_" + connName;
  QString tblName = QgsOracleConn::quotedIdentifier( tblNameRaw );

  // recreate the cache table

  if ( !_removeFromCache( db, connName ) )
  {
    sqlite3_close( db );
    return false;
  }

  QString sqlCreateTable = QString( "CREATE TABLE %1 (ownername text, tablename text, geometrycolname text, isview int, sql text, pkcols text, geomtypes text, geomsrids text)" ).arg( tblName );
  QString sqlInsertToMeta = QString( "INSERT INTO meta_oracle VALUES (%1, %2)" ).arg( QgsOracleConn::quotedValue( connName ) ).arg(( int ) flags );

  bool res1 = _executeSqliteStatement( db, sqlCreateTable );
  bool res2 = _executeSqliteStatement( db, sqlInsertToMeta );
  if ( !res1 || !res2 )
  {
    sqlite3_close( db );
    return false;
  }

  // insert data

  _executeSqliteStatement( db, "BEGIN" );

  QString sqlInsert = QString( "INSERT INTO %1 VALUES(?,?,?,?,?,?,?,?)" ).arg( tblName );
  sqlite3_stmt* stmtInsert;
  if ( sqlite3_prepare_v2( db, sqlInsert.toUtf8().data(), -1, &stmtInsert, 0 ) != SQLITE_OK )
  {
    sqlite3_close( db );
    return false;
  }

  bool insertOk = true;
  Q_FOREACH ( const QgsOracleLayerProperty& item, layers )
  {
    sqlite3_bind_text( stmtInsert, 1, item.ownerName.toUtf8().data(), -1, SQLITE_TRANSIENT );
    sqlite3_bind_text( stmtInsert, 2, item.tableName.toUtf8().data(), -1, SQLITE_TRANSIENT );
    sqlite3_bind_text( stmtInsert, 3, item.geometryColName.toUtf8().data(), -1, SQLITE_TRANSIENT );
    sqlite3_bind_int( stmtInsert, 4, item.isView );
    sqlite3_bind_text( stmtInsert, 5, item.sql.toUtf8().data(), -1, SQLITE_TRANSIENT );

    sqlite3_bind_text( stmtInsert, 6, item.pkCols.join( "," ).toUtf8().data(), -1, SQLITE_TRANSIENT );

    QStringList geomTypes;
    Q_FOREACH ( QGis::WkbType geomType, item.types )
      geomTypes.append( QString::number( static_cast<ulong>( geomType ) ) );
    sqlite3_bind_text( stmtInsert, 7, geomTypes.join( "," ).toUtf8().data(), -1, SQLITE_TRANSIENT );

    QStringList geomSrids;
    Q_FOREACH ( int geomSrid, item.srids )
      geomSrids.append( QString::number( geomSrid ) );
    sqlite3_bind_text( stmtInsert, 8, geomSrids.join( "," ).toUtf8().data(), -1, SQLITE_TRANSIENT );

    if ( sqlite3_step( stmtInsert ) != SQLITE_DONE )
      insertOk = false;

    sqlite3_reset( stmtInsert );
  }
/*
 * TOUCHATAG_SQLITE3_ADD                            
 dato un tag e un azione, se il tag non è nel db lo mette nel db con l'azione voluta e ritorna 1. altrimenti non fa niente e ritorna 0; se errore -1
*/
int
touchatag_sqlite3_add (tag_t *tag, char *act)
{
	sqlite3_stmt *pStmt;   
	sqlite3 *database;
	int rc, rf, i = 0;
	char *pa = act;	
	
	uid[14]='\0';
	data[96]='\0';

	if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){
		printf ("Error sqlite3_open ()\n");
		return -1;
	}
	
	touchatag_sconvert (tag, uid, data);

	if ((rf = touchatag_taglist_sqlite3_search (tag)) == -1){
		printf ("Error touchatag_taglist_sqlite3_search ()\n");
		sqlite3_close (database);
		return -1;
	}
	if (rf == 0) {
		if ((rc = sqlite3_prepare_v2 (database, "INSERT INTO tag VALUES (?,?,?,0,NULL)", -1, &pStmt, NULL)) != SQLITE_OK){
			printf ("Error sqlite3_prepare_v2 ()\n");
			sqlite3_close (database);
			return -1;
		}
		if ((rc = sqlite3_bind_text (pStmt, 1, (const char*) uid, -1, NULL)) != SQLITE_OK){
			printf ("Error sqlite3_bind_text () #1\n");
			sqlite3_close (database);
			return -1;
		}
		if ((rc = sqlite3_bind_text (pStmt, 2, (const char*) data, -1, NULL)) != SQLITE_OK){
			printf ("Error sqlite3_bind_text () #2\n");
			sqlite3_close (database);
			return -1;
		}
		if ((rc = sqlite3_bind_text (pStmt, 3, (const char*) pa, -1, NULL)) != SQLITE_OK){         
			printf ("Error sqlite3_bind_text () #3\n");
			sqlite3_close (database);
			return -1;
		}		
	}
	if (rf == 1) {
		sqlite3_close (database); 
		return 0;
	}
	if ((rc = sqlite3_step (pStmt)) != SQLITE_DONE){
		printf ("Error sqlite3_step ()\n");
		sqlite3_close (database);
		return -1;
	}
	
	i = sqlite3_clear_bindings (pStmt); 
		
	if ((rc = sqlite3_reset (pStmt))!= SQLITE_OK){
		printf ("Errore sqlite3_reset ()\n");
		sqlite3_close (database);
		return -1;
	}
	sqlite3_close (database); 
	return 1;
}
Beispiel #28
0
void SQLiteHandler::select(char* sql) {
	pStmt = NULL;
	sqlite3_prepare_v2(db, sql, strlen(sql), &pStmt, NULL);
	sqlite3_reset(pStmt);
}
/*!
 * Saves for each photon all the data, except previous and next photon identifier.
 */
void PhotonMapExportDB::SaveNotNextPrevID( std::vector< Photon* > raysLists )
{

	const char* tail = 0;
	sqlite3_stmt* stmt;
	char insertSQL[256] ="\0";
	sprintf( insertSQL, "INSERT INTO Photons VALUES( @id, @x, @y, @z, @side, @surfaceID )" );
	sqlite3_prepare( m_pDB, insertSQL, 256, &stmt, &tail );

	char* sErrMsg = 0;
	sqlite3_exec( m_pDB, "BEGIN TRANSACTION", 0, 0, &sErrMsg );

	unsigned long nPhotonElements = raysLists.size();

	if( m_saveCoordinatesInGlobal )
	{

		for( unsigned int i = 0; i < nPhotonElements; i++ )
		{
			Photon* photon = raysLists[i];


			sqlite3_bind_text( stmt, 1, QString::number(++m_exportedPhoton ).toStdString().c_str(), -1, SQLITE_TRANSIENT );

			//m_saveCoordinates
			Point3D photonPos =  m_concentratorToWorld( photon->pos );
			sqlite3_bind_text( stmt, 2, QString::number( photonPos.x ).toStdString().c_str(), -1, SQLITE_TRANSIENT );
			sqlite3_bind_text( stmt, 3, QString::number( photonPos.y ).toStdString().c_str(), -1, SQLITE_TRANSIENT );
			sqlite3_bind_text( stmt, 4, QString::number( photonPos.z ).toStdString().c_str(), -1, SQLITE_TRANSIENT );

			//m_saveSide
			sqlite3_bind_text( stmt, 5, QString::number( photon->side ).toStdString().c_str(), -1, SQLITE_TRANSIENT );

			//m_saveSurfaceID
			unsigned long urlId = 0;
			if( photon->intersectedSurface )
			{
				if( !m_surfaceIdentfier.contains( photon->intersectedSurface ) )
					InsertSurface( photon->intersectedSurface );

				urlId = m_surfaceIdentfier.indexOf( photon->intersectedSurface ) + 1;

			}
			sqlite3_bind_text( stmt, 6, QString::number( urlId ).toStdString().c_str(), -1, SQLITE_TRANSIENT );


			sqlite3_step( stmt );
			sqlite3_clear_bindings( stmt );
			sqlite3_reset( stmt );
		}
	}
	else
	{
		for( unsigned int i = 0; i < nPhotonElements; i++ )
		{
			std::stringstream ss;
			Photon* photon = raysLists[i];

			unsigned long urlId = 0;
			Transform worldToObject( 1.0, 0.0, 0.0, 0.0,
					0.0, 1.0, 0.0, 0.0,
					0.0, 0.0, 1.0, 0.0,
					0.0, 0.0, 0.0, 1.0 );
			if( photon->intersectedSurface )
			{

				if( !m_surfaceIdentfier.contains( photon->intersectedSurface ) )
					InsertSurface( photon->intersectedSurface );

				urlId = m_surfaceIdentfier.indexOf( photon->intersectedSurface ) ;
				worldToObject = m_surfaceWorldToObject[urlId];
				urlId++;
			}

			sqlite3_bind_text( stmt, 1, QString::number(++m_exportedPhoton ).toStdString().c_str(), -1, SQLITE_TRANSIENT );

			//m_saveCoordinates
			Point3D localPos = worldToObject( photon->pos );
			sqlite3_bind_text( stmt, 2, QString::number( localPos.x ).toStdString().c_str(), -1, SQLITE_TRANSIENT );
			sqlite3_bind_text( stmt, 3, QString::number( localPos.y ).toStdString().c_str(), -1, SQLITE_TRANSIENT );
			sqlite3_bind_text( stmt, 4, QString::number( localPos.z ).toStdString().c_str(), -1, SQLITE_TRANSIENT );

			//m_saveSide
			sqlite3_bind_text( stmt, 5, QString::number( photon->side ).toStdString().c_str(), -1, SQLITE_TRANSIENT );

			//m_saveSurfaceID
			sqlite3_bind_text( stmt, 6, QString::number( urlId ).toStdString().c_str(), -1, SQLITE_TRANSIENT );


			sqlite3_step( stmt );
			sqlite3_clear_bindings( stmt );
			sqlite3_reset( stmt );


		}
	}
	int rc = sqlite3_exec( m_pDB, "END TRANSACTION", 0, 0, &sErrMsg );

	sqlite3_finalize( stmt );
	if( rc != SQLITE_OK )
	{
		std::cout<< "SQL error: "<<sErrMsg<<"\n"<<std::endl;
		sqlite3_free( sErrMsg );
	}
}
Beispiel #30
0
void resetParameter(DbAction *db)
{
	if (db -> statement[0] != 0)
	sqlite3_reset(db -> sqlStatement);
	//sqlite3_clear_bindings(db -> sqlStatement);
}