Added new functions and helpers to help create tables and set them up. Bumped package version to 1.0.3

MySqlPlus.Example/Program.cs

@@ -8,19 +8,19 @@ namespace MontoyaTech.MySqlPlus.Example
         [MySqlRow("cars")]
         public class Car
         {
-            [MySqlColumn(Id = true, Name = "id")]
+            [MySqlColumn(Id = true, Name = "id", PrimaryKey = true, AutoIncrement = true, Nullable = false)]
             public ulong Id = 0;
 
             [MySqlColumn("make")]
             public string Make = null;
 
-            [MySqlColumn("model")]
+            [MySqlColumn("model", Nullable = false, Type = "VARCHAR(255)")]
-            public string Model = null;
+            public string Model = "Unknown";
 
-            [MySqlColumn("year")]
+            [MySqlColumn("year", Nullable = false)]
             public uint Year = 0;
 
-            [MySqlColumn("dateCreated", typeof(DateTimeToUnixConverter))]
+            [MySqlColumn("dateCreated", typeof(DateTimeToUnixConverter), DefaultValue = 0, Nullable = false)]
             public DateTime DateCreated = DateTime.UtcNow;
         }
 
@@ -28,6 +28,8 @@ namespace MontoyaTech.MySqlPlus.Example
         {
             var session = new MySqlSession("");
 
+            session.CreateTable<Car>();
+
             session.DeleteAll<Car>();
 
             session.Insert(new Car() { Make = "Chevy", Model = "Camaro", Year = 2011 });
@@ -46,6 +48,8 @@ namespace MontoyaTech.MySqlPlus.Example
             foreach (var car in cars)
                 session.Delete(car);
 
+            session.DeleteTable<Car>();
+
             Console.WriteLine("Done.");
             Console.ReadLine();
         }

MySqlPlus/DateTimeToUnixConverter.cs

@@ -11,6 +11,11 @@ namespace MontoyaTech.MySqlPlus
     /// </summary>
     public class DateTimeToUnixConverter : MySqlColumnConverter
     {
+        /// <summary>
+        /// Returns the MySql Type this converter converts to.
+        /// </summary>
+        public string ConvertToType { get { return "BIGINT UNSIGNED"; } }
+
         /// <summary>
         /// Converts from a Unix Time to a DateTime.
         /// </summary>
@@ -50,6 +55,10 @@ namespace MontoyaTech.MySqlPlus
 
                 return (ulong)(dateTime.ToUniversalTime().Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))).TotalSeconds;
             }
+            else if (input is int inputInt)
+            {
+                return (ulong)inputInt;
+            }
             else
             {
                 throw new NotSupportedException("Unsupported input object to convert to unix.");

MySqlPlus/MySqlColumn.cs

@@ -26,6 +26,36 @@ namespace MontoyaTech.MySqlPlus
         /// </summary>
         public string Name = null;
 
+        /// <summary>
+        /// The MySql Data type of the column, if null, the field type will be used instead.
+        /// </summary>
+        public string Type = null;
+
+        /// <summary>
+        /// Whether or not this column is a primary key.
+        /// </summary>
+        public bool PrimaryKey = false;
+
+        /// <summary>
+        /// Whether or not this column auto increments.
+        /// </summary>
+        public bool AutoIncrement = false;
+
+        /// <summary>
+        /// Whether or not this column can be null, default is true.
+        /// </summary>
+        public bool Nullable = true;
+
+        /// <summary>
+        /// Whether or not this column has a default value, default is true.
+        /// </summary>
+        public bool Default = true;
+
+        /// <summary>
+        /// An overrided default value for this column if set, default is null.
+        /// </summary>
+        public object DefaultValue = null;
+
         /// <summary>
         /// An optional MySqlColumnConverter that can convert this column to another
         /// data type when needed.
@@ -55,95 +85,22 @@ namespace MontoyaTech.MySqlPlus
         }
 
         /// <summary>
