273 lines
11 KiB
C#
273 lines
11 KiB
C#
using MySql.Data.MySqlClient;
|
|
using Mysqlx.Resultset;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace MontoyaTech.MySqlPlus
|
|
{
|
|
/// <summary>
|
|
/// A set of extensions to help work with MySqlColumns.
|
|
/// </summary>
|
|
public static class MySqlColumnExtensions
|
|
{
|
|
/// <summary>
|
|
/// Gets the FieldInfo and MySqlColumn for an Id column on a given row and returns
|
|
/// whether or not we found it.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="row"></param>
|
|
/// <param name="field"></param>
|
|
/// <param name="idColumn"></param>
|
|
public static bool GetMySqlPrimaryKey<T>(this T row, out FieldInfo field, out MySqlColumn idColumn)
|
|
{
|
|
var type = typeof(T);
|
|
|
|
return GetMySqlPrimaryKey(type, out field, out idColumn);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the FieldInfo and MySqlColumn for an Id column on a given row type and returns
|
|
/// whether or not we found it.
|
|
/// </summary>
|
|
/// <param name="type"></param>
|
|
/// <param name="field"></param>
|
|
/// <param name="idColumn"></param>
|
|
/// <returns></returns>
|
|
public static bool GetMySqlPrimaryKey(this Type type, out FieldInfo field, out MySqlColumn idColumn)
|
|
{
|
|
field = null;
|
|
|
|
idColumn = null;
|
|
|
|
var fields = type.GetFields();
|
|
|
|
if (fields == null || fields.Length == 0)
|
|
return false;
|
|
|
|
for (int i = 0; i < fields.Length; i++)
|
|
{
|
|
var column = fields[i].GetCustomAttribute<MySqlColumn>();
|
|
|
|
if (column != null && column.PrimaryKey)
|
|
{
|
|
field = fields[i];
|
|
idColumn = column;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
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 typeCode = Type.GetTypeCode(field.FieldType);
|
|
|
|
//If the field type is a nullable, get the actual field type.
|
|
if (field.FieldType.IsNullable())
|
|
typeCode = Type.GetTypeCode(Nullable.GetUnderlyingType(field.FieldType));
|
|
|
|
switch (typeCode)
|
|
{
|
|
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: {typeCode}");
|
|
}
|
|
}
|
|
|
|
/// <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);
|
|
|
|
//If this field is a nullable, get the underlying type.
|
|
bool nullable = false;
|
|
|
|
if (field.FieldType.IsNullable())
|
|
{
|
|
typeCode = Type.GetTypeCode(Nullable.GetUnderlyingType(field.FieldType));
|
|
|
|
nullable = true;
|
|
}
|
|
|
|
//Read the value based on the type code.
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Boolean:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(bool)) : reader.GetValue(columnIndex).ConvertToType<bool>());
|
|
break;
|
|
case TypeCode.Byte:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(byte)) : reader.GetValue(columnIndex).ConvertToType<byte>());
|
|
break;
|
|
case TypeCode.Char:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(char)) : reader.GetValue(columnIndex).ConvertToType<char>());
|
|
break;
|
|
case TypeCode.Decimal:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(decimal)) : reader.GetValue(columnIndex).ConvertToType<decimal>());
|
|
break;
|
|
case TypeCode.DateTime:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(DateTime)) : reader.GetValue(columnIndex).ConvertToType<DateTime>());
|
|
break;
|
|
case TypeCode.Double:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(double)) : reader.GetValue(columnIndex).ConvertToType<double>());
|
|
break;
|
|
case TypeCode.Int16:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(short)) : reader.GetValue(columnIndex).ConvertToType<short>());
|
|
break;
|
|
case TypeCode.Int32:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(int)) : reader.GetValue(columnIndex).ConvertToType<int>());
|
|
break;
|
|
case TypeCode.Int64:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(long)) : reader.GetValue(columnIndex).ConvertToType<long>());
|
|
break;
|
|
case TypeCode.SByte:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(sbyte)) : reader.GetValue(columnIndex).ConvertToType<sbyte>());
|
|
break;
|
|
case TypeCode.Single:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : 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) ? (nullable ? null : default(ushort)) : reader.GetValue(columnIndex).ConvertToType<ushort>());
|
|
break;
|
|
case TypeCode.UInt32:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null: default(uint)) : reader.GetValue(columnIndex).ConvertToType<uint>());
|
|
break;
|
|
case TypeCode.UInt64:
|
|
field.SetValue(row, reader.IsDBNull(columnIndex) ? (nullable ? null : default(ulong)) : reader.GetValue(columnIndex).ConvertToType<ulong>());
|
|
break;
|
|
default:
|
|
throw new NotSupportedException("Unsupported TypeCode");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether or not a MySqlColumn can be nullable or not based on the field definition and a row.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="column"></param>
|
|
/// <param name="field"></param>
|
|
/// <param name="row"></param>
|
|
/// <returns></returns>
|
|
public static bool IsNullable<T>(this MySqlColumn column, FieldInfo field, T row)
|
|
{
|
|
//If the column is the primary key, it cannot be null.
|
|
if (column.PrimaryKey)
|
|
return false;
|
|
|
|
var fieldType = field.FieldType;
|
|
|
|
var defaultValue = field.GetValue(row);
|
|
|
|
if (column.DefaultValue != null)
|
|
defaultValue = column.DefaultValue;
|
|
|
|
if (column.Converter != null)
|
|
fieldType = column.Converter.CreateInstance<MySqlColumnConverter>().ConvertTo(defaultValue).GetType();
|
|
|
|
if (fieldType.IsNullable())
|
|
return true;
|
|
|
|
if (fieldType.IsValueType)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|