/// <summary>
/// Fires a message event
/// </summary>
/// <param name="errors">SqlClient errors collection</param>
/// <remarks>
/// Sql specific messages.
/// </remarks>
protected void HandleSqlMessages(SqlErrorCollection errors)
{
foreach (SqlError error in errors)
{
if (error.Number == ChangeDatabase)
{
continue;
}
string detailedMessage = FormatSqlErrorMessage(error);
if (error.Class > 10)
{
// expose this event as error
Debug.Assert(detailedMessage.Length != 0);
RaiseBatchError(detailedMessage, error, textSpan);
//at least one error message has been used
hasErrors = true;
}
else
{
RaiseBatchMessage(detailedMessage, error.Message, error);
}
}
}
/// <summary>
/// makes the string containing the full exception report from the given SqlException.
/// </summary>
/// <param name="e">OleDbException</param>
/// <returns>string representing exception report</returns>
public static string exception_report(SqlException e)
{
StringBuilder result = new StringBuilder("SQLSRV2000 ERROR: ");
try
{
SqlErrorCollection myErrors = e.Errors;
result.AppendFormat("\nClass: {1}", e.Class.ToString());
result.AppendFormat("\nError #{1}: {2} on line {3}.", e.Number.ToString(), e.Message, e.LineNumber.ToString());
result.AppendFormat("\nError reported by {1} while connected to {2}", e.Source, e.Server);
result.Append("\nNeither record was written to database.");
result.Append("\nErrors collection contains:");
foreach (SqlError err in myErrors)
{
result.AppendFormat("\nClass: {1}", err.Class.ToString());
result.AppendFormat("\nError #{1}: {2} on line {3}.", err.Number.ToString(), err.Message, err.LineNumber.ToString());
result.AppendFormat("\nError reported by {1} while connected to {2}", err.Source, err.Server);
}
}
catch (Exception x)
{
result.AppendFormat("\nerror in exception_report(): {0}", x.Message);
}
return(result.ToString());
}
protected SqlException ProcessMessages(bool ignoreWarnings, bool ignoreNonFatalMessages)
{
SqlException result = null;
SqlErrorCollection temp = null; // temp variable to store that which is being thrown - so that local copies can be deleted
if (null != _errors)
{
Debug.Assert(0 != _errors.Count, "empty error collection?"); // must be something in the collection
if (ignoreNonFatalMessages)
{
temp = new SqlErrorCollection();
foreach (SqlError error in _errors)
{
if (error.Class >= TdsEnums.FATAL_ERROR_CLASS)
{
temp.Add(error);
}
}
if (temp.Count <= 0)
{
temp = null;
}
}
else
{
if (null != _warnings)
{
// When we throw an exception we place all the warnings that
// occurred at the end of the collection - after all the errors.
// That way the user can see all the errors AND warnings that
// occurred for the exception.
foreach (SqlError warning in _warnings)
{
_errors.Add(warning);
}
}
temp = _errors;
}
_errors = null;
_warnings = null;
}
else
{
Debug.Assert(null == _warnings || 0 != _warnings.Count, "empty warning collection?");// must be something in the collection
if (!ignoreWarnings)
{
temp = _warnings;
}
_warnings = null;
}
if (null != temp)
{
result = SqlException.CreateException(temp, ServerVersion);
}
return(result);
}
public void GetEnumerator_Success()
{
SqlErrorCollection c = CreateCollection();
IEnumerator e = c.GetEnumerator();
Assert.NotNull(e);
Assert.NotSame(e, c.GetEnumerator());
for (int i = 0; i < 2; i++)
{
Assert.Throws <InvalidOperationException>(() => e.Current);
Assert.True(e.MoveNext());
Assert.Same(c[0], e.Current);
Assert.False(e.MoveNext());
Assert.False(e.MoveNext());
Assert.False(e.MoveNext());
Assert.Throws <InvalidOperationException>(() => e.Current);
e.Reset();
}
}
public void Indexer_Throws()
{
SqlErrorCollection c = CreateCollection();
Assert.Throws <ArgumentOutOfRangeException>("index", () => c[-1]);
Assert.Throws <ArgumentOutOfRangeException>("index", () => c[c.Count]);
}
public void Indexer_Success()
{
SqlErrorCollection c = CreateCollection();
Assert.NotNull(c[0]);
Assert.Same(c[0], c[0]);
}
private static SqlException CreateLocalDBException(string errorMessage, string instance = null, int localDbError = 0, int sniError = 0)
{
Debug.Assert((localDbError == 0) || (sniError == 0), "LocalDB error and SNI error cannot be specified simultaneously");
Debug.Assert(!string.IsNullOrEmpty(errorMessage), "Error message should not be null or empty");
SqlErrorCollection collection = new SqlErrorCollection();
int errorCode = (localDbError == 0) ? sniError : localDbError;
if (sniError != 0)
{
string sniErrorMessage = SQL.GetSNIErrorMessage(sniError);
errorMessage = String.Format((IFormatProvider)null, "{0} (error: {1} - {2})",
errorMessage, sniError, sniErrorMessage);
}
collection.Add(new SqlError(errorCode, 0, TdsEnums.FATAL_ERROR_CLASS, instance, errorMessage, null, 0));
if (localDbError != 0)
{
collection.Add(new SqlError(errorCode, 0, TdsEnums.FATAL_ERROR_CLASS, instance, GetLocalDBMessage(localDbError), null, 0));
}
SqlException exc = SqlException.CreateException(collection, null);
exc._doNotReconnect = true;
return(exc);
}
public static void LogSqlErrorCollection(SqlErrorCollection errors)
{
for (int i = 0; i < errors.Count; i++)
{
LogSqlError(errors[i]);
}
}
public SqlException Build()
{
SqlError error = this.CreateError();
SqlErrorCollection errorCollection = this.CreateErrorCollection(error);
SqlException exception = this.CreateException(errorCollection);
return(exception);
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlErrorCollectionPrototype" /> class.
/// </summary>
/// <param name="collection">The collection.</param>
/// <remarks></remarks>
public SqlErrorCollectionPrototype([NotNull] SqlErrorCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
SqlErrorCollection = collection;
}
private static SqlErrorCollection GetErrorCollection()
{
ConstructorInfo constructor = typeof(SqlErrorCollection).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { }, null);
SqlErrorCollection collection = (SqlErrorCollection)constructor.Invoke(new object[] { });
return(collection);
}
private SqlErrorCollection CreateErrorCollection(SqlError error)
{
var sqlErrorCollectionCtor = typeof(SqlErrorCollection).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
SqlErrorCollection errorCollection = sqlErrorCollectionCtor.Invoke(new object[] { }) as SqlErrorCollection;
typeof(SqlErrorCollection).GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(errorCollection, new object[] { error });
return(errorCollection);
}
private static void ProcessErrors(SqlErrorCollection errors)
{
if (errors == null)
{
return;
}
foreach (var error in errors.Cast <SqlError>())
{
PrintMessage(string.Format(CultureInfo.CurrentCulture, "Sql Error: '{0}' (Severity {1}, State {2})", error.Message, error.Class, error.State));
}
}
private SqlErrorCollection CreateErrorCollection(SqlError error)
{
// Create instance via reflection...
var sqlErrorCollectionCtor = typeof(SqlErrorCollection).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
SqlErrorCollection errorCollection = sqlErrorCollectionCtor.Invoke(Array.Empty <object>()) as SqlErrorCollection;
// Add error...
typeof(SqlErrorCollection).GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(errorCollection, new object[] { error });
return(errorCollection);
}
/// <summary>
/// Creates a new instance of <see cref="SqlException"/>.
/// </summary>
/// <param name="number">The info number.</param>
/// <param name="errorMessage">The error message.</param>
/// <returns>An instance of <see cref="SqlException"/>.</returns>
public static SqlException Create(int number, string errorMessage = "Simulated exception.")
{
SqlError sqlError = SqlErrorConstructorDelegate(number);
SqlErrorCollection sqlErrorCollection = SqlErrorCollectionConstructorDelegate();
SqlErrorCollectionAddDelegate(sqlErrorCollection, sqlError);
SqlException sqlException = SqlExceptionConstructorDelegate(errorMessage, sqlErrorCollection, null, Guid.NewGuid());
return(sqlException);
}
public static SqlException GenerateFakeSqlException(int errorCode, string errorMessage = "")
{
SqlError sqlError = GenerateFakeSqlError(errorCode, errorMessage);
SqlErrorCollection collection = GenerateFakeSqlErrorCollection(sqlError);
return((SqlException)(Activator.CreateInstance(
typeof(SqlException),
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new object?[] { errorMessage, collection, null, Guid.Empty },
null) ?? throw new InvalidOperationException("Failed to create SqlException.")));
}
private static void ValidateCopyToThrows(
Action <SqlErrorCollection, SqlError[], int> copyTo,
Action <SqlErrorCollection> additionalValidation = null)
{
SqlErrorCollection c = CreateCollection();
Assert.Throws <ArgumentNullException>(() => copyTo(c, null, 0));
Assert.Throws <ArgumentNullException>(() => copyTo(c, null, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => copyTo(c, new SqlError[10], -1));
AssertExtensions.Throws <ArgumentException>("destinationArray", "", () => copyTo(c, new SqlError[10], 1000));
additionalValidation?.Invoke(c);
}
private SqlException CreateException(SqlErrorCollection errorCollection)
{
// Create instance via reflection...
var ctor = typeof(SqlException).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0];
SqlException sqlException = ctor.Invoke(new object[] {
// With message and error collection...
errorMessage,
errorCollection,
null,
Guid.NewGuid()
}) as SqlException;
return(sqlException);
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlExceptionPrototype" /> class.
/// </summary>
/// <param name="errorCollection">The error collection.</param>
/// <param name="serverVersion">The server version.</param>
/// <param name="conId">The connection id.</param>
/// <param name="innerException">The inner exception.</param>
public SqlExceptionPrototype(
SqlErrorCollection errorCollection,
string serverVersion = null,
Guid conId = default(Guid),
Exception innerException = null)
: this(
// ReSharper disable once AssignNullToNotNullAttribute
_constructor(
errorCollection,
serverVersion,
conId == default(Guid) ? Guid.NewGuid() : conId,
innerException))
{
}
protected SqlException ProcessMessages(bool ignoreWarnings, bool ignoreNonFatalMessages)
{
SqlErrorCollection errorCollection = null;
SqlException exception = null;
if (this._errors != null)
{
if (ignoreNonFatalMessages)
{
errorCollection = new SqlErrorCollection();
foreach (SqlError error in this._errors)
{
if (error.Class >= 20)
{
errorCollection.Add(error);
}
}
if (errorCollection.Count <= 0)
{
errorCollection = null;
}
}
else
{
if (this._warnings != null)
{
foreach (SqlError error2 in this._warnings)
{
this._errors.Add(error2);
}
}
errorCollection = this._errors;
}
this._errors = null;
this._warnings = null;
}
else
{
if (!ignoreWarnings)
{
errorCollection = this._warnings;
}
this._warnings = null;
}
if (errorCollection != null)
{
exception = SqlException.CreateException(errorCollection, this.ServerVersion);
}
return(exception);
}
internal void CleanMessages()
{
SmiEventSink_Default parent = (SmiEventSink_Default)_parent;
if (null != parent)
{
parent.CleanMessages();
}
else
{
_errors = null;
_warnings = null;
}
}
private static void ValidateCopyTo(Action <SqlErrorCollection, SqlError[], int> copyTo)
{
SqlErrorCollection c = CreateCollection();
SqlError[] destination = new SqlError[5];
copyTo(c, destination, 2);
Assert.Null(destination[0]);
Assert.Null(destination[1]);
Assert.Same(c[0], destination[2]);
Assert.Null(destination[3]);
Assert.Null(destination[4]);
}
public static SqlException GetSqlException()
{
SqlErrorCollection collection = Construct <SqlErrorCollection>();
SqlError error = Construct <SqlError>(-2, (byte)2, (byte)3, "server name", "error message", "proc", 100, (uint)1);
typeof(SqlErrorCollection)
.GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(collection, new object[] { error });
var e = typeof(SqlException)
.GetMethod("CreateException", BindingFlags.NonPublic | BindingFlags.Static, null, CallingConventions.ExplicitThis, new[] { typeof(SqlErrorCollection), typeof(string) }, new ParameterModifier[] { })
.Invoke(null, new object[] { collection, "11.0.0" }) as SqlException;
return(e);
}
private static SqlErrorCollection GenerateFakeSqlErrorCollection(params SqlError[] errors)
{
Type type = typeof(SqlErrorCollection);
SqlErrorCollection collection = (SqlErrorCollection)Activator.CreateInstance(type, true);
MethodInfo method = type.GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
foreach (SqlError error in errors)
{
method.Invoke(collection, new object[] { error });
}
return(collection);
}
private static SqlErrorCollection GenerateFakeSqlErrorCollection(params SqlError[] errors)
{
Type type = typeof(SqlErrorCollection);
SqlErrorCollection collection = (SqlErrorCollection)(Activator.CreateInstance(type, true) ?? throw new InvalidOperationException("Failed to create SqlErrorCollection."));
MethodInfo method = type.GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance) !;
foreach (SqlError error in errors)
{
method?.Invoke(collection, new object[] { error });
}
return(collection);
}
public static SqlException CreateSqlException(string errorMessage, int errorNumber)
{
SqlErrorCollection collection = Construct <SqlErrorCollection>();
SqlError error = GenerateFakeSqlError(errorNumber, errorMessage);
typeof(SqlErrorCollection)
.GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(collection, new object[] { error });
var createException = typeof(SqlException)
.GetMethod("CreateException", BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { typeof(SqlErrorCollection), typeof(string) }, null);
var e = createException.Invoke(null, new object[] { collection, "7.0.0" }) as SqlException;
return(e);
}
internal static SqlException NewSqlException(string message, int number, int level, int state)
{
SqlErrorCollection collection = Construct <SqlErrorCollection>();
SqlError error = Construct <SqlError>(number, (byte)state, (byte)level, "test server", message, "test procedure", state);
typeof(SqlErrorCollection)
.GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(collection, new object[] { error });
return(typeof(SqlException)
.GetMethod("CreateException", BindingFlags.NonPublic | BindingFlags.Static,
null,
CallingConventions.ExplicitThis,
new[] { typeof(SqlErrorCollection), typeof(string) },
new ParameterModifier[] { })
.Invoke(null, new object[] { collection, "7.0.0" }) as SqlException);
}
public static SqlException NewSqlException(int number = 1)
{
SqlErrorCollection collection = Construct <SqlErrorCollection>();
SqlError error = Construct <SqlError>(number, (byte)2, (byte)3, "server name", "error message", "proc", 100);
typeof(SqlErrorCollection)
.GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance)
.Invoke(collection, new object[] { error });
return(typeof(SqlException)
.GetMethod("CreateException", BindingFlags.NonPublic | BindingFlags.Static,
null,
CallingConventions.ExplicitThis,
new[] { typeof(SqlErrorCollection), typeof(string) },
Array.Empty <ParameterModifier>())
.Invoke(null, new object[] { collection, "7.0.0" }) as SqlException);
}
public static SqlException CreateSqlException(string errorMessage, int errorNumber, int state = 0, int severity = 10,
int lineNumber = 0, string server = "ServiceVirt", string procedureName = "ServiceVirtUnknownProcName")
{
SqlErrorCollection collection = GetErrorCollection();
SqlError error = GetError(errorNumber, errorMessage, state, severity, lineNumber, server, procedureName);
MethodInfo addMethod = collection.GetType().GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
addMethod.Invoke(collection, new object[] { error });
Type[] types = new Type[] { typeof(string), typeof(SqlErrorCollection), typeof(Exception), typeof(Guid) };
object[] parameters = new object[] { errorMessage, collection, null, Guid.NewGuid() };
ConstructorInfo constructor = typeof(SqlException).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);
SqlException exception = (SqlException)constructor.Invoke(parameters);
return(exception);
}
public static string ToLogString(this SqlErrorCollection errors)
{
string message = null;
if (errors != null)
{
var stringBuilder = new StringBuilder();
foreach (SqlError error in errors)
{
var s = error.ToLogString();
stringBuilder.AppendLine(s);
}
message = stringBuilder.ToString();
}
return(message);
}