-        /// Reads this column from a given data reader and stores the value into the provided field on a row.
+        /// Creates a new MySqlColumn with a name and type and optional column converter.
         /// </summary>
-        /// <typeparam name="T"></typeparam>
+        /// <param name="name"></param>
-        /// <param name="row"></param>
+        /// <param name="type"></param>
-        /// <param name="field"></param>
+        /// <param name="converter"></param>
-        /// <param name="reader"></param>
+        public MySqlColumn(string name, string type, Type converter = null)
-        /// <exception cref="NotSupportedException"></exception>
-        public void ReadValue<T>(T row, FieldInfo field, MySqlDataReader reader)
         {
-            //See if we can find the column index.
+            this.Name = name;
-            int columnIndex = -1;
-            int fields = reader.FieldCount;
-            for (int i = 0; i < fields; i++)
-            {
-                string name = reader.GetName(i);
 
-                if (name == this.Name || name == field.Name)
+            this.Type = type;
-                {
-                    columnIndex = i;
-                    break;
-                }
-            }
 
-            //If we didn't find the column, exit.
+            //Make sure the converter is valid if one was passed.
-            if (columnIndex == -1)
+            if (converter != null && !converter.IsAssignableTo(typeof(MySqlColumnConverter)))
-                return;
+                throw new NotSupportedException($"Converter must inherit {nameof(MySqlColumnConverter)}");
 
-            //See if we have a converter, use it to read the value.
+            this.Converter = converter;
-            if (this.Converter != null)
-            {
-                field.SetValue(row, this.Converter.CreateInstance<MySqlColumnConverter>().ConvertFrom(reader.GetValue(columnIndex)));
-            }
-            else
-            {
-                //Get our field type code
-                var typeCode = Type.GetTypeCode(field.FieldType);
-
-                //Read the value based on the type code.
-                switch (typeCode)
-                {
-                    case TypeCode.Boolean:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(bool) : reader.GetValue(columnIndex).ConvertToType<bool>());
-                        break;
-                    case TypeCode.Byte:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(byte) : reader.GetValue(columnIndex).ConvertToType<byte>());
-                        break;
-                    case TypeCode.Char:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(char) : reader.GetValue(columnIndex).ConvertToType<char>());
-                        break;
-                    case TypeCode.Decimal:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(decimal) : reader.GetValue(columnIndex).ConvertToType<decimal>());
-                        break;
-                    case TypeCode.DateTime:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(DateTime) : reader.GetValue(columnIndex).ConvertToType<DateTime>());
-                        break;
-                    case TypeCode.Double:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(double) : reader.GetValue(columnIndex).ConvertToType<double>());
-                        break;
-                    case TypeCode.Int16:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(short) : reader.GetValue(columnIndex).ConvertToType<short>());
-                        break;
-                    case TypeCode.Int32:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(int) : reader.GetValue(columnIndex).ConvertToType<int>());
-                        break;
-                    case TypeCode.Int64:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(long) : reader.GetValue(columnIndex).ConvertToType<long>());
-                        break;
-                    case TypeCode.SByte:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(sbyte) : reader.GetValue(columnIndex).ConvertToType<sbyte>());
-                        break;
-                    case TypeCode.Single:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(float) : reader.GetValue(columnIndex).ConvertToType<float>());
-                        break;
-                    case TypeCode.String:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(string) : reader.GetValue(columnIndex).ConvertToType<string>());
-                        break;
-                    case TypeCode.UInt16:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(ushort) : reader.GetValue(columnIndex).ConvertToType<ushort>());
-                        break;
-                    case TypeCode.UInt32:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(uint) : reader.GetValue(columnIndex).ConvertToType<uint>());
-                        break;
-                    case TypeCode.UInt64:
-                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(ulong) : reader.GetValue(columnIndex).ConvertToType<ulong>());
-                        break;
-                    default:
-                        throw new NotSupportedException("Unsupported TypeCode");
-                }
-            }
         }
     }
 }

