/// <summary>
/// Specifies MySQL JSON data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <returns>This column for fluent coding.</returns>
public static T AsMySqlJson <T>(this T column)
where T : Column <string>
{
column.VerifyNotNull(nameof(column));
column.SetMySqlType(MySqlType.Json(column));
return(column);
}
/// <summary>
/// Specifies MySQL CHAR data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="charSetName">The char set name of the data type.</param>
/// <param name="collationName">The collation name of the data type.</param>
/// <returns>This column for fluent coding.</returns>
public static T AsMySqlChar <T>(this T column, string charSetName = null, string collationName = null)
where T : Column <Char?>
{
column.VerifyNotNull(nameof(column));
column.SetMySqlType(MySqlType.SingleChar(column, charSetName, collationName));
return(column);
}
/// <summary>
/// Specifies MySQL TIMESTAMP data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="precision">The precision of the data type.</param>
/// <returns>This column for fluent coding.</returns>
public static _DateTime AsMySqlTimestamp(this _DateTime column, int precision = 0)
{
column.VerifyNotNull(nameof(column));
VerifyTimePrecision(precision, nameof(precision));
column.SetMySqlType(MySqlType.Timestamp(column, precision));
return(column);
}
private static void GetDebugInfo(this MySqlParameter mySqlParameter, out MySqlType mySqlType, out object value, out MySqlVersion mySqlVersion)
{
Tuple <MySqlType, object, MySqlVersion> result = null;
s_debugInfo.TryGetValue(mySqlParameter, out result);
mySqlType = result.Item1;
value = result.Item2;
mySqlVersion = result.Item3;
}
private static void VerifyMySqlParamInfo(MySqlVersion mySqlVersion, MySqlType mySqlType, MySqlParameterInfo expected)
{
var actual = mySqlType.GetSqlParameterInfo(mySqlVersion);
Assert.AreEqual(expected.MySqlDbType, actual.MySqlDbType);
Assert.AreEqual(expected.Size, actual.Size);
Assert.AreEqual(expected.Precision, actual.Precision);
Assert.AreEqual(expected.Scale, actual.Scale);
}
/// <summary>
/// Specifies MySQL VARBINARY(n) data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="size">The size of the data type.</param>
/// <returns>This column for fluent coding.</returns>
public static _Binary AsMySqlVarBinary(this _Binary column, int size = MAX_VARBINARY_SIZE)
{
column.VerifyNotNull(nameof(column));
if (size < MIN_VARBINARY_SIZE || size > MAX_VARBINARY_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(size));
}
column.SetMySqlType(MySqlType.VarBinary(column, size));
return(column);
}
/// <summary>
/// Specifies MySQL VARCHAR(n) data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="size">The size of the data type.</param>
/// <param name="charSetName">The char set name of the data type.</param>
/// <param name="collationName">The collation name of the data type.</param>
/// <returns>This column for fluent coding.</returns>
public static T AsMySqlVarChar <T>(this T column, int size, string charSetName = null, string collationName = null)
where T : Column <String>
{
column.VerifyNotNull(nameof(column));
if (size < MIN_VARCHAR_SIZE || size > MAX_VARCHAR_SIZE)
{
throw new ArgumentOutOfRangeException(nameof(size));
}
column.SetMySqlType(MySqlType.VarChar(column, size, charSetName, collationName));
return(column);
}
public column(column c)
{
name = c.name;
friendlyName = c.friendlyName;
fkTableName = c.fkTableName;
isFK = c.isFK;
insertReq = c.insertReq;
isSearchField = c.isSearchField;
isPrimaryKey = c.isPrimaryKey;
type = c.type;
size = c.size;
}
public column(string name, string friendlyName = null, bool insertReq = true, MySqlType type = MySqlType.notNeeded, int size = -1, bool isSearchField = false, bool?isFk = null, string fkTableName = null, bool isPrimaryKey = false)
{
Name = name;
FriendlyName = string.IsNullOrEmpty(friendlyName) ? name : friendlyName;
InsertReq = insertReq;
Type = type;
Size = size;
IsSearchField = isSearchField;
IsFK = isFk.HasValue ? isFk.Value : false;
FkTableName = fkTableName;
IsPrimaryKey = isPrimaryKey;
}
/// <summary>
/// Specifies MySQL DECIMAL data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="precision">The precision of the data type.</param>
/// <param name="scale">The scale of the data type.</param>
/// <returns>This column for fluent coding.</returns>
public static _Decimal AsMySqlDecimal(this _Decimal column, byte precision = DEFAULT_DECIMAL_PRECISION, byte scale = DEFAULT_DECIMAL_SCALE)
{
column.VerifyNotNull(nameof(column));
if (precision < MIN_DECIMAL_PRECISION || precision > MAX_DECIMAL_PRECISION)
{
throw new ArgumentOutOfRangeException(nameof(precision));
}
if (scale < MIN_DECIMAL_SCALE || scale > MAX_DECIMAL_SCALE)
{
throw new ArgumentOutOfRangeException(nameof(scale));
}
column.SetMySqlType(MySqlType.Decimal(column, precision, scale));
return(column);
}
/// <summary>
///
/// </summary>
/// <param name="ParameterName"></param>
/// <param name="DataType"></param>
/// <param name="Value"></param>
/// <param name="Direction"></param>
/// <returns></returns>
internal static MySqlParameter CreateInputParameter(string ParameterName,
MySqlType DataType, object Value, ParameterDirection Direction)
{
MySqlParameter param = new MySqlParameter(ParameterName, DataType);
param.Direction = Direction;
//CStr only for strings
if (DataType == MySqlType.VarChar || DataType == MySqlType.Text)
{
if (Value != null)
{
string strTempStringVal = (string)Value;
if (strTempStringVal.Trim() == "")
param.MySqlValue = null;
else
param.MySqlValue = strTempStringVal.Trim();
}
}
else if (DataType == MySqlType.Char)
{
if (Value != null)
{
Char chrTempCharVal = (Char)Value;
if (chrTempCharVal == ' ')
param.MySqlValue = null;
else
param.MySqlValue = chrTempCharVal;
}
}
else
param.MySqlValue = Value;
return param;
}
/// <summary>
/// Specifies MySQL LONGTEXT data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <param name="charSetName">The char set name of the data type.</param>
/// <param name="collationName">The collation name of the data type.</param>
/// <returns>This column for fluent coding.</returns>
public static _String AsMySqlLongText(this _String column, string charSetName = null, string collationName = null)
{
column.VerifyNotNull(nameof(column));
column.SetMySqlType(MySqlType.LongText(column, charSetName, collationName));
return(column);
}
private static MySqlTypeProvider <T?> GetInt64EnumColumnDescriptorProvider <T>()
where T : struct, IConvertible
{
return(new MySqlTypeProvider <T?>(x => MySqlType.Int64Enum <T>((_Int64Enum <T>)x)));
}
/// <summary>
///
/// </summary>
/// <param name="ParameterName"></param>
/// <param name="DataType"></param>
/// <param name="Value"></param>
/// <returns></returns>
internal static MySqlParameter CreateInputParameter(string ParameterName,
MySqlType DataType, object Value)
{
return CreateInputParameter(ParameterName, DataType, Value, ParameterDirection.Input);
}
internal static void SetDebugInfo(this MySqlParameter mySqlParameter, MySqlType mySqlType, object value, MySqlVersion mySqlVersion)
{
Debug.Assert(mySqlParameter != null);
Debug.Assert(mySqlType != null);
s_debugInfo.Add(mySqlParameter, new Tuple <MySqlType, object, MySqlVersion>(mySqlType, value, mySqlVersion));
}
internal static _Int32 AsJsonOrdinality(this _Int32 column)
{
column.SetMySqlType(MySqlType.JsonOrdinality(column));
return(column);
}
private static void SetMySqlType(this Column column, MySqlType mySqlType)
{
column.AddOrUpdate(mySqlType);
}
/// <summary>
/// Specifies MySQL LONGBLOB data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <returns>This column for fluent coding.</returns>
public static _Binary AsMySqlLongBlob(this _Binary column)
{
column.VerifyNotNull(nameof(column));
column.SetMySqlType(MySqlType.LongBlob(column));
return(column);
}
private bool CanEliminateCast(MySqlType sourceMySqlType, MySqlType targetMySqlType)
{
return(sourceMySqlType.GetSqlParameterInfo(MySqlVersion).MySqlDbType == targetMySqlType.GetSqlParameterInfo(MySqlVersion).MySqlDbType);
}
/// <summary>
///
/// </summary>
/// <param name="ParameterName"></param>
/// <param name="DataType"></param>
/// <returns></returns>
internal static MySqlParameter CreateOutputParameter(string ParameterName,
MySqlType DataType)
{
return CreateOutputParameter(ParameterName, DataType, ParameterDirection.Output);
}
/// <summary>
/// Specifies MySQL DATE data type for column.
/// </summary>
/// <param name="column">The column.</param>
/// <returns>This column for fluent coding.</returns>
public static _DateTime AsMySqlDate(this _DateTime column)
{
column.VerifyNotNull(nameof(column));
column.SetMySqlType(MySqlType.Date(column));
return(column);
}
/// <summary>
///
/// </summary>
/// <param name="ParameterName"></param>
/// <param name="DataType"></param>
/// <param name="Direction"></param>
/// <returns></returns>
internal static MySqlParameter CreateOutputParameter(string ParameterName,
MySqlType DataType, ParameterDirection Direction)
{
MySqlParameter param = new MySqlParameter(ParameterName, DataType);
param.Direction = Direction;
return param;
}
public string GetStringDBTypeFromType(Type tp)
{
if (tp != typeof(object))
{
MySqlType typeMySql = GetDBTypeFromType(tp);
string strtype = "";
switch (typeMySql)
{
case MySqlType.BFile: strtype = "BFILE"; break;
case MySqlType.Blob: strtype = "BLOB"; break;
case MySqlType.Byte: strtype = "NUMBER(1,0)"; break;
case MySqlType.Char: strtype = "CHAR"; break;
case MySqlType.Clob: strtype = "CLOB"; break;
case MySqlType.Cursor: strtype = "REF CURSOR"; break;
case MySqlType.DateTime: strtype = "DATE"; break;
case MySqlType.Double: strtype = "NUMBER(50,0)"; break;
//case MySqlType.Double: strtype = "FLOAT"; break;
case MySqlType.Float: strtype = "FLOAT"; break;
//INTEGER Marche aussi... .?
case MySqlType.Int16: strtype = "NUMBER"; break;
case MySqlType.Int32: strtype = "NUMBER"; break;
case MySqlType.IntervalDayToSecond: strtype = "INTERVAL DAY TO SECOND"; break;
case MySqlType.IntervalYearToMonth: strtype = "INTERVAL YEAR TO MONTH"; break;
case MySqlType.LongRaw: strtype = "LONGRAW"; break;
case MySqlType.LongVarChar: strtype = "LONG"; break;
case MySqlType.NChar: strtype = "NCHAR"; break;
case MySqlType.NClob: strtype = "NCLOB"; break;
case MySqlType.NVarChar: strtype = "NVARCHAR2"; break;
case MySqlType.Number: strtype = "NUMBER"; break;
case MySqlType.Raw: strtype = "RAW"; break;
case MySqlType.RowId: strtype = "ROWID"; break;
case MySqlType.SByte: strtype = "UNSIGNED INTEGER"; break;
case MySqlType.Timestamp: strtype = "TIMESTAMP"; break;
case MySqlType.TimestampLocal: strtype = "TIMESTAMP WITH LOCAL TIMEZONE"; break;
case MySqlType.TimestampWithTZ: strtype = "TIMESTAMP WITH TIMEZONE"; break;
case MySqlType.UInt16: strtype = "UNSIGNED INTEGER"; break;
case MySqlType.UInt32: strtype = "UNSIGNED INTEGER"; break;
case MySqlType.VarChar: strtype = "VARCHAR2"; break;
default:
break;
}
if (strtype != "")
{
return(strtype);
}
else
{
return(typeMySql.ToString());
}
}
else
{
return("sql_variant");
}
}
