0ecdbebb09
Before this change, we've tried to open the database in read/write, but not create mode. In situations where the database didn't exist yet, this logged an error to the console, and we proceeded to opening it again in read/write/create mode, which actually created the file. The reason we did this is so that we could detect really old caching databases from January 2016 in case a developer upgraded from an older SDK (iOS v3.1 and earlier, Android v3.2 and earlier) that didn't have https://github.com/mapbox/mapbox-gl-native/pull/3715 yet. However, these error messages, while innocent, look scary in the console and some users suspect that it's a bug. This change opens the file directly in read/write/create mode, omitting the first failed attempt. To handle old cache databases, we're now deleting the `http_cache` table, which was the only table in those old databases, and create the new schema, rather than deleting the entire file and recreating the Database object. In most scenarios, this will lead to one fewer opening attempt, while the database migration will continue to work for the few users who upgrade all the way from a January 2016 SDK. Additionally, this fixes a mismatch between the Qt and non-Qt implementation: Qt doesn't support opening a file in read/write mode without the create flag. This means that we've seen a different control flow on Qt compared to the non-Qt implementation when opening a database.
118 lines
4.0 KiB
C++
118 lines
4.0 KiB
C++
#pragma once
|
|
|
|
#include <mbgl/storage/resource.hpp>
|
|
#include <mbgl/storage/offline.hpp>
|
|
#include <mbgl/util/exception.hpp>
|
|
#include <mbgl/util/noncopyable.hpp>
|
|
#include <mbgl/util/optional.hpp>
|
|
#include <mbgl/util/constants.hpp>
|
|
#include <mbgl/util/mapbox.hpp>
|
|
|
|
#include <unordered_map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <list>
|
|
|
|
namespace mapbox {
|
|
namespace sqlite {
|
|
class Database;
|
|
class Statement;
|
|
class Query;
|
|
} // namespace sqlite
|
|
} // namespace mapbox
|
|
|
|
namespace mbgl {
|
|
|
|
class Response;
|
|
class TileID;
|
|
|
|
struct MapboxTileLimitExceededException : util::Exception {
|
|
MapboxTileLimitExceededException() : util::Exception("Mapbox tile limit exceeded") {}
|
|
};
|
|
|
|
class OfflineDatabase : private util::noncopyable {
|
|
public:
|
|
// Limits affect ambient caching (put) only; resources required by offline
|
|
// regions are exempt.
|
|
OfflineDatabase(std::string path, uint64_t maximumCacheSize = util::DEFAULT_MAX_CACHE_SIZE);
|
|
~OfflineDatabase();
|
|
|
|
optional<Response> get(const Resource&);
|
|
|
|
// Return value is (inserted, stored size)
|
|
std::pair<bool, uint64_t> put(const Resource&, const Response&);
|
|
|
|
std::vector<OfflineRegion> listRegions();
|
|
|
|
OfflineRegion createRegion(const OfflineRegionDefinition&,
|
|
const OfflineRegionMetadata&);
|
|
|
|
OfflineRegionMetadata updateMetadata(const int64_t regionID, const OfflineRegionMetadata&);
|
|
|
|
void deleteRegion(OfflineRegion&&);
|
|
|
|
// Return value is (response, stored size)
|
|
optional<std::pair<Response, uint64_t>> getRegionResource(int64_t regionID, const Resource&);
|
|
optional<int64_t> hasRegionResource(int64_t regionID, const Resource&);
|
|
uint64_t putRegionResource(int64_t regionID, const Resource&, const Response&);
|
|
void putRegionResources(int64_t regionID, const std::list<std::tuple<Resource, Response>>&, OfflineRegionStatus&);
|
|
|
|
OfflineRegionDefinition getRegionDefinition(int64_t regionID);
|
|
OfflineRegionStatus getRegionCompletedStatus(int64_t regionID);
|
|
|
|
void setOfflineMapboxTileCountLimit(uint64_t);
|
|
uint64_t getOfflineMapboxTileCountLimit();
|
|
bool offlineMapboxTileCountLimitExceeded();
|
|
uint64_t getOfflineMapboxTileCount();
|
|
bool exceedsOfflineMapboxTileCountLimit(const Resource&);
|
|
|
|
private:
|
|
int userVersion();
|
|
void ensureSchema();
|
|
void removeExisting();
|
|
void removeOldCacheTable();
|
|
void migrateToVersion3();
|
|
void migrateToVersion5();
|
|
void migrateToVersion6();
|
|
|
|
mapbox::sqlite::Statement& getStatement(const char *);
|
|
|
|
optional<std::pair<Response, uint64_t>> getTile(const Resource::TileData&);
|
|
optional<int64_t> hasTile(const Resource::TileData&);
|
|
bool putTile(const Resource::TileData&, const Response&,
|
|
const std::string&, bool compressed);
|
|
|
|
optional<std::pair<Response, uint64_t>> getResource(const Resource&);
|
|
optional<int64_t> hasResource(const Resource&);
|
|
bool putResource(const Resource&, const Response&,
|
|
const std::string&, bool compressed);
|
|
|
|
uint64_t putRegionResourceInternal(int64_t regionID, const Resource&, const Response&);
|
|
|
|
optional<std::pair<Response, uint64_t>> getInternal(const Resource&);
|
|
optional<int64_t> hasInternal(const Resource&);
|
|
std::pair<bool, uint64_t> putInternal(const Resource&, const Response&, bool evict);
|
|
|
|
// Return value is true iff the resource was previously unused by any other regions.
|
|
bool markUsed(int64_t regionID, const Resource&);
|
|
|
|
std::pair<int64_t, int64_t> getCompletedResourceCountAndSize(int64_t regionID);
|
|
std::pair<int64_t, int64_t> getCompletedTileCountAndSize(int64_t regionID);
|
|
|
|
const std::string path;
|
|
std::unique_ptr<mapbox::sqlite::Database> db;
|
|
std::unordered_map<const char *, const std::unique_ptr<mapbox::sqlite::Statement>> statements;
|
|
|
|
template <class T>
|
|
T getPragma(const char *);
|
|
|
|
uint64_t maximumCacheSize;
|
|
|
|
uint64_t offlineMapboxTileCountLimit = util::mapbox::DEFAULT_OFFLINE_TILE_COUNT_LIMIT;
|
|
optional<uint64_t> offlineMapboxTileCount;
|
|
|
|
bool evict(uint64_t neededFreeSize);
|
|
};
|
|
|
|
} // namespace mbgl
|