Add() private method

private Add ( SqlError error ) : void
error SqlError
return void
Ejemplo n.º 1
0
 internal SqlInfoMessageEventArgs(TdsInternalErrorCollection tdsErrors)
 {
     foreach (TdsInternalError e in tdsErrors)
     {
         errors.Add(e.Class, e.LineNumber, e.Message, e.Number, e.Procedure, e.Server, "Mono SqlClient Data Provider", e.State);
     }
 }
Ejemplo n.º 2
0
        internal static Exception CannotCompleteDelegatedTransactionWithOpenResults()
        {
            SqlErrorCollection errorCollection = new SqlErrorCollection();

            errorCollection.Add(new SqlError(-2, 0, 11, null, Res.GetString("ADP_OpenReaderExists"), "", 0));
            return(SqlException.CreateException(errorCollection, null));
        }
Ejemplo n.º 3
0
		internal SqlException (string message, Exception inner, SqlError sqlError)
			: base (message == null ? DEF_MESSAGE : message, inner)
		{
			HResult = -2146232060;
			errors = new SqlErrorCollection ();
			if (sqlError != null)
				errors.Add (sqlError);
		}
Ejemplo n.º 4
0
        //
        // Connection resiliency
        //
        static internal SqlException CR_ReconnectTimeout()
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(TdsEnums.TIMEOUT_EXPIRED, (byte)0x00, TdsEnums.MIN_ERROR_CLASS, null, SQLMessage.Timeout(), "", 0, TdsEnums.SNI_WAIT_TIMEOUT));
            SqlException exc = SqlException.CreateException(errors, "");

            return(exc);
        }
 private static SqlException CreateLocalDBException(string errorMessage, string instance = null, int localDbError = 0, int sniError = 0)
 {
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     int infoNumber = (localDbError == 0) ? sniError : localDbError;
     if (sniError != 0)
     {
         string name = string.Format(null, "SNI_ERROR_{0}", new object[] { sniError });
         errorMessage = string.Format(null, "{0} (error: {1} - {2})", new object[] { errorMessage, sniError, Res.GetString(name) });
     }
     errorCollection.Add(new SqlError(infoNumber, 0, 20, instance, errorMessage, null, 0));
     if (localDbError != 0)
     {
         errorCollection.Add(new SqlError(infoNumber, 0, 20, instance, GetLocalDBMessage(localDbError), null, 0));
     }
     SqlException exception = SqlException.CreateException(errorCollection, null);
     exception._doNotReconnect = true;
     return exception;
 }
Ejemplo n.º 6
0
        static internal Exception CR_NextAttemptWillExceedQueryTimeout(SqlException innerException, Guid connectionId)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.MIN_ERROR_CLASS, null, Res.GetString(Res.SQLCR_NextAttemptWillExceedQueryTimeout), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", connectionId, innerException);

            return(exc);
        }
Ejemplo n.º 7
0
        static internal SqlException CR_AllAttemptsFailed(SqlException innerException, Guid connectionId)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.MIN_ERROR_CLASS, null, Res.GetString(Res.SQLCR_AllAttemptsFailed), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", connectionId, innerException);

            return(exc);
        }
Ejemplo n.º 8
0
        static internal SqlException CR_UnrecoverableClient(Guid connectionId)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.FATAL_ERROR_CLASS, null, Res.GetString(Res.SQLCR_UnrecoverableClient), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", connectionId);

            return(exc);
        }
Ejemplo n.º 9
0
        static internal SqlException CR_TDSVersionNotPreserved(SqlInternalConnectionTds internalConnection)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.FATAL_ERROR_CLASS, null, Res.GetString(Res.SQLCR_TDSVestionNotPreserved), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", internalConnection);

            return(exc);
        }
Ejemplo n.º 10
0
        internal static SqlException CR_NoCRAckAtReconnection(SqlInternalConnectionTds internalConnection)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.FATAL_ERROR_CLASS, null, SR.GetString(SR.SQLCR_NoCRAckAtReconnection), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", internalConnection);

            return(exc);
        }
Ejemplo n.º 11
0
        static internal SqlException CR_ReconnectionCancelled()
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.MIN_ERROR_CLASS, null, SQLMessage.OperationCancelled(), "", 0));
            SqlException exc = SqlException.CreateException(errors, "");

            return(exc);
        }
Ejemplo n.º 12
0
        internal static Exception CR_EncryptionChanged(SqlInternalConnectionTds internalConnection)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.FATAL_ERROR_CLASS, null, Res.GetString(Res.SQLCR_EncryptionChanged), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", internalConnection);

            return(exc);
        }
