Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity/System/Data/EntitySqlException.cs

@@ -0,0 +1,303 @@
+//---------------------------------------------------------------------
+// <copyright file="EntitySqlException.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner  [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+
+namespace System.Data
+{
+    using System;
+    using System.Data.Common.EntitySql;
+    using System.Data.Entity;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Runtime.Serialization;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Text;
+
+    /// <summary>
+    /// Represents an eSQL Query compilation exception;
+    /// The class of exceptional conditions that may cause this exception to be raised are mainly:
+    /// 1) Syntax Errors: raised during query text parsing and when a given query does not conform to eSQL formal grammar;
+    /// 2) Semantic Errors: raised when semantic rules of eSQL language are not met such as metadata or schema information
+    ///    not accurate or not present, type validation errors, scoping rule violations, user of undefined variables, etc.
+    /// For more information, see eSQL Language Spec.
+    /// </summary>
+    [Serializable]
+    public sealed class EntitySqlException : EntityException
+    {
+        #region Private Fields
+        /// <summary>
+        /// error message description. 
+        /// </summary>
+        private string _errorDescription;
+
+        /// <summary>
+        /// information about the context where the error occurred 
+        /// </summary>
+        private string _errorContext;
+
+        /// <summary>
+        /// error line number
+        /// </summary>
+        private int _line;
+
+        /// <summary>
+        /// error column number
+        /// </summary>
+        private int _column;
+        #endregion
+
+        #region Public Constructors
+        /// <summary>
+        /// Initializes a new instance of <see cref="EntitySqlException"/> with the generic error message.
+        /// </summary>
+        public EntitySqlException()
+            : this(System.Data.Entity.Strings.GeneralQueryError)
+        {
+            HResult = HResults.InvalidQuery;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="EntitySqlException"/> with the given message.
+        /// </summary>
+        public EntitySqlException(string message)
+            : base(message)
+        {
+            HResult = HResults.InvalidQuery;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="EntitySqlException"/> with the given message and innerException instance.
+        /// </summary>
+        public EntitySqlException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+            HResult = HResults.InvalidQuery;
+        }
+
+        /// <summary>
+        /// Initializes a new instance <see cref="EntitySqlException"/> with the given serializationInfo and streamingContext.
+        /// </summary>
+        /// <param name="serializationInfo"></param>
+        /// <param name="streamingContext"></param>
+        private EntitySqlException(SerializationInfo serializationInfo, StreamingContext streamingContext)
+            : base(serializationInfo, streamingContext)
+        {
+            HResult = HResults.InvalidQuery;
+            _errorDescription = serializationInfo.GetString("ErrorDescription");
+            _errorContext = serializationInfo.GetString("ErrorContext");
+            _line = serializationInfo.GetInt32("Line");
+            _column = serializationInfo.GetInt32("Column");
+        }
+        #endregion
+
+        #region Internal Constructors
+        /// <summary>
+        /// Initializes a new instance EntityException with an ErrorContext instance and a given error message.
+        /// </summary>
+        internal static EntitySqlException Create(ErrorContext errCtx, string errorMessage, Exception innerException)
+        {
+            return EntitySqlException.Create(errCtx.CommandText, errorMessage, errCtx.InputPosition, errCtx.ErrorContextInfo, errCtx.UseContextInfoAsResourceIdentifier, innerException);
+        }
+
+        /// <summary>
+        /// Initializes a new instance EntityException with contextual information to allow detailed error feedback.
+        /// </summary>
+        internal static EntitySqlException Create(string commandText,
+                                                  string errorDescription,
+                                                  int errorPosition,
+                                                  string errorContextInfo,
+                                                  bool loadErrorContextInfoFromResource,
+                                                  Exception innerException)
+        {
+            int line;
+            int column;
+            string errorContext = FormatErrorContext(commandText, errorPosition, errorContextInfo, loadErrorContextInfoFromResource, out line, out column);
+
+            string errorMessage = FormatQueryError(errorDescription, errorContext);
+
+            return new EntitySqlException(errorMessage, errorDescription, errorContext, line, column, innerException);
+        }
+
+        /// <summary>
+        /// core constructor
+        /// </summary>
+        private EntitySqlException(string message, string errorDescription, string errorContext, int line, int column, Exception innerException)
+            : base(message, innerException)
+        {
+            _errorDescription = errorDescription;
+            _errorContext = errorContext;
+            _line = line;
+            _column = column;
+
+            HResult = HResults.InvalidQuery;
+        }
+
+        #endregion
+
+        #region Public Properties
+        /// <summary>
+        /// Gets the error description explaining the reason why the query was not accepted or an empty String.Empty
+        /// </summary>
+        public string ErrorDescription
+        {
+            get
+            {
+                return _errorDescription ?? String.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Gets the aproximate context where the error occurred if available.
+        /// </summary>
+        public string ErrorContext
+        {
+            get
+            {
+                return _errorContext ?? String.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Returns the the aproximate line number where the error occurred
+        /// </summary>
+        public int Line
+        {
+            get { return _line; }
+        }
+
+        /// <summary>
+        /// Returns the the aproximate column number where the error occurred
+        /// </summary>
+        public int Column
+        {
+            get { return _column; }
+        }
+        #endregion
+
+        #region Helpers
+        internal static string GetGenericErrorMessage(string commandText, int position)
+        {
+            int lineNumber = 0;
+            int colNumber = 0;
+            return FormatErrorContext(commandText, position, EntityRes.GenericSyntaxError, true, out lineNumber, out colNumber);
+        }
+
+        /// <summary>
+        /// Returns error context in the format [[errorContextInfo, ]line ddd, column ddd].
+        /// Returns empty string if errorPosition is less than 0 and errorContextInfo is not specified.
+        /// </summary>
+        internal static string FormatErrorContext(
+            string commandText,
+            int errorPosition,
+            string errorContextInfo,
+            bool loadErrorContextInfoFromResource,
+            out int lineNumber,
+            out int columnNumber)
+        {
+            Debug.Assert(errorPosition > -1, "position in input stream cannot be < 0");
+            Debug.Assert(errorPosition <= commandText.Length, "position in input stream cannot be greater than query text size");
+
+            if (loadErrorContextInfoFromResource)
+            {
+                errorContextInfo = !String.IsNullOrEmpty(errorContextInfo) ? EntityRes.GetString(errorContextInfo) : String.Empty;
+            }
+
+            //
+            // Replace control chars and newLines for single representation characters
+            //
+            StringBuilder sb = new StringBuilder(commandText.Length);
+            for (int i = 0; i < commandText.Length; i++)
+            {
+                Char c = commandText[i];
+                if (CqlLexer.IsNewLine(c))
+                {
+                    c = '\n';
+                }
+                else if ((Char.IsControl(c) || Char.IsWhiteSpace(c)) && ('\r' != c))
+                {
+                    c = ' ';
+                }
+                sb.Append(c);
+            }
+            commandText = sb.ToString().TrimEnd(new char[] { '\n' });
+
+            //
+            // Compute line and column
+            //
+            string[] queryLines = commandText.Split(new char[] { '\n' }, StringSplitOptions.None);
+            for (lineNumber = 0, columnNumber = errorPosition;
+                 lineNumber < queryLines.Length && columnNumber > queryLines[lineNumber].Length;
+                 columnNumber -= (queryLines[lineNumber].Length + 1), ++lineNumber) ;
+
+            ++lineNumber; // switch lineNum and colNum to 1-based indexes
+            ++columnNumber;
+
+            //
+            // Error context format: "[errorContextInfo,] line ddd, column ddd"
+            //
+            sb = new Text.StringBuilder();
+            if (!String.IsNullOrEmpty(errorContextInfo))
+            {
+                sb.AppendFormat(CultureInfo.CurrentCulture, "{0}, ", errorContextInfo);
+            }
+
+            if (errorPosition >= 0)
+            {
+                sb.AppendFormat(CultureInfo.CurrentCulture,
+                                "{0} {1}, {2} {3}",
+                                System.Data.Entity.Strings.LocalizedLine,
+                                lineNumber,
+                                System.Data.Entity.Strings.LocalizedColumn,
+                                columnNumber);
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Returns error message in the format: "error such and such[, near errorContext]."
+        /// </summary>
+        private static string FormatQueryError(string errorMessage, string errorContext)
+        {
+            //
+            // Message format: error such and such[, near errorContextInfo].
+            //
+            StringBuilder sb = new StringBuilder();
+            sb.Append(errorMessage);
+            if (!String.IsNullOrEmpty(errorContext))
+            {
+                sb.AppendFormat(CultureInfo.CurrentCulture, " {0} {1}", System.Data.Entity.Strings.LocalizedNear, errorContext);
+            }
+
+            return sb.Append(".").ToString();
+        }
+        #endregion
+
+        #region ISerializable implementation
+        /// <summary>
+        /// sets the System.Runtime.Serialization.SerializationInfo
+        /// with information about the exception.
+        /// </summary>
+        /// <param name="info">The System.Runtime.Serialization.SerializationInfo that holds the serialized
+        /// object data about the exception being thrown.
+        /// </param>
+        /// <param name="context"></param>
+        [SecurityCritical]
+        [PermissionSet(SecurityAction.LinkDemand, Unrestricted = true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("ErrorDescription", _errorDescription);
+            info.AddValue("ErrorContext", _errorContext);
+            info.AddValue("Line", _line);
+            info.AddValue("Column", _column);
+        }
+        #endregion
+    }
+}