/// <summary>
/// Creates the new.
/// </summary>
/// <param name="connectionLock">The connection lock.</param>
/// <param name="databasePath">The database path.</param>
/// <param name="openFlags">The open flags.</param>
/// <returns></returns>
private static SQLiteParallelConnection CreateNew(
SemaphoreSlim connectionLock,
string databasePath,
SQLiteOpenFlags openFlags)
{
// Only return new connection if cancellation is not requested
if (!PoolCancellationToken.Token.IsCancellationRequested)
{
DelegateRetry retry = new DelegateRetry(3, new TimeSpan(0, 0, 0, 500), true /*double delay*/);
Func <SQLiteParallelConnection> function = delegate
{
return(new SQLiteParallelConnection(connectionLock, databasePath, openFlags)
{
BusyTimeout = TimeSpan.FromMinutes(3)
});
};
// if there is a transient exception such as the file not getting created as we expect we run this to retry the creaton of the connection.
// this becomes particuarly important for the first writer which actually creates teh db today. A better design would be to do a check in the create database call
return(retry.RetryN <SQLiteParallelConnection>(function, new Func <Exception, bool>(DelegateRetry.IsTransientSqlException)));
}
return(null);
}
public Entry(SQLiteConnectionString connectionString, SQLiteOpenFlags openFlags)
{
ConnectionString = connectionString;
Connection = new SQLiteConnectionWithLock(connectionString, openFlags);
}
/// <summary>
/// Constructs a new SQLiteConnectionString with all the data needed to open an SQLiteConnection.
/// </summary>
/// <param name="databasePath">
/// Specifies the path to the database file.
/// </param>
/// <param name="openFlags">
/// Flags controlling how the connection should be opened.
/// </param>
/// <param name="storeDateTimeAsTicks">
/// Specifies whether to store DateTime properties as ticks (true) or strings (false). You
/// absolutely do want to store them as Ticks in all new projects. The value of false is
/// only here for backwards compatibility. There is a *significant* speed advantage, with no
/// down sides, when setting storeDateTimeAsTicks = true.
/// If you use DateTimeOffset properties, it will be always stored as ticks regardingless
/// the storeDateTimeAsTicks parameter.
/// </param>
/// <param name="key">
/// Specifies the encryption key to use on the database. Should be a string or a byte[].
/// </param>
/// <param name="preKeyAction">
/// Executes prior to setting key for SQLCipher databases
/// </param>
/// <param name="postKeyAction">
/// Executes after setting key for SQLCipher databases
/// </param>
/// <param name="vfsName">
/// Specifies the Virtual File System to use on the database.
/// </param>
/// <param name="dateTimeStringFormat">
/// Specifies the format to use when storing DateTime properties as strings.
/// </param>
/// <param name="storeTimeSpanAsTicks">
/// Specifies whether to store TimeSpan properties as ticks (true) or strings (false). You
/// absolutely do want to store them as Ticks in all new projects. The value of false is
/// only here for backwards compatibility. There is a *significant* speed advantage, with no
/// down sides, when setting storeTimeSpanAsTicks = true.
/// </param>
public SQLiteConnectionString(string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks, object key = null, Action <SQLiteConnection> preKeyAction = null, Action <SQLiteConnection> postKeyAction = null, string vfsName = null, string dateTimeStringFormat = DateTimeSqliteDefaultFormat, bool storeTimeSpanAsTicks = true)
{
if (key != null && !((key is byte[]) || (key is string)))
{
throw new ArgumentException("Encryption keys must be strings or byte arrays", nameof(key));
}
UniqueKey = string.Format("{0}_{1:X8}", databasePath, (uint)openFlags);
StoreDateTimeAsTicks = storeDateTimeAsTicks;
StoreTimeSpanAsTicks = storeTimeSpanAsTicks;
DateTimeStringFormat = dateTimeStringFormat;
DateTimeStyle = "o".Equals(DateTimeStringFormat, StringComparison.OrdinalIgnoreCase) || "r".Equals(DateTimeStringFormat, StringComparison.OrdinalIgnoreCase) ? System.Globalization.DateTimeStyles.RoundtripKind : System.Globalization.DateTimeStyles.None;
Key = key;
PreKeyAction = preKeyAction;
PostKeyAction = postKeyAction;
OpenFlags = openFlags;
VfsName = vfsName;
#if NETFX_CORE
DatabasePath = IsInMemoryPath(databasePath)
? databasePath
: System.IO.Path.Combine(MetroStyleDataPath, databasePath);
#else
DatabasePath = databasePath;
#endif
}
public SQLiteAsyncConnection(string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = true)
{
_openFlags = openFlags;
_connectionString = new SQLiteConnectionString(databasePath, storeDateTimeAsTicks);
}
/// <summary>
/// Constructs a new SQLiteConnection and opens a SQLite database specified by databasePath.
/// </summary>
/// <param name="databasePath">
/// Specifies the path to the database file.
/// </param>
/// <param name="storeDateTimeAsTicks">
/// Specifies whether to store DateTime properties as ticks (true) or strings (false). You
/// absolutely do want to store them as Ticks in all new projects. The default of false is
/// only here for backwards compatibility. There is a *significant* speed advantage, with no
/// down sides, when setting storeDateTimeAsTicks = true.
/// </param>
public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = false)
{
DatabasePath = databasePath;
#if NETFX_CORE
SQLite3.SetDirectory(/*temp directory type*/ 2, Windows.Storage.ApplicationData.Current.TemporaryFolder.Path);
#endif
Sqlite3DatabaseHandle handle;
#if SILVERLIGHT
var r = SQLite3.Open(databasePath, out handle, (int)openFlags, IntPtr.Zero);
#else
// open using the byte[]
// in the case where the path may include Unicode
// force open to using UTF-8 using sqlite3_open_v2
var databasePathAsBytes = GetNullTerminatedUtf8(DatabasePath);
var r = SQLite3.Open(databasePathAsBytes, out handle, (int)openFlags, IntPtr.Zero);
#endif
Handle = handle;
if (r != SQLite3.Result.OK)
{
throw SQLiteException.New(r, String.Format("Could not open database file: {0} ({1})", DatabasePath, r));
}
_open = true;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
BusyTimeout = TimeSpan.FromSeconds(0.1);
}
/// <summary>
/// Gets a SQLite database connection given a database name. The database will be loaded from the application's
/// assets.
/// </summary>
/// <param name="databaseName">The database file name.</param>
/// <param name="openFlags">The flags to be used while opening the database.</param>
/// <returns>A <see cref="SQLiteConnection"/> object containing the required connection.</returns>
public SQLiteConnection GetConnection(
string databaseName,
SQLiteOpenFlags openFlags)
{
// Copy the database to the "Local application data" folder. (This is required because we can not load a
// SQLite database directly from the .apk package; SQLite requires R/W access and we would like to avoid
// memory backing).
string directoryPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Tell-OP");
string databasePath = Path.Combine(directoryPath, databaseName);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
if (!File.Exists(databasePath))
{
using (BinaryReader dbReader = new BinaryReader(Xamarin.Forms.Forms.Context.Assets.Open(databaseName)))
{
using (BinaryWriter dbWriter = new BinaryWriter(new FileStream(databasePath, FileMode.Create)))
{
byte[] dbBuffer = new byte[2048];
int len = 0;
while ((len = dbReader.Read(dbBuffer, 0, dbBuffer.Length)) > 0)
{
dbWriter.Write(dbBuffer, 0, len);
}
}
}
}
// Initialize the connection.
return(new SQLiteConnection(databasePath, openFlags));
}
protected BaseSqliteDatabaseService(ISqliteConfig config)
{
ConnectionString = config.DatabasePath;
_tableTypes = config.TableTypes;
_flags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.SharedCache;
}
public SQLiteAsyncConnection(string databasePath, SQLiteOpenFlags?flags = null, bool storeDateTimeAsTicks = false)
{
_flags = flags ?? (SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.NoMutex | SQLiteOpenFlags.SharedCache);
_connectionString = new SQLiteConnectionString(databasePath, storeDateTimeAsTicks);
_pool = new SQLiteConnectionPool(_connectionString, _flags);
}
public SQLiteContactsCache(string databasePath, SQLiteOpenFlags flags)
{
_databasePath = databasePath ?? throw new ArgumentNullException(nameof(databasePath));
_flags = flags;
// lazy-инициализация БД взята из примера: https://docs.microsoft.com/en-us/xamarin/xamarin-forms/data-cloud/data/databases
_lazyInitializer = new Lazy <SQLiteAsyncConnection>(() => new SQLiteAsyncConnection(_databasePath, _flags));
InitializeAsync().SafeFireAndForget(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="SQLiteParallelConnection"/> class.
/// </summary>
/// <param name="connectionLock">The connection lock.</param>
/// <param name="databasePath">The database path.</param>
/// <param name="openFlags">The open flags.</param>
/// <param name="storeDateTimeAsTicks">if set to <c>true</c> [store date time as ticks].</param>
public SQLiteParallelConnection(
SemaphoreSlim connectionLock,
string databasePath,
SQLiteOpenFlags openFlags,
bool storeDateTimeAsTicks = false) : base(databasePath, openFlags, storeDateTimeAsTicks)
{
this.connectionLock = connectionLock;
this.IsReadonly = (openFlags & SQLiteOpenFlags.ReadOnly) != 0;
}
public SqLiteConfig(
string databaseName,
bool storeDateTimeAsTicks = true,
SQLiteOpenFlags? openFlags = null)
{
DatabaseName = databaseName;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
OpenFlags = openFlags ?? SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create;
}
private static SQLiteConnection ConnectWithDb()
{
string documentsPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
string path = Path.Combine(documentsPath, "PwszAlarm.db3");
const SQLiteOpenFlags Flags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create;
SQLiteConnection db = new SQLiteConnection(path, Flags);
return(db);
}
public SQLiteConnectionSettings(string databasePath, SQLiteOpenFlags openFlags, bool overridePath = false)
{
this.DatabasePath = databasePath;
this.OpenFlags = openFlags;
this.OverridePath = overridePath;
this.HasOpenFlags = true;
BuildKey();
}
private async System.Threading.Tasks.Task <bool> CreateConnectionAsync()
{
bool ret = false;
try
{
Stopwatch sw = Stopwatch.StartNew();
this.HistoryDic.Clear();
this.HasChanged.WriteFullFence(false);
this.DeletedCount.WriteFullFence(0);
this.AddedCount.WriteFullFence(0);
//FullMutex for safe multithreading
SQLiteOpenFlags flags = SQLiteOpenFlags.Create | SQLiteOpenFlags.FullMutex;
if (this.ReadOnly)
{
flags = flags | SQLiteOpenFlags.ReadOnly;
}
else
{
flags = flags | SQLiteOpenFlags.ReadWrite;
}
if (this.IsSQLiteDBConnected())
{
this.DisposeConnection();
}
//If the database file doesn't exist, the default behaviour is to create a new file
sqlite_conn = new SQLiteAsyncConnection(this.Filename, flags, true);
//make sure table exists:
CreateTableResult ctr = await sqlite_conn.CreateTableAsync <History>();
await sqlite_conn.ExecuteScalarAsync <int>(@"PRAGMA journal_mode = 'WAL';", new object[] { });
await sqlite_conn.ExecuteScalarAsync <int>(@"PRAGMA busy_timeout = 30000;", new object[] { });
sw.Stop();
Global.Log($"Created connection to SQLite db v{sqlite_conn.LibVersionNumber} in {sw.ElapsedMilliseconds}ms - TableCreate={ctr.ToString()}: {this.Filename}");
HasChanged.WriteFullFence(true);
}
catch (Exception ex)
{
Global.Log("Error: " + Global.ExMsg(ex));
}
return(ret);
}
private static SQLiteConnection ConnectWithDb()
{
string documentsPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
string path = Path.Combine(documentsPath, "FakroDatabase.db3");
//System.IO.File.Delete(path);
const SQLiteOpenFlags flags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create;
SQLiteConnection dbConnection = new SQLiteConnection(path, flags);
return(dbConnection);
}
public virtual void Close(SQLiteConnectionString connectionString, SQLiteOpenFlags openFlags)
{
var connection = GetConnection(connectionString, openFlags);
lock (_entriesLock)
{
connection.Dispose();
_entries.Remove(connectionString.ConnectionString);
}
}
/// <sumary>
/// Constructor that creates database and all the tables in specified location
/// with specified flags
/// </sumary>
/// <param name="dbPath"> Path to the file with database data </param>
/// <param name="flags"> Additional flags that the database should use </param>
public DatabaseService(string dbPath, SQLiteOpenFlags flags)
{
_database = new SQLiteAsyncConnection(dbPath, flags);
_database.CreateTableAsync <Band>().Wait();
_database.CreateTableAsync <Genre>().Wait();
_database.CreateTableAsync <Musician>().Wait();
_database.CreateTableAsync <Place>().Wait();
_database.CreateTableAsync <Skill>().Wait();
_database.CreateTableAsync <BandGenres>().Wait();
_database.CreateTableAsync <BandMusicians>().Wait();
_database.CreateTableAsync <Invitation>().Wait();
}
public void Load(SQLiteOpenFlags openFlags = SQLiteOpenFlags.ReadOnly, Action <DatabaseController> onComplete = null)
{
Unload();
if ((openFlags & SQLiteOpenFlags.ReadWrite) == SQLiteOpenFlags.ReadWrite)
{
LoadReadWrite(openFlags, onComplete);
}
else
{
LoadReadOnly(openFlags, onComplete);
}
}
public SqLiteConfig(
string databaseName,
bool storeDateTimeAsTicks = true,
IBlobSerializer serializer = null,
IContractResolver resolver = null,
SQLiteOpenFlags? openFlags = null)
{
DatabaseName = databaseName;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
BlobSerializer = serializer;
//OpenFlags = openFlags ?? SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create;
}
public SQLiteConnectionString(string databasePath, bool storeDateTimeAsTicks,
IBlobSerializer serializer = null,
IContractResolver resolver = null,
SQLiteOpenFlags? openFlags = null)
{
ConnectionString = databasePath;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
DatabasePath = databasePath;
Serializer = serializer;
Resolver = resolver ?? ContractResolver.Current;
OpenFlags = openFlags ?? SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create;
}
public Repository(string path, SQLiteOpenFlags flags)
{
lazyInitializer = new Lazy <SQLiteAsyncConnection>(() =>
{
return(new SQLiteAsyncConnection(path, flags));
});
Initialize().SafeFireAndForget(false, (e) =>
{
#if DEBUG
throw e;
#endif
});
}
public SQLiteConnectionPool(string databasePath, SQLiteOpenFlags flags = SQLiteOpenFlags.ReadOnly, int minPoolSize = 1, int maxPoolSize = 10)
{
if (minPoolSize <= 0)
throw new ArgumentOutOfRangeException(nameof(minPoolSize), minPoolSize, "minPoolSize must be 1 or greater.");
if (maxPoolSize <= 0 || maxPoolSize < minPoolSize)
throw new ArgumentOutOfRangeException(nameof(maxPoolSize), maxPoolSize, "maxPoolSize must be greater than 1 and minPoolSize");
DatabasePath = databasePath;
DatabaseOpenFlags = flags;
MinPoolSize = minPoolSize;
MaxPoolSize = maxPoolSize;
}
/// <summary>
/// Initializes a new instance of the <see cref="SQLiteConnectionWithLockBridge" />
/// class.
/// </summary>
/// <param name="sqlitePlatform">The sqlite platform.</param>
/// <param name="databasePath">The database path.</param>
/// <param name="openFlags">The open flags.</param>
/// <param name="columnInformationProvider">The column information provider.</param>
/// <param name="storeDateTimeAsTicks">if set to <c>true</c> [store date time as ticks].</param>
/// <param name="serializer">The serializer.</param>
/// <param name="tableMappings">The table mappings.</param>
/// <param name="extraTypeMappings">The extra type mappings.</param>
/// <param name="resolver">The resolver.</param>
public SQLiteConnectionWithLockBridge(
ISQLitePlatform sqlitePlatform, string databasePath, SQLiteOpenFlags openFlags,
IColumnInformationProvider columnInformationProvider = null,
bool storeDateTimeAsTicks = true, IBlobSerializer serializer = null,
IDictionary <string, TableMapping> tableMappings = null,
IDictionary <Type, string> extraTypeMappings = null, IContractResolver resolver = null)
: base(
sqlitePlatform,
new SQLiteConnectionString(
databasePath, storeDateTimeAsTicks, serializer, resolver, openFlags), tableMappings,
extraTypeMappings)
{
ColumnInformationProvider = columnInformationProvider
?? new ColumnInformationProviderBridge();
}
/// <summary>
/// Establishes a new connection to the indicated database.
/// </summary>
/// <param name="_dbName">Db name.</param>
/// <param name="authentication">Authentication.</param>
public bool EstablishConnection(string _dbName, SQLiteOpenFlags authentication)
{
_connection = null;
if (!File.Exists(DialogueDBAdmin.streamingPath + _dbName))
{
Debug.Log("Failed to Establish the Connection! The indicated Database does not exist! ");
return(false);
}
_connection = new SQLiteConnection(DialogueDBAdmin.streamingPath + _dbName, authentication);
Debug.Log("The Connection has been established successfully! ");
return(true);
}
void LoadReadOnly(SQLiteOpenFlags openFlags, Action <DatabaseController> onComplete)
{
if (File.Exists(saveFilePath))
{
DidLoad(new SQLiteConnection(saveFilePath, openFlags, true), onComplete);
}
else if (!assetFilePath.Contains("://"))
{
DidLoad(new SQLiteConnection(assetFilePath, openFlags, true), onComplete);
}
else
{
Copy(assetFilePath, saveFilePath, delegate {
DidLoad(new SQLiteConnection(saveFilePath, openFlags, true), onComplete);
});
}
}
public override SQLiteConnection GetDatabase(string name, SQLiteOpenFlags openFlags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create,
bool storeDateTimeAsTicks = true, IBlobSerializer serializer = null,
IDictionary <string, TableMapping> tableMappings = null,
IDictionary <Type, string> extraTypeMappings = null, IContractResolver resolver = null)
{
Directory.CreateDirectory(BasePath);
ISQLitePlatform platform;
if (RuntimeInfo.IsWindows)
{
platform = new SQLitePlatformWin32();
}
else
{
platform = new SQLitePlatformGeneric();
}
return(new SQLiteConnection(platform, Path.Combine(BasePath, $@"{name}.db"), openFlags, storeDateTimeAsTicks, serializer, tableMappings, extraTypeMappings, resolver));
}
/// <summary>
/// Gets a SQLite database connection given a database name. The
/// database will be loaded from the application's assets.
/// </summary>
/// <param name="databaseName">The database file name.</param>
/// <param name="openFlags">The flags to be used while opening the
/// database.</param>
/// <returns>A <see cref="SQLiteConnection"/> object containing the
/// required connection.</returns>
public SQLiteConnection GetConnection(
string databaseName,
SQLiteOpenFlags openFlags)
{
// Copy the database to the "Local application data" folder.
// (This is required because we can not load a SQLite database
// directly from the .apk package; SQLite requires R/W access and
// we would like to avoid memory backing).
// TODO: do we need to add "Tell-OP" at the end? See
// https://developer.xamarin.com/guides/ios/application_fundamentals/working_with_the_file_system/
string directoryPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "..", "Library", "Application Support");
string databasePath = Path.Combine(directoryPath, databaseName);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
if (!File.Exists(databasePath))
{
char[] splitChars = { '.' };
string[] splitDBName = databaseName.Split(splitChars);
string splitName;
string splitExt;
if (splitChars.GetLength(0) == 1)
{
splitName = splitDBName[0];
splitExt = string.Empty;
}
else
{
splitName = splitDBName[0];
splitExt = splitDBName[1];
}
File.Copy(NSBundle.MainBundle.PathForResource(splitName, splitExt), databasePath);
}
// Initialize the connection.
return(new SQLiteConnection(databasePath, openFlags));
}
void LoadReadWrite(SQLiteOpenFlags openFlags, Action <DatabaseController> onComplete)
{
string pathToCopy = File.Exists(saveFilePath) ? saveFilePath : (File.Exists(assetFilePath) ? assetFilePath : null);
if (!string.IsNullOrEmpty(pathToCopy))
{
Copy(pathToCopy, tempFilePath, delegate {
DidLoad(new SQLiteConnection(tempFilePath, openFlags, true), onComplete);
});
}
else
{
var tempPath = Path.Combine(Application.persistentDataPath, "Temp");
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
DidLoad(new SQLiteConnection(tempFilePath, openFlags, true), onComplete);
}
}
public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = false)
{
if (string.IsNullOrEmpty(databasePath))
{
throw new ArgumentException("Must be specified", "databasePath");
}
DatabasePath = databasePath;
mayCreateSyncObject(databasePath);
byte[] nullTerminatedUtf = GetNullTerminatedUtf8(DatabasePath);
IntPtr db;
SQLite3.Result result = SQLite3.Open(nullTerminatedUtf, out db, (int)openFlags, IntPtr.Zero);
Handle = db;
if (result != 0)
{
throw SQLiteException.New(result, $"Could not open database file: {DatabasePath} ({result})");
}
_open = true;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
BusyTimeout = TimeSpan.FromSeconds(0.1);
}
static SQLiteConnection EstablishConnection(string databasePath)
{
try
{
const SQLiteOpenFlags flags = SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite;
return(new SQLiteConnection(databasePath, flags, storeDateTimeAsTicks: true));
}
catch (BadImageFormatException e)
{
throw new ApplicationException("Could not initialize SQLite connection - this is probably a sign that you've included sqlite3.dll for the wrong platform. Figure out whether your process is running as x86 or x64 and be sure to include a version of sqlite3.dll that is compiled for that platform", e);
}
catch (DllNotFoundException e)
{
throw new ApplicationException(string.Format("Unable to load sqlite3.dll - you need to make sure that the sqlite3.dll is present in the runtime directory ({0}) of your program. Figure out whether your process is running as x86 or x64 and be sure to include a version of sqlite3.dll that is compiled for that platform", AppDomain.CurrentDomain.BaseDirectory), e);
}
catch (Exception e)
{
throw new ApplicationException(string.Format("An error occurred when attempting to initialize SQLite database {0}", databasePath), e);
}
}
/// <summary>
/// Constructs a new SQLiteConnection and opens a SQLite database specified by databasePath.
/// </summary>
/// <param name="databasePath">
/// Specifies the path to the database file.
/// </param>
/// <param name="storeDateTimeAsTicks">
/// Specifies whether to store DateTime properties as ticks (true) or strings (false). You
/// absolutely do want to store them as Ticks in all new projects. The default of false is
/// only here for backwards compatibility. There is a *significant* speed advantage, with no
/// down sides, when setting storeDateTimeAsTicks = true.
/// </param>
public SQLiteConnection(string key, string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = false)
{
DatabasePath = databasePath;
mayCreateSyncObject(databasePath);
Sqlite3DatabaseHandle handle;
UnityEngine.Debug.Log("start SQLite3.Open");
// open using the byte[]
// in the case where the path may include Unicode
// force open to using UTF-8 using sqlite3_open_v2
var databasePathAsBytes = GetNullTerminatedUtf8(DatabasePath);
var r = SQLite3.Open(databasePathAsBytes, out handle, (int)openFlags, IntPtr.Zero);
UnityEngine.Debug.LogFormat("open result = {0}", r);
if (r != SQLite3.Result.OK)
{
throw new Exception(String.Format("Could not open database file: {0} ({1})", DatabasePath, r));
}
_open = true;
Handle = handle;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
BusyTimeout = TimeSpan.FromSeconds(0.1);
if (!string.IsNullOrEmpty(key))
{
UnityEngine.Debug.Log("start SQLite3.Key");
var rr = SQLite3.Key(Handle, key, key.Length);
UnityEngine.Debug.LogFormat("key result = {0}", rr);
if (rr != SQLite3.Result.OK)
{
string msg = SQLite3.GetErrmsg(Handle);
throw new Exception(msg);
}
}
}
public SQLiteConnection(string databasePath, string password, SQLiteOpenFlags openFlags,
bool storeDateTimeAsTicks = false)
{
if (string.IsNullOrEmpty(databasePath))
{
throw new ArgumentException("Must be specified", "databasePath");
}
DatabasePath = databasePath;
Sqlite3DatabaseHandle handle;
byte[] databasePathAsBytes = GetNullTerminatedUtf8(this.DatabasePath);
SQLite3.Result r = SQLite3.Open(databasePathAsBytes, out handle, (int)openFlags, IntPtr.Zero);
Handle = handle;
if (r != SQLite3.Result.OK)
{
throw SQLiteException.New(r,
string.Format("Could not open database file: {0} ({1})", this.DatabasePath, r));
}
if (!string.IsNullOrEmpty(password))
{
SQLite3.Result result = SQLite3.Key(handle, password, password.Length);
if (result != SQLite3.Result.OK)
{
throw SQLiteException.New(r,
string.Format("Could not open database file: {0} ({1})", this.DatabasePath, r));
}
}
Opened = true;
StoreDateTimeAsTicks = storeDateTimeAsTicks;
BusyTimeout = TimeSpan.FromSeconds(0.1);
}
public SQLiteConnectionWithLock GetConnection(SQLiteConnectionString connectionString, SQLiteOpenFlags openFlags)
{
lock (_entriesLock)
{
Entry entry;
string key = connectionString.ConnectionString;
if (!_entries.TryGetValue(key, out entry))
{
entry = new Entry(connectionString, openFlags);
_entries[key] = entry;
}
return(entry.Connection);
}
}
public abstract SQLiteConnection GetDatabase(string name, SQLiteOpenFlags openFlags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create,
bool storeDateTimeAsTicks = true, IBlobSerializer serializer = null,
IDictionary <string, TableMapping> tableMappings = null,
IDictionary <Type, string> extraTypeMappings = null, IContractResolver resolver = null);
public static extern SQLiteErrorCode sqlite3_open_v2(byte[] utf8Filename, out SqliteDatabaseHandle db, SQLiteOpenFlags flags, byte[] vfs);