Ejemplo n.º 13
0
        static internal Exception ROR_TimeoutAfterRoutingInfo(SqlInternalConnectionTds internalConnection)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, (byte)0x00, TdsEnums.FATAL_ERROR_CLASS, null, (Res.GetString(Res.SQLROR_TimeoutAfterRoutingInfo)), "", 0));
            SqlException exc = SqlException.CreateException(errors, null, internalConnection);

            exc._doNotReconnect = true;
            return(exc);
        }
Ejemplo n.º 14
0
        static internal Exception ROR_FailoverNotSupportedServer(SqlInternalConnectionTds internalConnection)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, (byte)0x00, TdsEnums.FATAL_ERROR_CLASS, null, (Res.GetString(Res.SQLROR_FailoverNotSupported)), "", 0));
            SqlException exc = SqlException.CreateException(errors, null, internalConnection);

            exc._doNotReconnect = true;
            return(exc);
        }
Ejemplo n.º 15
0
        internal static Exception ROR_RecursiveRoutingNotSupported(SqlInternalConnectionTds internalConnection)
        {
            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, (byte)0x00, TdsEnums.FATAL_ERROR_CLASS, null, (SR.GetString(SR.SQLROR_RecursiveRoutingNotSupported)), "", 0));
            SqlException exc = SqlException.CreateException(errors, null, internalConnection);

            exc._doNotReconnect = true;
            return(exc);
        }
Ejemplo n.º 16
0
        internal static Exception ROR_RecursiveRoutingNotSupported()
        {
            SqlErrorCollection errorCollection = new SqlErrorCollection();

            errorCollection.Add(new SqlError(0, 0, 20, null, Res.GetString("SQLROR_RecursiveRoutingNotSupported"), "", 0));
            SqlException exception = SqlException.CreateException(errorCollection, null);

            exception._doNotReconnect = true;
            return(exception);
        }
Ejemplo n.º 17
0
        internal static Exception ROR_UnexpectedRoutingInfo()
        {
            SqlErrorCollection errorCollection = new SqlErrorCollection();

            errorCollection.Add(new SqlError(0, 0, 20, null, Res.GetString("SQLROR_UnexpectedRoutingInfo"), "", 0));
            SqlException exception = SqlException.CreateException(errorCollection, null);

            exception._doNotReconnect = true;
            return(exception);
        }
Ejemplo n.º 18
0
 internal SqlException(string message, Exception inner, SqlError sqlError)
     : base(message == null ? DEF_MESSAGE : message, inner)
 {
     HResult = -2146232060;
     errors  = new SqlErrorCollection();
     if (sqlError != null)
     {
         errors.Add(sqlError);
     }
 }
Ejemplo n.º 19
0
        static internal Exception UnsupportedFeatureAndToken(SqlInternalConnectionTds internalConnection, string token)
        {
            var innerException = ADP.NotSupported(Res.GetString(Res.SQL_UnsupportedToken, token));

            SqlErrorCollection errors = new SqlErrorCollection();

            errors.Add(new SqlError(0, 0, TdsEnums.FATAL_ERROR_CLASS, null, Res.GetString(Res.SQL_UnsupportedFeature), "", 0));
            SqlException exc = SqlException.CreateException(errors, "", internalConnection, innerException);

            return(exc);
        }
Ejemplo n.º 20
0
        //
        // MultiSubnetFailover
        //

        /// <summary>
        /// used to block two scenarios if MultiSubnetFailover is true:
        /// * server-provided failover partner - raising SqlException in this case
        /// * connection string with failover partner and MultiSubnetFailover=true - rasing argument one in this case with the same message
        /// </summary>
        static internal Exception MultiSubnetFailoverWithFailoverPartner(bool serverProvidedFailoverPartner, SqlInternalConnectionTds internalConnection)
        {
            string msg = Res.GetString(Res.SQLMSF_FailoverPartnerNotSupported);

            if (serverProvidedFailoverPartner)
            {
                // Replacing InvalidOperation with SQL exception
                SqlErrorCollection errors = new SqlErrorCollection();
                errors.Add(new SqlError(0, (byte)0x00, TdsEnums.FATAL_ERROR_CLASS, null, msg, "", 0));
                SqlException exc = SqlException.CreateException(errors, null, internalConnection);
                exc._doNotReconnect = true; // disable open retry logic on this error
                return(exc);
            }
            else
            {
                return(ADP.Argument(msg));
            }
        }
