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)); }