MySqlPlus/MySqlColumnConverter.cs

@@ -25,5 +25,10 @@ namespace MontoyaTech.MySqlPlus
         /// <param name="input"></param>
         /// <returns></returns>
         object ConvertFrom(object input);
+
+        /// <summary>
+        /// Returns the MySql Column Type that this converter converts that data into.
+        /// </summary>
+        string ConvertToType { get; }
     }
 }

MySqlPlus/MySqlColumnExtensions.cs

@@ -1,4 +1,5 @@
-using Mysqlx.Resultset;
+using MySql.Data.MySqlClient;
+using Mysqlx.Resultset;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -62,5 +63,163 @@ namespace MontoyaTech.MySqlPlus
 
             return false;
         }
+
+        /// <summary>
+        /// Gets the MySqlColumn type for a given column from a field and a column.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <param name="column"></param>
+        /// <returns></returns>
+        public static string GetMySqlColumnType(this MySqlColumn column, FieldInfo field)
+        {
+            if (!string.IsNullOrWhiteSpace(column.Type))
+                return column.Type;
+
+            if (column.Converter != null)
+                return column.Converter.CreateInstance<MySqlColumnConverter>().ConvertToType;
+
+            var code = Type.GetTypeCode(field.FieldType);
+
+            switch (code)
+            {
+                case TypeCode.Boolean:
+                    return "BOOLEAN";
+
+                case TypeCode.Byte:
+                    return "TINYINT UNSIGNED";
+
+                case TypeCode.Char:
+                    return "SMALLINT UNSIGNED";
+
+                case TypeCode.Decimal:
+                    return "DECIMAL";
+
+                case TypeCode.Double:
+                    return "DOUBLE";
+
+                case TypeCode.Single:
+                    return "FLOAT";
+
+                case TypeCode.Int16:
+                    return "SMALLINT";
+
+                case TypeCode.Int32:
+                    return "INT";
+
+                case TypeCode.Int64:
+                    return "BIGINT";
+
+                case TypeCode.String:
+                    return "LONGTEXT";
+
+                case TypeCode.UInt16:
+                    return "SMALLINT UNSIGNED";
+
+                case TypeCode.UInt32:
+                    return "INT UNSIGNED";
+
+                case TypeCode.UInt64:
+                    return "BIGINT UNSIGNED";
+
+                case TypeCode.SByte:
+                    return "TINYINT";
+
+                default:
+                    throw new NotSupportedException($"Unsupported column type code: {code}");
+            }
+        }
+
+        /// <summary>
+        /// Reads the value of a MySqlColumn from a MySqlDataReader and sets the value on the corresponding field on an instance of a row.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="column"></param>
+        /// <param name="row"></param>
+        /// <param name="field"></param>
+        /// <param name="reader"></param>
+        /// <exception cref="NotSupportedException"></exception>
+        public static void ReadValue<T>(this MySqlColumn column, T row, FieldInfo field, MySqlDataReader reader)
+        {
+            //See if we can find the column index.
+            int columnIndex = -1;
+            int fields = reader.FieldCount;
+            for (int i = 0; i < fields; i++)
+            {
+                string name = reader.GetName(i);
+
+                if (name == column.Name || name == field.Name)
+                {
+                    columnIndex = i;
+                    break;
+                }
+            }
+
+            //If we didn't find the column, exit.
+            if (columnIndex == -1)
+                return;
+
+            //See if we have a converter, use it to read the value.
+            if (column.Converter != null)
+            {
+                field.SetValue(row, column.Converter.CreateInstance<MySqlColumnConverter>().ConvertFrom(reader.GetValue(columnIndex)));
+            }
+            else
+            {
+                //Get our field type code
+                var typeCode = Type.GetTypeCode(field.FieldType);
+
+                //Read the value based on the type code.
+                switch (typeCode)
+                {
+                    case TypeCode.Boolean:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(bool) : reader.GetValue(columnIndex).ConvertToType<bool>());
+                        break;
+                    case TypeCode.Byte:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(byte) : reader.GetValue(columnIndex).ConvertToType<byte>());
+                        break;
+                    case TypeCode.Char:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(char) : reader.GetValue(columnIndex).ConvertToType<char>());
+                        break;
+                    case TypeCode.Decimal:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(decimal) : reader.GetValue(columnIndex).ConvertToType<decimal>());
+                        break;
+                    case TypeCode.DateTime:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(DateTime) : reader.GetValue(columnIndex).ConvertToType<DateTime>());
+                        break;
+                    case TypeCode.Double:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(double) : reader.GetValue(columnIndex).ConvertToType<double>());
+                        break;
+                    case TypeCode.Int16:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(short) : reader.GetValue(columnIndex).ConvertToType<short>());
+                        break;
+                    case TypeCode.Int32:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(int) : reader.GetValue(columnIndex).ConvertToType<int>());
+                        break;
+                    case TypeCode.Int64:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(long) : reader.GetValue(columnIndex).ConvertToType<long>());
+                        break;
+                    case TypeCode.SByte:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(sbyte) : reader.GetValue(columnIndex).ConvertToType<sbyte>());
+                        break;
+                    case TypeCode.Single:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(float) : reader.GetValue(columnIndex).ConvertToType<float>());
+                        break;
+                    case TypeCode.String:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(string) : reader.GetValue(columnIndex).ConvertToType<string>());
+                        break;
+                    case TypeCode.UInt16:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(ushort) : reader.GetValue(columnIndex).ConvertToType<ushort>());
+                        break;
+                    case TypeCode.UInt32:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(uint) : reader.GetValue(columnIndex).ConvertToType<uint>());
+                        break;
+                    case TypeCode.UInt64:
+                        field.SetValue(row, reader.IsDBNull(columnIndex) ? default(ulong) : reader.GetValue(columnIndex).ConvertToType<ulong>());
+                        break;
+                    default:
+                        throw new NotSupportedException("Unsupported TypeCode");
+                }
+            }
+        }
     }
 }