Ejemplo n.º 21
0
        // Fires a single InfoMessageEvent
        private void FireInfoMessageEvent(SqlConnection connection, TdsParserStateObject stateObj, SqlError error)
        {
            string serverVersion = null;

            Debug.Assert(connection != null && _connHandler.Connection == connection);

            if (_state == TdsParserState.OpenLoggedIn)
            {
                serverVersion = _connHandler.ServerVersion;
            }

            SqlErrorCollection sqlErs = new SqlErrorCollection();

            sqlErs.Add(error);

            SqlException exc = SqlException.CreateException(sqlErs, serverVersion, _connHandler);

            bool notified;
            connection.OnInfoMessage(new SqlInfoMessageEventArgs(exc), out notified);
            if (notified)
            {
                // observable side-effects, no retry
                stateObj._syncOverAsync = true;
            }
            return;
        }
        /// <summary>
        /// Get the Federated Authentication Token.
        /// </summary>
        /// <param name="fedAuthInfo">Information obtained from server as Federated Authentication Info.</param>
        /// <returns>SqlFedAuthToken</returns>
        internal SqlFedAuthToken GetFedAuthToken(SqlFedAuthInfo fedAuthInfo) {

            Debug.Assert(fedAuthInfo != null, "fedAuthInfo should not be null.");

            // No:of milliseconds to sleep for the inital back off.
            int sleepInterval = 100;

            // No:of attempts, for tracing purposes, if we underwent retries.
            int numberOfAttempts = 0;

            // Object that will be returned to the caller, containing all required data about the token.
            SqlFedAuthToken fedAuthToken = new SqlFedAuthToken();

            // Username to use in error messages.
            string username = null;

            while (true) {
                numberOfAttempts++;
                try {
                    if (ConnectionOptions.Authentication == SqlAuthenticationMethod.ActiveDirectoryIntegrated) {
                        username = TdsEnums.NTAUTHORITYANONYMOUSLOGON;
                        fedAuthToken.accessToken = ADALNativeWrapper.ADALGetAccessTokenForWindowsIntegrated(fedAuthInfo.stsurl,
                                                                                                                fedAuthInfo.spn,
                                                                                                                _clientConnectionId, ActiveDirectoryAuthentication.AdoClientId,
                                                                                                                ref fedAuthToken.expirationFileTime);
                    }
                    else if (_credential != null) {
                        username = _credential.UserId;
                        fedAuthToken.accessToken = ADALNativeWrapper.ADALGetAccessToken(_credential.UserId,
                                                                                            _credential.Password,
                                                                                            fedAuthInfo.stsurl,
                                                                                            fedAuthInfo.spn,
                                                                                            _clientConnectionId,
                                                                                            ActiveDirectoryAuthentication.AdoClientId,
                                                                                            ref fedAuthToken.expirationFileTime);
                    }
                    else {
                        username = ConnectionOptions.UserID;
                        fedAuthToken.accessToken = ADALNativeWrapper.ADALGetAccessToken(ConnectionOptions.UserID,
                                                                                            ConnectionOptions.Password,
                                                                                            fedAuthInfo.stsurl,
                                                                                            fedAuthInfo.spn,
                                                                                            _clientConnectionId,
                                                                                            ActiveDirectoryAuthentication.AdoClientId,
                                                                                            ref fedAuthToken.expirationFileTime);
                    }

                    Debug.Assert(fedAuthToken.accessToken != null, "AccessToken should not be null.");
#if DEBUG
                    if (_forceAdalRetry) {
                        // 3399614468 is 0xCAA20004L just for testing.
                        throw new AdalException("Force retry in GetFedAuthToken", ActiveDirectoryAuthentication.GetAccessTokenTansisentError, 3399614468, 6);
                    }
#endif
                    // Break out of the retry loop in successful case.
                    break;
                }
                catch (AdalException adalException) {

                    uint errorCategory = adalException.GetCategory();

                    if (ActiveDirectoryAuthentication.GetAccessTokenTansisentError != errorCategory
                        || _timeout.IsExpired
                        || _timeout.MillisecondsRemaining <= sleepInterval) {

                        string errorStatus = adalException.GetStatus().ToString("X");

                        Bid.Trace("<sc.SqlInternalConnectionTds.GetFedAuthToken.ADALException category:> %d#  <error:> %s#\n", (int)errorCategory, errorStatus);

                        // Error[0]
                        SqlErrorCollection sqlErs = new SqlErrorCollection();
                        sqlErs.Add(new SqlError(0, (byte)0x00, (byte)TdsEnums.MIN_ERROR_CLASS, ConnectionOptions.DataSource, Res.GetString(Res.SQL_ADALFailure, username, ConnectionOptions.Authentication.ToString("G")), ActiveDirectoryAuthentication.AdalGetAccessTokenFunctionName, 0));

                        // Error[1]
                        string errorMessage1 = Res.GetString(Res.SQL_ADALInnerException, errorStatus, adalException.GetState());
                        sqlErs.Add(new SqlError(0, (byte)0x00, (byte)TdsEnums.MIN_ERROR_CLASS, ConnectionOptions.DataSource, errorMessage1, ActiveDirectoryAuthentication.AdalGetAccessTokenFunctionName, 0));

                        // Error[2]
                        if (!string.IsNullOrEmpty(adalException.Message)) {
                            sqlErs.Add(new SqlError(0, (byte)0x00, (byte)TdsEnums.MIN_ERROR_CLASS, ConnectionOptions.DataSource, adalException.Message, ActiveDirectoryAuthentication.AdalGetAccessTokenFunctionName, 0));
                        }
                        SqlException exc = SqlException.CreateException(sqlErs, "", this);
                        throw exc;
                    }

                    Bid.Trace("<sc.SqlInternalConnectionTds.GetFedAuthToken|ADV> %d#, sleeping %d{Milliseconds}\n", ObjectID, sleepInterval);
                    Bid.Trace("<sc.SqlInternalConnectionTds.GetFedAuthToken|ADV> %d#, remaining %d{Milliseconds}\n", ObjectID, _timeout.MillisecondsRemaining);

                    Thread.Sleep(sleepInterval);
                    sleepInterval *= 2;
                }
            }

            Debug.Assert(fedAuthToken != null, "fedAuthToken should not be null.");
            Debug.Assert(fedAuthToken.accessToken != null && fedAuthToken.accessToken.Length > 0, "fedAuthToken.accessToken should not be null or empty.");

            // Store the newly generated token in _newDbConnectionPoolAuthenticationContext, only if using pooling.
            if (_dbConnectionPool != null) {
                DateTime expirationTime = DateTime.FromFileTimeUtc(fedAuthToken.expirationFileTime);
                _newDbConnectionPoolAuthenticationContext = new DbConnectionPoolAuthenticationContext(fedAuthToken.accessToken, expirationTime);
            }

            Bid.Trace("<sc.SqlInternalConnectionTds.GetFedAuthToken> %d#, Finished generating federated authentication token.\n", ObjectID);

            return fedAuthToken;
        }
