public void Initialize()
{
using (connection.Lock())
{
connection.CreateTable <BackgroundTrackItem>();
}
}
public Task RunInTransactionAsync(Action <SQLiteConnection> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
conn.BeginTransaction();
try
{
action(conn);
conn.Commit();
}
catch (Exception)
{
conn.Rollback();
throw;
}
}
}));
}
private static SQLiteConnectionWithLock ReadConnectionFactory()
{
if (readConn != null)
{
return(readConn);
}
//SQLite3.Config(ConfigOption.Serialized);
var databaseFile = "readDatabase.db";
var connectionString = new SQLiteConnectionString(databaseFile, SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.FullMutex, true, null);
readConn = new SQLiteConnectionWithLock(connectionString);
using (readConn.Lock())
{
readConn.CreateCommand(@"PRAGMA synchronous = NORMAL;
PRAGMA temp_store = MEMORY;
PRAGMA page_size = 4096;
PRAGMA cache_size = 10000;
PRAGMA journal_mode = WAL;", Array.Empty <object>()).ExecuteScalar <int>();
}
return(readConn);
}
/// <summary>
///
/// </summary>
/// <param name="connectionString">The connection string to the mbtiles file</param>
/// <param name="schema">The TileSchema of the mbtiles file. If this parameter is set the schema information
/// within the mbtiles file will be ignored. </param>
/// <param name="type">BaseLayer or Overlay</param>
/// <param name="determineZoomLevelsFromTilesTable">When 'determineZoomLevelsFromTilesTable' is true the zoom levels
/// will be determined from the available tiles in the 'tiles' table. This operation can take long if there are many tiles in
/// the 'tiles' table. When 'determineZoomLevelsFromTilesTable' is false the zoom levels will be read from the metadata table
///(by reading 'zoommin' and 'zoommax'). If there are no zoom levels specificied in the metadata table the GlobalSphericalMercator
///default levels are assumed. This parameter will have no effect if the schema is passed in as argument. The default is false.</param>
/// <param name="determineTileRangeFromTilesTable">In some cases not all tiles specified by the schema are present in each
/// level. When 'determineTileRangeFromTilesTable' is 'true' the range of tiles available for each level is determined
/// by the tiles present for each level in the 'tiles' table. The advantage is that requests can be faster because they do not have to
/// go to the database if they are outside the TileRange. The downside is that for large files it can take long to read the TileRange
/// from the tiles table. The default is false.</param>
public MbTilesTileSource(SQLiteConnectionString connectionString, ITileSchema schema = null, MbTilesType type = MbTilesType.None,
bool determineZoomLevelsFromTilesTable = false, bool determineTileRangeFromTilesTable = false)
{
_connectionString = connectionString;
using (var connection = new SQLiteConnectionWithLock(connectionString))
using (connection.Lock())
{
Schema = schema ?? ReadSchemaFromDatabase(connection, determineZoomLevelsFromTilesTable);
Type = type == MbTilesType.None ? ReadType(connection) : type;
Version = ReadString(connection, "version");
Attribution = new Attribution(ReadString(connection, "attribution"));
Description = ReadString(connection, "description");
Name = ReadString(connection, "name");
Json = ReadString(connection, "json");
Compression = ReadString(connection, "compression");
if (determineTileRangeFromTilesTable)
{
// the tile range should be based on the tiles actually present.
var zoomLevelsFromDatabase = Schema.Resolutions.Select(r => r.Key);
_tileRange = ReadTileRangeForEachLevelFromTilesTable(connection, zoomLevelsFromDatabase);
}
}
}
public Task RunInTransactionAsync(Action <SQLiteConnection> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
conn.BeginTransaction();
try
{
action(conn);
conn.Commit();
}
catch (Exception)
{
conn.Rollback();
throw;
}
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public void UpdateToLatestVersion()
{
var context = Mvx.Resolve <UpdateContext>();
context.Connection = _connection;
var version = GetCurrentVersion();
var updates = GetPendingUpdates(version);
foreach (var update in updates)
{
var meta = update.Item2;
var code = update.Item1;
Trace($"Applying updated #{meta.Version} [{meta.Tag}]...");
using (_connection.Lock())
{
_connection.RunInTransaction(() =>
{
code.Apply(context);
var row = new VersionRow {
Tag = meta.Tag, Timestamp = new DateTime(), Version = meta.Version
};
_connection.Insert(row);
});
}
Trace($"Update #{meta.Version} [{meta.Tag}] was successfully applied.");
}
}
public static Item GetItemSync(long id)
{
SQLiteConnectionWithLock con = _connection.GetConnection();
using (con.Lock())
{
return(con.Query <Item>("SELECT * FROM items WHERE _id=?", id).FirstOrDefault <Item>());
}
}
public Task <TableMapping> GetMappingAsync <T> ()
{
return(Task.Factory.StartNew(() => {
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock()) {
return conn.GetMapping(typeof(T));
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> InsertOrIgnoreAsync(object item)
{
return(Task.Factory.StartNew(() => {
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock()) {
return conn.InsertOrIgnore(item);
}
}));
}
public void RemoveRecipe(int id)
{
if (_isDisposed)
{
throw new ObjectDisposedException(nameof(RecipePersistenceService));
}
using (_connection.Lock())
{
_connection.RunInTransaction(() =>
{
//Remove all fields
var mapping = _connection.GetMapping <RecipeTextFieldRow>();
_connection.Execute($"DELETE FROM {mapping.TableName} WHERE RecipeId = ?", id);
//Remove recipe
_connection.Delete <RecipeRow>(id);
});
}
}
public Task <int> DeleteAllAsync <T>()
{
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.DeleteAll <T>();
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> DeleteAllAsync <T>()
{
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.DeleteAll <T>();
}
}));
}
public Task <int> DropTableAsync <T>(CancellationToken cancellationToken = default(CancellationToken))
where T : new()
{
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.DropTable <T>();
}
}, cancellationToken, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> DropTableAsync <T>()
where T : new()
{
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.DropTable <T>();
}
}));
}
public Task <int> InsertOrIgnoreAllAsync(IEnumerable objects, CancellationToken cancellationToken = default(CancellationToken))
{
if (objects == null)
{
throw new ArgumentNullException("objects");
}
return(Task.Factory.StartNew(() => {
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock()) {
return conn.InsertOrIgnoreAll(objects);
}
}, cancellationToken, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> UpdateAsync(object item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.Update(item);
}
}));
}
public Task <int> DeleteAsync <T>(object pk)
{
if (pk == null)
{
throw new ArgumentNullException("pk");
}
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.Delete <T>(pk);
}
}));
}
public Task <int> InsertAllAsync(IEnumerable items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.InsertAll(items);
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> DeleteAsync <T>(object pk)
{
if (pk == null)
{
throw new ArgumentNullException("pk");
}
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.Delete <T>(pk);
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> InsertAllAsync(IEnumerable items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.InsertAll(items);
}
}));
}
public Task <int> UpdateAsync(object item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.Update(item);
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <int> InsertOrReplaceAsync(object item, CancellationToken cancellationToken = default(CancellationToken))
{
if (item == null)
{
throw new ArgumentNullException("item");
}
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.InsertOrReplace(item);
}
}, cancellationToken, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public void InsertOrReplaceWithChildren(T entity)
{
//using (SQLiteConnection _dbManager = new SQLiteConnection(_baseUrl.GetDatabasePath(), WriteOnlyFlags))
using (SQLiteConnectionWithLock _dbManager = new SQLiteConnectionWithLock(new SQLiteConnectionString(_baseUrl.GetDatabasePath(), false, null), SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.FullMutex | SQLiteOpenFlags.SharedCache))
using (_dbManager.Lock())
{
try
{
_dbManager.InsertOrReplaceWithChildren(entity, true);
}
catch (Exception ex)
{
Debug.WriteLine($"SQLiteError: {ex.Message}");
}
}
}
public Task <T> FindAsync <T>(Expression <Func <T, bool> > predicate)
where T : new()
{
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
return(Task.Factory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.Find(predicate);
}
}, CancellationToken.None, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <T> FindAsync <T>(Expression <Func <T, bool> > predicate)
where T : new()
{
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
return(_taskFactory.StartNew(() =>
{
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
return conn.Find(predicate);
}
}));
}
public MbTilesTileSource(SQLiteConnectionString connectionString, ITileSchema schema = null, MbTilesType type = MbTilesType.None)
{
_connectionString = connectionString;
var connection = new SQLiteConnectionWithLock(connectionString, SQLiteOpenFlags.ReadOnly);
using (connection.Lock())
{
Type = type == MbTilesType.None ? ReadType(connection) : type;
var schemaFromDatabase = ReadSchemaFromDatabase(connection);
Schema = schema ?? schemaFromDatabase;
// the tile range should be based on the tiles actually present.
var zoomLevelsFromDatabase = schemaFromDatabase.Resolutions.Select(r => r.Key);
_tileRange = ReadZoomLevelsFromTilesTable(connection, zoomLevelsFromDatabase);
}
}
internal MbTilesCache(SQLiteConnectionString connectionString, ITileSchema schema = null, MbTilesType type = MbTilesType.None)
{
/*
* if (_connectionPool == null)
* throw new InvalidOperationException("You must assign a platform prior to using MbTilesCache by calling MbTilesTileSource.SetPlatform()");
*/
_connectionString = connectionString;
var connection = new SQLiteConnectionWithLock(_platform, connectionString);
using (connection.Lock())
{
_type = type == MbTilesType.None ? ReadType(connection) : type;
if (schema == null)
{
// Format (if defined)
_format = ReadFormat(connection);
// Extent
_extent = ReadExtent(connection);
if (HasMapTable(connection))
{
// it is possible to override the schema by definining it in a 'map' table.
// This method depends on reading tiles from an 'images' table, which
// is not part of the MBTiles spec
// Declared zoom levels
var declaredZoomLevels = ReadZoomLevels(connection, out _tileRange);
// Create schema
_schema = new GlobalMercator(_format.ToString(), declaredZoomLevels);
}
else
{
// this is actually the most regular case:
_schema = new GlobalSphericalMercator();
}
}
else
{
_schema = schema;
}
}
}
public byte[] Find(TileIndex index)
{
if (IsTileIndexValid(index))
{
byte[] result;
var cn = new SQLiteConnectionWithLock(_platform, _connectionString);
using (cn.Lock())
{
const string sql =
"SELECT tile_data FROM \"tiles\" WHERE zoom_level=? AND tile_row=? AND tile_column=?;";
result = cn.ExecuteScalar <byte[]>(sql, int.Parse(index.Level), index.Row, index.Col);
}
return(result == null || result.Length == 0
? null
: result);
}
return(null);
}
public Task <T> FindAsync <T>(object pk, CancellationToken cancellationToken = default(CancellationToken))
where T : new()
{
if (pk == null)
{
throw new ArgumentNullException("pk");
}
return(Task.Factory.StartNew(() =>
{
cancellationToken.ThrowIfCancellationRequested();
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
cancellationToken.ThrowIfCancellationRequested();
return conn.Find <T>(pk);
}
}, cancellationToken, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
public Task <T> GetAsync <T>(Expression <Func <T, bool> > predicate, CancellationToken cancellationToken = default(CancellationToken))
where T : new()
{
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
return(Task.Factory.StartNew(() =>
{
cancellationToken.ThrowIfCancellationRequested();
SQLiteConnectionWithLock conn = GetConnection();
using (conn.Lock())
{
cancellationToken.ThrowIfCancellationRequested();
return conn.Get(predicate);
}
}, cancellationToken, _taskCreationOptions, _taskScheduler ?? TaskScheduler.Default));
}