MySqlPlus/MySqlCommandExtensions.cs

@@ -155,12 +155,6 @@ namespace MontoyaTech.MySqlPlus
             //Get the row information.
             var rowAttribute = type.GetCustomAttribute<MySqlRow>();
 
-            //Get all the fields.
-            var fields = type.GetFields();
-
-            if (fields == null || fields.Length == 0)
-                throw new Exception("Found no public fields on given row.");
-
             //Get the id field
             if (!type.GetMySqlId(out FieldInfo idField, out MySqlColumn idColumn))
                 throw new Exception("Failed to find the id column on the given row.");
@@ -280,5 +274,160 @@ namespace MontoyaTech.MySqlPlus
             //Set the command text.
             command.CommandText = builder.ToString();
         }
+
+        /// <summary>
+        /// Setups this MySqlCommand to create a table from a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="command"></param>
+        public static void CreateTable<T>(this MySqlCommand command)
+        {
+            //Get the type of T
+            var type = typeof(T);
+
+            //Create a new instance of the row
+            var row = type.CreateInstance<T>();
+
+            //Get the row information.
+            var rowAttribute = type.GetCustomAttribute<MySqlRow>();
+
+            //Start building the query.
+            var builder = new StringBuilder();
+
+            //Write the delete from section
+            builder.Append($"CREATE TABLE `{(rowAttribute == null || string.IsNullOrWhiteSpace(rowAttribute.Name) ? type.Name : rowAttribute.Name)}` (");
+
+            //Write all the columns
+            var fields = type.GetFields();
+
+            if (fields != null)
+            {
+                bool separate = false;
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    var field = fields[i];
+
+                    var column = field.GetCustomAttribute<MySqlColumn>();
+
+                    if (column != null)
+                    {
+                        if (separate)
+                            builder.Append(", ");
+
+                        //Write the column name
+                        builder.Append($"{(string.IsNullOrWhiteSpace(column.Name) ? fields[i].Name : column.Name)} ");
+
+                        //Write the column data type
+                        builder.Append($"{column.GetMySqlColumnType(fields[i])} ");
+
+                        //Write the column null information
+                        builder.Append($"{(column.Nullable ? "NULL" : "NOT NULL")} ");
+
+                        //Write the column default value if needed. (We can't do this if the column is auto increment)
+                        if (column.Default && !column.AutoIncrement)
+                        {
+                            var defaultValue = column.DefaultValue;
+
+                            //If we don't have a default value, attempt to get it from the field.
+                            if (defaultValue == null)
+                                defaultValue = field.GetValue(row);
+
+                            //Quirk, don't do this if the converter is null, and the default is null, and we are nullable.
+                            if (!(column.Converter == null && defaultValue == null && column.Nullable))
+                            {
+                                if (column.Converter != null)
+                                    defaultValue = column.Converter.CreateInstance<MySqlColumnConverter>().ConvertTo(defaultValue);
+
+                                builder.Append($"{(column.Default ? $"DEFAULT @{i}" : "")} ");
+
+                                command.Parameters.AddWithValue($"@{i}", defaultValue);
+                            }
+                        }
+
+                        //Write the column auto increment information.
+                        builder.Append($"{(column.AutoIncrement ? "AUTO_INCREMENT" : "")}");
+
+                        if (column.PrimaryKey)
+                            builder.Append($", PRIMARY KEY ({(string.IsNullOrWhiteSpace(column.Name) ? fields[i].Name : column.Name)})");
+
+                        separate = true;
+                    }
+                }
+            }
+
+            builder.Append(")");
+
+            //Set the command text.
+            command.CommandText = builder.ToString();
+        }
+
+        /// <summary>
+        /// Setups this MySqlCommand to check if a table exists for a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="command"></param>
+        public static void TableExists<T>(this MySqlCommand command)
+        {
+            //Get the type of T
+            var type = typeof(T);
+
+            //Get the row information.
+            var rowAttribute = type.GetCustomAttribute<MySqlRow>();
+
+            //Start building the query.
+            var builder = new StringBuilder();
+
+            //Write the delete from section
+            builder.Append($"SHOW TABLES LIKE `{(rowAttribute == null || string.IsNullOrWhiteSpace(rowAttribute.Name) ? type.Name : rowAttribute.Name)}`");
+
+            //Set the command text
+            command.CommandText = builder.ToString();
+        }
+
+        /// <summary>
+        /// Setups this MySqlCommand to empty the table for a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="command"></param>
+        public static void EmptyTable<T>(this MySqlCommand command)
+        {
+            //Get the type of T
+            var type = typeof(T);
+
+            //Get the row information.
+            var rowAttribute = type.GetCustomAttribute<MySqlRow>();
+
+            //Start building the query.
+            var builder = new StringBuilder();
+
+            //Write the delete from section
+            builder.Append($"TRUNCATE TABLE `{(rowAttribute == null || string.IsNullOrWhiteSpace(rowAttribute.Name) ? type.Name : rowAttribute.Name)}`");
+
+            //Set the command text
+            command.CommandText = builder.ToString();
+        }
+
+        /// <summary>
+        /// Setups this MySqlCommand to delete a table for a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="command"></param>
+        public static void DeleteTable<T>(this MySqlCommand command)
+        {
+            //Get the type of T
+            var type = typeof(T);
+
+            //Get the row information.
+            var rowAttribute = type.GetCustomAttribute<MySqlRow>();
+
+            //Start building the query.
+            var builder = new StringBuilder();
+
+            //Write the delete from section
+            builder.Append($"DROP TABLE `{(rowAttribute == null || string.IsNullOrWhiteSpace(rowAttribute.Name) ? type.Name : rowAttribute.Name)}`");
+
+            //Set the command text
+            command.CommandText = builder.ToString();
+        }
     }
 }

