int PinnedMediaDBManager::getSchemaVersion(u64& version)
{
    int rv = 0;
    int rc;
    int sql_type;
    static const char* SQL_GET_SCHEMA_VERSION_FROM_DB_ATTR =
            "SELECT id, value "
            "FROM db_attr "
            "WHERE id="XSTR(KEY_SCHEMA_VERSION);
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_GET_SCHEMA_VERSION_FROM_DB_ATTR, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_GET_SCHEMA_VERSION_FROM_DB_ATTR, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);
    CHECK_ROW_EXIST(rv, rc, m_db, end);

    sql_type = sqlite3_column_type(stmt, 1);
    if (sql_type == SQLITE_INTEGER) {
        version = sqlite3_column_int64(stmt, 1);
    } else {
        LOG_WARN("Bad column type index: %d", 1);
        rv = -1;
        goto end;
    }

end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
int PinnedMediaDBManager::insertPinnedMediaItem(const std::string& path, const std::string& object_id, u64 device_id)
{
    int rv = 0;
    int rc;
    static const char* SQL_UPDATE_PINNED_MEDIA_ITEM =
            "INSERT OR REPLACE INTO pin_item (path,"
                                             "object_id,"
                                             "device_id) "
            "VALUES (?,?,?)";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_UPDATE_PINNED_MEDIA_ITEM, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_UPDATE_PINNED_MEDIA_ITEM, m_db, end);

    rc = sqlite3_bind_text(stmt, 1, path.c_str(), -1, SQLITE_STATIC);
    CHECK_BIND(rv, rc, m_db, end);

    rc = sqlite3_bind_text(stmt, 2, object_id.c_str(), -1, SQLITE_STATIC);
    CHECK_BIND(rv, rc, m_db, end);

    rc = sqlite3_bind_int64(stmt, 3, device_id);
    CHECK_BIND(rv, rc, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);

