/src/ZebraFlickr/Core/Store/SQLite/SQLite.cs

Large files files are truncated, but you can click here to view the full file

//

// Copyright (c) 2009-2012 Krueger Systems, Inc.

// 

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// 

// The above copyright notice and this permission notice shall be included in

// all copies or substantial portions of the Software.

// 

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

//

#if WINDOWS_PHONE

#define USE_CSHARP_SQLITE

#endif



using System;

using System.Diagnostics;

using System.Runtime.InteropServices;

using System.Collections.Generic;

using System.Reflection;

using System.Linq;

using System.Linq.Expressions;

using System.Threading;



#if USE_CSHARP_SQLITE

using Community.CsharpSqlite;

using Sqlite3DatabaseHandle = Community.CsharpSqlite.Sqlite3.sqlite3;

using Sqlite3Statement = Community.CsharpSqlite.Sqlite3.Vdbe;

#else

using Sqlite3DatabaseHandle = System.IntPtr;

using Sqlite3Statement = System.IntPtr;

#endif



namespace SQLite

{

	public class SQLiteException : System.Exception

	{

		public SQLite3.Result Result { get; private set; }



		protected SQLiteException(SQLite3.Result r, string message)

			: base(message)

		{

			Result = r;

		}



		public static SQLiteException New(SQLite3.Result r, string message)

		{

			return new SQLiteException(r, message);

		}

	}



	[Flags]

	public enum SQLiteOpenFlags

	{

		ReadOnly = 1, ReadWrite = 2, Create = 4,

		NoMutex = 0x8000, FullMutex = 0x10000,

		SharedCache = 0x20000, PrivateCache = 0x40000,

		ProtectionComplete = 0x00100000,

		ProtectionCompleteUnlessOpen = 0x00200000,

		ProtectionCompleteUntilFirstUserAuthentication = 0x00300000,

		ProtectionNone = 0x00400000

	}



	/// <summary>

	/// Represents an open connection to a SQLite database.

	/// </summary>

	public class SQLiteConnection : IDisposable

	{

		private bool _open;

		private TimeSpan _busyTimeout;

		private Dictionary<string, TableMapping> _mappings = null;

		private Dictionary<string, TableMapping> _tables = null;

		private System.Diagnostics.Stopwatch _sw;

		private long _elapsedMilliseconds = 0;



		private int _trasactionDepth = 0;

		private Random _rand = new Random();



		public Sqlite3DatabaseHandle Handle { get; private set; }

#if USE_CSHARP_SQLITE

		internal static readonly Sqlite3DatabaseHandle NullHandle = null;

#else

		internal static readonly Sqlite3DatabaseHandle NullHandle = IntPtr.Zero;

#endif



		public string DatabasePath { get; private set; }



		public bool TimeExecution { get; set; }



		public bool Trace { get; set; }



		public bool StoreDateTimeAsTicks { get; private set; }



		/// <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, bool storeDateTimeAsTicks = false)

		{

			DatabasePath = databasePath;

			Sqlite3DatabaseHandle handle;

			var r = SQLite3.Open(DatabasePath, out handle);

			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(1);

		}



		/// <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;

			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

			byte[] databasePathAsBytes;

			int databasePathLength;



			databasePathLength = System.Text.Encoding.UTF8.GetByteCount(DatabasePath);

			databasePathAsBytes = new byte[databasePathLength + 1];

			databasePathLength = System.Text.Encoding.UTF8.GetBytes(DatabasePath, 0, DatabasePath.Length, databasePathAsBytes, 0);



			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(1);

		}



		static SQLiteConnection()

		{

			if (_preserveDuringLinkMagic)

			{

				var ti = new TableInfo();

				ti.name = "magic";

			}

		}



		/// <summary>

		/// Used to list some code that we want the MonoTouch linker

		/// to see, but that we never want to actually execute.

		/// </summary>

		static bool _preserveDuringLinkMagic = false;



		/// <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="BusyTimeout"/> has accumulated.

		/// </summary>

		public TimeSpan BusyTimeout

		{

			get { return _busyTimeout; }

			set

			{

				_busyTimeout = value;

				if (Handle != NullHandle)

				{

					SQLite3.BusyTimeout(Handle, (int)_busyTimeout.TotalMilliseconds);

				}

			}

		}



		/// <summary>

		/// Returns the mappings from types to tables that the connection

		/// currently understands.

		/// </summary>

		public IEnumerable<TableMapping> TableMappings