Ejemplo n.º 23
0
 private void AddErrorsToCollection(SqlErrorCollection inCollection, ref SqlErrorCollection collectionToAddTo, ref bool broken)
 {
     if (inCollection != null)
     {
         foreach (SqlError error in inCollection)
         {
             collectionToAddTo.Add(error);
             broken |= (error.Class >= TdsEnums.FATAL_ERROR_CLASS);
         }
     }
 }
 internal static Exception ROR_UnexpectedRoutingInfo()
 {
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     errorCollection.Add(new SqlError(0, 0, 20, null, Res.GetString("SQLROR_UnexpectedRoutingInfo"), "", 0));
     SqlException exception = SqlException.CreateException(errorCollection, null);
     exception._doNotReconnect = true;
     return exception;
 }
 internal static Exception ROR_RecursiveRoutingNotSupported()
 {
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     errorCollection.Add(new SqlError(0, 0, 20, null, Res.GetString("SQLROR_RecursiveRoutingNotSupported"), "", 0));
     SqlException exception = SqlException.CreateException(errorCollection, null);
     exception._doNotReconnect = true;
     return exception;
 }
 internal static Exception CannotCompleteDelegatedTransactionWithOpenResults()
 {
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     errorCollection.Add(new SqlError(-2, 0, 11, null, Res.GetString("ADP_OpenReaderExists"), "", 0));
     return SqlException.CreateException(errorCollection, null);
 }
 internal SqlException GetErrors(int commandIndex)
 {
     SqlException exception = null;
     int num3 = this._SqlRPCBatchArray[commandIndex].errorsIndexEnd - this._SqlRPCBatchArray[commandIndex].errorsIndexStart;
     if (0 >= num3)
     {
         return exception;
     }
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     for (int i = this._SqlRPCBatchArray[commandIndex].errorsIndexStart; i < this._SqlRPCBatchArray[commandIndex].errorsIndexEnd; i++)
     {
         errorCollection.Add(this._SqlRPCBatchArray[commandIndex].errors[i]);
     }
     for (int j = this._SqlRPCBatchArray[commandIndex].warningsIndexStart; j < this._SqlRPCBatchArray[commandIndex].warningsIndexEnd; j++)
     {
         errorCollection.Add(this._SqlRPCBatchArray[commandIndex].warnings[j]);
     }
     return SqlException.CreateException(errorCollection, this.Connection.ServerVersion);
 }
 private void FireInfoMessageEvent(SqlConnection connection, TdsParserStateObject stateObj, SqlError error)
 {
     string serverVersion = null;
     if (this._state == TdsParserState.OpenLoggedIn)
     {
         serverVersion = this._connHandler.ServerVersion;
     }
     SqlErrorCollection errorCollection = new SqlErrorCollection();
     errorCollection.Add(error);
     SqlException exception = SqlException.CreateException(errorCollection, serverVersion);
     connection.OnInfoMessage(new SqlInfoMessageEventArgs(exception));
 }
        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;
        }
Ejemplo n.º 30
0
        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;
        }
 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;
 }