MySqlPlus/MySqlDataReaderExtensions.cs

@@ -124,8 +124,29 @@ namespace MontoyaTech.MySqlPlus
         /// <param name="rows"></param>
         public static void ReadAll<T>(this MySqlDataReader reader, List<T> rows)
         {
-            while (reader.Read<T>(out T row))
+            var type = typeof(T);
+
+            var fields = type.GetFields();
+
+            if (fields == null || fields.Length == 0)
+                throw new Exception("Found no public fields on given row.");
+
+            while (reader.Read())
+            {
+                var row = type.CreateInstance<T>();
+
+                for (int i = 0; i < fields.Length; i++)
+                {
+                    var column = fields[i].GetCustomAttribute<MySqlColumn>();
+
+                    if (column == null)
+                        continue;
+                    else
+                        column.ReadValue(row, fields[i], reader);
+                }
+
                 rows.Add(row);
+            }
         }
     }
 }

MySqlPlus/MySqlManagedConnection.cs

@@ -153,6 +153,9 @@ namespace MontoyaTech.MySqlPlus
         /// <returns></returns>
         public MySqlDataReader ExecuteReader(MySqlCommand command, int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true)
         {
+            if (string.IsNullOrWhiteSpace(command.CommandText))
+                throw new ArgumentException("Given command must have CommandText set.");
+
             int backoffSleep = 2000;
             command.CommandTimeout = 60; //Time in seconds
 
@@ -220,6 +223,9 @@ namespace MontoyaTech.MySqlPlus
         /// <exception cref="Exception"></exception>
         public int ExecuteNonQuery(MySqlCommand command, int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true)
         {
+            if (string.IsNullOrWhiteSpace(command.CommandText))
+                throw new ArgumentException("Given command must have CommandText set.");
+
             int backoffSleep = 2000;
             command.CommandTimeout = 60; // time in seconds
 

MySqlPlus/MySqlPlus.csproj

@@ -7,7 +7,7 @@
     <AssemblyName>MontoyaTech.MySqlPlus</AssemblyName>
     <RootNamespace>MontoyaTech.MySqlPlus</RootNamespace>
     <Title>MontoyaTech.MySqlPlus</Title>
-    <Version>1.0.2</Version>
+    <Version>1.0.3</Version>
     <Company>MontoyaTech</Company>
     <Description>A simple C# library to help work with MySql.</Description>
     <Copyright>MontoyaTech 2023</Copyright>

MySqlPlus/MySqlSession.cs

@@ -189,6 +189,64 @@ namespace MontoyaTech.MySqlPlus
             }
         }
 
+        /// <summary>
+        /// Creates a new table in the db of a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public void CreateTable<T>()
+        {
+            using (var command = new MySqlCommand())
+            {
+                command.CreateTable<T>();
+
+                this.Connection.ExecuteNonQuery(command);
+            }
+        }
+
+        /// <summary>
+        /// Returns whether or not a table exists in the db of a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public bool TableExists<T>()
+        {
+            using (var command = new MySqlCommand())
+            {
+                command.TableExists<T>();
+
+                using (var reader = this.Connection.ExecuteReader(command))
+                    return reader.Read();
+            }
+        }
+
+        /// <summary>
+        /// Emptys a table in the db for a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public void EmptyTable<T>()
+        {
+            using (var command = new MySqlCommand())
+            {
+                command.EmptyTable<T>();
+
+                this.Connection.ExecuteNonQuery(command);
+            }
+        }
+
+        /// <summary>
+        /// Deletes a table in the db for a given row type.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public void DeleteTable<T>()
+        {
+            using (var command = new MySqlCommand())
+            {
+                command.DeleteTable<T>();
+
+                this.Connection.ExecuteNonQuery(command);
+            }
+        }
+
         /// <summary>
         /// Implicitly converts a MySqlSession to a MySqlConnection.
         /// </summary>