public EntityUpdateException(Exception ex) : base(ex.Message) { Type type = ex.GetType(); ValidationCodeResult = new EntityUpdateErrorResult(); var entityUpdateErrorResult = (EntityUpdateErrorResult)ValidationCodeResult; if (type == typeof(PostgresException)) { PostgresException dbEx = ex as PostgresException; entityUpdateErrorResult.Data = dbEx.Data; entityUpdateErrorResult.Code = dbEx.Code; entityUpdateErrorResult.ColumnName = dbEx.ColumnName; entityUpdateErrorResult.ConstraintName = dbEx.ConstraintName; entityUpdateErrorResult.DataTypeName = dbEx.DataTypeName; entityUpdateErrorResult.Detail = dbEx.Detail; entityUpdateErrorResult.File = dbEx.File; entityUpdateErrorResult.InternalQuery = dbEx.InternalQuery; this.Message = dbEx.Message; this.MessageText = dbEx.MessageText; entityUpdateErrorResult.Position = dbEx.Position; entityUpdateErrorResult.Routine = dbEx.Routine; entityUpdateErrorResult.SchemaName = dbEx.SchemaName; entityUpdateErrorResult.Severity = dbEx.Severity; entityUpdateErrorResult.SqlState = dbEx.SqlState; entityUpdateErrorResult.TableName = dbEx.TableName; entityUpdateErrorResult.Where = dbEx.Where; } }
public static bool IsUniqueConstraintViolationException(this PostgresException e, string constraintName) { const string constraintViolationErrorCode = "23505"; return(string.Equals(e.SqlState, constraintViolationErrorCode, StringComparison.InvariantCultureIgnoreCase) && string.Equals(e.ConstraintName, constraintName, StringComparison.InvariantCultureIgnoreCase)); }
public void DetailsAreRemoved() { using (var conn = OpenConnection(ConnectionString + ";SuppressDetailedExceptions=true")) { // Make sure messages are in English conn.ExecuteNonQuery(@"SET lc_messages='en_US.UTF-8'"); conn.ExecuteNonQuery(@" CREATE OR REPLACE FUNCTION pg_temp.emit_exception() RETURNS VOID AS 'BEGIN RAISE EXCEPTION ''testexception'' USING DETAIL = ''testdetail''; END;' LANGUAGE 'plpgsql'; "); PostgresException ex = null !; try { conn.ExecuteNonQuery("SELECT pg_temp.emit_exception()"); Assert.Fail("No exception was thrown"); } catch (PostgresException e) { ex = e; } Assert.That(ex.Detail, Is.EqualTo("Detail suppressed as SuppressDetailInPostgressError is enabled")); var data = ex.Data; Assert.That(data[nameof(PostgresException.Detail)], Is.EqualTo("Detail suppressed as SuppressDetailInPostgressError is enabled")); var exString = ex.ToString(); Assert.That(exString, Does.Not.Contain("testdetail")); } }
private void ParsePostgresException(Exception ex) { PostgresException pEx1 = ex as PostgresException; if (pEx1 != null) { m_sSqlState = pEx1.Code; m_sErrorInfo = pEx1.Message.ToLower(); m_sDBMSErrorInfo = pEx1.Message.ToLower(); byte[] buf = BitConverter.GetBytes(pEx1.HResult); byte[] errCode = new byte[2]; Array.Copy(buf, 0, errCode, 0, 2); m_iErrorCode = BitConverter.ToInt16(errCode, 0); } NpgsqlException pEx = ex as NpgsqlException; if (pEx != null) { m_sErrorInfo = pEx.Message.ToLower(); m_sDBMSErrorInfo = pEx.Message.ToLower(); byte[] buf = BitConverter.GetBytes(pEx.HResult); byte[] errCode = new byte[2]; Array.Copy(buf, 0, errCode, 0, 2); m_iErrorCode = BitConverter.ToInt16(errCode, 0); } }
private static SqlStorageException ToSqlStorageException(PostgresException postgresException) { return(PostgresExceptionRecognizer.TryRecognizeException(postgresException, out var sqlStorageRecognizedException) && sqlStorageRecognizedException != null ? sqlStorageRecognizedException : new UnknownSqlStorageException(postgresException)); }
public ICollection <CustomerDto> GetCustomers() { try { var customer = _dbContext.Customer; if (customer != null) { ICollection <CustomerDto> customerDto = new List <CustomerDto>(); foreach (var item in customer) { customerDto.Add(Mappers.CustomerRepository.MapToDto(item)); } return(customerDto); } } catch (Exception ex) { if (ex.InnerException.GetType().ToString() == "Npgsql.PostgresException") { PostgresException postgresException = (PostgresException)ex.InnerException; throw new NSIException("Db error: " + postgresException.Detail, Level.Error, ErrorType.DBError); } else { throw ex.InnerException; } } return(null); }
public bool DeleteCustomerById(int customerId) { try { var customer = _dbContext.Customer.FirstOrDefault(x => x.CustomerId == customerId); if (customer != null) { customer.IsDeleted = true; _dbContext.SaveChanges(); return(true); } return(false); } catch (Exception ex) { if (ex.InnerException.GetType().ToString() == "Npgsql.PostgresException") { PostgresException postgresException = (PostgresException)ex.InnerException; throw new NSIException("Db error: " + postgresException.Detail, Level.Error, ErrorType.DBError); } else { throw ex.InnerException; } } }
public bool EditCustomer(int id, CustomerDto customerDto) { try { var customer = _dbContext.Customer.FirstOrDefault(x => x.CustomerId == customerDto.CustomerId); if (customer != null) { customer.CustomerName = customerDto.CustomerName ?? customer.CustomerName; customer.IsActive = customerDto.IsActive ?? customer.IsActive; customer.IsDeleted = customerDto.IsDeleted ?? customer.IsDeleted; customer.DateModified = customerDto.DateModified ?? DateTime.Now; customer.PricingPackageId = customerDto.PricingPackageId ?? customer.PricingPackageId; customer.AddressId = customerDto.AddressId ?? customer.AddressId; _dbContext.SaveChanges(); return(true); } return(false); } catch (Exception ex) { if (ex.InnerException.GetType().ToString() == "Npgsql.PostgresException") { PostgresException postgresException = (PostgresException)ex.InnerException; throw new NSIException("Db error: " + postgresException.Detail, Level.Error, ErrorType.DBError); } else { throw ex.InnerException; } } }
private ContentResult GetExceptionContent(PostgresException e) { logger.LogError(e, LoggingService.FormatPostgresExceptionMessage(e, stringData)); // state 42501 insufficient_privilege, see: https://www.postgresql.org/docs/11/errcodes-appendix.html return(e.SqlState == "42501" ? UnauthorizedContent() : BadRequestContent(e)); }
private static bool IsTransientError(PostgresException pgex) { switch (pgex.SqlState) { case "40001": // serialzation_failure case "53000": // insufficient_resources case "53100": // disk_full case "53200": // out_of_memory case "53300": // too_many_connections case "53400": // configuration_limit_exceeded case "57P03": // cannot_connect_now case "58000": // system_error case "58030": // io_error case "55P03": // lock_not_available case "55006": // object_in_use case "55000": // object_not_in_prerequisite_state case "08000": // connection_exception case "08003": // connection_does_not_exist case "08006": // connection_failure case "08001": // sqlclient_unable_to_establish_sqlconnection case "08004": // sqlserver_rejected_establishment_of_sqlconnection case "08007": // transaction_resolution_unknown return(true); default: return(false); } }
public void Serialization() { var actual = new PostgresException("message text", "high", "high2", "53300", "detail", "hint", 18, 42, "internal query", "where", "schema", "table", "column", "data type", "constraint", "file", "line", "routine"); var formatter = new BinaryFormatter(); var stream = new MemoryStream(); formatter.Serialize(stream, actual); stream.Seek(0, SeekOrigin.Begin); var expected = (PostgresException)formatter.Deserialize(stream); Assert.That(expected.Severity, Is.EqualTo(actual.Severity)); Assert.That(expected.InvariantSeverity, Is.EqualTo(actual.InvariantSeverity)); Assert.That(expected.SqlState, Is.EqualTo(actual.SqlState)); Assert.That(expected.MessageText, Is.EqualTo(actual.MessageText)); Assert.That(expected.Detail, Is.EqualTo(actual.Detail)); Assert.That(expected.Hint, Is.EqualTo(actual.Hint)); Assert.That(expected.Position, Is.EqualTo(actual.Position)); Assert.That(expected.InternalPosition, Is.EqualTo(actual.InternalPosition)); Assert.That(expected.InternalQuery, Is.EqualTo(actual.InternalQuery)); Assert.That(expected.Where, Is.EqualTo(actual.Where)); Assert.That(expected.SchemaName, Is.EqualTo(actual.SchemaName)); Assert.That(expected.TableName, Is.EqualTo(actual.TableName)); Assert.That(expected.ColumnName, Is.EqualTo(actual.ColumnName)); Assert.That(expected.DataTypeName, Is.EqualTo(actual.DataTypeName)); Assert.That(expected.ConstraintName, Is.EqualTo(actual.ConstraintName)); Assert.That(expected.File, Is.EqualTo(actual.File)); Assert.That(expected.Line, Is.EqualTo(actual.Line)); Assert.That(expected.Routine, Is.EqualTo(actual.Routine)); }
public void SetError(PostgresException exception) { ErrorCode = exception.SqlState; ErrorMessage = exception.MessageText; return; }
protected override void ThrowSqlException(Type tableType, Exception ex) { if (!(ex is NpgsqlException)) { throw ex; } PostgresException nerror = ex as PostgresException; if (nerror.SqlState != "23505" || nerror.Detail.Contains(" already exists") == false) { throw ex; } StringBuilder output = new StringBuilder(); string[] captions = null; string[] keys = null; try { string msg = nerror.Detail; try { var match = Regex.Match(msg, @"Key \((?<c>(\w| |,)+)\)"); if (match != null && match.Length > 0) { string indexname = match.Groups["c"].Value; keys = indexname.Split(','); keys = (from m in keys select m.Trim()).ToArray(); captions = new string[keys.Length]; for (int i = 0; i < keys.Length; i++) { var pinfo = tableType.GetTypeInfo().GetProperty(keys[i]); WayDBColumnAttribute columnAtt = pinfo.GetCustomAttribute(typeof(WayDBColumnAttribute)) as WayDBColumnAttribute; captions[i] = columnAtt.Caption; if (output.Length > 0) { output.Append(','); } output.Append(columnAtt.Caption.IsNullOrEmpty() ? keys[i] : columnAtt.Caption); } } } catch (Exception ee) { throw ex; } } catch { throw ex; } throw new RepeatValueException(keys, captions, "此" + output + "已存在"); }
public PostgresExceptionInfo(PostgresException exception, Regex detailExpression) : this() { if (!string.IsNullOrEmpty(exception.TableName)) { TableName = exception.TableName; } if (!string.IsNullOrEmpty(exception.Detail)) { var match = detailExpression.Match(exception.Detail); if (match.Success) { string columns = match.Groups["KeyColumns"].Value; string values = match.Groups["KeyValues"].Value; string constraintType = match.Groups["ConstraintType"].Value; if (!string.IsNullOrEmpty(columns)) { ColumnNames = columns.Replace("\"", ""); } if (!string.IsNullOrEmpty(values)) { Values = values; } if (!string.IsNullOrEmpty(constraintType)) { ConstraintType = GetConstrainType(constraintType); } } } }
private string FormatMessage(PostgresException pex, DBTable table, DBItem dbItem) { var text = string.IsNullOrEmpty(pex.Detail) ? pex.MessageText : pex.Detail; var refTable = string.IsNullOrEmpty(pex.TableName) ? null : DBService.Schems.ParseTable(pex.TableName); var builder = new StringBuilder(); text = text.Replace("character varying", "Text"); foreach (var item in text.Split(new char[] { ',', ' ', '"', '(', ')' }, StringSplitOptions.RemoveEmptyEntries)) { if (table != null) { var column = refTable?.ParseColumnProperty(item) ?? table?.ParseColumnProperty(item); if (column != null) { builder.Append(column.DisplayName); builder.Append(' '); continue; } } builder.Append(item); builder.Append(' '); } return(builder.ToString()); }
void IVocabularyWindow.DefineLexicalData(dictionary_type lexicalType) { Word[] selected = SelectedWords().OrderBy(x => x.Id).ToArray(); if (selected.Length > 1) { using (ISession session = DataHelper.OpenSession()) { using (ITransaction transaction = session.BeginTransaction()) { Dictionary d = null; try { for (int i = 0; i < selected.Length; i++) { for (int j = i + 1; j < selected.Length; j++) { d = new Dictionary(); d.Left = selected[i]; d.Right = selected[j]; d.DictionaryType = lexicalType; session.SaveOrUpdate(d); } } transaction.Commit(); } catch (ADOException e) { transaction.Rollback(); Trace.TraceError(ErrorHelper.Message(e)); PostgresException ne = e.InnerException as PostgresException; if (ne != null && ne.SqlState == "23505") { string format = string.Empty; switch (lexicalType) { case dictionary_type.synonym: format = Strings.SynonymsAlreadyExist; break; case dictionary_type.antonym: format = Strings.AntnymsAlreadyExist; break; default: break; } KryptonMessageBox.Show(this, string.Format(format, d.Left, d.Right), Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Error); } else { ErrorHelper.ShowDbError(this, e); } } } } } }
public InterneuronDBException(PostgresException npgEx, short errorCode = 500, string errorMessage = "", string errorType = "System Error", string errorId = null) : base($"Http.{errorCode} {errorType} {errorMessage}", npgEx) { this.ErrorId = errorId ?? Guid.NewGuid().ToString(); this.ErrorCode = errorCode; this.ErrorMessage = errorMessage; this.ErrorType = errorType; this.ErrorResponseMessage = $"Error fetching data from database. Please check the error log with ID: {this.ErrorId} for more details"; }
/// <summary> /// Metod som utifrån ett postgresexception sedan kan skicka ut en sträng med relevant meddelande /// </summary> /// <param name="ex"></param> /// <returns>Sträng med felmeddelande</returns> public static string ErrorMessage(PostgresException ex) { string errorMessage = ""; //ex.ConstraintName //Returnera den sträng du skapat med information return(errorMessage); }
// See Issue #985(EFCore) private bool RetryOnExistsFailure(PostgresException exception) { if (exception.SqlState == "3D000") { ClearPool(); return(true); } return(false); }
public static bool IsPrimaryKeyViolationException(this PostgresException e) { const string constraintViolationErrorCode = "23505"; const string primaryKeyNamePrefix = "pk_"; const string primaryKeyNameSuffix = "_pkey"; return(string.Equals(e.SqlState, constraintViolationErrorCode, StringComparison.InvariantCultureIgnoreCase) && (e.ConstraintName.StartsWith(primaryKeyNamePrefix, StringComparison.InvariantCultureIgnoreCase) || e.ConstraintName.EndsWith(primaryKeyNameSuffix, StringComparison.InvariantCultureIgnoreCase))); }
public static void SendPgError(this WorkspaceConnection ws, PostgresException e) { var message = new Message(e); if (ws.ErrorOffset.HasValue && message.Position != 0) { message.Position -= ws.ErrorOffset.Value; } ws.Proxy.SendAsync($"error-{ws.Id}", message).GetAwaiter().GetResult(); }
private SqlExceptionType ProcessServerSideException(PostgresException serverSideException) { // There is no guaranteed way to detect a operation timeout. // We simply check that error message says something about CommandTimeout connection parameter. if (serverSideException.Message.ToUpperInvariant().Contains("COMMANDTIMEOUT")) { return(SqlExceptionType.OperationTimeout); } if (serverSideException.SqlState.Length != 5) { return(SqlExceptionType.Unknown); } var errorCode = serverSideException.SqlState.ToUpperInvariant(); var errorCodeClass = errorCode.Substring(0, 2); // Error codes have been taken from // http://www.postgresql.org/docs/8.4/static/errcodes-appendix.html switch (errorCodeClass) { case "08": // connection_exception return(SqlExceptionType.ConnectionError); case "42": // syntax_error_or_access_rule_violation if (errorCode == "42501") { return(SqlExceptionType.Unknown); } return(SqlExceptionType.SyntaxError); } switch (errorCode) { case "23502": // not_null_violation case "23514": // check_violation return(SqlExceptionType.CheckConstraintViolation); case "23001": // restrict_violation case "23503": // foreign_key_violation return(SqlExceptionType.ReferentialConstraintViolation); case "23505": // unique_violation return(SqlExceptionType.UniqueConstraintViolation); case "40P01": // deadlock_detected return(SqlExceptionType.Deadlock); case "40001": // serialization_failure return(SqlExceptionType.SerializationFailure); } return(SqlExceptionType.Unknown); }
public bool IsUniqueViolation() { PostgresException exception = this.PostgresException; if (exception == null) { return(false); } return(exception.SqlState == PostgresErrorCodes.UniqueViolation); }
private static AsyncInjectOutcomePolicy CreateRetryChaosAsync(IPolicies policies) { var fault = new PostgresException(string.Empty, string.Empty, string.Empty, ChaosPolicyShared.GetRandomString(RetryablePostGreErrors.Errors.ToList())); return(MonkeyPolicy.InjectExceptionAsync(with => with.Fault(fault) .InjectionRate((context, token) => ChaosPolicyShared.InjectionRateAsync(context, RetryConstants.RetryCount, RetryAttempts)) .Enabled(policies.EnableChaos) )); }
private void ProcessException(PostgresException ex) { var constraintName = ex.ConstraintName ?? string.Empty; if (_exceptionsOnConstraints != null && _exceptionsOnConstraints.ContainsKey(constraintName)) { var exception = _exceptionsOnConstraints[constraintName]; throw exception; } throw ex; }
private static string GetExceptionMessage(PostgresException exception) { if (exception.SqlState == "23503") { var isDelete = exception.MessageText.Contains("delete"); return(isDelete ? "message.SQL23503D" : "message.SQL23503A"); } else { return($"message.SQL{exception.SqlState}"); } }
private static string FormatPostgresExceptionMessage(PostgresException e) { var sb = new StringBuilder(); sb.Append($"{NL}PostgreSQL error:{NL}"); foreach (var entry in e.Data.Cast <DictionaryEntry>().Where(entry => entry.Value != null)) { sb.Append($"{NL}{entry.Key}: {entry.Value}"); } sb.Append($"{NL}{NL}"); return(sb.ToString()); }
private string GetReadableErrorMessage(PostgresException innerException) { switch (innerException.SqlState) { case DbErrorCodes.UNIQUE_VIOLATION: return("Unique violation error"); case DbErrorCodes.FOREIGN_KEY_VIOLATION: return("Foreign key violation error"); default: return(null); } }
private static string FormatPostgresExceptionMessage(PostgresException e) => $"{e.Severity}\n" + $"Message: {e.Message}\n" + $"Detail: {e.Detail}\n" + $"Line: {e.Line}\n" + $"InternalPosition: {e.InternalPosition}\n" + $"Position: {e.Position}\n" + $"SqlState: {e.SqlState}\n" + $"Statement: {e.Statement}\n" + $"ColumnName: {e.ColumnName}\n" + $"ConstraintName: {e.ConstraintName}\n" + $"TableName: {e.TableName}\n" + $"InternalQuery: {e.InternalQuery}\n" + $"Where: {e.Where}\n" + $"Hint: {e.Hint}\n\n";
private ContentResult BadRequestContent(PostgresException e) => new ContentResult { StatusCode = 400, Content = JsonConvert.SerializeObject(new { messeage = e.MessageText, details = e.Detail, table = e.TableName, column = e.ColumnName, constraint = e.ConstraintName, error = true }), ContentType = contentType };