jellyfin/Emby.Server.Implementations/Data/BaseSqliteRepository.cs

402 lines
12 KiB
C#
Raw Normal View History

2016-11-18 08:39:20 +00:00
using System;
using System.Collections.Generic;
2016-12-13 15:44:34 +00:00
using System.Globalization;
2016-11-18 08:39:20 +00:00
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Model.Logging;
using SQLitePCL.pretty;
using System.Linq;
2016-11-19 07:51:07 +00:00
using SQLitePCL;
2016-11-18 08:39:20 +00:00
namespace Emby.Server.Implementations.Data
{
public abstract class BaseSqliteRepository : IDisposable
{
protected string DbFilePath { get; set; }
2016-11-20 23:48:52 +00:00
protected ReaderWriterLockSlim WriteLock;
2016-11-18 08:39:20 +00:00
protected ILogger Logger { get; private set; }
protected BaseSqliteRepository(ILogger logger)
{
Logger = logger;
2016-11-20 23:48:52 +00:00
2016-12-11 05:12:00 +00:00
WriteLock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
2016-11-20 23:48:52 +00:00
}
2016-12-11 05:12:00 +00:00
protected TransactionMode TransactionMode
2016-11-20 23:48:52 +00:00
{
2016-12-13 08:45:04 +00:00
get { return TransactionMode.Deferred; }
2016-11-18 08:39:20 +00:00
}
2016-12-11 05:12:00 +00:00
protected TransactionMode ReadTransactionMode
2016-11-28 19:26:48 +00:00
{
2016-12-11 05:12:00 +00:00
get { return TransactionMode.Deferred; }
2016-11-28 19:26:48 +00:00
}
2016-12-11 05:12:00 +00:00
internal static int ThreadSafeMode { get; set; }
2016-11-19 07:51:07 +00:00
static BaseSqliteRepository()
2016-11-18 08:39:20 +00:00
{
SQLite3.EnableSharedCache = false;
2016-11-19 07:51:07 +00:00
int rc = raw.sqlite3_config(raw.SQLITE_CONFIG_MEMSTATUS, 0);
//CheckOk(rc);
2016-12-11 05:12:00 +00:00
rc = raw.sqlite3_config(raw.SQLITE_CONFIG_MULTITHREAD, 1);
2016-12-13 15:44:34 +00:00
//rc = raw.sqlite3_config(raw.SQLITE_CONFIG_SINGLETHREAD, 1);
2016-12-13 07:36:30 +00:00
//rc = raw.sqlite3_config(raw.SQLITE_CONFIG_SERIALIZED, 1);
2016-12-11 05:12:00 +00:00
//CheckOk(rc);
rc = raw.sqlite3_enable_shared_cache(1);
ThreadSafeMode = raw.sqlite3_threadsafe();
2016-11-19 07:51:07 +00:00
}
2016-11-20 21:02:32 +00:00
private static bool _versionLogged;
2016-11-21 08:54:53 +00:00
private string _defaultWal;
2016-12-13 15:44:34 +00:00
protected ManagedConnection _connection;
2016-11-21 08:54:53 +00:00
2016-12-13 15:44:34 +00:00
protected virtual bool EnableSingleConnection
2016-11-19 07:51:07 +00:00
{
2016-12-13 15:44:34 +00:00
get { return true; }
}
protected ManagedConnection CreateConnection(bool isReadOnly = false)
{
if (_connection != null)
{
return _connection;
}
2016-12-13 08:45:04 +00:00
lock (WriteLock)
2016-11-20 21:02:32 +00:00
{
2016-12-13 08:45:04 +00:00
if (!_versionLogged)
{
_versionLogged = true;
Logger.Info("Sqlite version: " + SQLite3.Version);
Logger.Info("Sqlite compiler options: " + string.Join(",", SQLite3.CompilerOptions.ToArray()));
}
2016-11-20 21:02:32 +00:00
2016-12-13 08:45:04 +00:00
ConnectionFlags connectionFlags;
2016-11-18 08:39:20 +00:00
2016-12-13 08:45:04 +00:00
if (isReadOnly)
{
//Logger.Info("Opening read connection");
//connectionFlags = ConnectionFlags.ReadOnly;
connectionFlags = ConnectionFlags.Create;
connectionFlags |= ConnectionFlags.ReadWrite;
}
else
{
//Logger.Info("Opening write connection");
connectionFlags = ConnectionFlags.Create;
connectionFlags |= ConnectionFlags.ReadWrite;
}
2016-11-21 08:54:53 +00:00
2016-12-13 15:44:34 +00:00
if (EnableSingleConnection)
{
connectionFlags |= ConnectionFlags.PrivateCache;
}
else
{
connectionFlags |= ConnectionFlags.SharedCached;
}
2016-12-13 08:45:04 +00:00
connectionFlags |= ConnectionFlags.NoMutex;
2016-11-18 08:39:20 +00:00
2016-12-13 08:45:04 +00:00
var db = SQLite3.Open(DbFilePath, connectionFlags, null);
2016-11-18 08:39:20 +00:00
2016-12-13 08:45:04 +00:00
if (string.IsNullOrWhiteSpace(_defaultWal))
{
_defaultWal = db.Query("PRAGMA journal_mode").SelectScalarString().First();
2016-11-29 19:12:37 +00:00
2016-12-13 08:45:04 +00:00
Logger.Info("Default journal_mode for {0} is {1}", DbFilePath, _defaultWal);
}
2016-11-21 08:54:53 +00:00
2016-12-13 08:45:04 +00:00
var queries = new List<string>
2016-12-13 15:44:34 +00:00
{
//"PRAGMA cache size=-10000"
//"PRAGMA read_uncommitted = true",
"PRAGMA synchronous=Normal"
};
if (CacheSize.HasValue)
{
queries.Add("PRAGMA cache_size=-" + CacheSize.Value.ToString(CultureInfo.InvariantCulture));
}
2016-11-19 18:09:15 +00:00
2016-12-13 08:45:04 +00:00
if (EnableTempStoreMemory)
{
queries.Add("PRAGMA temp_store = memory");
}
2016-11-27 19:36:56 +00:00
2016-12-13 08:45:04 +00:00
//var cacheSize = CacheSize;
//if (cacheSize.HasValue)
//{
2016-11-20 23:48:52 +00:00
2016-12-13 08:45:04 +00:00
//}
2016-11-19 18:09:15 +00:00
2016-12-13 08:45:04 +00:00
////foreach (var query in queries)
////{
//// db.Execute(query);
////}
2016-11-18 08:39:20 +00:00
2016-12-13 08:45:04 +00:00
//Logger.Info("synchronous: " + db.Query("PRAGMA synchronous").SelectScalarString().First());
//Logger.Info("temp_store: " + db.Query("PRAGMA temp_store").SelectScalarString().First());
2016-11-18 08:39:20 +00:00
2016-12-13 08:45:04 +00:00
/*if (!string.Equals(_defaultWal, "wal", StringComparison.OrdinalIgnoreCase))
{
queries.Add("PRAGMA journal_mode=WAL");
2016-11-21 20:22:43 +00:00
2016-12-13 08:45:04 +00:00
using (WriteLock.Write())
{
db.ExecuteAll(string.Join(";", queries.ToArray()));
}
}
else*/
foreach (var query in queries)
2016-11-21 03:52:58 +00:00
{
2016-12-13 08:45:04 +00:00
db.Execute(query);
2016-11-21 03:52:58 +00:00
}
2016-11-19 07:51:07 +00:00
2016-12-13 15:44:34 +00:00
_connection = new ManagedConnection(db, false);
return _connection;
2016-12-13 08:45:04 +00:00
}
2016-11-18 08:39:20 +00:00
}
2016-12-13 15:44:34 +00:00
public IStatement PrepareStatement(ManagedConnection connection, string sql)
{
return connection.PrepareStatement(sql);
}
public IStatement PrepareStatementSafe(ManagedConnection connection, string sql)
{
return connection.PrepareStatement(sql);
}
2016-12-11 05:12:00 +00:00
public IStatement PrepareStatement(IDatabaseConnection connection, string sql)
{
return connection.PrepareStatement(sql);
}
public IStatement PrepareStatementSafe(IDatabaseConnection connection, string sql)
{
return connection.PrepareStatement(sql);
}
2016-12-13 08:45:04 +00:00
public List<IStatement> PrepareAll(IDatabaseConnection connection, IEnumerable<string> sql)
2016-12-11 05:12:00 +00:00
{
2016-12-13 08:45:04 +00:00
return PrepareAllSafe(connection, sql);
2016-12-11 05:12:00 +00:00
}
2016-12-13 08:45:04 +00:00
public List<IStatement> PrepareAllSafe(IDatabaseConnection connection, IEnumerable<string> sql)
2016-12-11 05:12:00 +00:00
{
2016-12-13 08:45:04 +00:00
return sql.Select(connection.PrepareStatement).ToList();
2016-12-11 05:12:00 +00:00
}
2016-12-13 15:44:34 +00:00
protected void RunDefaultInitialization(ManagedConnection db)
2016-11-29 19:12:37 +00:00
{
var queries = new List<string>
{
"PRAGMA journal_mode=WAL",
"PRAGMA page_size=4096",
2016-12-13 08:45:04 +00:00
"PRAGMA synchronous=Normal"
2016-11-29 19:12:37 +00:00
};
if (EnableTempStoreMemory)
{
queries.AddRange(new List<string>
{
"pragma default_temp_store = memory",
"pragma temp_store = memory"
});
}
db.ExecuteAll(string.Join(";", queries.ToArray()));
2016-12-13 08:45:04 +00:00
Logger.Info("PRAGMA synchronous=" + db.Query("PRAGMA synchronous").SelectScalarString().First());
2016-11-29 19:12:37 +00:00
}
2016-11-27 19:36:56 +00:00
protected virtual bool EnableTempStoreMemory
{
get
{
return false;
}
}
2016-11-19 18:09:15 +00:00
protected virtual int? CacheSize
{
get
{
return null;
}
}
2016-11-19 07:51:07 +00:00
internal static void CheckOk(int rc)
{
string msg = "";
if (raw.SQLITE_OK != rc)
{
throw CreateException((ErrorCode)rc, msg);
}
}
internal static Exception CreateException(ErrorCode rc, string msg)
{
var exp = new Exception(msg);
return exp;
}
2016-11-18 08:39:20 +00:00
private bool _disposed;
protected void CheckDisposed()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().Name + " has been disposed and cannot be accessed.");
}
}
public void Dispose()
{
_disposed = true;
Dispose(true);
GC.SuppressFinalize(this);
}
private readonly object _disposeLock = new object();
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool dispose)
{
if (dispose)
{
try
{
lock (_disposeLock)
{
2016-11-19 08:40:13 +00:00
using (WriteLock.Write())
{
2016-12-13 15:44:34 +00:00
if (_connection != null)
{
2016-12-17 08:27:41 +00:00
using (_connection)
{
}
2016-12-13 15:44:34 +00:00
_connection = null;
}
2016-11-19 08:40:13 +00:00
CloseConnection();
}
2016-11-18 08:39:20 +00:00
}
}
catch (Exception ex)
{
Logger.ErrorException("Error disposing database", ex);
}
}
}
protected virtual void CloseConnection()
{
}
2016-11-18 09:28:39 +00:00
protected List<string> GetColumnNames(IDatabaseConnection connection, string table)
2016-11-18 09:28:39 +00:00
{
var list = new List<string>();
2016-11-18 09:28:39 +00:00
foreach (var row in connection.Query("PRAGMA table_info(" + table + ")"))
{
if (row[1].SQLiteType != SQLiteType.Null)
{
var name = row[1].ToString();
list.Add(name);
2016-11-18 09:28:39 +00:00
}
}
return list;
}
protected void AddColumn(IDatabaseConnection connection, string table, string columnName, string type, List<string> existingColumnNames)
{
if (existingColumnNames.Contains(columnName, StringComparer.OrdinalIgnoreCase))
{
return;
}
2016-11-20 23:48:52 +00:00
connection.Execute("alter table " + table + " add column " + columnName + " " + type + " NULL");
2016-11-18 09:28:39 +00:00
}
2016-11-18 08:39:20 +00:00
}
2016-11-19 08:40:13 +00:00
public static class ReaderWriterLockSlimExtensions
{
private sealed class ReadLockToken : IDisposable
{
private ReaderWriterLockSlim _sync;
public ReadLockToken(ReaderWriterLockSlim sync)
{
_sync = sync;
sync.EnterReadLock();
}
public void Dispose()
{
if (_sync != null)
{
_sync.ExitReadLock();
_sync = null;
}
}
}
private sealed class WriteLockToken : IDisposable
{
private ReaderWriterLockSlim _sync;
public WriteLockToken(ReaderWriterLockSlim sync)
{
_sync = sync;
sync.EnterWriteLock();
}
public void Dispose()
{
if (_sync != null)
{
_sync.ExitWriteLock();
_sync = null;
}
}
}
2016-12-11 05:12:00 +00:00
public class DummyToken : IDisposable
{
public void Dispose()
{
}
}
2016-11-19 08:40:13 +00:00
public static IDisposable Read(this ReaderWriterLockSlim obj)
{
2016-12-11 05:12:00 +00:00
//if (BaseSqliteRepository.ThreadSafeMode > 0)
//{
// return new DummyToken();
//}
2016-12-13 15:44:34 +00:00
return new WriteLockToken(obj);
2016-11-19 08:40:13 +00:00
}
public static IDisposable Write(this ReaderWriterLockSlim obj)
{
2016-12-11 05:12:00 +00:00
//if (BaseSqliteRepository.ThreadSafeMode > 0)
//{
// return new DummyToken();
//}
return new WriteLockToken(obj);
}
}
2016-11-18 08:39:20 +00:00
}