public void Add_WithArgs4_NoErrors()
{
const string parameterName = "@a_parameter";
const AseDbType type = AseDbType.VarChar;
const int size = 256;
const string sourceColumn = "a_column";
const ParameterDirection parameterDirection = ParameterDirection.Output;
const bool isNullable = true;
const byte precision = 16;
const byte scale = 24;
const DataRowVersion sourceVersion = DataRowVersion.Default;
const string value = "a value";
var parameterCollection = new AseParameterCollection();
var parameter = parameterCollection.Add(parameterName, type, size, parameterDirection, isNullable, precision, scale, sourceColumn, sourceVersion, value);
Assert.AreEqual(parameterName, parameter.ParameterName);
Assert.AreEqual(type, parameter.AseDbType);
Assert.AreEqual(size, parameter.Size);
Assert.AreEqual(parameterDirection, parameter.Direction);
Assert.AreEqual(isNullable, parameter.IsNullable);
Assert.AreEqual(precision, parameter.Precision);
Assert.AreEqual(scale, parameter.Scale);
Assert.AreEqual(sourceColumn, parameter.SourceColumn);
Assert.AreEqual(sourceVersion, parameter.SourceVersion);
Assert.AreEqual(value, parameter.Value);
Assert.AreEqual(1, parameterCollection.Count);
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterName">The name of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
/// <param name="sourceColumn">The name of the source column.</param>
public AseParameter(string parameterName, AseDbType dbType, int size, string sourceColumn) : this()
{
ParameterName = parameterName;
AseDbType = dbType;
Size = size;
SourceColumn = sourceColumn;
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterIndex">The index of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
/// <param name="sourceColumn">The name of the source column.</param>
public AseParameter(int parameterIndex, AseDbType dbType, int size, string sourceColumn) : this()
{
ParameterIndex = parameterIndex;
AseDbType = dbType;
Size = size;
SourceColumn = sourceColumn;
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterName">The name of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
/// <param name="isNullable"> true if the value of the field can be null; otherwise, false.</param>
/// <param name="precision">The total number of digits to the left and right of the decimal point to which Value is resolved.</param>
/// <param name="scale">The total number of decimal places to which Value is resolved.</param>
public AseParameter(string parameterName, AseDbType dbType, int size, bool isNullable, int precision, int scale) : this()
{
ParameterName = parameterName;
AseDbType = dbType;
Size = size;
IsNullable = isNullable;
Precision = (byte)precision;
Scale = (byte)scale;
}
/// <summary>
/// When a parameter's type is set, this will be called to "clean it up".
/// In particular, the reference driver treats DateTime and BigDateTime as the same value (and both are transmitted as a TDS_BIGDATETIMEN type), so we should do the same.
/// </summary>
public static AseDbType CleanupAseDbType(AseDbType aseDbType)
{
// DateTime and BigDateTime are implemented the same way.
if (aseDbType == AseDbType.BigDateTime)
{
return(AseDbType.DateTime);
}
// it's clean, leave it alone!
return(aseDbType);
}
public void ConstructParameter_WithArgs1_NoErrors()
{
const string parameterName = "@a_parameter";
const AseDbType type = AseDbType.VarChar;
var parameter = new AseParameter(parameterName, type);
Assert.AreEqual(parameterName, parameter.ParameterName);
Assert.AreEqual(type, parameter.AseDbType);
Assert.AreEqual(ParameterDirection.Input, parameter.Direction);
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterIndex">The index of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
/// <param name="direction">One of the <see cref="ParameterDirection" /> values.</param>
/// <param name="isNullable"> true if the value of the field can be null; otherwise, false.</param>
/// <param name="precision">The total number of digits to the left and right of the decimal point to which Value is resolved.</param>
/// <param name="scale">The total number of decimal places to which Value is resolved.</param>
/// <param name="sourceColumn">The name of the source column.</param>
/// <param name="sourceVersion">One of the <see cref="DataRowVersion" /> values.</param>
/// <param name="value">An object that is the value of the parameter.</param>
public AseParameter(int parameterIndex, AseDbType dbType, int size, ParameterDirection direction, bool isNullable, int precision, int scale, string sourceColumn, DataRowVersion sourceVersion, object value) : this()
{
ParameterIndex = parameterIndex;
AseDbType = dbType;
Size = size;
Direction = direction;
IsNullable = isNullable;
Precision = (byte)precision;
Scale = (byte)scale;
SourceColumn = sourceColumn;
SourceVersion = sourceVersion;
Value = value;
}
public void Add_WithArgs1_NoErrors()
{
const string parameterName = "@a_parameter";
const AseDbType type = AseDbType.VarChar;
var parameterCollection = new AseParameterCollection();
var parameter = parameterCollection.Add(parameterName, type);
Assert.AreEqual(parameterName, parameter.ParameterName);
Assert.AreEqual(type, parameter.AseDbType);
Assert.AreEqual(ParameterDirection.Input, parameter.Direction);
Assert.AreEqual(1, parameterCollection.Count);
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterName">The name of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
/// <param name="direction">One of the <see cref="ParameterDirection" /> values.</param>
/// <param name="isNullable"> true if the value of the field can be null; otherwise, false.</param>
/// <param name="precision">The total number of digits to the left and right of the decimal point to which Value is resolved.</param>
/// <param name="scale">The total number of decimal places to which Value is resolved.</param>
/// <param name="sourceColumn">The name of the source column.</param>
/// <param name="sourceVersion">One of the <see cref="DataRowVersion" /> values.</param>
/// <param name="value">An object that is the value of the parameter.</param>
public AseParameter(string parameterName, AseDbType dbType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale,
string sourceColumn, DataRowVersion sourceVersion, object value) : this()
{
ParameterName = parameterName;
AseDbType = dbType;
Size = size;
Direction = direction;
IsNullable = isNullable;
Precision = precision;
Scale = scale;
SourceColumn = sourceColumn;
SourceVersion = sourceVersion;
Value = value;
}
public void ConstructParameter_WithArgs3_NoErrors()
{
const string parameterName = "@a_parameter";
const AseDbType type = AseDbType.VarChar;
const int size = 256;
const string sourceColumn = "a_column";
var parameter = new AseParameter(parameterName, type, size, sourceColumn);
Assert.AreEqual(parameterName, parameter.ParameterName);
Assert.AreEqual(type, parameter.AseDbType);
Assert.AreEqual(ParameterDirection.Input, parameter.Direction);
Assert.AreEqual(size, parameter.Size);
Assert.AreEqual(sourceColumn, parameter.SourceColumn);
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterName">The name of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
public AseParameter(string parameterName, AseDbType dbType) : this()
{
ParameterName = parameterName;
AseDbType = dbType;
if (dbType == AseDbType.Money)
{
Precision = 20;
Scale = 4;
}
else
{
if (dbType != AseDbType.SmallMoney)
{
return;
}
Precision = 12;
Scale = 4;
}
}
internal static object AsSendableValue(this object value, AseDbType aseDbType)
{
if (value == null)
{
return(DBNull.Value);
}
switch (value)
{
case string s:
return(s.AsSendable());
case char c:
return(c.AsSendable());
case byte[] b:
return(b.AsSendable(aseDbType));
default:
return(value);
}
}
public void ConstructParameter_ViaProperties_Success()
{
const string parameterName = "@a_parameter";
const AseDbType type = AseDbType.VarChar;
const int size = 256;
const string sourceColumn = "a_column";
const ParameterDirection parameterDirection = ParameterDirection.Output;
const bool isNullable = true;
const byte precision = 16;
const byte scale = 24;
const DataRowVersion sourceVersion = DataRowVersion.Default;
const string value = "a value";
var parameter = new AseParameter
{
ParameterName = parameterName,
AseDbType = type,
Size = size,
Direction = parameterDirection,
IsNullable = isNullable,
Precision = precision,
Scale = scale,
SourceColumn = sourceColumn,
SourceVersion = sourceVersion,
Value = value
};
Assert.AreEqual(parameterName, parameter.ParameterName);
Assert.AreEqual(type, parameter.AseDbType);
Assert.AreEqual(size, parameter.Size);
Assert.AreEqual(parameterDirection, parameter.Direction);
Assert.AreEqual(isNullable, parameter.IsNullable);
Assert.AreEqual(precision, parameter.Precision);
Assert.AreEqual(scale, parameter.Scale);
Assert.AreEqual(sourceColumn, parameter.SourceColumn);
Assert.AreEqual(sourceVersion, parameter.SourceVersion);
Assert.AreEqual(value, parameter.Value);
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterIndex">The index of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
public AseParameter(int parameterIndex, AseDbType dbType, int size) : this()
{
ParameterIndex = parameterIndex;
AseDbType = dbType;
Size = size;
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterIndex">The index of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
public AseParameter(int parameterIndex, AseDbType dbType) : this()
{
ParameterIndex = parameterIndex;
AseDbType = dbType;
}
private static byte[] AsSendable(this byte[] value, AseDbType aseDbType)
{
return(value.Length == 0 && aseDbType != AseDbType.Image
? new byte[] { 0 }
: value);
}
/// <summary>
/// Constructor function for an <see cref="AseParameter" />instance.
/// </summary>
/// <param name="parameterName">The name of the parameter to add.</param>
/// <param name="dbType">The <see cref="AseDbType" /> of the parameter to add.</param>
/// <param name="size">The size as <see cref="int" />.</param>
public AseParameter(string parameterName, AseDbType dbType, int size) : this()
{
ParameterName = parameterName;
AseDbType = dbType;
Size = size;
}
public static DbType GetDbType(AseDbType aseDbType)
{
return(AseDbTypeToDbTypeMap.ContainsKey(aseDbType)
? AseDbTypeToDbTypeMap[aseDbType]
: default(DbType));
}
