bool MapDatabaseSQLite3::saveBlock(const v3s16 &pos, const std::string &data)
{
verifyDatabase();
#ifdef __ANDROID__
/**
* Note: For some unknown reason SQLite3 fails to REPLACE blocks on Android,
* deleting them and then inserting works.
*/
bindPos(m_stmt_read, pos);
if (sqlite3_step(m_stmt_read) == SQLITE_ROW) {
deleteBlock(pos);
}
sqlite3_reset(m_stmt_read);
#endif
bindPos(m_stmt_write, pos);
SQLOK(sqlite3_bind_blob(m_stmt_write, 2, data.data(), data.size(), NULL),
"Internal error: failed to bind query at " __FILE__ ":" TOSTRING(__LINE__));
SQLRES(sqlite3_step(m_stmt_write), SQLITE_DONE, "Failed to save block")
sqlite3_reset(m_stmt_write);
return true;
}
void Database_SQLite3::endSave()
{
verifyDatabase();
SQLRES(sqlite3_step(m_stmt_end), SQLITE_DONE,
"Failed to commit SQLite3 transaction");
sqlite3_reset(m_stmt_end);
}
void Database_SQLite3::beginSave()
{
verifyDatabase();
SQLRES(sqlite3_step(m_stmt_begin), SQLITE_DONE,
"Failed to start SQLite3 transaction");
sqlite3_reset(m_stmt_begin);
}
Network * DB::addNetwork(Network &net)
{
int res;
SQLOK(bind_text(stmt_add_network, 1, net.name.data(), net.name.size(),
NULL), "binding network name");
SQLRES(step(stmt_add_network), SQLITE_DONE,
"running network insertion statement");
SQLOK(reset(stmt_add_network),
"reseting network insertion statement");
net.id = sqlite3_last_insert_rowid(dbh);
networks.push_back(net);
return &networks[networks.size() - 1];
}
Buffer * DB::addBuffer(Buffer &buf)
{
int res;
SQLOK(bind_int (stmt_add_buffer, 1, buf.networkid),
"binding buffer networkid");
SQLOK(bind_text(stmt_add_buffer, 2, buf.name.data(), buf.name.size(),
NULL), "binding buffer name");
SQLRES(step(stmt_add_buffer), SQLITE_DONE,
"running buffer insertion statement");
SQLOK(reset(stmt_add_buffer),
"reseting buffer insertion statement");
buf.id = sqlite3_last_insert_rowid(dbh);
buffers.push_back(buf);
return &buffers[buffers.size() - 1];
}
int RollbackManager::getNodeId(const std::string &name)
{
for (std::vector<Entity>::const_iterator iter = knownNodes.begin();
iter != knownNodes.end(); ++iter) {
if (iter->name == name) {
return iter->id;
}
}
SQLOK(sqlite3_bind_text(stmt_knownNode_insert, 1, name.c_str(), name.size(), NULL));
SQLRES(sqlite3_step(stmt_knownNode_insert), SQLITE_DONE);
SQLOK(sqlite3_reset(stmt_knownNode_insert));
int id = sqlite3_last_insert_rowid(db);
registerNewNode(id, name);
return id;
}
void DB::addMessage(Message &msg)
{
int res;
SQLOK(bind_int64(stmt_add_message, 1, msg.time),
"binding message time");
SQLOK(bind_int (stmt_add_message, 2, (int) msg.type),
"binding message type");
SQLOK(bind_int (stmt_add_message, 3, msg.bufferid),
"binding message bufferid");
SQLOK(bind_int (stmt_add_message, 4, msg.senderid),
"binding message senderid");
SQLOK(bind_text (stmt_add_message, 5, msg.text.data(), msg.text.size(),
NULL), "binding message text");
SQLRES(step(stmt_add_message), SQLITE_DONE,
"running message insertion statement");
SQLOK(reset(stmt_add_message),
"reseting message insertion statement");
}
Sender * DB::addSender(Sender &snd)
{
int res;
SQLOK(bind_text(stmt_add_sender, 1, snd.nick.data(), snd.nick.size(),
NULL), "binding sender nick");
SQLOK(bind_text(stmt_add_sender, 2, snd.user.data(), snd.user.size(),
NULL), "binding sender ident");
SQLOK(bind_text(stmt_add_sender, 3, snd.host.data(), snd.host.size(),
NULL), "binding sender host");
SQLRES(step(stmt_add_sender), SQLITE_DONE,
"running sender insertion statement");
SQLOK(reset(stmt_add_sender),
"reseting sender insertion statement");
snd.id = sqlite3_last_insert_rowid(dbh);
senders.push_back(snd);
return &senders[senders.size() - 1];
}
void DB::endSave()
{
int res;
SQLRES(step(stmt_commit), SQLITE_DONE, "running commit statement");
SQLOK(reset(stmt_commit), "reseting commit statement");
}
void DB::beginSave()
{
int res;
SQLRES(step(stmt_begin), SQLITE_DONE, "running begin statement");
SQLOK(reset(stmt_begin), "reseting begin statement");
}
void RollbackManager::migrate(const std::string & file_path)
{
std::cout << "Migrating from rollback.txt to rollback.sqlite." << std::endl;
std::ifstream fh(file_path.c_str(), std::ios::in | std::ios::ate);
if (!fh.good()) {
throw FileNotGoodException("Unable to open rollback.txt");
}
std::streampos file_size = fh.tellg();
if (file_size < 10) {
errorstream << "Empty rollback log." << std::endl;
return;
}
fh.seekg(0);
sqlite3_stmt *stmt_begin;
sqlite3_stmt *stmt_commit;
SQLOK(sqlite3_prepare_v2(db, "BEGIN", -1, &stmt_begin, NULL));
SQLOK(sqlite3_prepare_v2(db, "COMMIT", -1, &stmt_commit, NULL));
std::string bit;
int i = 0;
time_t start = time(0);
time_t t = start;
SQLRES(sqlite3_step(stmt_begin), SQLITE_DONE);
sqlite3_reset(stmt_begin);
do {
ActionRow row;
row.id = 0;
// Get the timestamp
std::getline(fh, bit, ' ');
bit = trim(bit);
if (!atoi(bit.c_str())) {
std::getline(fh, bit);
continue;
}
row.timestamp = atoi(bit.c_str());
// Get the actor
row.actor = getActorId(deSerializeJsonString(fh));
// Get the action type
std::getline(fh, bit, '[');
std::getline(fh, bit, ' ');
if (bit == "modify_inventory_stack") {
row.type = RollbackAction::TYPE_MODIFY_INVENTORY_STACK;
row.location = trim(deSerializeJsonString(fh));
std::getline(fh, bit, ' ');
row.list = trim(deSerializeJsonString(fh));
std::getline(fh, bit, ' ');
std::getline(fh, bit, ' ');
row.index = atoi(trim(bit).c_str());
std::getline(fh, bit, ' ');
row.add = (int)(trim(bit) == "add");
row.stack.deSerialize(deSerializeJsonString(fh));
row.stack.id = getNodeId(row.stack.name);
std::getline(fh, bit);
} else if (bit == "set_node") {
row.type = RollbackAction::TYPE_SET_NODE;
std::getline(fh, bit, '(');
std::getline(fh, bit, ',');
row.x = atoi(trim(bit).c_str());
std::getline(fh, bit, ',');
row.y = atoi(trim(bit).c_str());
std::getline(fh, bit, ')');
row.z = atoi(trim(bit).c_str());
std::getline(fh, bit, ' ');
row.oldNode = getNodeId(trim(deSerializeJsonString(fh)));
std::getline(fh, bit, ' ');
std::getline(fh, bit, ' ');
row.oldParam1 = atoi(trim(bit).c_str());
std::getline(fh, bit, ' ');
row.oldParam2 = atoi(trim(bit).c_str());
row.oldMeta = trim(deSerializeJsonString(fh));
std::getline(fh, bit, ' ');
row.newNode = getNodeId(trim(deSerializeJsonString(fh)));
std::getline(fh, bit, ' ');
std::getline(fh, bit, ' ');
row.newParam1 = atoi(trim(bit).c_str());
std::getline(fh, bit, ' ');
row.newParam2 = atoi(trim(bit).c_str());
row.newMeta = trim(deSerializeJsonString(fh));
std::getline(fh, bit, ' ');
std::getline(fh, bit, ' ');
std::getline(fh, bit);
row.guessed = (int)(trim(bit) == "actor_is_guess");
} else {
errorstream << "Unrecognized rollback action type \""
<< bit << "\"!" << std::endl;
continue;
}
registerRow(row);
++i;
if (time(0) - t >= 1) {
SQLRES(sqlite3_step(stmt_commit), SQLITE_DONE);
sqlite3_reset(stmt_commit);
t = time(0);
std::cout
<< " Done: " << static_cast<int>((static_cast<float>(fh.tellg()) / static_cast<float>(file_size)) * 100) << "%"
<< " Speed: " << i / (t - start) << "/second \r" << std::flush;
SQLRES(sqlite3_step(stmt_begin), SQLITE_DONE);
sqlite3_reset(stmt_begin);
}
} while (fh.good());
SQLRES(sqlite3_step(stmt_commit), SQLITE_DONE);
sqlite3_reset(stmt_commit);
SQLOK(sqlite3_finalize(stmt_begin));
SQLOK(sqlite3_finalize(stmt_commit));
std::cout
<< " Done: 100% " << std::endl
<< "Now you can delete the old rollback.txt file." << std::endl;
}
void Database_SQLite3::endSave() {
verifyDatabase();
SQLRES(sqlite3_step(m_stmt_end), SQLITE_DONE);
sqlite3_reset(m_stmt_end);
}
void Database_SQLite3::beginSave() {
verifyDatabase();
SQLRES(sqlite3_step(m_stmt_begin), SQLITE_DONE);
sqlite3_reset(m_stmt_begin);
}
