Add async CreateTables and CreateIndex overloads

Working on praeclarum#480

src/SQLite.cs

@@ -479,14 +479,103 @@ public int CreateTable(Type ty, CreateFlags createFlags = CreateFlags.None)
 			return count;
 		}
 
-        /// <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)
+		/// <summary>
+		/// Executes a "create table if not exists" on the database for each type. 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 for each type.
+		/// </returns>
+		public CreateTablesResult CreateTables<T, T2> (CreateFlags createFlags = CreateFlags.None)
+			where T : new()
+			where T2 : new()
+		{
+			return CreateTables (createFlags, typeof (T), typeof (T2));
+		}
+
+		/// <summary>
+		/// Executes a "create table if not exists" on the database for each type. 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 for each type.
+		/// </returns>
+		public CreateTablesResult CreateTables<T, T2, T3> (CreateFlags createFlags = CreateFlags.None)
+			where T : new()
+			where T2 : new()
+			where T3 : new()
+		{
+			return CreateTables (createFlags, typeof (T), typeof (T2), typeof (T3));
+		}
+
+		/// <summary>
+		/// Executes a "create table if not exists" on the database for each type. 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 for each type.
+		/// </returns>
+		public CreateTablesResult CreateTables<T, T2, T3, T4> (CreateFlags createFlags = CreateFlags.None)
+			where T : new()
+			where T2 : new()
+			where T3 : new()
+			where T4 : new()
+		{
+			return CreateTables (createFlags, typeof (T), typeof (T2), typeof (T3), typeof (T4));
+		}
+
+		/// <summary>
+		/// Executes a "create table if not exists" on the database for each type. 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 for each type.
+		/// </returns>
+		public CreateTablesResult CreateTables<T, T2, T3, T4, T5> (CreateFlags createFlags = CreateFlags.None)
+			where T : new()
+			where T2 : new()
+			where T3 : new()
+			where T4 : new()
+			where T5 : new()
+		{
+			return CreateTables (createFlags, typeof (T), typeof (T2), typeof (T3), typeof (T4), typeof (T5));
+		}
+
+		/// <summary>
+		/// Executes a "create table if not exists" on the database for each type. 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 for each type.
+		/// </returns>
+		public CreateTablesResult CreateTables (CreateFlags createFlags = CreateFlags.None, params Type[] types)
+		{
+			var result = new CreateTablesResult ();
+			foreach (Type type in types) {
+				int aResult = CreateTable (type, createFlags);
+				result.Results[type] = aResult;
+			}
+			return result;
+		}
+
+		/// <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)
         {
             const string sqlFormat = "create {2} index if not exists \"{3}\" on \"{0}\"(\"{1}\")";
             var sql = String.Format(sqlFormat, tableName, string.Join ("\", \"", columnNames), unique ? "unique" : "", indexName);
@@ -534,7 +623,7 @@ public int CreateIndex(string tableName, string[] columnNames, bool unique = fal
         /// <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)
+        public int CreateIndex<T>(Expression<Func<T, object>> property, bool unique = false)
         {
             MemberExpression mx;
             if (property.Body.NodeType == ExpressionType.Convert)
@@ -556,7 +645,7 @@ public void CreateIndex<T>(Expression<Func<T, object>> property, bool unique = f
             var map = GetMapping<T>();
             var colName = map.FindColumnWithPropertyName(propName).Name;
 
-            CreateIndex(map.TableName, colName, unique);
+            return CreateIndex(map.TableName, colName, unique);
         }
 
 		public class ColumnInfo
@@ -2724,6 +2813,16 @@ private void Dispose (bool disposing)
 		}
 	}
 
+	public class CreateTablesResult
+	{
+		public Dictionary<Type, int> Results { get; private set; }
+
+		public CreateTablesResult ()
+		{
+			Results = new Dictionary<Type, int> ();
+		}
+	}
+
 	public abstract class BaseTableQuery
 	{
 		protected class Ordering

src/SQLiteAsync.cs

@@ -97,10 +97,25 @@ public Task EnableLoadExtensionAsync (bool enabled)
 			});
 		}
 
-		public Task<CreateTablesResult> CreateTableAsync<T> (CreateFlags createFlags = CreateFlags.None)
+		public Task<int> CreateTableAsync<T> (CreateFlags createFlags = CreateFlags.None)
 			where T : new ()
 		{
-			return CreateTablesAsync (createFlags, typeof(T));
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateTable<T> (createFlags);
+				}
+			});
+		}
+
+		public Task<int> CreateTableAsync (Type ty, CreateFlags createFlags = CreateFlags.None)
+		{
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateTable (ty, createFlags);
+				}
+			});
 		}
 
 		public Task<CreateTablesResult> CreateTablesAsync<T, T2> (CreateFlags createFlags = CreateFlags.None)
@@ -143,12 +158,8 @@ public Task<CreateTablesResult> CreateTablesAsync (CreateFlags createFlags = Cre
 				CreateTablesResult result = new CreateTablesResult ();
 				var conn = GetConnection ();
 				using (conn.Lock ()) {
-					foreach (Type type in types) {
-						int aResult = conn.CreateTable (type, createFlags);
-						result.Results[type] = aResult;
-					}
+					return conn.CreateTables (createFlags, types);
 				}
-				return result;
 			});
 		}
 
@@ -173,6 +184,56 @@ public Task<int> DropTableAsync (TableMapping map)
 			});
 		}
 
+		public Task<int> CreateIndexAsync (string tableName, string columnName, bool unique = false)
+		{
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateIndex (tableName, columnName, unique);
+				}
+			});
+		}
+
+		public Task<int> CreateIndexAsync (string indexName, string tableName, string columnName, bool unique = false)
+		{
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateIndex (indexName, tableName, columnName, unique);
+				}
+			});
+		}
+
+		public Task<int> CreateIndexAsync (string tableName, string[] columnNames, bool unique = false)
+		{
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateIndex (tableName, columnNames, unique);
+				}
+			});
+		}
+
+		public Task<int> CreateIndexAsync (string indexName, string tableName, string[] columnNames, bool unique = false)
+		{
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateIndex (indexName, tableName, columnNames, unique);
+				}
+			});
+		}
+
+		public Task<int> CreateIndexAsync<T> (Expression<Func<T, object>> property, bool unique = false)
+		{
+			return Task.Factory.StartNew (() => {
+				var conn = GetConnection ();
+				using (conn.Lock ()) {
+					return conn.CreateIndex (property, unique);
+				}
+			});
+		}
+
 		public Task<int> InsertAsync (object obj)
 		{
 			return Task.Factory.StartNew (() => {
@@ -675,16 +736,6 @@ public Task<T> FirstOrDefaultAsync ()
 		}
     }
 
-	public class CreateTablesResult
-	{
-		public Dictionary<Type, int> Results { get; private set; }
-
-		public CreateTablesResult ()
-		{
-			Results = new Dictionary<Type, int> ();
-		}
-	}
-
 	class SQLiteConnectionPool
 	{
 		class Entry

tests/ApiDiff/Program.cs

@@ -68,6 +68,7 @@ public Apis (Type type, string nameSuffix = "")
 			          .Where (x => x.MemberType != MemberTypes.NestedType)
 			          .Where (x => !x.Name.StartsWith("get_") && !x.Name.StartsWith ("set_") && !x.Name.StartsWith ("remove_") && !x.Name.StartsWith ("add_"))
 			          .Select (x => new Api(x, nameSuffix))
+			          .OrderBy (x => x.Index)
 			          .OrderBy (x => x.Name)
 			          .ToList ();
 		}