		{

			get

			{

				if (_tables == null)

				{

					return Enumerable.Empty<TableMapping>();

				}

				else

				{

					return _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>

		/// <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)

		{

			if (_mappings == null)

			{

				_mappings = new Dictionary<string, TableMapping>();

			}

			TableMapping map;

			if (!_mappings.TryGetValue(type.FullName, out map))

			{

				map = new TableMapping(type);

				_mappings[type.FullName] = map;

			}

			return map;

		}



		/// <summary>

		/// Retrieves the mapping that is automatically generated for the given type.

		/// </summary>

		/// <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>()

		{

			return GetMapping(typeof(T));

		}



		private struct IndexedColumn

		{

			public int Order;

			public string ColumnName;

		}



		private struct IndexInfo

		{

			public string IndexName;

			public string TableName;

			public bool Unique;

			public List<IndexedColumn> Columns;

		}



		/// <summary>

		/// Executes a "drop table" on the database.  This is non-recoverable.

		/// </summary>

		public int DropTable<T>()

		{

			var map = GetMapping(typeof(T));



			var query = string.Format("drop table if exists \"{0}\"", map.TableName);



			return Execute(query);

		}



		/// <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>()

		{

			return CreateTable(typeof(T));

		}



		/// <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>

		/// <returns>

		/// The number of entries added to the database schema.

		/// </returns>

		public int CreateTable(Type ty)

		{

			if (_tables == null)

			{

				_tables = new Dictionary<string, TableMapping>();

			}

			TableMapping map;

			if (!_tables.TryGetValue(ty.FullName, out map))

			{

				map = GetMapping(ty);

				_tables.Add(ty.FullName, map);

			}

			var query = "create table if not exists \"" + map.TableName + "\"(\n";



			var decls = map.Columns.Select(p => Orm.SqlDecl(p, StoreDateTimeAsTicks));

			var decl = string.Join(",\n", decls.ToArray());

			query += decl;

			query += ")";



			var count = Execute(query);



			if (count == 0)

			{ //Possible bug: This always seems to return 0?

				// Table already exists, migrate it

				MigrateTable(map);

			}



			var indexes = new Dictionary<string, IndexInfo>();

			foreach (var c in map.Columns)

			{

				foreach (var i in c.Indices)

				{

					var iname = i.Name ?? map.TableName + "_" + c.Name;

					IndexInfo iinfo;

					if (!indexes.TryGetValue(iname, out iinfo))

					{

						iinfo = new IndexInfo

						{

							IndexName = iname,

							TableName = map.TableName,

							Unique = i.Unique,

							Columns = new List<IndexedColumn>()

						};

						indexes.Add(iname, iinfo);

					}



					if (i.Unique != iinfo.Unique)

						throw new Exception("All the columns in an index must have the same value for their Unique property");



					iinfo.Columns.Add(new IndexedColumn

					{

						Order = i.Order,

						ColumnName = c.Name

					});

				}

			}



			foreach (var indexName in indexes.Keys)

			{

				var index = indexes[indexName];

				const string sqlFormat = "create {3} index if not exists \"{0}\" on \"{1}\"(\"{2}\")";

				var columns = String.Join("\",\"", index.Columns.OrderBy(i => i.Order).Select(i => i.ColumnName).ToArray());

				var sql = String.Format(sqlFormat, indexName, index.TableName, columns, index.Unique ? "unique" : "");

				count += Execute(sql);

			}



			return count;

		}



		public class TableInfo

		{

			public int cid { get; set; }



			public string name { get; set; }



			public string type { get; set; }



			public int notnull { get; set; }



			public string dflt_value { get; set; }



			public int pk { get; set; }

		}



		void MigrateTable(TableMapping map)

		{

			var query = "pragma table_info(\"" + map.TableName + "\")";



			var existingCols = Query<TableInfo>(query);



			var toBeAdded = new List<TableMapping.Column>();



			foreach (var p in map.Columns)

			{

				var found = false;

				foreach (var c in existingCols)

				{

					found = p.Name == c.name;

					if (found)

						break;

				}

				if (!found)

				{

					toBeAdded.Add(p);

				}

			}



			foreach (var p in toBeAdded)

			{

				var addCol = "alter table \"" + map.TableName + "\" add column " + Orm.SqlDecl(p, StoreDateTimeAsTicks);

				Execute(addCol);

			}

		}



		/// <summary>

		/// Creates a new SQLiteCommand. Can be overridden to provide a sub-class.

		/// </summary>

		/// <seealso cref="SQLiteCommand.OnInstanceCreated"/>

		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="args">

		/// Arguments to substitute for the occurences of '?' in the command text.

		/// </param>

		/// <returns>

		/// A <see cref="SQLiteCommand"/>

		/// </returns>

		public SQLiteCommand CreateCommand(string cmdText, params object[] ps)

		{

			if (!_open)

			{

				throw SQLiteException.New(SQLite3.Result.Error, "Cannot create commands from unopened database");

			}

			else

			{

				var cmd = NewCommand();

				cmd.CommandText = cmdText;

				foreach (var o in ps)

				{

					cmd.Bind(o);

				}

				return cmd;

			}

		}



		/// <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)

		{

			var cmd = CreateCommand(query, args);



			if (TimeExecution)

			{

				if (_sw == null)

				{

					_sw = new System.Diagnostics.Stopwatch();

				}

				_sw.Reset();

				_sw.Start();

			}



			var r = cmd.ExecuteNonQuery();



			if (TimeExecution)

			{

				_sw.Stop();

				_elapsedMilliseconds += _sw.ElapsedMilliseconds;

				Debug.WriteLine(string.Format("Finished in {0} ms ({1:0.0} s total)", _sw.ElapsedMilliseconds, _elapsedMilliseconds / 1000.0));

			}



			return r;

		}



		public T ExecuteScalar<T>(string query, params object[] args)

		{

			var cmd = CreateCommand(query, args);



			if (TimeExecution)

			{

				if (_sw == null)

				{

					_sw = new System.Diagnostics.Stopwatch();

				}

				_sw.Reset();

				_sw.Start();

			}



			var r = cmd.ExecuteScalar<T>();



			if (TimeExecution)

			{

				_sw.Stop();

				_elapsedMilliseconds += _sw.ElapsedMilliseconds;

				Debug.WriteLine(string.Format("Finished in {0} ms ({1:0.0} s total)", _sw.ElapsedMilliseconds, _elapsedMilliseconds / 1000.0));

			}



			return r;

		}



		/// <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()

		{

			var cmd = CreateCommand(query, args);

			return cmd.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()

		{

			var cmd = CreateCommand(query, args);

			return cmd.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="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)

		{

			var cmd = CreateCommand(query, args);

			return cmd.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="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)

		{

			var cmd = CreateCommand(query, args);

			return cmd.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()

		{

			var map = GetMapping(typeof(T));

			return Query<T>(map.GetByPrimaryKeySql, pk).First();

		}



		/// <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 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()

		{

			var map = GetMapping(typeof(T));

			return Query<T>(map.GetByPrimaryKeySql, pk).FirstOrDefault();

		}



		/// <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 object type.

		/// </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 Query(map, map.GetByPrimaryKeySql, pk).FirstOrDefault();

		}



		/// <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 Table<T>().Where(predicate).FirstOrDefault();

		}



		/// <summary>

		/// Whether <see cref="BeginTransaction"/> has been called and the database is waiting for a <see cref="Commit"/>.

		/// </summary>

		public bool IsInTransaction

		{

			get { return _trasactionDepth > 0; }

		}



		/// <summary>

		/// Begins a new transaction. Call <see cref="Commit"/> to end the transaction.

		/// </summary>

		/// <example cref="System.InvalidOperationException">Throws if a transaction has already begun.</example>

		public void BeginTransaction()

		{

			// The BEGIN command only works if the transaction stack is empty, 

			//    or in other words if there are no pending transactions. 

			// If the transaction stack is not empty when the BEGIN command is invoked, 

			//    then the command fails with an error.

			// Rather than crash with an error, we will just ignore calls to BeginTransaction

			//    that would result in an error.

			if (Interlocked.CompareExchange(ref _trasactionDepth, 1, 0) == 0)

			{

				try

				{

					Execute("begin transaction");

				}

				catch (Exception ex)

				{

					var sqlExp = ex as SQLiteException;

					if (sqlExp != null)

					{

						// It is recommended that applications respond to the errors listed below 

						//    by explicitly issuing a ROLLBACK command.

						// TODO: This rollback failsafe should be localized to all throw sites.

						switch (sqlExp.Result)

						{

							case SQLite3.Result.IOError:

							case SQLite3.Result.Full:

							case SQLite3.Result.Busy:

							case SQLite3.Result.NoMem:

							case SQLite3.Result.Interrupt:

								RollbackTo(null, true);

								break;

						}

					}

					else

					{

						// Call decrement and not VolatileWrite in case we've already 

						//    created a transaction point in SaveTransactionPoint since the catch.

						Interlocked.Decrement(ref _trasactionDepth);

					}



					throw;

				}

			}

			else

			{

				// Calling BeginTransaction on an already open transaction is invalid

				throw new System.InvalidOperationException("Cannot begin a transaction while already in a transaction.");

			}

		}



		/// <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="RollbackTo"/> to undo transactions since the returned savepoint.

		/// Call <see cref="Release"/> to commit transactions after the savepoint returned here.

		/// Call <see cref="Commit"/> to end the transaction, committing all changes.

		/// </summary>

		/// <returns>A string naming the savepoint.</returns>

		public string SaveTransactionPoint()

		{

			int depth = Interlocked.Increment(ref _trasactionDepth) - 1;

			string retVal = "S" + (short)_rand.Next(short.MaxValue) + "D" + depth;



			try

			{

				Execute("savepoint " + retVal);

			}

			catch (Exception ex)

			{

				var sqlExp = ex as SQLiteException;

				if (sqlExp != null)

				{

					// It is recommended that applications respond to the errors listed below 

					//    by explicitly issuing a ROLLBACK command.

					// TODO: This rollback failsafe should be localized to all throw sites.

					switch (sqlExp.Result)

					{

						case SQLite3.Result.IOError:

						case SQLite3.Result.Full:

						case SQLite3.Result.Busy:

						case SQLite3.Result.NoMem:

						case SQLite3.Result.Interrupt:

							RollbackTo(null, true);

							break;

					}

				}

				else

				{

					Interlocked.Decrement(ref _trasactionDepth);

				}



				throw;

			}



			return retVal;

		}



		/// <summary>

		/// Rolls back the transaction that was begun by <see cref="BeginTransaction"/> or <see cref="SaveTransactionPoint"/>.

		/// </summary>

		public void Rollback()

		{

			RollbackTo(null, false);

		}



		/// <summary>

		/// Rolls back the savepoint created by <see cref="BeginTransaction"/> or SaveTransactionPoint.

		/// </summary>

		/// <param name="savepoint">The name of the savepoint to roll back to, as returned by <see cref="SaveTransactionPoint"/>.  If savepoint is null or empty, this method is equivalent to a call to <see cref="Rollback"/></param>

		public void RollbackTo(string savepoint)

		{

			RollbackTo(savepoint, false);

		}



		/// <summary>

		/// Rolls back the transaction that was begun by <see cref="BeginTransaction"/>.

		/// </summary>

		/// <param name="noThrow">true to avoid throwing exceptions, false otherwise</param>

		private void RollbackTo(string savepoint, bool noThrow)

		{

			// Rolling back without a TO clause rolls backs all transactions 

			//    and leaves the transaction stack empty.   

			try

			{

				if (String.IsNullOrEmpty(savepoint))

				{

					if (Interlocked.Exchange(ref _trasactionDepth, 0) > 0)

					{

						Execute("rollback");

					}

				}

				else

				{

					DoSavePointExecute(savepoint, "rollback to ");

				}

			}

			catch (SQLiteException)

			{

				if (!noThrow)

					throw;



			}

			// No need to rollback if there are no transactions open.

		}



		/// <summary>

		/// Releases a savepoint returned from <see cref="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="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="SaveTransactionPoint"/></param>

		public void Release(string savepoint)

		{

			DoSavePointExecute(savepoint, "release ");

		}



		private void DoSavePointExecute(string savepoint, string cmd)

		{

			// Validate the savepoint

			int firstLen = savepoint.IndexOf('D');

			if (firstLen >= 2 && savepoint.Length > firstLen + 1)

			{

				int depth;

				if (Int32.TryParse(savepoint.Substring(firstLen + 1), out depth))

				{

					// TODO: Mild race here, but inescapable without locking almost everywhere.

					if (0 <= depth && depth < _trasactionDepth)

					{

#if NETFX_CORE

                        Volatile.Write (ref _trasactionDepth, depth);

#elif SILVERLIGHT

						_trasactionDepth = depth;

#else

						Thread.VolatileWrite(ref _trasactionDepth, depth);

#endif

						Execute(cmd + savepoint);

						return;

					}

				}

			}



			throw new ArgumentException("savePoint", "savePoint is not valid, and should be the result of a call to SaveTransactionPoint.");

		}



		/// <summary>

		/// Commits the transaction that was begun by <see cref="BeginTransaction"/>.

		/// </summary>

		public void Commit()

		{

			if (Interlocked.Exchange(ref _trasactionDepth, 0) != 0)

			{

				Execute("commit");

			}

			// Do nothing on a commit with no open transaction

		}



		/// <summary>

		/// Executes <param 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="Action"/> to perform within a transaction. <param name="action"> can contain any number

		/// of operations on the connection but should never call <see cref="BeginTransaction"/> or

		/// <see cref="Commit"/>.

		/// </param>

		public void RunInTransaction(Action action)

		{

			try

			{

				var savePoint = SaveTransactionPoint();

				action();

				Release(savePoint);

			}

			catch (Exception)

			{

				Rollback();

				throw;

			}

		}



		/// <summary>

		/// Inserts all specified objects.

		/// </summary>

		/// <param name="objects">

		/// An <see cref="IEnumerable"/> of the objects to insert.

		/// </param>

		/// <returns>

		/// The number of rows added to the table.

		/// </returns>

		public int InsertAll(System.Collections.IEnumerable objects, bool beginTransaction = true)

		{

			if (beginTransaction)

			{

				BeginTransaction();

			}

			var c = 0;

			foreach (var r in objects)

			{

				c += Insert(r);

			}

			if (beginTransaction)

			{

				Commit();

			}

			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 Insert(obj, "", obj.GetType());

		}



		public int Insert(object obj, Type objType)

		{

			return Insert(obj, "", objType);

		}



		public int Insert(object obj, string extra)

		{

			if (obj == null)

			{

				return 0;

			}

			return Insert(obj, extra, obj.GetType());

		}



		/// <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 || objType == null)

			{

				return 0;

			}



			var map = GetMapping(objType);



			var cols = map.InsertColumns;

			var vals = new object[cols.Length];

			for (var i = 0; i < vals.Length; i++)

			{

				vals[i] = cols[i].GetValue(obj);

			}



			var insertCmd = map.GetInsertCommand(this, extra);

			var count = insertCmd.ExecuteNonQuery(vals);



			if (map.HasAutoIncPK)

			{

				var id = SQLite3.LastInsertRowid(Handle);

				map.SetAutoIncPK(obj, id);

			}



			return count;

		}



		/// <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 Update(obj, obj.GetType());

		}



		public int Update(object obj, Type objType)

		{

			if (obj == null || objType == null)

			{

				return 0;

			}



			var map = GetMapping(objType);



			var pk = map.PK;



			if (pk == null)

			{

				throw new NotSupportedException("Cannot update " + map.TableName + ": it has no PK");

			}



			var cols = from p in map.Columns

					   where p != pk

					   select p;

			var vals = from c in cols

					   select c.GetValue(obj);

			var ps = new List<object>(vals);

			ps.Add(pk.GetValue(obj));

			var q = string.Format("update \"{0}\" set {1} where {2} = ? ", map.TableName, string.Join(",", (from c in cols

																											select "\"" + c.Name + "\" = ? ").ToArray()), pk.Name);

			return Execute(q, ps.ToArray());

		}



		/// <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)

		{

			var map = GetMapping(objectToDelete.GetType());

			var pk = map.PK;

			if (pk == null)

			{

				throw new NotSupportedException("Cannot delete " + map.TableName + ": it has no PK");

			}

			var q = string.Format("delete from \"{0}\" where \"{1}\" = ?", map.TableName, pk.Name);

			return Execute(q, pk.GetValue(objectToDelete));

		}



		/// <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)

		{

			var map = GetMapping(typeof(T));

			var pk = map.PK;

			if (pk == null)

			{

				throw new NotSupportedException("Cannot delete " + map.TableName + ": it has no PK");

			}

			var q = string.Format("delete from \"{0}\" where \"{1}\" = ?", map.TableName, pk.Name);

			return Execute(q, primaryKey);

		}



		/// <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>()

		{

			var map = GetMapping(typeof(T));

			var query = string.Format("delete from \"{0}\"", map.TableName);

			return Execute(query);

		}



		public void Dispose()

		{

			Close();

		}



		public void Close()

		{

			if (_open && Handle != NullHandle)

			{

				try

				{

					if (_mappings != null)

					{

						foreach (var sqlInsertCommand in _mappings.Values)

						{

							sqlInsertCommand.Dispose();

						}

					}

					var r = SQLite3.Close(Handle);

					if (r != SQLite3.Result.OK)

					{

						string msg = SQLite3.GetErrmsg(Handle);

						throw SQLiteException.New(r, msg);

					}

				}

				finally

				{

					Handle = NullHandle;

					_open = false;

				}

			}

		}

	}



	/// <summary>

	/// Represents a parsed connection string.

	/// </summary>

	class SQLiteConnectionString

	{

		public string ConnectionString { get; private set; }

		public string DatabasePath { get; private set; }

		public bool StoreDateTimeAsTicks { get; private set; }



#if NETFX_CORE

		static readonly string MetroStyleDataPath = Windows.Storage.ApplicationData.Current.LocalFolder.Path;

#endif



		public SQLiteConnectionString(string databasePath, bool storeDateTimeAsTicks)

		{

			ConnectionString = databasePath;

			StoreDateTimeAsTicks = storeDateTimeAsTicks;



#if NETFX_CORE

			DatabasePath = System.IO.Path.Combine (MetroStyleDataPath, databasePath);

#else

			DatabasePath = databasePath;

#endif

		}

	}



	[AttributeUsage(AttributeTargets.Class)]

	public class TableAttribute : Attribute

	{

		public string Name { get; set; }



		public TableAttribute(string name)

		{

			Name = name;

		}

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class ColumnAttribute : Attribute

	{

		public string Name { get; set; }



		public ColumnAttribute(string name)

		{

			Name = name;

		}

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class PrimaryKeyAttribute : Attribute

	{

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class AutoIncrementAttribute : Attribute

	{

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class IndexedAttribute : Attribute

	{

		public string Name { get; set; }

		public int Order { get; set; }

		public virtual bool Unique { get; set; }



		public IndexedAttribute()

		{

		}



		public IndexedAttribute(string name, int order)

		{

			Name = name;

			Order = order;

		}

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class IgnoreAttribute : Attribute

	{

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class UniqueAttribute : IndexedAttribute

	{

		public override bool Unique

		{

			get { return true; }

			set { /* throw?  */ }

		}

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class MaxLengthAttribute : Attribute

	{

		public int Value { get; private set; }



		public MaxLengthAttribute(int length)

		{

			Value = length;

		}

	}



	[AttributeUsage(AttributeTargets.Property)]

	public class CollationAttribute : Attribute

	{

		public string Value { get; private set; }



		public CollationAttribute(string collation)

		{

			Value = collation;

		}

	}



	public class TableMapping

	{

		public Type MappedType { get; private set; }



		public string TableName { get; private set; }



		public Column[] Columns { get; private set; }



		public Column PK { get; private set; }



		public string GetByPrimaryKeySql { get; private set; }



		Column _autoPk = null;

		Column[] _insertColumns = null;



		public TableMapping(Type type)

		{

			MappedType = type;



#if NETFX_CORE

			var tableAttr = (TableAttribute)System.Reflection.CustomAttributeExtensions

                .GetCustomAttribute(type.GetTypeInfo(), typeof(TableAttribute), true);

#else

			var tableAttr = (TableAttribute)type.GetCustomAttributes(typeof(TableAttribute), true).FirstOrDefault();

#endif



			TableName = tableAttr != null ? tableAttr.Name : MappedType.Name;



#if !NETFX_CORE

			var props = MappedType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty);

#else

			var props = from p in MappedType.GetRuntimeProperties()

						where ((p.GetMethod != null && p.GetMethod.IsPublic) || (p.SetMethod != null && p.SetMethod.IsPublic) || (p.GetMethod != null && p.GetMethod.IsStatic) || (p.SetMethod != null && p.SetMethod.IsStatic))

						select p;

#endif

			var cols = new List<Column>();

			foreach (var p in props)

			{

#if !NETFX_CORE

				var ignore = p.GetCustomAttributes(typeof(IgnoreAttribute), true).Length > 0;

#else

				var ignore = p.GetCustomAttributes (typeof(IgnoreAttribute), true).Count() > 0;

#endif

				if (p.CanWrite && !ignore)

				{

					cols.Add(new Column(p));

				}

			}

			Columns = cols.ToArray();

			foreach (var c in Columns)

			{

				if (c.IsAutoInc && c.IsPK)

				{

					_autoPk = c;

				}

				if (c.IsPK)

				{

					PK = c;

				}

			}



			HasAutoIncPK = _autoPk != null;



			if (PK != null)

			{

				GetByPrimaryKeySql = string.Format("select * from \"{0}\" where \"{1}\" = ?", TableName, PK.Name);

			}

			else

			{

				// People should not be calling Get/Find without a PK

				GetByPrimaryKeySql = string.Format("select * from \"{0}\" limit 1", TableName);

			}

		}



		public bool HasAutoIncPK { get; private set; }



		public void SetAutoIncPK(object obj, long id)

		{

			if (_autoPk != null)

			{

				_autoPk.SetValue(obj, Convert.ChangeType(id, _autoPk.ColumnType, null));

			}

		}



		public Column[] InsertColumns

		{

			get

			{

				if (_insertColumns == null)

				{

					_insertColumns = Columns.Where(c => !c.IsAutoInc).ToArray();

				}

				return _insertColumns;

			}

		}



		public Column FindColumnWithPropertyName(string propertyName)

		{

			var exact = Columns.Where(c => c.PropertyName == propertyName).FirstOrDefault();

			return exact;

		}



		public Column FindColumn(string columnName)

		{

			var exact = Columns.Where(c => c.Name == columnName).FirstOrDefault();

			return exact;

		}



		PreparedSqlLiteInsertCommand _insertCommand;

		string _insertCommandExtra = null;



		public PreparedSqlLiteInsertCommand GetInsertCommand(SQLiteConnection conn, string extra)

		{

			if (_insertCommand == null)

			{

				_insertCommand = CreateInsertCommand(conn, extra);

				_insertCommandExtra = extra;

			}

			else if (_insertCommandExtra != extra)

			{

				_insertCommand.Dispose();

				_insertCommand = CreateInsertCommand(conn, extra);

				_insertCommandExtra = extra;

			}

			return _insertCommand;

		}



		private PreparedSqlLiteInsertCommand CreateInsertCommand(SQLiteConnection conn, string extra)

		{

			var cols = InsertColumns;

			string insertSql;

			if (!cols.Any() && Columns.Count() == 1 && Columns[0].IsAutoInc)

			{

				insertSql = string.Format("insert {1} into \"{0}\" default values", TableName, extra);

			}

			else

			{

				insertSql = string.Format("insert {3} into \"{0}\"({1}) values ({2})", TableName,

								   string.Join(",", (from c in cols

													 select "\"" + c.Name + "\"").ToArray()),

								   string.Join(",", (from c in cols

													 select "?").ToArray()), extra);



			}



			var insertCommand = new PreparedSqlLiteInsertCommand(conn);

			insertCommand.CommandText = insertSql;

			return insertCommand;

		}



		protected internal void Dispose()

		{

			if (_insertCommand != null)

			{

				_insertCommand.Dispose();

				_insertCommand = null;

			}

		}



		public class Column

		{

			PropertyInfo _prop;



			public string Name { get; private set; }



			public string PropertyName { get { return _prop.Name; } }



			public Type ColumnType { get; private set; }



			public string Collation { get; private set; }



			public bool IsAutoInc { get; private set; }



			public bool IsPK { get; private set; }



			public IEnumerable<IndexedAttribute> Indices { get; set; }



			public bool IsNullable { get; private set; }



			public int MaxStringLength { get; private set; }



			public Column(PropertyInfo prop)

			{

				var colAttr = (ColumnAttribute)prop.GetCustomAttributes(typeof(ColumnAttribute), true).FirstOrDefault();



				_prop = prop;

				Name = colAttr == null ? prop.Name : colAttr.Name;

				//If this type is Nullable<T> then Nullable.GetUnderlyingType returns the T, otherwise it returns null, so get the the actual type instead

				ColumnType = Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType;

				Collation = Orm.Collation(prop);

				IsAutoInc = Orm.IsAutoInc(prop);

				IsPK = Orm.IsPK(prop);

				Indices = Orm.GetIndices(prop);

				IsNullable = !IsPK;

				MaxStringLength = Orm.MaxStringLength(prop);

			}



			public void SetValue(object obj, object val)

			{

				_prop.SetValue(obj, val, null);

			}



			public object GetValue(object obj)

			{

				return _prop.GetValue(obj, null);

			}

		}

	}



	public static class Orm

	{

		public const int DefaultMaxStringLength = 140;



		public static string SqlDecl(TableMapping.Column p, bool storeDateTimeAsTicks)

		{

			string decl = "\"" + p.Name + "\" " + SqlType(p, storeDateTimeAsTicks) + " ";



			if (p.IsPK)

			{

				decl += "primary key ";

			}

			if (p.IsAutoInc)

			{

				decl += "autoincrement ";

			}

			if (!p.IsNullable)

			{

				decl += "not null ";

			}

			if (!string.IsNullOrEmpty(p.Collation))

			{

				decl += "collate " + p.Collation + " ";

			}



			return decl;

		}



		public static string SqlType(TableMapping.Column p, bool storeDateTimeAsTicks)

		{

			var clrType = p.ColumnType;

			if (clrType == typeof(Boolean) || clrType == typeof(Byte) || clrType == typeof(UInt16) || clrType == typeof(SByte) || clrType == typeof(Int16) || clrType == typeof(Int32))

			{

				return "integer";

			}

			else if (clrType == typeof(UInt32) || clrType == typeof(Int64))

			{

				return "bigint";

			}

			else if (clrType == typeof(Single) || clrType == typeof(Double) || clrType == typeof(Decimal))

			{

				return "float";

			}

			else if (clrType == typeof(String))

			{

				int len = p.MaxStringLength;

				return "varchar(" + len + ")";

			}

			else if (clrType == typeof(DateTime))

			{

				return storeDateTimeAsTicks ? "bigint" : "datetime";

#if !NETFX_CORE

			}

			else if (clrType.IsEnum)

			{

#else

			} else if (clrType.GetTypeInfo().IsEnum) {

#endif

				return "integer";

			}

			else if (clrType == typeof(byte[]))

			{

				return "blob";

#if SQLITE_SUPPORT_GUID

            } else if (clrType == typeof(Guid)) {

                return "varchar(36)";

#endif

			}

			else

			{

#if SQLITE_SUPPORT_SERIALIZATION

                return "text";

#else

				throw new NotSupportedException("Don't know about " + clrType);

#endif

			}

		}



		public static bool IsPK(MemberInfo p)

		{

			var attrs = p.GetCustomAttributes(typeof(PrimaryKeyAttribute), true);

#if !NETFX_CORE

			return attrs.Length > 0;

#else

			return attrs.Count() > 0;

#endif

		}



		public static string Collation(MemberInfo p)

		{

			var attrs = p.GetCustomAttributes(typeof(CollationAttribute), true);

#if !NETFX_CORE

			if (attrs.Length > 0)

			{

				return ((CollationAttribute)attrs[0]).Value;

#else

			if (attrs.Count() > 0) {

                return ((CollationAttribute)attrs.First()).Value;

#endif

			}

			else

			{

				return string.Empty;

			}

		}



		public static bool IsAutoInc(MemberInfo p)

		{

			var attrs = p.GetCustomAttributes(typeof(AutoIncrementAttribute), true);

#if !NETFX_CORE

			return attrs.Length > 0;

#else

			return attrs.Count() > 0;

#endif

		}



		public static IEnumerable<IndexedAttribute> GetIndices(MemberInfo p)

		{

			var attrs = p.GetCustomAttributes(typeof(IndexedAttribute), true);

			return attrs.Cast<IndexedAttribute>();

		}



		public static int MaxStringLength(PropertyInfo p)

		{

			var attrs = p.GetCustomAttributes(typeof(MaxLengthAttribute), true);

#if !NETFX_CORE

			if (attrs.Length > 0)

			{

				return ((MaxLengthAttribute)attrs[0]).Value;

#else

			if (attrs.Count() > 0) {

				return ((MaxLengthAttribute)attrs.First()).Value;

#endif

			}

			else

			{

				return DefaultMaxStringLength;

			}

		}

	}



	public class SQLiteCommand

	{

		SQLiteConnection _conn;

		private List<Binding> _bindings;



		public string CommandText { get; set; }



		internal SQLiteCommand(SQLiteConnection conn)

		{

			_conn = conn;

			_bindings = new List<Binding>();

			CommandText = "";

		}



		public int ExecuteNonQuery()

		{

			if (_conn.Trace)

			{

				Debug.WriteLine("Executing: " + this);

			}



			var r = SQLite3.Result.OK;

			var stmt = Prepare();

			r = SQLite3.Step(stmt);

			Finalize(stmt);

			if (r == SQLite3.Result.Done)

			{

				int rowsAffected = SQLite3.Changes(_conn.Handle);

				return rowsAffected;

			}

            else if (r == SQLite3.Result.Row)

            {

                return -1;

            }

			else if (r == SQLite3.Result.Error)

			{

				string msg = SQLite3.GetErrmsg(_conn.Handle);

				throw SQLiteException.New(r, msg);

			}

			else

			{

				throw SQLiteException.New(r, r.ToString());

			}

		}



		public IEnumerable<T> ExecuteDeferredQuery<T>() where T : new()

		{

			return ExecuteDeferredQuery<T>(_conn.GetMapping(typeof(T)));

		}



		public List<T> ExecuteQuery<T>() where T : new()

		{

			return ExecuteDeferredQuery<T>(_conn.GetMapping(typeof(T))).ToList();

		}



		public List<T> ExecuteQuery<T>(TableMapping map)

		{

			return ExecuteDeferredQuery<T>(map).ToList();

		}



		/// <summary>

		/// Invoked ev…