摘自编译后的.cs文件，版权归原作者所有：
// Decompiled with JetBrains decompiler
// Type: SQLite.SQLiteConnection
// Assembly: SQLite-net, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: E6176266-E10E-4143-A13A-15E20E5B743C
// Assembly location: ...\packages\sqlite-net-pcl.1.4.118\lib\netstandard1.1\SQLite-net.dll
using SQLitePCL;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading;
namespace SQLite
{
/// <summary>Represents an open connection to a SQLite database.</summary>
public class SQLiteConnection : IDisposable
{
private Random _rand = new Random();
private bool _open;
private TimeSpan _busyTimeout;
private Dictionary<string, TableMapping> _mappings;
private Dictionary<string, TableMapping> _tables;
private Stopwatch _sw;
private long _elapsedMilliseconds;
private int _transactionDepth;
internal static readonly sqlite3 NullHandle;
public sqlite3 Handle { get; private set; }
public string DatabasePath { get; private set; }
public bool TimeExecution { get; set; }
public bool Trace { get; set; }
public Action<string> Tracer { get; set; }
public bool StoreDateTimeAsTicks { get; private set; }
static SQLiteConnection()
{
Batteries_V2.Init();
}
/// <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 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>
public SQLiteConnection(string databasePath, bool storeDateTimeAsTicks = true)
: this(databasePath, SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create, 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="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>
public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags, bool storeDateTimeAsTicks = true)
{
if (string.IsNullOrEmpty(databasePath))
throw new ArgumentException("Must be specified", nameof (databasePath));
this.DatabasePath = databasePath;
sqlite3 db;
SQLite3.Result r = SQLite3.Open(databasePath, out db, (int) openFlags, IntPtr.Zero);
this.Handle = db;
if (r != SQLite3.Result.OK)
throw SQLiteException.New(r, string.Format("Could not open database file: {0} ({1})", new object[2]
{
(object) this.DatabasePath,
(object) r
}));
this._open = true;
this.StoreDateTimeAsTicks = storeDateTimeAsTicks;
this.BusyTimeout = TimeSpan.FromSeconds(0.1);
this.Tracer = (Action<string>) (line => {});
}
/// <summary>
/// Sets a busy handler to sleep the specified amount of time when a table is locked.
/// The handler will sleep multiple times until a total time of <see cref="P:SQLite.SQLiteConnection.BusyTimeout" /> has accumulated.
/// </summary>
public TimeSpan BusyTimeout
{
get
{
return this._busyTimeout;
}
set
{
this._busyTimeout = value;
if (this.Handle == SQLiteConnection.NullHandle)
return;
int num = (int) SQLite3.BusyTimeout(this.Handle, (int) this._busyTimeout.TotalMilliseconds);
}
}
/// <summary>
/// Returns the mappings from types to tables that the connection
/// currently understands.
/// </summary>
public IEnumerable<TableMapping> TableMappings
{
get
{
if (this._tables == null)
return Enumerable.Empty<TableMapping>();
return (IEnumerable<TableMapping>) this._tables.Values;
}
}
/// <summary>
/// Retrieves the mapping that is automatically generated for the given type.
/// </summary>
/// <param name="type">
/// The type whose mapping to the database is returned.
/// </param>
/// <param name="createFlags">
/// Optional flags allowing implicit PK and indexes based on naming conventions
/// </param>
/// <returns>
/// The mapping represents the schema of the columns of the database and contains
/// methods to set and get properties of objects.
/// </returns>
public TableMapping GetMapping(Type type, CreateFlags createFlags = CreateFlags.None)
{
if (this._mappings == null)
this._mappings = new Dictionary<string, TableMapping>();
TableMapping tableMapping;
if (!this._mappings.TryGetValue(type.FullName, out tableMapping))
{
tableMapping = new TableMapping(type, createFlags);
this._mappings[type.FullName] = tableMapping;
}
return tableMapping;
}
/// <summary>
/// Retrieves the mapping that is automatically generated for the given type.
/// </summary>
/// <param name="createFlags">
/// Optional flags allowing implicit PK and indexes based on naming conventions
/// </param>
/// <returns>
/// The mapping represents the schema of the columns of the database and contains
/// methods to set and get properties of objects.
/// </returns>
public TableMapping GetMapping<T>(CreateFlags createFlags = CreateFlags.None)
{
return this.GetMapping(typeof (T), createFlags);
}
/// <summary>
/// Executes a "drop table" on the database. This is non-recoverable.
/// </summary>
public int DropTable<T>()
{
return this.DropTable(this.GetMapping(typeof (T), CreateFlags.None));
}
/// <summary>
/// Executes a "drop table" on the database. This is non-recoverable.
/// </summary>
/// <param name="map">The TableMapping used to identify the table.</param>
public int DropTable(TableMapping map)
{
return this.Execute(string.Format("drop table if exists \"{0}\"", new object[1]
{
(object) map.TableName
}));
}
/// <summary>
/// Executes a "create table if not exists" on the database. It also
/// creates any specified indexes on the columns of the table. It uses
/// a schema automatically generated from the specified type. You can
/// later access this schema by calling GetMapping.
/// </summary>
/// <returns>The number of entries added to the database schema.</returns>
public int CreateTable<T>(CreateFlags createFlags = CreateFlags.None)
{
return this.CreateTable(typeof (T), createFlags);
}
/// <summary>
/// Executes a "create table if not exists" on the database. It also
/// creates any specified indexes on the columns of the table. It uses
/// a schema automatically generated from the specified type. You can
/// later access this schema by calling GetMapping.
/// </summary>
/// <param name="ty">Type to reflect to a database table.</param>
/// <param name="createFlags">Optional flags allowing implicit PK and indexes based on naming conventions.</param>
/// <returns>The number of entries added to the database schema.</returns>
public int CreateTable(Type ty, CreateFlags createFlags = CreateFlags.None)
{
if (this._tables == null)
this._tables = new Dictionary<string, TableMapping>();
TableMapping mapping;
if (!this._tables.TryGetValue(ty.FullName, out mapping))
{
mapping = this.GetMapping(ty, createFlags);
this._tables.Add(ty.FullName, mapping);
}
if (mapping.Columns.Length == 0)
throw new Exception(string.Format("Cannot create a table with zero columns (does '{0}' have public properties?)", new object[1]
{
(object) ty.FullName
}));
bool flag1 = (uint) (createFlags & CreateFlags.FullTextSearch3) > 0U;
bool flag2 = (uint) (createFlags & CreateFlags.FullTextSearch4) > 0U;
string str1 = flag1 | flag2 ? "virtual " : string.Empty;
string str2 = flag1 ? "using fts3 " : (flag2 ? "using fts4 " : string.Empty);
int num = this.Execute("create " + str1 + "table if not exists \"" + mapping.TableName + "\" " + str2 + "(\n" + string.Join(",\n", ((IEnumerable<TableMapping.Column>) mapping.Columns).Select<TableMapping.Column, string>((Func<TableMapping.Column, string>) (p => Orm.SqlDecl(p, this.StoreDateTimeAsTicks))).ToArray<string>()) + ")");
if (num == 0)
this.MigrateTable(mapping);
Dictionary<string, SQLiteConnection.IndexInfo> dictionary = new Dictionary<string, SQLiteConnection.IndexInfo>();
foreach (TableMapping.Column column in mapping.Columns)
{
foreach (IndexedAttribute index in column.Indices)
{
string key = index.Name ?? mapping.TableName + "_" + column.Name;
SQLiteConnection.IndexInfo indexInfo;
if (!dictionary.TryGetValue(key, out indexInfo))
{
indexInfo = new SQLiteConnection.IndexInfo()
{
IndexName = key,
TableName = mapping.TableName,
Unique = index.Unique,
Columns = new List<SQLiteConnection.IndexedColumn>()
};
dictionary.Add(key, indexInfo);
}
if (index.Unique != indexInfo.Unique)
throw new Exception("All the columns in an index must have the same value for their Unique property");
indexInfo.Columns.Add(new SQLiteConnection.IndexedColumn()
{
Order = index.Order,
ColumnName = column.Name
});
}
}
foreach (string key in dictionary.Keys)
{
SQLiteConnection.IndexInfo indexInfo = dictionary[key];
string[] array = indexInfo.Columns.OrderBy<SQLiteConnection.IndexedColumn, int>((Func<SQLiteConnection.IndexedColumn, int>) (i => i.Order)).Select<SQLiteConnection.IndexedColumn, string>((Func<SQLiteConnection.IndexedColumn, string>) (i => i.ColumnName)).ToArray<string>();
num += this.CreateIndex(key, indexInfo.TableName, array, indexInfo.Unique);
}
return num;
}
/// <summary>Creates an index for the specified table and columns.</summary>
/// <param name="indexName">Name of the index to create</param>
/// <param name="tableName">Name of the database table</param>
/// <param name="columnNames">An array of column names to index</param>
/// <param name="unique">Whether the index should be unique</param>
public int CreateIndex(string indexName, string tableName, string[] columnNames, bool unique = false)
{
return this.Execute(string.Format("create {2} index if not exists \"{3}\" on \"{0}\"(\"{1}\")", (object) tableName, (object) string.Join("\", \"", columnNames), unique ? (object) nameof (unique) : (object) "", (object) indexName));
}
/// <summary>Creates an index for the specified table and column.</summary>
/// <param name="indexName">Name of the index to create</param>
/// <param name="tableName">Name of the database table</param>
/// <param name="columnName">Name of the column to index</param>
/// <param name="unique">Whether the index should be unique</param>
public int CreateIndex(string indexName, string tableName, string columnName, bool unique = false)
{
return this.CreateIndex(indexName, tableName, new string[1]
{
columnName
}, (unique ? 1 : 0) != 0);
}
/// <summary>Creates an index for the specified table and column.</summary>
/// <param name="tableName">Name of the database table</param>
/// <param name="columnName">Name of the column to index</param>
/// <param name="unique">Whether the index should be unique</param>
public int CreateIndex(string tableName, string columnName, bool unique = false)
{
return this.CreateIndex(tableName + "_" + columnName, tableName, columnName, unique);
}
/// <summary>Creates an index for the specified table and columns.</summary>
/// <param name="tableName">Name of the database table</param>
/// <param name="columnNames">An array of column names to index</param>
/// <param name="unique">Whether the index should be unique</param>
public int CreateIndex(string tableName, string[] columnNames, bool unique = false)
{
return this.CreateIndex(tableName + "_" + string.Join("_", columnNames), tableName, columnNames, unique);
}
/// <summary>
/// Creates an index for the specified object property.
/// e.g. CreateIndex<Client>(c => c.Name);
/// </summary>
/// <typeparam name="T">Type to reflect to a database table.</typeparam>
/// <param name="property">Property to index</param>
/// <param name="unique">Whether the index should be unique</param>
public void CreateIndex<T>(Expression<Func<T, object>> property, bool unique = false)
{
PropertyInfo member = (property.Body.NodeType != ExpressionType.Convert ? property.Body as MemberExpression : ((UnaryExpression) property.Body).Operand as MemberExpression).Member as PropertyInfo;
if ((object) member == null)
throw new ArgumentException("The lambda expression 'property' should point to a valid Property");
string name1 = member.Name;
TableMapping mapping = this.GetMapping<T>(CreateFlags.None);
string name2 = mapping.FindColumnWithPropertyName(name1).Name;
this.CreateIndex(mapping.TableName, name2, unique);
}
public List<SQLiteConnection.ColumnInfo> GetTableInfo(string tableName)
{
return this.Query<SQLiteConnection.ColumnInfo>("pragma table_info(\"" + tableName + "\")");
}
private void MigrateTable(TableMapping map)
{
List<SQLiteConnection.ColumnInfo> tableInfo = this.GetTableInfo(map.TableName);
List<TableMapping.Column> columnList = new List<TableMapping.Column>();
foreach (TableMapping.Column column in map.Columns)
{
bool flag = false;
foreach (SQLiteConnection.ColumnInfo columnInfo in tableInfo)
{
flag = string.Compare(column.Name, columnInfo.Name, StringComparison.OrdinalIgnoreCase) == 0;
if (flag)
break;
}
if (!flag)
columnList.Add(column);
}
foreach (TableMapping.Column p in columnList)
this.Execute("alter table \"" + map.TableName + "\" add column " + Orm.SqlDecl(p, this.StoreDateTimeAsTicks));
}
/// <summary>
/// Creates a new SQLiteCommand. Can be overridden to provide a sub-class.
/// </summary>
/// <seealso cref="M:SQLite.SQLiteCommand.OnInstanceCreated(System.Object)" />
protected virtual SQLiteCommand NewCommand()
{
return new SQLiteCommand(this);
}
/// <summary>
/// Creates a new SQLiteCommand given the command text with arguments. Place a '?'
/// in the command text for each of the arguments.
/// </summary>
/// <param name="cmdText">The fully escaped SQL.</param>
/// <param name="ps">
/// Arguments to substitute for the occurences of '?' in the command text.
/// </param>
/// <returns>
/// A <see cref="T:SQLite.SQLiteCommand" />
/// </returns>
public SQLiteCommand CreateCommand(string cmdText, params object[] ps)
{
if (!this._open)
throw SQLiteException.New(SQLite3.Result.Error, "Cannot create commands from unopened database");
SQLiteCommand sqLiteCommand = this.NewCommand();
sqLiteCommand.CommandText = cmdText;
foreach (object p in ps)
sqLiteCommand.Bind(p);
return sqLiteCommand;
}
/// <summary>
/// Creates a SQLiteCommand given the command text (SQL) with arguments. Place a '?'
/// in the command text for each of the arguments and then executes that command.
/// Use this method instead of Query when you don't expect rows back. Such cases include
/// INSERTs, UPDATEs, and DELETEs.
/// You can set the Trace or TimeExecution properties of the connection
/// to profile execution.
/// </summary>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// The number of rows modified in the database as a result of this execution.
/// </returns>
public int Execute(string query, params object[] args)
{
SQLiteCommand command = this.CreateCommand(query, args);
if (this.TimeExecution)
{
if (this._sw == null)
this._sw = new Stopwatch();
this._sw.Reset();
this._sw.Start();
}
int num = command.ExecuteNonQuery();
if (this.TimeExecution)
{
this._sw.Stop();
this._elapsedMilliseconds += this._sw.ElapsedMilliseconds;
}
return num;
}
public T ExecuteScalar<T>(string query, params object[] args)
{
SQLiteCommand command = this.CreateCommand(query, args);
if (this.TimeExecution)
{
if (this._sw == null)
this._sw = new Stopwatch();
this._sw.Reset();
this._sw.Start();
}
T obj = command.ExecuteScalar<T>();
if (this.TimeExecution)
{
this._sw.Stop();
this._elapsedMilliseconds += this._sw.ElapsedMilliseconds;
}
return obj;
}
/// <summary>
/// Creates a SQLiteCommand given the command text (SQL) with arguments. Place a '?'
/// in the command text for each of the arguments and then executes that command.
/// It returns each row of the result using the mapping automatically generated for
/// the given type.
/// </summary>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// An enumerable with one result for each row returned by the query.
/// </returns>
public List<T> Query<T>(string query, params object[] args) where T : new()
{
return this.CreateCommand(query, args).ExecuteQuery<T>();
}
/// <summary>
/// Creates a SQLiteCommand given the command text (SQL) with arguments. Place a '?'
/// in the command text for each of the arguments and then executes that command.
/// It returns each row of the result using the mapping automatically generated for
/// the given type.
/// </summary>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// An enumerable with one result for each row returned by the query.
/// The enumerator will call sqlite3_step on each call to MoveNext, so the database
/// connection must remain open for the lifetime of the enumerator.
/// </returns>
public IEnumerable<T> DeferredQuery<T>(string query, params object[] args) where T : new()
{
return this.CreateCommand(query, args).ExecuteDeferredQuery<T>();
}
/// <summary>
/// Creates a SQLiteCommand given the command text (SQL) with arguments. Place a '?'
/// in the command text for each of the arguments and then executes that command.
/// It returns each row of the result using the specified mapping. This function is
/// only used by libraries in order to query the database via introspection. It is
/// normally not used.
/// </summary>
/// <param name="map">
/// A <see cref="T:SQLite.TableMapping" /> to use to convert the resulting rows
/// into objects.
/// </param>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// An enumerable with one result for each row returned by the query.
/// </returns>
public List<object> Query(TableMapping map, string query, params object[] args)
{
return this.CreateCommand(query, args).ExecuteQuery<object>(map);
}
/// <summary>
/// Creates a SQLiteCommand given the command text (SQL) with arguments. Place a '?'
/// in the command text for each of the arguments and then executes that command.
/// It returns each row of the result using the specified mapping. This function is
/// only used by libraries in order to query the database via introspection. It is
/// normally not used.
/// </summary>
/// <param name="map">
/// A <see cref="T:SQLite.TableMapping" /> to use to convert the resulting rows
/// into objects.
/// </param>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// An enumerable with one result for each row returned by the query.
/// The enumerator will call sqlite3_step on each call to MoveNext, so the database
/// connection must remain open for the lifetime of the enumerator.
/// </returns>
public IEnumerable<object> DeferredQuery(TableMapping map, string query, params object[] args)
{
return this.CreateCommand(query, args).ExecuteDeferredQuery<object>(map);
}
/// <summary>
/// Returns a queryable interface to the table represented by the given type.
/// </summary>
/// <returns>
/// A queryable object that is able to translate Where, OrderBy, and Take
/// queries into native SQL.
/// </returns>
public TableQuery<T> Table<T>() where T : new()
{
return new TableQuery<T>(this);
}
/// <summary>
/// Attempts to retrieve an object with the given primary key from the table
/// associated with the specified type. Use of this method requires that
/// the given type have a designated PrimaryKey (using the PrimaryKeyAttribute).
/// </summary>
/// <param name="pk">The primary key.</param>
/// <returns>
/// The object with the given primary key. Throws a not found exception
/// if the object is not found.
/// </returns>
public T Get<T>(object pk) where T : new()
{
return this.Query<T>(this.GetMapping(typeof (T), CreateFlags.None).GetByPrimaryKeySql, pk).First<T>();
}
/// <summary>
/// Attempts to retrieve an object with the given primary key from the table
/// associated with the specified type. Use of this method requires that
/// the given type have a designated PrimaryKey (using the PrimaryKeyAttribute).
/// </summary>
/// <param name="pk">The primary key.</param>
/// <param name="map">The TableMapping used to identify the table.</param>
/// <returns>
/// The object with the given primary key. Throws a not found exception
/// if the object is not found.
/// </returns>
public object Get(object pk, TableMapping map)
{
return this.Query(map, map.GetByPrimaryKeySql, pk).First<object>();
}
/// <summary>
/// Attempts to retrieve the first object that matches the predicate from the table
/// associated with the specified type.
/// </summary>
/// <param name="predicate">A predicate for which object to find.</param>
/// <returns>
/// The object that matches the given predicate. Throws a not found exception
/// if the object is not found.
/// </returns>
public T Get<T>(Expression<Func<T, bool>> predicate) where T : new()
{
return this.Table<T>().Where(predicate).First();
}
/// <summary>
/// Attempts to retrieve an object with the given primary key from the table
/// associated with the specified type. Use of this method requires that
/// the given type have a designated PrimaryKey (using the PrimaryKeyAttribute).
/// </summary>
/// <param name="pk">The primary key.</param>
/// <returns>
/// The object with the given primary key or null
/// if the object is not found.
/// </returns>
public T Find<T>(object pk) where T : new()
{
return this.Query<T>(this.GetMapping(typeof (T), CreateFlags.None).GetByPrimaryKeySql, pk).FirstOrDefault<T>();
}
/// <summary>
/// Attempts to retrieve an object with the given primary key from the table
/// associated with the specified type. Use of this method requires that
/// the given type have a designated PrimaryKey (using the PrimaryKeyAttribute).
/// </summary>
/// <param name="pk">The primary key.</param>
/// <param name="map">The TableMapping used to identify the table.</param>
/// <returns>
/// The object with the given primary key or null
/// if the object is not found.
/// </returns>
public object Find(object pk, TableMapping map)
{
return this.Query(map, map.GetByPrimaryKeySql, pk).FirstOrDefault<object>();
}
/// <summary>
/// Attempts to retrieve the first object that matches the predicate from the table
/// associated with the specified type.
/// </summary>
/// <param name="predicate">A predicate for which object to find.</param>
/// <returns>
/// The object that matches the given predicate or null
/// if the object is not found.
/// </returns>
public T Find<T>(Expression<Func<T, bool>> predicate) where T : new()
{
return this.Table<T>().Where(predicate).FirstOrDefault();
}
/// <summary>
/// Attempts to retrieve the first object that matches the query from the table
/// associated with the specified type.
/// </summary>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// The object that matches the given predicate or null
/// if the object is not found.
/// </returns>
public T FindWithQuery<T>(string query, params object[] args) where T : new()
{
return this.Query<T>(query, args).FirstOrDefault<T>();
}
/// <summary>
/// Attempts to retrieve the first object that matches the query from the table
/// associated with the specified type.
/// </summary>
/// <param name="map">The TableMapping used to identify the table.</param>
/// <param name="query">The fully escaped SQL.</param>
/// <param name="args">
/// Arguments to substitute for the occurences of '?' in the query.
/// </param>
/// <returns>
/// The object that matches the given predicate or null
/// if the object is not found.
/// </returns>
public object FindWithQuery(TableMapping map, string query, params object[] args)
{
return this.Query(map, query, args).FirstOrDefault<object>();
}
/// <summary>
/// Whether <see cref="M:SQLite.SQLiteConnection.BeginTransaction" /> has been called and the database is waiting for a <see cref="M:SQLite.SQLiteConnection.Commit" />.
/// </summary>
public bool IsInTransaction
{
get
{
return this._transactionDepth > 0;
}
}
/// <summary>
/// Begins a new transaction. Call <see cref="M:SQLite.SQLiteConnection.Commit" /> to end the transaction.
/// </summary>
/// <example cref="T:System.InvalidOperationException">Throws if a transaction has already begun.</example>
public void BeginTransaction()
{
if (Interlocked.CompareExchange(ref this._transactionDepth, 1, 0) != 0)
throw new InvalidOperationException("Cannot begin a transaction while already in a transaction.");
try
{
this.Execute("begin transaction");
}
catch (Exception ex)
{
SQLiteException sqLiteException = ex as SQLiteException;
if (sqLiteException != null)
{
switch (sqLiteException.Result)
{
case SQLite3.Result.Busy:
case SQLite3.Result.NoMem:
case SQLite3.Result.Interrupt:
case SQLite3.Result.IOError:
case SQLite3.Result.Full:
this.RollbackTo((string) null, true);
break;
}
}
else
Interlocked.Decrement(ref this._transactionDepth);
throw;
}
}
/// <summary>
/// Creates a savepoint in the database at the current point in the transaction timeline.
/// Begins a new transaction if one is not in progress.
///
/// Call <see cref="M:SQLite.SQLiteConnection.RollbackTo(System.String)" /> to undo transactions since the returned savepoint.
/// Call <see cref="M:SQLite.SQLiteConnection.Release(System.String)" /> to commit transactions after the savepoint returned here.
/// Call <see cref="M:SQLite.SQLiteConnection.Commit" /> to end the transaction, committing all changes.
/// </summary>
/// <returns>A string naming the savepoint.</returns>
public string SaveTransactionPoint()
{
string str = "S" + (object) this._rand.Next((int) short.MaxValue) + "D" + (object) (Interlocked.Increment(ref this._transactionDepth) - 1);
try
{
this.Execute("savepoint " + str);
}
catch (Exception ex)
{
SQLiteException sqLiteException = ex as SQLiteException;
if (sqLiteException != null)
{
switch (sqLiteException.Result)
{
case SQLite3.Result.Busy:
case SQLite3.Result.NoMem:
case SQLite3.Result.Interrupt:
case SQLite3.Result.IOError:
case SQLite3.Result.Full:
this.RollbackTo((string) null, true);
break;
}
}
else
Interlocked.Decrement(ref this._transactionDepth);
throw;
}
return str;
}
/// <summary>
/// Rolls back the transaction that was begun by <see cref="M:SQLite.SQLiteConnection.BeginTransaction" /> or <see cref="M:SQLite.SQLiteConnection.SaveTransactionPoint" />.
/// </summary>
public void Rollback()
{
this.RollbackTo((string) null, false);
}
/// <summary>
/// Rolls back the savepoint created by <see cref="M:SQLite.SQLiteConnection.BeginTransaction" /> or SaveTransactionPoint.
/// </summary>
/// <param name="savepoint">The name of the savepoint to roll back to, as returned by <see cref="M:SQLite.SQLiteConnection.SaveTransactionPoint" />. If savepoint is null or empty, this method is equivalent to a call to <see cref="M:SQLite.SQLiteConnection.Rollback" /></param>
public void RollbackTo(string savepoint)
{
this.RollbackTo(savepoint, false);
}
/// <summary>
/// Rolls back the transaction that was begun by <see cref="M:SQLite.SQLiteConnection.BeginTransaction" />.
/// </summary>
/// <param name="savepoint">The name of the savepoint to roll back to, as returned by <see cref="M:SQLite.SQLiteConnection.SaveTransactionPoint" />. If savepoint is null or empty, this method is equivalent to a call to <see cref="M:SQLite.SQLiteConnection.Rollback" /></param>
/// <param name="noThrow">true to avoid throwing exceptions, false otherwise</param>
private void RollbackTo(string savepoint, bool noThrow)
{
try
{
if (string.IsNullOrEmpty(savepoint))
{
if (Interlocked.Exchange(ref this._transactionDepth, 0) <= 0)
return;
this.Execute("rollback");
}
else
this.DoSavePointExecute(savepoint, "rollback to ");
}
catch (SQLiteException ex)
{
if (noThrow)
return;
throw;
}
}
/// <summary>
/// Releases a savepoint returned from <see cref="M:SQLite.SQLiteConnection.SaveTransactionPoint" />. Releasing a savepoint
/// makes changes since that savepoint permanent if the savepoint began the transaction,
/// or otherwise the changes are permanent pending a call to <see cref="M:SQLite.SQLiteConnection.Commit" />.
///
/// The RELEASE command is like a COMMIT for a SAVEPOINT.
/// </summary>
/// <param name="savepoint">The name of the savepoint to release. The string should be the result of a call to <see cref="M:SQLite.SQLiteConnection.SaveTransactionPoint" /></param>
public void Release(string savepoint)
{
this.DoSavePointExecute(savepoint, "release ");
}
private void DoSavePointExecute(string savepoint, string cmd)
{
int num = savepoint.IndexOf('D');
int result;
if (num < 2 || savepoint.Length <= num + 1 || (!int.TryParse(savepoint.Substring(num + 1), out result) || 0 > result) || result >= this._transactionDepth)
throw new ArgumentException("savePoint is not valid, and should be the result of a call to SaveTransactionPoint.", "savePoint");
Volatile.Write(ref this._transactionDepth, result);
this.Execute(cmd + savepoint);
}
/// <summary>
/// Commits the transaction that was begun by <see cref="M:SQLite.SQLiteConnection.BeginTransaction" />.
/// </summary>
public void Commit()
{
if (Interlocked.Exchange(ref this._transactionDepth, 0) == 0)
return;
this.Execute("commit");
}
/// <summary>
/// Executes <paramref name="action" /> within a (possibly nested) transaction by wrapping it in a SAVEPOINT. If an
/// exception occurs the whole transaction is rolled back, not just the current savepoint. The exception
/// is rethrown.
/// </summary>
/// <param name="action">
/// The <see cref="T:System.Action" /> to perform within a transaction. <paramref name="action" /> can contain any number
/// of operations on the connection but should never call <see cref="M:SQLite.SQLiteConnection.BeginTransaction" /> or
/// <see cref="M:SQLite.SQLiteConnection.Commit" />.
/// </param>
public void RunInTransaction(Action action)
{
try
{
string savepoint = this.SaveTransactionPoint();
action();
this.Release(savepoint);
}
catch (Exception ex)
{
this.Rollback();
throw;
}
}
/// <summary>Inserts all specified objects.</summary>
/// <param name="objects">
/// An <see cref="T:System.Collections.IEnumerable" /> of the objects to insert.
/// <param name="runInTransaction" />
/// A boolean indicating if the inserts should be wrapped in a transaction.
/// </param>
/// <returns>The number of rows added to the table.</returns>
public int InsertAll(IEnumerable objects, bool runInTransaction = true)
{
int c = 0;
if (runInTransaction)
{
this.RunInTransaction((Action) (() =>
{
foreach (object obj in objects)
c += this.Insert(obj);
}));
}
else
{
foreach (object obj in objects)
c += this.Insert(obj);
}
return c;
}
/// <summary>Inserts all specified objects.</summary>
/// <param name="objects">
/// An <see cref="T:System.Collections.IEnumerable" /> of the objects to insert.
/// </param>
/// <param name="extra">
/// Literal SQL code that gets placed into the command. INSERT {extra} INTO ...
/// </param>
/// <param name="runInTransaction">
/// A boolean indicating if the inserts should be wrapped in a transaction.
/// </param>
/// <returns>The number of rows added to the table.</returns>
public int InsertAll(IEnumerable objects, string extra, bool runInTransaction = true)
{
int c = 0;
if (runInTransaction)
{
this.RunInTransaction((Action) (() =>
{
foreach (object obj in objects)
c += this.Insert(obj, extra);
}));
}
else
{
foreach (object obj in objects)
c += this.Insert(obj);
}
return c;
}
/// <summary>Inserts all specified objects.</summary>
/// <param name="objects">
/// An <see cref="T:System.Collections.IEnumerable" /> of the objects to insert.
/// </param>
/// <param name="objType">The type of object to insert.</param>
/// <param name="runInTransaction">
/// A boolean indicating if the inserts should be wrapped in a transaction.
/// </param>
/// <returns>The number of rows added to the table.</returns>
public int InsertAll(IEnumerable objects, Type objType, bool runInTransaction = true)
{
int c = 0;
if (runInTransaction)
{
this.RunInTransaction((Action) (() =>
{
foreach (object obj in objects)
c += this.Insert(obj, objType);
}));
}
else
{
foreach (object obj in objects)
c += this.Insert(obj, objType);
}
return c;
}
/// <summary>
/// Inserts the given object and retrieves its
/// auto incremented primary key if it has one.
/// </summary>
/// <param name="obj">The object to insert.</param>
/// <returns>The number of rows added to the table.</returns>
public int Insert(object obj)
{
if (obj == null)
return 0;
return this.Insert(obj, "", Orm.GetType(obj));
}
/// <summary>
/// Inserts the given object and retrieves its
/// auto incremented primary key if it has one.
/// If a UNIQUE constraint violation occurs with
/// some pre-existing object, this function deletes
/// the old object.
/// </summary>
/// <param name="obj">The object to insert.</param>
/// <returns>The number of rows modified.</returns>
public int InsertOrReplace(object obj)
{
if (obj == null)
return 0;
return this.Insert(obj, "OR REPLACE", Orm.GetType(obj));
}
/// <summary>
/// Inserts the given object and retrieves its
/// auto incremented primary key if it has one.
/// </summary>
/// <param name="obj">The object to insert.</param>
/// <param name="objType">The type of object to insert.</param>
/// <returns>The number of rows added to the table.</returns>
public int Insert(object obj, Type objType)
{
return this.Insert(obj, "", objType);
}
/// <summary>
/// Inserts the given object and retrieves its
/// auto incremented primary key if it has one.
/// If a UNIQUE constraint violation occurs with
/// some pre-existing object, this function deletes
/// the old object.
/// </summary>
/// <param name="obj">The object to insert.</param>
/// <param name="objType">The type of object to insert.</param>
/// <returns>The number of rows modified.</returns>
public int InsertOrReplace(object obj, Type objType)
{
return this.Insert(obj, "OR REPLACE", objType);
}
/// <summary>
/// Inserts the given object and retrieves its
/// auto incremented primary key if it has one.
/// </summary>
/// <param name="obj">The object to insert.</param>
/// <param name="extra">
/// Literal SQL code that gets placed into the command. INSERT {extra} INTO ...
/// </param>
/// <returns>The number of rows added to the table.</returns>
public int Insert(object obj, string extra)
{
if (obj == null)
return 0;
return this.Insert(obj, extra, Orm.GetType(obj));
}
/// <summary>
/// Inserts the given object and retrieves its
/// auto incremented primary key if it has one.
/// </summary>
/// <param name="obj">The object to insert.</param>
/// <param name="extra">
/// Literal SQL code that gets placed into the command. INSERT {extra} INTO ...
/// </param>
/// <param name="objType">The type of object to insert.</param>
/// <returns>The number of rows added to the table.</returns>
public int Insert(object obj, string extra, Type objType)
{
if (obj == null || (object) objType == null)
return 0;
TableMapping mapping = this.GetMapping(objType, CreateFlags.None);
if (mapping.PK != null && mapping.PK.IsAutoGuid && mapping.PK.GetValue(obj).Equals((object) Guid.Empty))
mapping.PK.SetValue(obj, (object) Guid.NewGuid());
TableMapping.Column[] columnArray = string.Compare(extra, "OR REPLACE", StringComparison.OrdinalIgnoreCase) == 0 ? mapping.InsertOrReplaceColumns : mapping.InsertColumns;
object[] source = new object[columnArray.Length];
for (int index = 0; index < source.Length; ++index)
source[index] = columnArray[index].GetValue(obj);
PreparedSqlLiteInsertCommand insertCommand = mapping.GetInsertCommand(this, extra);
int num;
lock (insertCommand)
{
try
{
num = insertCommand.ExecuteNonQuery(source);
}
catch (SQLiteException ex)
{
if (SQLite3.ExtendedErrCode(this.Handle) == SQLite3.ExtendedResult.ConstraintNotNull)
throw NotNullConstraintViolationException.New(ex.Result, ex.Message, mapping, obj);
throw;
}
if (mapping.HasAutoIncPK)
{
long id = SQLite3.LastInsertRowid(this.Handle);
mapping.SetAutoIncPK(obj, id);
}
}
if (num > 0)
this.OnTableChanged(mapping, NotifyTableChangedAction.Insert);
return num;
}
/// <summary>
/// Updates all of the columns of a table using the specified object
/// except for its primary key.
/// The object is required to have a primary key.
/// </summary>
/// <param name="obj">
/// The object to update. It must have a primary key designated using the PrimaryKeyAttribute.
/// </param>
/// <returns>The number of rows updated.</returns>
public int Update(object obj)
{
if (obj == null)
return 0;
return this.Update(obj, Orm.GetType(obj));
}
/// <summary>
/// Updates all of the columns of a table using the specified object
/// except for its primary key.
/// The object is required to have a primary key.
/// </summary>
/// <param name="obj">
/// The object to update. It must have a primary key designated using the PrimaryKeyAttribute.
/// </param>
/// <param name="objType">The type of object to insert.</param>
/// <returns>The number of rows updated.</returns>
public int Update(object obj, Type objType)
{
if (obj == null || (object) objType == null)
return 0;
TableMapping mapping = this.GetMapping(objType, CreateFlags.None);
TableMapping.Column pk = mapping.PK;
if (pk == null)
throw new NotSupportedException("Cannot update " + mapping.TableName + ": it has no PK");
IEnumerable<TableMapping.Column> source = ((IEnumerable<TableMapping.Column>) mapping.Columns).Where<TableMapping.Column>((Func<TableMapping.Column, bool>) (p => p != pk));
List<object> objectList = new List<object>(source.Select<TableMapping.Column, object>((Func<TableMapping.Column, object>) (c => c.GetValue(obj))));
objectList.Add(pk.GetValue(obj));
string query = string.Format("update \"{0}\" set {1} where {2} = ? ", new object[3]
{
(object) mapping.TableName,
(object) string.Join(",", source.Select<TableMapping.Column, string>((Func<TableMapping.Column, string>) (c => "\"" + c.Name + "\" = ? ")).ToArray<string>()),
(object) pk.Name
});
int num;
try
{
num = this.Execute(query, objectList.ToArray());
}
catch (SQLiteException ex)
{
if (ex.Result == SQLite3.Result.Constraint && SQLite3.ExtendedErrCode(this.Handle) == SQLite3.ExtendedResult.ConstraintNotNull)
throw NotNullConstraintViolationException.New(ex, mapping, obj);
throw ex;
}
if (num > 0)
this.OnTableChanged(mapping, NotifyTableChangedAction.Update);
return num;
}
/// <summary>Updates all specified objects.</summary>
/// <param name="objects">
/// An <see cref="T:System.Collections.IEnumerable" /> of the objects to insert.
/// </param>
/// <param name="runInTransaction">
/// A boolean indicating if the inserts should be wrapped in a transaction
/// </param>
/// <returns>The number of rows modified.</returns>
public int UpdateAll(IEnumerable objects, bool runInTransaction = true)
{
int c = 0;
if (runInTransaction)
{
this.RunInTransaction((Action) (() =>
{
foreach (object obj in objects)
c += this.Update(obj);
}));
}
else
{
foreach (object obj in objects)
c += this.Update(obj);
}
return c;
}
/// <summary>
/// Deletes the given object from the database using its primary key.
/// </summary>
/// <param name="objectToDelete">
/// The object to delete. It must have a primary key designated using the PrimaryKeyAttribute.
/// </param>
/// <returns>The number of rows deleted.</returns>
public int Delete(object objectToDelete)
{
TableMapping mapping = this.GetMapping(Orm.GetType(objectToDelete), CreateFlags.None);
TableMapping.Column pk = mapping.PK;
if (pk == null)
throw new NotSupportedException("Cannot delete " + mapping.TableName + ": it has no PK");
int num = this.Execute(string.Format("delete from \"{0}\" where \"{1}\" = ?", new object[2]
{
(object) mapping.TableName,
(object) pk.Name
}), pk.GetValue(objectToDelete));
if (num > 0)
this.OnTableChanged(mapping, NotifyTableChangedAction.Delete);
return num;
}
/// <summary>Deletes the object with the specified primary key.</summary>
/// <param name="primaryKey">The primary key of the object to delete.</param>
/// <returns>The number of objects deleted.</returns>
/// <typeparam name="T">The type of object.</typeparam>
public int Delete<T>(object primaryKey)
{
return this.Delete(primaryKey, this.GetMapping(typeof (T), CreateFlags.None));
}
/// <summary>Deletes the object with the specified primary key.</summary>
/// <param name="primaryKey">The primary key of the object to delete.</param>
/// <param name="map">The TableMapping used to identify the table.</param>
/// <returns>The number of objects deleted.</returns>
public int Delete(object primaryKey, TableMapping map)
{
TableMapping.Column pk = map.PK;
if (pk == null)
throw new NotSupportedException("Cannot delete " + map.TableName + ": it has no PK");
int num = this.Execute(string.Format("delete from \"{0}\" where \"{1}\" = ?", new object[2]
{
(object) map.TableName,
(object) pk.Name
}), primaryKey);
if (num > 0)
this.OnTableChanged(map, NotifyTableChangedAction.Delete);
return num;
}
/// <summary>
/// Deletes all the objects from the specified table.
/// WARNING WARNING: Let me repeat. It deletes ALL the objects from the
/// specified table. Do you really want to do that?
/// </summary>
/// <returns>The number of objects deleted.</returns>
/// <typeparam name="T">The type of objects to delete.</typeparam>
public int DeleteAll<T>()
{
return this.DeleteAll(this.GetMapping(typeof (T), CreateFlags.None));
}
/// <summary>
/// Deletes all the objects from the specified table.
/// WARNING WARNING: Let me repeat. It deletes ALL the objects from the
/// specified table. Do you really want to do that?
/// </summary>
/// <param name="map">The TableMapping used to identify the table.</param>
/// <returns>The number of objects deleted.</returns>
public int DeleteAll(TableMapping map)
{
int num = this.Execute(string.Format("delete from \"{0}\"", new object[1]
{
(object) map.TableName
}));
if (num > 0)
this.OnTableChanged(map, NotifyTableChangedAction.Delete);
return num;
}
~SQLiteConnection()
{
this.Dispose(false);
}
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize((object) this);
}
public void Close()
{
this.Dispose(true);
}
protected virtual void Dispose(bool disposing)
{
if (!this._open)
return;
if (this.Handle == SQLiteConnection.NullHandle)
return;
try
{
if (disposing)
{
if (this._mappings != null)
{
foreach (TableMapping tableMapping in this._mappings.Values)
tableMapping.Dispose();
}
SQLite3.Result r = SQLite3.Close2(this.Handle);
if (r != SQLite3.Result.OK)
{
string errmsg = SQLite3.GetErrmsg(this.Handle);
throw SQLiteException.New(r, errmsg);
}
}
else
{
int num = (int) SQLite3.Close2(this.Handle);
}
}
finally
{
this.Handle = SQLiteConnection.NullHandle;
this._open = false;
}
}
private void OnTableChanged(TableMapping table, NotifyTableChangedAction action)
{
// ISSUE: reference to a compiler-generated field
EventHandler<NotifyTableChangedEventArgs> tableChanged = this.TableChanged;
if (tableChanged == null)
return;
tableChanged((object) this, new NotifyTableChangedEventArgs(table, action));
}
public event EventHandler<NotifyTableChangedEventArgs> TableChanged;
private struct IndexedColumn
{
public int Order;
public string ColumnName;
}
private struct IndexInfo
{
public string IndexName;
public string TableName;
public bool Unique;
public List<SQLiteConnection.IndexedColumn> Columns;
}
public class ColumnInfo
{
[Column("name")]
public string Name { get; set; }
public int notnull { get; set; }
public override string ToString()
{
return this.Name;
}
}
}
}
872
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