end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
Пример #3
0
bool loadBuddies(SkypePlugin *np, const std::string &db_path, std::string &user, std::map<std::string, std::string> &group_map) {
	bool ret = false;
	sqlite3 *db;
	LOG4CXX_INFO(logger, "Opening database " << db_path);
	if (sqlite3_open(db_path.c_str(), &db)) {
		sqlite3_close(db);
		LOG4CXX_ERROR(logger, "Can't open database");
	}
	else {
		sqlite3_stmt *stmt;
// 		aliases, fullname, 
		PREP_STMT(stmt, "select skypename, displayname, mood_text from Contacts;");
		if (stmt) {
			BEGIN(stmt);
			int ret2;
			while((ret2 = sqlite3_step(stmt)) == SQLITE_ROW) {
				const char *d;
				d = (const char *) sqlite3_column_text(stmt, 0);
				if (!d) {
					continue;
				}

				ret = true;

				std::string buddy = d;
				d = (const char *) sqlite3_column_text(stmt, 1);
				std::string alias = d ? d : buddy;
				d = (const char *) sqlite3_column_text(stmt, 2);
				std::string mood_text = d ? d : "";

				std::vector<std::string> groups;
				if (group_map.find(buddy) != group_map.end()) {
					groups.push_back(group_map[buddy]);
				}
				np->handleBuddyChanged(user, buddy, alias, groups, pbnetwork::STATUS_NONE, mood_text);
			}
			if (ret2 != SQLITE_DONE) {
				FINALIZE_STMT(stmt);
				ret = false;
			}
		}
		else {
			LOG4CXX_ERROR(logger, "Can't create prepared statement");
			LOG4CXX_ERROR(logger, (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db)));
		}
		sqlite3_close(db);
	}
	return ret;
}
Пример #4
0
SQLite3Backend::~SQLite3Backend(){
	if (m_db) {
		// Would be nice to use this:
		//
		//   sqlite3_stmt *pStmt;
		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {
		//    sqlite3_finalize(pStmt);
		//   }
		//
		// But requires SQLite3 >= 3.6.0 beta
	
		FINALIZE_STMT(m_setUser);
		sqlite3_close(m_db);
	}
}
Пример #5
0
void DB::loadNetworks()
{
	int res;
	sqlite3_stmt * stmt;
	PREPARE_STMT(stmt, "network loading",
		"SELECT * FROM \"network\" ORDER BY \"id\" ASC");

	while ((res = sqlite3_step(stmt)) == SQLITE_ROW) {
		Network net;
		net.id = sqlite3_column_int(stmt, 0);
		net.name = (const char *) sqlite3_column_text(stmt, 1);

		networks.push_back(std::move(net));
	}
	FINALIZE_STMT(stmt, "network loading");
}
Пример #6
0
void DB::loadBuffers()
{
	int res;
	sqlite3_stmt * stmt;
	PREPARE_STMT(stmt, "buffer loading",
		"SELECT * FROM buffer ORDER BY id ASC");

	while ((res = sqlite3_step(stmt)) == SQLITE_ROW) {
		Buffer buf;
		buf.id = sqlite3_column_int(stmt, 0);
		buf.networkid = sqlite3_column_int(stmt, 1);
		buf.name = (const char *) sqlite3_column_text(stmt, 2);

		buffers.push_back(std::move(buf));
	}
	FINALIZE_STMT(stmt, "buffer loading");
}
Пример #7
0
void DB::loadSenders()
{
	int res;
	sqlite3_stmt * stmt;
	PREPARE_STMT(stmt, "sender loading",
		"SELECT * FROM \"sender\" ORDER BY \"id\" ASC");

	while ((res = sqlite3_step(stmt)) == SQLITE_ROW) {
		Sender snd;
		snd.id = sqlite3_column_int(stmt, 0);
		snd.nick = (const char *) sqlite3_column_text(stmt, 1);
		snd.user = (const char *) sqlite3_column_text(stmt, 2);
		snd.host = (const char *) sqlite3_column_text(stmt, 3);

		senders.push_back(std::move(snd));
	}
	FINALIZE_STMT(stmt, "sender loading");
}
int PinnedMediaDBManager::commitTransaction()
{
    int rv = 0;
    int rc;
    static const char* SQL_COMMIT = "COMMIT";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_COMMIT, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_COMMIT, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);

 end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
int PinnedMediaDBManager::beginTransaction()
{
    int rv = 0;
    int rc;
    static const char* SQL_BEGIN = "BEGIN IMMEDIATE";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_BEGIN, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_BEGIN, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);

 end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
int PinnedMediaDBManager::deleteAllPinnedMediaItems()
{
    int rv = 0;
    int rc;
    static const char* SQL_DELETE_ALL_PINNED_MEDIA_ITEMS =
            "DELETE FROM pin_item";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_DELETE_ALL_PINNED_MEDIA_ITEMS, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_DELETE_ALL_PINNED_MEDIA_ITEMS, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);

end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
Пример #11
0
bool getAvatar(const std::string &db_path, const std::string &name, std::string &photo) {
	bool ret = false;
	sqlite3 *db;
	LOG4CXX_INFO(logger, "Opening database " << db_path);
	if (sqlite3_open(db_path.c_str(), &db)) {
		sqlite3_close(db);
		LOG4CXX_ERROR(logger, "Can't open database");
	}
	else {
		sqlite3_stmt *stmt;
		PREP_STMT(stmt, "SELECT avatar_image FROM Contacts WHERE skypename=?");
		if (stmt) {
			BEGIN(stmt);
			BIND_STR(stmt, name);
			if(sqlite3_step(stmt) == SQLITE_ROW) {
				int size = sqlite3_column_bytes(stmt, 0);
				if (size > 0) {
				    const void *data = sqlite3_column_blob(stmt, 0);
				    photo = std::string((const char *)data + 1, size - 1);
				    ret = true;
				} else {
				    ret = false;
				}
			}
			else {
				LOG4CXX_ERROR(logger, (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db)));
			}

			int ret;
			while((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
			}
			FINALIZE_STMT(stmt);
		}
		else {
			LOG4CXX_ERROR(logger, "Can't create prepared statement");
			LOG4CXX_ERROR(logger, (sqlite3_errmsg(db) == NULL ? "" : sqlite3_errmsg(db)));
		}
		sqlite3_close(db);
	}
	return ret;
}
Пример #12
0
DB::~DB()
{
	int res;
	try {
		FINALIZE_STMT(stmt_add_message, "message insertion");
		FINALIZE_STMT(stmt_add_buffer, "buffer insertion");
		FINALIZE_STMT(stmt_add_network, "network insertion");
		FINALIZE_STMT(stmt_add_sender, "sender insertion");
		FINALIZE_STMT(stmt_begin, "begin");
		FINALIZE_STMT(stmt_commit, "commit");

		SQLOK(close(dbh), "closing database");
	} catch (std::exception &e) {
		std::cerr << "Failed to close database: " << e.what() << std::endl;
	}
}
int PinnedMediaDBManager::deleteAllRelatedPinnedMediaItems(u64 device_id)
{
    int rv = 0;
    int rc;
    static const char* SQL_DELETE_PINNED_MEDIA_ITEM_BY_DEVICE_ID =
            "DELETE FROM pin_item WHERE device_id=?";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_DELETE_PINNED_MEDIA_ITEM_BY_DEVICE_ID, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_DELETE_PINNED_MEDIA_ITEM_BY_DEVICE_ID, m_db, end);

    rc = sqlite3_bind_int64(stmt, 1, device_id);
    CHECK_BIND(rv, rc, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);

end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
int PinnedMediaDBManager::deletePinnedMediaItem(const std::string& path)
{
    int rv = 0;
    int rc;
    static const char* SQL_DELETE_PINNED_MEDIA_ITEM_BY_PATH =
            "DELETE FROM pin_item WHERE path=?";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_DELETE_PINNED_MEDIA_ITEM_BY_PATH, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_DELETE_PINNED_MEDIA_ITEM_BY_PATH, m_db, end);

    rc = sqlite3_bind_text(stmt, 1, path.c_str(), -1, SQLITE_STATIC);
    CHECK_BIND(rv, rc, m_db, end);

    rc = sqlite3_step(stmt);
    CHECK_STEP(rv, rc, m_db, end);

end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
int PinnedMediaDBManager::selectPinnedMediaItem(const std::string& object_id, u64 device_id, PinnedMediaItem& output_pinned_media_item)
{
    int rv = 0;
    int rc;
    static const char* SQL_SELECT_PINNED_MEDIA_ITEM_BY_OBJECT_ID_AND_DEVICE_ID =
            "SELECT path, object_id, device_id "
            "FROM pin_item "
            "WHERE object_id=? AND device_id=?";
    sqlite3_stmt *stmt = NULL;

    CHECK_DB_HANDLE(rv, m_db, end);

    rc = sqlite3_prepare_v2(m_db, SQL_SELECT_PINNED_MEDIA_ITEM_BY_OBJECT_ID_AND_DEVICE_ID, -1, &stmt, NULL);
    CHECK_PREPARE(rv, rc, SQL_SELECT_PINNED_MEDIA_ITEM_BY_OBJECT_ID_AND_DEVICE_ID, m_db, end);

    rc = sqlite3_bind_text(stmt, 1, object_id.c_str(), -1, SQLITE_STATIC);
    CHECK_BIND(rv, rc, m_db, end);

    rc = sqlite3_bind_int64(stmt, 2, device_id);
    CHECK_BIND(rv, rc, m_db, end);

    {
        std::string path;
        std::string object_id;
        u64 device_id;
        int sql_type;
        rc = sqlite3_step(stmt);
        CHECK_STEP(rv, rc, m_db, end);
        CHECK_ROW_EXIST(rv, rc, m_db, end);

        sql_type = sqlite3_column_type(stmt, 0);
        if (sql_type == SQLITE_TEXT) {
            path = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
        } else {
            LOG_WARN("Bad column type index: %d", 0);
            rv = -1;
            goto end;
        }

        sql_type = sqlite3_column_type(stmt, 1);
        if (sql_type == SQLITE_TEXT) {
            object_id = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
        } else {
            LOG_WARN("Bad column type index: %d", 1);
            rv = -1;
            goto end;
        }

        sql_type = sqlite3_column_type(stmt, 2);
        if (sql_type == SQLITE_INTEGER) {
            device_id = sqlite3_column_int64(stmt, 2);
        } else {
            LOG_WARN("Bad column type index: %d", 2);
            rv = -1;
            goto end;
        }

        output_pinned_media_item.path = path;
        output_pinned_media_item.object_id = object_id;
        output_pinned_media_item.device_id = device_id;
    }

end:
    FINALIZE_STMT(rv, rc, m_db, stmt);
    return rv;
}
Пример #16
0
SQLite3Backend::~SQLite3Backend(){
	if (m_db) {
		// Would be nice to use this:
		//
		//   sqlite3_stmt *pStmt;
		//   while((pStmt = sqlite3_next_stmt(db, 0)) != 0 ) {
		//    sqlite3_finalize(pStmt);
		//   }
		//
		// But requires SQLite3 >= 3.6.0 beta
	
		FINALIZE_STMT(m_setUser);
		FINALIZE_STMT(m_getUser);
		FINALIZE_STMT(m_removeUser);
		FINALIZE_STMT(m_removeUserBuddies);
		FINALIZE_STMT(m_removeUserSettings);
		FINALIZE_STMT(m_removeUserBuddiesSettings);
		FINALIZE_STMT(m_removeBuddy);
		FINALIZE_STMT(m_removeBuddySettings);
		FINALIZE_STMT(m_addBuddy);
		FINALIZE_STMT(m_updateBuddy);
		FINALIZE_STMT(m_getBuddies);
		FINALIZE_STMT(m_getBuddiesSettings);
		FINALIZE_STMT(m_getUserSetting);
		FINALIZE_STMT(m_setUserSetting);
		FINALIZE_STMT(m_updateUserSetting);
		FINALIZE_STMT(m_updateBuddySetting);
		FINALIZE_STMT(m_getBuddySetting);
		FINALIZE_STMT(m_setUserOnline);
		FINALIZE_STMT(m_getOnlineUsers);
		FINALIZE_STMT(m_getAllUsers);
		sqlite3_close(m_db);
	}
}