Merge pull request #13440 from grafana/reminder_refactoring

Transaction issues for alert reminder

Gopkg.lock

@@ -19,6 +19,12 @@
   packages = ["."]
   revision = "7677a1d7c1137cd3dd5ba7a076d0c898a1ef4520"
 
+[[projects]]
+  branch = "master"
+  name = "github.com/VividCortex/mysqlerr"
+  packages = ["."]
+  revision = "6c6b55f8796f578c870b7e19bafb16103bc40095"
+
 [[projects]]
   name = "github.com/aws/aws-sdk-go"
   packages = [
@@ -673,6 +679,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "81a37e747b875cf870c1b9486fa3147e704dea7db8ba86f7cb942d3ddc01d3e3"
+  inputs-digest = "6e9458f912a5f0eb3430b968f1b4dbc4e3b7671b282cf4fe1573419a6d9ba0d4"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -203,3 +203,7 @@ ignored = [
 [[constraint]]
   name = "github.com/denisenkom/go-mssqldb"
   revision = "270bc3860bb94dd3a3ffd047377d746c5e276726"
+
+[[constraint]]
+  name = "github.com/VividCortex/mysqlerr"
+  branch = "master"

devenv/docker/ha_test/docker-compose.yaml

@@ -8,18 +8,33 @@ services:
     volumes:
       - /var/run/docker.sock:/tmp/docker.sock:ro
 
-  mysql:
+  db:
     image: mysql
     environment:
       MYSQL_ROOT_PASSWORD: rootpass
       MYSQL_DATABASE: grafana
       MYSQL_USER: grafana
       MYSQL_PASSWORD: password
+    ports:
+      - 3306
     healthcheck:
       test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost"]
       timeout: 10s
       retries: 10
 
+  # db:
+  #   image: postgres:9.3
+  #   environment:
+  #     POSTGRES_DATABASE: grafana
+  #     POSTGRES_USER: grafana
+  #     POSTGRES_PASSWORD: password
+  #   ports:
+  #     - 5432
+  #   healthcheck:
+  #     test: ["CMD-SHELL", "pg_isready -d grafana -U grafana"]
+  #     timeout: 10s
+  #     retries: 10
+
   grafana:
     image: grafana/grafana:dev
     volumes:
@@ -27,17 +42,23 @@ services:
     environment:
       - VIRTUAL_HOST=grafana.loc
       - GF_SERVER_ROOT_URL=http://grafana.loc
-      - GF_DATABASE_TYPE=mysql
-      - GF_DATABASE_HOST=mysql:3306
       - GF_DATABASE_NAME=grafana
       - GF_DATABASE_USER=grafana
       - GF_DATABASE_PASSWORD=password
+      - GF_DATABASE_TYPE=mysql
+      - GF_DATABASE_HOST=db:3306
       - GF_SESSION_PROVIDER=mysql
-      - GF_SESSION_PROVIDER_CONFIG=grafana:password@tcp(mysql:3306)/grafana?allowNativePasswords=true
+      - GF_SESSION_PROVIDER_CONFIG=grafana:password@tcp(db:3306)/grafana?allowNativePasswords=true
+      # - GF_DATABASE_TYPE=postgres
+      # - GF_DATABASE_HOST=db:5432
+      # - GF_DATABASE_SSL_MODE=disable
+      # - GF_SESSION_PROVIDER=postgres
+      # - GF_SESSION_PROVIDER_CONFIG=user=grafana password=password host=db port=5432 dbname=grafana sslmode=disable
+      - GF_LOG_FILTERS=alerting.notifier:debug,alerting.notifier.slack:debug
     ports:
       - 3000
     depends_on:
-      mysql:
+      db:
         condition: service_healthy
 
   prometheus:
@@ -54,4 +75,4 @@ services:
   #   environment:
   #     - DATA_SOURCE_NAME=grafana:password@(mysql:3306)/
   #   ports:
-  #     - 9104
+  #     - 9104

pkg/models/alert.go

@@ -75,7 +75,7 @@ type Alert struct {
 
 	EvalData     *simplejson.Json
 	NewStateDate time.Time
-	StateChanges int
+	StateChanges int64
 
 	Created time.Time
 	Updated time.Time
@@ -156,7 +156,7 @@ type SetAlertStateCommand struct {
 	Error    string
 	EvalData *simplejson.Json
 
-	Timestamp time.Time
+	Result Alert
 }
 
 //Queries

pkg/models/alert_notifications.go

@@ -8,8 +8,18 @@ import (
 )
 
 var (
-	ErrNotificationFrequencyNotFound = errors.New("Notification frequency not specified")
-	ErrJournalingNotFound            = errors.New("alert notification journaling not found")
+	ErrNotificationFrequencyNotFound         = errors.New("Notification frequency not specified")
+	ErrAlertNotificationStateNotFound        = errors.New("alert notification state not found")
+	ErrAlertNotificationStateVersionConflict = errors.New("alert notification state update version conflict")
+	ErrAlertNotificationStateAlreadyExist    = errors.New("alert notification state already exists.")
+)
+
+type AlertNotificationStateType string
+
+var (
+	AlertNotificationStatePending   = AlertNotificationStateType("pending")
+	AlertNotificationStateCompleted = AlertNotificationStateType("completed")
+	AlertNotificationStateUnknown   = AlertNotificationStateType("unknown")
 )
 
 type AlertNotification struct {
@@ -76,33 +86,34 @@ type GetAllAlertNotificationsQuery struct {
 	Result []*AlertNotification
 }
 
-type AlertNotificationJournal struct {
-	Id         int64
-	OrgId      int64
-	AlertId    int64
-	NotifierId int64
-	SentAt     int64
-	Success    bool
+type AlertNotificationState struct {
+	Id                           int64
+	OrgId                        int64
+	AlertId                      int64
+	NotifierId                   int64
+	State                        AlertNotificationStateType
+	Version                      int64
+	UpdatedAt                    int64
+	AlertRuleStateUpdatedVersion int64
 }
 
-type RecordNotificationJournalCommand struct {
-	OrgId      int64
-	AlertId    int64
-	NotifierId int64
-	SentAt     int64
-	Success    bool
-}
+type SetAlertNotificationStateToPendingCommand struct {
+	Id                           int64
+	AlertRuleStateUpdatedVersion int64
+	Version                      int64
 
-type GetLatestNotificationQuery struct {
-	OrgId      int64
-	AlertId    int64
-	NotifierId int64
+	ResultVersion int64
+}
 
-	Result []AlertNotificationJournal
+type SetAlertNotificationStateToCompleteCommand struct {
+	Id      int64
+	Version int64
 }
 
-type CleanNotificationJournalCommand struct {
+type GetOrCreateNotificationStateQuery struct {
 	OrgId      int64
 	AlertId    int64
 	NotifierId int64
+
+	Result *AlertNotificationState
 }

pkg/services/alerting/interfaces.go

@@ -3,6 +3,8 @@ package alerting
 import (
 	"context"
 	"time"
+
+	"github.com/grafana/grafana/pkg/models"
 )
 
 type EvalHandler interface {
@@ -20,7 +22,7 @@ type Notifier interface {
 	NeedsImage() bool
 
 	// ShouldNotify checks this evaluation should send an alert notification
-	ShouldNotify(ctx context.Context, evalContext *EvalContext) bool
+	ShouldNotify(ctx context.Context, evalContext *EvalContext, notificationState *models.AlertNotificationState) bool
 
 	GetNotifierId() int64
 	GetIsDefault() bool
@@ -28,11 +30,16 @@ type Notifier interface {
 	GetFrequency() time.Duration
 }
 
-type NotifierSlice []Notifier
+type notifierState struct {
+	notifier Notifier
+	state    *models.AlertNotificationState
+}
+
+type notifierStateSlice []*notifierState
 
-func (notifiers NotifierSlice) ShouldUploadImage() bool {
-	for _, notifier := range notifiers {
-		if notifier.NeedsImage() {
+func (notifiers notifierStateSlice) ShouldUploadImage() bool {
+	for _, ns := range notifiers {
+		if ns.notifier.NeedsImage() {
 			return true
 		}
 	}

pkg/services/alerting/notifier.go

@@ -1,10 +1,8 @@
 package alerting
 
 import (
-	"context"
 	"errors"
 	"fmt"
-	"time"
 
 	"github.com/grafana/grafana/pkg/bus"
 	"github.com/grafana/grafana/pkg/components/imguploader"
@@ -41,61 +39,78 @@ type notificationService struct {
 }
 
 func (n *notificationService) SendIfNeeded(context *EvalContext) error {
-	notifiers, err := n.getNeededNotifiers(context.Rule.OrgId, context.Rule.Notifications, context)
+	notifierStates, err := n.getNeededNotifiers(context.Rule.OrgId, context.Rule.Notifications, context)
 	if err != nil {
 		return err
 	}
 
-	if len(notifiers) == 0 {
+	if len(notifierStates) == 0 {
 		return nil
 	}
 
-	if notifiers.ShouldUploadImage() {
+	if notifierStates.ShouldUploadImage() {
 		if err = n.uploadImage(context); err != nil {
 			n.log.Error("Failed to upload alert panel image.", "error", err)
 		}
 	}
 
-	return n.sendNotifications(context, notifiers)
+	return n.sendNotifications(context, notifierStates)
 }
 
-func (n *notificationService) sendNotifications(evalContext *EvalContext, notifiers []Notifier) error {
-	for _, notifier := range notifiers {
-		not := notifier
+func (n *notificationService) sendAndMarkAsComplete(evalContext *EvalContext, notifierState *notifierState) error {
+	notifier := notifierState.notifier
 
-		err := bus.InTransaction(evalContext.Ctx, func(ctx context.Context) error {
-			n.log.Debug("trying to send notification", "id", not.GetNotifierId())
+	n.log.Debug("Sending notification", "type", notifier.GetType(), "id", notifier.GetNotifierId(), "isDefault", notifier.GetIsDefault())
+	metrics.M_Alerting_Notification_Sent.WithLabelValues(notifier.GetType()).Inc()
 
-			// Verify that we can send the notification again
-			// but this time within the same transaction.
-			if !evalContext.IsTestRun && !not.ShouldNotify(ctx, evalContext) {
-				return nil
-			}
+	err := notifier.Notify(evalContext)
 
-			n.log.Debug("Sending notification", "type", not.GetType(), "id", not.GetNotifierId(), "isDefault", not.GetIsDefault())
-			metrics.M_Alerting_Notification_Sent.WithLabelValues(not.GetType()).Inc()
+	if err != nil {
+		n.log.Error("failed to send notification", "id", notifier.GetNotifierId(), "error", err)
+	}
 
-			//send notification
-			success := not.Notify(evalContext) == nil
+	if evalContext.IsTestRun {
+		return nil
+	}
 
-			if evalContext.IsTestRun {
-				return nil
-			}
+	cmd := &m.SetAlertNotificationStateToCompleteCommand{
+		Id:      notifierState.state.Id,
+		Version: notifierState.state.Version,
+	}
 
-			//write result to db.
-			cmd := &m.RecordNotificationJournalCommand{
-				OrgId:      evalContext.Rule.OrgId,
-				AlertId:    evalContext.Rule.Id,
-				NotifierId: not.GetNotifierId(),
-				SentAt:     time.Now().Unix(),
-				Success:    success,
-			}
+	return bus.DispatchCtx(evalContext.Ctx, cmd)
+}
 
-			return bus.DispatchCtx(ctx, cmd)
-		})
+func (n *notificationService) sendNotification(evalContext *EvalContext, notifierState *notifierState) error {
+	if !evalContext.IsTestRun {
+		setPendingCmd := &m.SetAlertNotificationStateToPendingCommand{
+			Id:                           notifierState.state.Id,
+			Version:                      notifierState.state.Version,
+			AlertRuleStateUpdatedVersion: evalContext.Rule.StateChanges,
+		}
+
+		err := bus.DispatchCtx(evalContext.Ctx, setPendingCmd)
+		if err == m.ErrAlertNotificationStateVersionConflict {
+			return nil
+		}
 
 		if err != nil {
-			n.log.Error("failed to send notification", "id", not.GetNotifierId())
+			return err
+		}
+
+		// We need to update state version to be able to log
+		// unexpected version conflicts when marking notifications as ok
+		notifierState.state.Version = setPendingCmd.ResultVersion
+	}
+
+	return n.sendAndMarkAsComplete(evalContext, notifierState)
+}
+
+func (n *notificationService) sendNotifications(evalContext *EvalContext, notifierStates notifierStateSlice) error {
+	for _, notifierState := range notifierStates {
+		err := n.sendNotification(evalContext, notifierState)
+		if err != nil {
+			n.log.Error("failed to send notification", "id", notifierState.notifier.GetNotifierId(), "error", err)
 		}
 	}
 
@@ -142,22 +157,38 @@ func (n *notificationService) uploadImage(context *EvalContext) (err error) {
 	return nil
 }
 
-func (n *notificationService) getNeededNotifiers(orgId int64, notificationIds []int64, evalContext *EvalContext) (NotifierSlice, error) {
+func (n *notificationService) getNeededNotifiers(orgId int64, notificationIds []int64, evalContext *EvalContext) (notifierStateSlice, error) {
 	query := &m.GetAlertNotificationsToSendQuery{OrgId: orgId, Ids: notificationIds}
 
 	if err := bus.Dispatch(query); err != nil {
 		return nil, err
 	}
 
-	var result []Notifier
+	var result notifierStateSlice
 	for _, notification := range query.Result {
 		not, err := n.createNotifierFor(notification)
 		if err != nil {
-			return nil, err
+			n.log.Error("Could not create notifier", "notifier", notification.Id, "error", err)
+			continue
+		}
+
+		query := &m.GetOrCreateNotificationStateQuery{
+			NotifierId: notification.Id,
+			AlertId:    evalContext.Rule.Id,
+			OrgId:      evalContext.Rule.OrgId,
+		}
+
+		err = bus.DispatchCtx(evalContext.Ctx, query)
+		if err != nil {
+			n.log.Error("Could not get notification state.", "notifier", notification.Id, "error", err)
+			continue
 		}
 
-		if not.ShouldNotify(evalContext.Ctx, evalContext) {
-			result = append(result, not)
+		if not.ShouldNotify(evalContext.Ctx, evalContext, query.Result) {
+			result = append(result, &notifierState{
+				notifier: not,
+				state:    query.Result,
+			})
 		}
 	}
 

pkg/services/alerting/notifiers/alertmanager.go

@@ -46,7 +46,7 @@ type AlertmanagerNotifier struct {
 	log log.Logger
 }
 
-func (this *AlertmanagerNotifier) ShouldNotify(ctx context.Context, evalContext *alerting.EvalContext) bool {
+func (this *AlertmanagerNotifier) ShouldNotify(ctx context.Context, evalContext *alerting.EvalContext, notificationState *m.AlertNotificationState) bool {
 	this.log.Debug("Should notify", "ruleId", evalContext.Rule.Id, "state", evalContext.Rule.State, "previousState", evalContext.PrevAlertState)
 
 	// Do not notify when we become OK for the first time.

pkg/services/alerting/notifiers/base.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"time"
 
-	"github.com/grafana/grafana/pkg/bus"
 	"github.com/grafana/grafana/pkg/log"
 	"github.com/grafana/grafana/pkg/models"
 
@@ -46,54 +45,45 @@ func NewNotifierBase(model *models.AlertNotification) NotifierBase {
 	}
 }
 
-func defaultShouldNotify(context *alerting.EvalContext, sendReminder bool, frequency time.Duration, journals []models.AlertNotificationJournal) bool {
+// ShouldNotify checks this evaluation should send an alert notification
+func (n *NotifierBase) ShouldNotify(ctx context.Context, context *alerting.EvalContext, notiferState *models.AlertNotificationState) bool {
 	// Only notify on state change.
-	if context.PrevAlertState == context.Rule.State && !sendReminder {
+	if context.PrevAlertState == context.Rule.State && !n.SendReminder {
 		return false
 	}
 
-	// get last successfully sent notification
-	lastNotify := time.Time{}
-	for _, j := range journals {
-		if j.Success {
-			lastNotify = time.Unix(j.SentAt, 0)
-			break
+	if context.PrevAlertState == context.Rule.State && n.SendReminder {
+		// Do not notify if interval has not elapsed
+		lastNotify := time.Unix(notiferState.UpdatedAt, 0)
+		if notiferState.UpdatedAt != 0 && lastNotify.Add(n.Frequency).After(time.Now()) {
+			return false
 		}
-	}
-
-	// Do not notify if interval has not elapsed
-	if sendReminder && !lastNotify.IsZero() && lastNotify.Add(frequency).After(time.Now()) {
-		return false
-	}
 
-	// Do not notify if alert state if OK or pending even on repeated notify
-	if sendReminder && (context.Rule.State == models.AlertStateOK || context.Rule.State == models.AlertStatePending) {
-		return false
+		// Do not notify if alert state is OK or pending even on repeated notify
+		if context.Rule.State == models.AlertStateOK || context.Rule.State == models.AlertStatePending {
+			return false
+		}
 	}
 
 	// Do not notify when we become OK for the first time.
-	if (context.PrevAlertState == models.AlertStatePending) && (context.Rule.State == models.AlertStateOK) {
+	if context.PrevAlertState == models.AlertStatePending && context.Rule.State == models.AlertStateOK {
 		return false
 	}
 
-	return true
-}
-
-// ShouldNotify checks this evaluation should send an alert notification
-func (n *NotifierBase) ShouldNotify(ctx context.Context, c *alerting.EvalContext) bool {
-	cmd := &models.GetLatestNotificationQuery{
-		OrgId:      c.Rule.OrgId,
-		AlertId:    c.Rule.Id,
-		NotifierId: n.Id,
+	// Do not notify when we OK -> Pending
+	if context.PrevAlertState == models.AlertStateOK && context.Rule.State == models.AlertStatePending {
+		return false
 	}
 
-	err := bus.DispatchCtx(ctx, cmd)
-	if err != nil {
-		n.log.Error("Could not determine last time alert notifier fired", "Alert name", c.Rule.Name, "Error", err)
-		return false
+	// Do not notifu if state pending and it have been updated last minute
+	if notiferState.State == models.AlertNotificationStatePending {
+		lastUpdated := time.Unix(notiferState.UpdatedAt, 0)
+		if lastUpdated.Add(1 * time.Minute).After(time.Now()) {
+			return false
+		}
 	}
 
-	return defaultShouldNotify(c, n.SendReminder, n.Frequency, cmd.Result)
+	return true
 }
 
 func (n *NotifierBase) GetType() string {

pkg/services/alerting/notifiers/base_test.go

@@ -2,12 +2,9 @@ package notifiers
 
 import (
 	"context"
-	"errors"
 	"testing"
 	"time"
 
-	"github.com/grafana/grafana/pkg/bus"
-
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	m "github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/services/alerting"
@@ -23,34 +20,34 @@ func TestShouldSendAlertNotification(t *testing.T) {
 		newState     m.AlertStateType
 		sendReminder bool
 		frequency    time.Duration
-		journals     []m.AlertNotificationJournal
+		state        *m.AlertNotificationState
 
 		expect bool
 	}{
 		{
 			name:         "pending -> ok should not trigger an notification",
-			newState:     m.AlertStatePending,
-			prevState:    m.AlertStateOK,
+			newState:     m.AlertStateOK,
+			prevState:    m.AlertStatePending,
 			sendReminder: false,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{},
 
 			expect: false,
 		},
 		{
 			name:         "ok -> alerting should trigger an notification",
-			newState:     m.AlertStateOK,
-			prevState:    m.AlertStateAlerting,
+			newState:     m.AlertStateAlerting,
+			prevState:    m.AlertStateOK,
 			sendReminder: false,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{},
 
 			expect: true,
 		},
 		{
 			name:         "ok -> pending should not trigger an notification",
-			newState:     m.AlertStateOK,
-			prevState:    m.AlertStatePending,
+			newState:     m.AlertStatePending,
+			prevState:    m.AlertStateOK,
 			sendReminder: false,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{},
 
 			expect: false,
 		},
@@ -59,100 +56,100 @@ func TestShouldSendAlertNotification(t *testing.T) {
 			newState:     m.AlertStateOK,
 			prevState:    m.AlertStateOK,
 			sendReminder: false,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{},
 
 			expect: false,
 		},
 		{
-			name:         "ok -> alerting should trigger an notification",
+			name:         "ok -> ok with reminder should not trigger an notification",
 			newState:     m.AlertStateOK,
-			prevState:    m.AlertStateAlerting,
+			prevState:    m.AlertStateOK,
 			sendReminder: true,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{},
+
+			expect: false,
+		},
+		{
+			name:         "alerting -> ok should trigger an notification",
+			newState:     m.AlertStateOK,
+			prevState:    m.AlertStateAlerting,
+			sendReminder: false,
+			state:        &m.AlertNotificationState{},
 
 			expect: true,
 		},
 		{
-			name:         "ok -> ok with reminder should not trigger an notification",
+			name:         "alerting -> ok should trigger an notification when reminders enabled",
 			newState:     m.AlertStateOK,
-			prevState:    m.AlertStateOK,
+			prevState:    m.AlertStateAlerting,
+			frequency:    time.Minute * 10,
 			sendReminder: true,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{UpdatedAt: tnow.Add(-time.Minute).Unix()},
 
-			expect: false,
+			expect: true,
 		},
 		{
-			name:         "alerting -> alerting with reminder and no journaling should trigger",
+			name:         "alerting -> alerting with reminder and no state should trigger",
 			newState:     m.AlertStateAlerting,
 			prevState:    m.AlertStateAlerting,
 			frequency:    time.Minute * 10,
 			sendReminder: true,
-			journals:     []m.AlertNotificationJournal{},
+			state:        &m.AlertNotificationState{},
 
 			expect: true,
 		},
 		{
-			name:         "alerting -> alerting with reminder and successful recent journal event should not trigger",
+			name:         "alerting -> alerting with reminder and last notification sent 1 minute ago should not trigger",
 			newState:     m.AlertStateAlerting,
 			prevState:    m.AlertStateAlerting,
 			frequency:    time.Minute * 10,
 			sendReminder: true,
-			journals: []m.AlertNotificationJournal{
-				{SentAt: tnow.Add(-time.Minute).Unix(), Success: true},
-			},
+			state:        &m.AlertNotificationState{UpdatedAt: tnow.Add(-time.Minute).Unix()},
 
 			expect: false,
 		},
 		{
-			name:         "alerting -> alerting with reminder and failed recent journal event should trigger",
+			name:         "alerting -> alerting with reminder and last notifciation sent 11 minutes ago should trigger",
 			newState:     m.AlertStateAlerting,
 			prevState:    m.AlertStateAlerting,
 			frequency:    time.Minute * 10,
 			sendReminder: true,
-			expect:       true,
-			journals: []m.AlertNotificationJournal{
-				{SentAt: tnow.Add(-time.Minute).Unix(), Success: false}, // recent failed notification
-				{SentAt: tnow.Add(-time.Hour).Unix(), Success: true},    // old successful notification
-			},
+			state:        &m.AlertNotificationState{UpdatedAt: tnow.Add(-11 * time.Minute).Unix()},
+
+			expect: true,
+		},
+		{
+			name:      "OK -> alerting with notifciation state pending and updated 30 seconds ago should not trigger",
+			newState:  m.AlertStateAlerting,
+			prevState: m.AlertStateOK,
+			state:     &m.AlertNotificationState{State: m.AlertNotificationStatePending, UpdatedAt: tnow.Add(-30 * time.Second).Unix()},
+
+			expect: false,
+		},
+		{
+			name:      "OK -> alerting with notifciation state pending and updated 2 minutes ago should trigger",
+			newState:  m.AlertStateAlerting,
+			prevState: m.AlertStateOK,
+			state:     &m.AlertNotificationState{State: m.AlertNotificationStatePending, UpdatedAt: tnow.Add(-2 * time.Minute).Unix()},
+
+			expect: true,
 		},
 	}
 
 	for _, tc := range tcs {
 		evalContext := alerting.NewEvalContext(context.TODO(), &alerting.Rule{
-			State: tc.newState,
+			State: tc.prevState,
 		})
 
-		evalContext.Rule.State = tc.prevState
-		if defaultShouldNotify(evalContext, true, tc.frequency, tc.journals) != tc.expect {
+		evalContext.Rule.State = tc.newState
+		nb := &NotifierBase{SendReminder: tc.sendReminder, Frequency: tc.frequency}
+
+		if nb.ShouldNotify(evalContext.Ctx, evalContext, tc.state) != tc.expect {
 			t.Errorf("failed test %s.\n expected \n%+v \nto return: %v", tc.name, tc, tc.expect)
 		}
 	}
 }
 
-func TestShouldNotifyWhenNoJournalingIsFound(t *testing.T) {
-	Convey("base notifier", t, func() {
-		bus.ClearBusHandlers()
-
-		notifier := NewNotifierBase(&m.AlertNotification{
-			Id:       1,
-			Name:     "name",
-			Type:     "email",
-			Settings: simplejson.New(),
-		})
-		evalContext := alerting.NewEvalContext(context.TODO(), &alerting.Rule{})
-
-		Convey("should not notify query returns error", func() {
-			bus.AddHandlerCtx("", func(ctx context.Context, q *m.GetLatestNotificationQuery) error {
-				return errors.New("some kind of error unknown error")
-			})
-
-			if notifier.ShouldNotify(context.Background(), evalContext) {
-				t.Errorf("should not send notifications when query returns error")
-			}
-		})
-	})
-}
-
 func TestBaseNotifier(t *testing.T) {
 	Convey("default constructor for notifiers", t, func() {
 		bJson := simplejson.New()

pkg/services/alerting/result_handler.go

@@ -67,6 +67,12 @@ func (handler *DefaultResultHandler) Handle(evalContext *EvalContext) error {
 			}
 
 			handler.log.Error("Failed to save state", "error", err)
+		} else {
+
+			// StateChanges is used for de duping alert notifications
+			// when two servers are raising. This makes sure that the server
+			// with the last state change always sends a notification.
+			evalContext.Rule.StateChanges = cmd.Result.StateChanges
 		}
 
 		// save annotation
@@ -88,19 +94,6 @@ func (handler *DefaultResultHandler) Handle(evalContext *EvalContext) error {
 		}
 	}
 
-	if evalContext.Rule.State == m.AlertStateOK && evalContext.PrevAlertState != m.AlertStateOK {
-		for _, notifierId := range evalContext.Rule.Notifications {
-			cmd := &m.CleanNotificationJournalCommand{
-				AlertId:    evalContext.Rule.Id,
-				NotifierId: notifierId,
-				OrgId:      evalContext.Rule.OrgId,
-			}
-			if err := bus.DispatchCtx(evalContext.Ctx, cmd); err != nil {
-				handler.log.Error("Failed to clean up old notification records", "notifier", notifierId, "alert", evalContext.Rule.Id, "Error", err)
-			}
-		}
-	}
-
 	handler.notifier.SendIfNeeded(evalContext)
 	return nil
 }

pkg/services/alerting/rule.go

@@ -23,6 +23,8 @@ type Rule struct {
 	State               m.AlertStateType
 	Conditions          []Condition
 	Notifications       []int64
+
+	StateChanges int64
 }
 
 type ValidationError struct {
@@ -100,6 +102,7 @@ func NewRuleFromDBAlert(ruleDef *m.Alert) (*Rule, error) {
 	model.State = ruleDef.State
 	model.NoDataState = m.NoDataOption(ruleDef.Settings.Get("noDataState").MustString("no_data"))
 	model.ExecutionErrorState = m.ExecutionErrorOption(ruleDef.Settings.Get("executionErrorState").MustString("alerting"))
+	model.StateChanges = ruleDef.StateChanges
 
 	for _, v := range ruleDef.Settings.Get("notifications").MustArray() {
 		jsonModel := simplejson.NewFromAny(v)

pkg/services/alerting/test_notification.go

@@ -39,7 +39,7 @@ func handleNotificationTestCommand(cmd *NotificationTestCommand) error {
 		return err
 	}
 
-	return notifier.sendNotifications(createTestEvalContext(cmd), []Notifier{notifiers})
+	return notifier.sendNotifications(createTestEvalContext(cmd), notifierStateSlice{{notifier: notifiers}})
 }
 
 func createTestEvalContext(cmd *NotificationTestCommand) *EvalContext {

pkg/services/sqlstore/alert.go

@@ -60,6 +60,10 @@ func deleteAlertByIdInternal(alertId int64, reason string, sess *DBSession) erro
 		return err
 	}
 
+	if _, err := sess.Exec("DELETE FROM alert_notification_state WHERE alert_id = ?", alertId); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -275,6 +279,8 @@ func SetAlertState(cmd *m.SetAlertStateCommand) error {
 		}
 
 		sess.ID(alert.Id).Update(&alert)
+
+		cmd.Result = alert
 		return nil
 	})
 }

pkg/services/sqlstore/alert_notification.go

@@ -3,6 +3,7 @@ package sqlstore
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -18,16 +19,23 @@ func init() {
 	bus.AddHandler("sql", DeleteAlertNotification)
 	bus.AddHandler("sql", GetAlertNotificationsToSend)
 	bus.AddHandler("sql", GetAllAlertNotifications)
-	bus.AddHandlerCtx("sql", RecordNotificationJournal)
-	bus.AddHandlerCtx("sql", GetLatestNotification)
-	bus.AddHandlerCtx("sql", CleanNotificationJournal)
+	bus.AddHandlerCtx("sql", GetOrCreateAlertNotificationState)
+	bus.AddHandlerCtx("sql", SetAlertNotificationStateToCompleteCommand)
+	bus.AddHandlerCtx("sql", SetAlertNotificationStateToPendingCommand)
 }
 
 func DeleteAlertNotification(cmd *m.DeleteAlertNotificationCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 		sql := "DELETE FROM alert_notification WHERE alert_notification.org_id = ? AND alert_notification.id = ?"
-		_, err := sess.Exec(sql, cmd.OrgId, cmd.Id)
-		return err
+		if _, err := sess.Exec(sql, cmd.OrgId, cmd.Id); err != nil {
+			return err
+		}
+
+		if _, err := sess.Exec("DELETE FROM alert_notification_state WHERE alert_notification_state.org_id = ? AND alert_notification_state.notifier_id = ?", cmd.OrgId, cmd.Id); err != nil {
+			return err
+		}
+
+		return nil
 	})
 }
 
@@ -229,44 +237,123 @@ func UpdateAlertNotification(cmd *m.UpdateAlertNotificationCommand) error {
 	})
 }
 
-func RecordNotificationJournal(ctx context.Context, cmd *m.RecordNotificationJournalCommand) error {
-	return withDbSession(ctx, func(sess *DBSession) error {
-		journalEntry := &m.AlertNotificationJournal{
-			OrgId:      cmd.OrgId,
-			AlertId:    cmd.AlertId,
-			NotifierId: cmd.NotifierId,
-			SentAt:     cmd.SentAt,
-			Success:    cmd.Success,
+func SetAlertNotificationStateToCompleteCommand(ctx context.Context, cmd *m.SetAlertNotificationStateToCompleteCommand) error {
+	return inTransactionCtx(ctx, func(sess *DBSession) error {
+		version := cmd.Version
+		var current m.AlertNotificationState
+		sess.ID(cmd.Id).Get(&current)
+
+		newVersion := cmd.Version + 1
+
+		sql := `UPDATE alert_notification_state SET
+			state = ?,
+			version = ?,
+			updated_at = ?
+		WHERE
+			id = ?`
+
+		_, err := sess.Exec(sql, m.AlertNotificationStateCompleted, newVersion, timeNow().Unix(), cmd.Id)
+
+		if err != nil {
+			return err
 		}
 
-		_, err := sess.Insert(journalEntry)
-		return err
+		if current.Version != version {
+			sqlog.Error("notification state out of sync. the notification is marked as complete but has been modified between set as pending and completion.", "notifierId", current.NotifierId)
+		}
+
+		return nil
 	})
 }
 
-func GetLatestNotification(ctx context.Context, cmd *m.GetLatestNotificationQuery) error {
+func SetAlertNotificationStateToPendingCommand(ctx context.Context, cmd *m.SetAlertNotificationStateToPendingCommand) error {
 	return withDbSession(ctx, func(sess *DBSession) error {
-		nj := []m.AlertNotificationJournal{}
-
-		err := sess.Desc("alert_notification_journal.sent_at").
-			Where("alert_notification_journal.org_id = ?", cmd.OrgId).
-			Where("alert_notification_journal.alert_id = ?", cmd.AlertId).
-			Where("alert_notification_journal.notifier_id = ?", cmd.NotifierId).
-			Find(&nj)
+		newVersion := cmd.Version + 1
+		sql := `UPDATE alert_notification_state SET
+			state = ?,
+			version = ?,
+			updated_at = ?,
+			alert_rule_state_updated_version = ?
+		WHERE
+			id = ? AND
+			(version = ? OR alert_rule_state_updated_version < ?)`
+
+		res, err := sess.Exec(sql,
+			m.AlertNotificationStatePending,
+			newVersion,
+			timeNow().Unix(),
+			cmd.AlertRuleStateUpdatedVersion,
+			cmd.Id,
+			cmd.Version,
+			cmd.AlertRuleStateUpdatedVersion)
 
 		if err != nil {
 			return err
 		}
 
-		cmd.Result = nj
+		affected, _ := res.RowsAffected()
+		if affected == 0 {
+			return m.ErrAlertNotificationStateVersionConflict
+		}
+
+		cmd.ResultVersion = newVersion
+
 		return nil
 	})
 }
 
-func CleanNotificationJournal(ctx context.Context, cmd *m.CleanNotificationJournalCommand) error {
+func GetOrCreateAlertNotificationState(ctx context.Context, cmd *m.GetOrCreateNotificationStateQuery) error {
 	return inTransactionCtx(ctx, func(sess *DBSession) error {
-		sql := "DELETE FROM alert_notification_journal WHERE alert_notification_journal.org_id = ? AND alert_notification_journal.alert_id = ? AND alert_notification_journal.notifier_id = ?"
-		_, err := sess.Exec(sql, cmd.OrgId, cmd.AlertId, cmd.NotifierId)
-		return err
+		nj := &m.AlertNotificationState{}
+
+		exist, err := getAlertNotificationState(sess, cmd, nj)
+
+		// if exists, return it, otherwise create it with default values
+		if err != nil {
+			return err
+		}
+
+		if exist {
+			cmd.Result = nj
+			return nil
+		}
+
+		notificationState := &m.AlertNotificationState{
+			OrgId:      cmd.OrgId,
+			AlertId:    cmd.AlertId,
+			NotifierId: cmd.NotifierId,
+			State:      m.AlertNotificationStateUnknown,
+			UpdatedAt:  timeNow().Unix(),
+		}
+
+		if _, err := sess.Insert(notificationState); err != nil {
+			if dialect.IsUniqueConstraintViolation(err) {
+				exist, err = getAlertNotificationState(sess, cmd, nj)
+
+				if err != nil {
+					return err
+				}
+
+				if !exist {
+					return errors.New("Should not happen")
+				}
+
+				cmd.Result = nj
+				return nil
+			}
+
+			return err
+		}
+
+		cmd.Result = notificationState
+		return nil
 	})
 }
+
+func getAlertNotificationState(sess *DBSession, cmd *m.GetOrCreateNotificationStateQuery, nj *m.AlertNotificationState) (bool, error) {
+	return sess.
+		Where("alert_notification_state.org_id = ?", cmd.OrgId).
+		Where("alert_notification_state.alert_id = ?", cmd.AlertId).
+		Where("alert_notification_state.notifier_id = ?", cmd.NotifierId).
+		Get(nj)
+}

pkg/services/sqlstore/alert_notification_test.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
-	m "github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/models"
 	. "github.com/smartystreets/goconvey/convey"
 )
 
@@ -14,58 +14,133 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 	Convey("Testing Alert notification sql access", t, func() {
 		InitTestDB(t)
 
-		Convey("Alert notification journal", func() {
-			var alertId int64 = 7
-			var orgId int64 = 5
-			var notifierId int64 = 10
+		Convey("Alert notification state", func() {
+			var alertID int64 = 7
+			var orgID int64 = 5
+			var notifierID int64 = 10
+			oldTimeNow := timeNow
+			now := time.Date(2018, 9, 30, 0, 0, 0, 0, time.UTC)
+			timeNow = func() time.Time { return now }
+
+			Convey("Get no existing state should create a new state", func() {
+				query := &models.GetOrCreateNotificationStateQuery{AlertId: alertID, OrgId: orgID, NotifierId: notifierID}
+				err := GetOrCreateAlertNotificationState(context.Background(), query)
+				So(err, ShouldBeNil)
+				So(query.Result, ShouldNotBeNil)
+				So(query.Result.State, ShouldEqual, "unknown")
+				So(query.Result.Version, ShouldEqual, 0)
+				So(query.Result.UpdatedAt, ShouldEqual, now.Unix())
+
+				Convey("Get existing state should not create a new state", func() {
+					query2 := &models.GetOrCreateNotificationStateQuery{AlertId: alertID, OrgId: orgID, NotifierId: notifierID}
+					err := GetOrCreateAlertNotificationState(context.Background(), query2)
+					So(err, ShouldBeNil)
+					So(query2.Result, ShouldNotBeNil)
+					So(query2.Result.Id, ShouldEqual, query.Result.Id)
+					So(query2.Result.UpdatedAt, ShouldEqual, now.Unix())
+				})
 
-			Convey("Getting last journal should raise error if no one exists", func() {
-				query := &m.GetLatestNotificationQuery{AlertId: alertId, OrgId: orgId, NotifierId: notifierId}
-				GetLatestNotification(context.Background(), query)
-				So(len(query.Result), ShouldEqual, 0)
+				Convey("Update existing state to pending with correct version should update database", func() {
+					s := *query.Result
 
-				// recording an journal entry in another org to make sure org filter works as expected.
-				journalInOtherOrg := &m.RecordNotificationJournalCommand{AlertId: alertId, NotifierId: notifierId, OrgId: 10, Success: true, SentAt: 1}
-				err := RecordNotificationJournal(context.Background(), journalInOtherOrg)
-				So(err, ShouldBeNil)
+					cmd := models.SetAlertNotificationStateToPendingCommand{
+						Id:                           s.Id,
+						Version:                      s.Version,
+						AlertRuleStateUpdatedVersion: s.AlertRuleStateUpdatedVersion,
+					}
 
-				Convey("should be able to record two journaling events", func() {
-					createCmd := &m.RecordNotificationJournalCommand{AlertId: alertId, NotifierId: notifierId, OrgId: orgId, Success: true, SentAt: 1}
+					err := SetAlertNotificationStateToPendingCommand(context.Background(), &cmd)
+					So(err, ShouldBeNil)
+					So(cmd.ResultVersion, ShouldEqual, 1)
 
-					err := RecordNotificationJournal(context.Background(), createCmd)
+					query2 := &models.GetOrCreateNotificationStateQuery{AlertId: alertID, OrgId: orgID, NotifierId: notifierID}
+					err = GetOrCreateAlertNotificationState(context.Background(), query2)
 					So(err, ShouldBeNil)
+					So(query2.Result.Version, ShouldEqual, 1)
+					So(query2.Result.State, ShouldEqual, models.AlertNotificationStatePending)
+					So(query2.Result.UpdatedAt, ShouldEqual, now.Unix())
+
+					Convey("Update existing state to completed should update database", func() {
+						s := *query.Result
+						setStateCmd := models.SetAlertNotificationStateToCompleteCommand{
+							Id:      s.Id,
+							Version: cmd.ResultVersion,
+						}
+						err := SetAlertNotificationStateToCompleteCommand(context.Background(), &setStateCmd)
+						So(err, ShouldBeNil)
 
-					createCmd.SentAt += 1000 //increase epoch
+						query3 := &models.GetOrCreateNotificationStateQuery{AlertId: alertID, OrgId: orgID, NotifierId: notifierID}
+						err = GetOrCreateAlertNotificationState(context.Background(), query3)
+						So(err, ShouldBeNil)
+						So(query3.Result.Version, ShouldEqual, 2)
+						So(query3.Result.State, ShouldEqual, models.AlertNotificationStateCompleted)
+						So(query3.Result.UpdatedAt, ShouldEqual, now.Unix())
+					})
 
-					err = RecordNotificationJournal(context.Background(), createCmd)
-					So(err, ShouldBeNil)
+					Convey("Update existing state to completed should update database. regardless of version", func() {
+						s := *query.Result
+						unknownVersion := int64(1000)
+						cmd := models.SetAlertNotificationStateToCompleteCommand{
+							Id:      s.Id,
+							Version: unknownVersion,
+						}
+						err := SetAlertNotificationStateToCompleteCommand(context.Background(), &cmd)
+						So(err, ShouldBeNil)
 
-					Convey("get last journaling event", func() {
-						err := GetLatestNotification(context.Background(), query)
+						query3 := &models.GetOrCreateNotificationStateQuery{AlertId: alertID, OrgId: orgID, NotifierId: notifierID}
+						err = GetOrCreateAlertNotificationState(context.Background(), query3)
 						So(err, ShouldBeNil)
-						So(len(query.Result), ShouldEqual, 2)
-						last := query.Result[0]
-						So(last.SentAt, ShouldEqual, 1001)
-
-						Convey("be able to clear all journaling for an notifier", func() {
-							cmd := &m.CleanNotificationJournalCommand{AlertId: alertId, NotifierId: notifierId, OrgId: orgId}
-							err := CleanNotificationJournal(context.Background(), cmd)
-							So(err, ShouldBeNil)
-
-							Convey("querying for last journaling should return no journal entries", func() {
-								query := &m.GetLatestNotificationQuery{AlertId: alertId, OrgId: orgId, NotifierId: notifierId}
-								err := GetLatestNotification(context.Background(), query)
-								So(err, ShouldBeNil)
-								So(len(query.Result), ShouldEqual, 0)
-							})
-						})
+						So(query3.Result.Version, ShouldEqual, unknownVersion+1)
+						So(query3.Result.State, ShouldEqual, models.AlertNotificationStateCompleted)
+						So(query3.Result.UpdatedAt, ShouldEqual, now.Unix())
 					})
 				})
+
+				Convey("Update existing state to pending with incorrect version should return version mismatch error", func() {
+					s := *query.Result
+					s.Version = 1000
+					cmd := models.SetAlertNotificationStateToPendingCommand{
+						Id:                           s.NotifierId,
+						Version:                      s.Version,
+						AlertRuleStateUpdatedVersion: s.AlertRuleStateUpdatedVersion,
+					}
+					err := SetAlertNotificationStateToPendingCommand(context.Background(), &cmd)
+					So(err, ShouldEqual, models.ErrAlertNotificationStateVersionConflict)
+				})
+
+				Convey("Updating existing state to pending with incorrect version since alert rule state update version is higher", func() {
+					s := *query.Result
+					cmd := models.SetAlertNotificationStateToPendingCommand{
+						Id:                           s.Id,
+						Version:                      s.Version,
+						AlertRuleStateUpdatedVersion: 1000,
+					}
+					err := SetAlertNotificationStateToPendingCommand(context.Background(), &cmd)
+					So(err, ShouldBeNil)
+
+					So(cmd.ResultVersion, ShouldEqual, 1)
+				})
+
+				Convey("different version and same alert state change version should return error", func() {
+					s := *query.Result
+					s.Version = 1000
+					cmd := models.SetAlertNotificationStateToPendingCommand{
+						Id:                           s.Id,
+						Version:                      s.Version,
+						AlertRuleStateUpdatedVersion: s.AlertRuleStateUpdatedVersion,
+					}
+					err := SetAlertNotificationStateToPendingCommand(context.Background(), &cmd)
+					So(err, ShouldNotBeNil)
+				})
+			})
+
+			Reset(func() {
+				timeNow = oldTimeNow
 			})
 		})
 
 		Convey("Alert notifications should be empty", func() {
-			cmd := &m.GetAlertNotificationsQuery{
+			cmd := &models.GetAlertNotificationsQuery{
 				OrgId: 2,
 				Name:  "email",
 			}
@@ -76,7 +151,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 		})
 
 		Convey("Cannot save alert notifier with send reminder = true", func() {
-			cmd := &m.CreateAlertNotificationCommand{
+			cmd := &models.CreateAlertNotificationCommand{
 				Name:         "ops",
 				Type:         "email",
 				OrgId:        1,
@@ -86,7 +161,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 
 			Convey("and missing frequency", func() {
 				err := CreateAlertNotificationCommand(cmd)
-				So(err, ShouldEqual, m.ErrNotificationFrequencyNotFound)
+				So(err, ShouldEqual, models.ErrNotificationFrequencyNotFound)
 			})
 
 			Convey("invalid frequency", func() {
@@ -98,7 +173,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 		})
 
 		Convey("Cannot update alert notifier with send reminder = false", func() {
-			cmd := &m.CreateAlertNotificationCommand{
+			cmd := &models.CreateAlertNotificationCommand{
 				Name:         "ops update",
 				Type:         "email",
 				OrgId:        1,
@@ -109,14 +184,14 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 			err := CreateAlertNotificationCommand(cmd)
 			So(err, ShouldBeNil)
 
-			updateCmd := &m.UpdateAlertNotificationCommand{
+			updateCmd := &models.UpdateAlertNotificationCommand{
 				Id:           cmd.Result.Id,
 				SendReminder: true,
 			}
 
 			Convey("and missing frequency", func() {
 				err := UpdateAlertNotification(updateCmd)
-				So(err, ShouldEqual, m.ErrNotificationFrequencyNotFound)
+				So(err, ShouldEqual, models.ErrNotificationFrequencyNotFound)
 			})
 
 			Convey("invalid frequency", func() {
@@ -129,7 +204,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 		})
 
 		Convey("Can save Alert Notification", func() {
-			cmd := &m.CreateAlertNotificationCommand{
+			cmd := &models.CreateAlertNotificationCommand{
 				Name:         "ops",
 				Type:         "email",
 				OrgId:        1,
@@ -151,7 +226,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 			})
 
 			Convey("Can update alert notification", func() {
-				newCmd := &m.UpdateAlertNotificationCommand{
+				newCmd := &models.UpdateAlertNotificationCommand{
 					Name:         "NewName",
 					Type:         "webhook",
 					OrgId:        cmd.Result.OrgId,
@@ -167,7 +242,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 			})
 
 			Convey("Can update alert notification to disable sending of reminders", func() {
-				newCmd := &m.UpdateAlertNotificationCommand{
+				newCmd := &models.UpdateAlertNotificationCommand{
 					Name:         "NewName",
 					Type:         "webhook",
 					OrgId:        cmd.Result.OrgId,
@@ -182,12 +257,12 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 		})
 
 		Convey("Can search using an array of ids", func() {
-			cmd1 := m.CreateAlertNotificationCommand{Name: "nagios", Type: "webhook", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
-			cmd2 := m.CreateAlertNotificationCommand{Name: "slack", Type: "webhook", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
-			cmd3 := m.CreateAlertNotificationCommand{Name: "ops2", Type: "email", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
-			cmd4 := m.CreateAlertNotificationCommand{IsDefault: true, Name: "default", Type: "email", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
+			cmd1 := models.CreateAlertNotificationCommand{Name: "nagios", Type: "webhook", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
+			cmd2 := models.CreateAlertNotificationCommand{Name: "slack", Type: "webhook", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
+			cmd3 := models.CreateAlertNotificationCommand{Name: "ops2", Type: "email", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
+			cmd4 := models.CreateAlertNotificationCommand{IsDefault: true, Name: "default", Type: "email", OrgId: 1, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
 
-			otherOrg := m.CreateAlertNotificationCommand{Name: "default", Type: "email", OrgId: 2, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
+			otherOrg := models.CreateAlertNotificationCommand{Name: "default", Type: "email", OrgId: 2, SendReminder: true, Frequency: "10s", Settings: simplejson.New()}
 
 			So(CreateAlertNotificationCommand(&cmd1), ShouldBeNil)
 			So(CreateAlertNotificationCommand(&cmd2), ShouldBeNil)
@@ -196,7 +271,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 			So(CreateAlertNotificationCommand(&otherOrg), ShouldBeNil)
 
 			Convey("search", func() {
-				query := &m.GetAlertNotificationsToSendQuery{
+				query := &models.GetAlertNotificationsToSendQuery{
 					Ids:   []int64{cmd1.Result.Id, cmd2.Result.Id, 112341231},
 					OrgId: 1,
 				}
@@ -207,7 +282,7 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 			})
 
 			Convey("all", func() {
-				query := &m.GetAllAlertNotificationsQuery{
+				query := &models.GetAllAlertNotificationsQuery{
 					OrgId: 1,
 				}
 

pkg/services/sqlstore/migrations/alert_mig.go

@@ -107,4 +107,27 @@ func addAlertMigrations(mg *Migrator) {
 
 	mg.AddMigration("create notification_journal table v1", NewAddTableMigration(notification_journal))
 	mg.AddMigration("add index notification_journal org_id & alert_id & notifier_id", NewAddIndexMigration(notification_journal, notification_journal.Indices[0]))
+
+	mg.AddMigration("drop alert_notification_journal", NewDropTableMigration("alert_notification_journal"))
+
+	alert_notification_state := Table{
+		Name: "alert_notification_state",
+		Columns: []*Column{
+			{Name: "id", Type: DB_BigInt, IsPrimaryKey: true, IsAutoIncrement: true},
+			{Name: "org_id", Type: DB_BigInt, Nullable: false},
+			{Name: "alert_id", Type: DB_BigInt, Nullable: false},
+			{Name: "notifier_id", Type: DB_BigInt, Nullable: false},
+			{Name: "state", Type: DB_NVarchar, Length: 50, Nullable: false},
+			{Name: "version", Type: DB_BigInt, Nullable: false},
+			{Name: "updated_at", Type: DB_BigInt, Nullable: false},
+			{Name: "alert_rule_state_updated_version", Type: DB_BigInt, Nullable: false},
+		},
+		Indices: []*Index{
+			{Cols: []string{"org_id", "alert_id", "notifier_id"}, Type: UniqueIndex},
+		},
+	}
+
+	mg.AddMigration("create alert_notification_state table v1", NewAddTableMigration(alert_notification_state))
+	mg.AddMigration("add index alert_notification_state org_id & alert_id & notifier_id",
+		NewAddIndexMigration(alert_notification_state, alert_notification_state.Indices[0]))
 }

pkg/services/sqlstore/migrator/dialect.go

@@ -44,6 +44,8 @@ type Dialect interface {
 
 	CleanDB() error
 	NoOpSql() string
+
+	IsUniqueConstraintViolation(err error) bool
 }
 
 func NewDialect(engine *xorm.Engine) Dialect {

pkg/services/sqlstore/migrator/mysql_dialect.go

@@ -5,6 +5,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/VividCortex/mysqlerr"
+	"github.com/go-sql-driver/mysql"
 	"github.com/go-xorm/xorm"
 )
 
@@ -125,3 +127,13 @@ func (db *Mysql) CleanDB() error {
 
 	return nil
 }
+
+func (db *Mysql) IsUniqueConstraintViolation(err error) bool {
+	if driverErr, ok := err.(*mysql.MySQLError); ok {
+		if driverErr.Number == mysqlerr.ER_DUP_ENTRY {
+			return true
+		}
+	}
+
+	return false
+}

pkg/services/sqlstore/migrator/postgres_dialect.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/go-xorm/xorm"
+	"github.com/lib/pq"
 )
 
 type Postgres struct {
@@ -136,3 +137,13 @@ func (db *Postgres) CleanDB() error {
 
 	return nil
 }
+
+func (db *Postgres) IsUniqueConstraintViolation(err error) bool {
+	if driverErr, ok := err.(*pq.Error); ok {
+		if driverErr.Code == "23505" {
+			return true
+		}
+	}
+
+	return false
+}

pkg/services/sqlstore/migrator/sqlite_dialect.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/go-xorm/xorm"
+	sqlite3 "github.com/mattn/go-sqlite3"
 )
 
 type Sqlite3 struct {
@@ -82,3 +83,13 @@ func (db *Sqlite3) DropIndexSql(tableName string, index *Index) string {
 func (db *Sqlite3) CleanDB() error {
 	return nil
 }
+
+func (db *Sqlite3) IsUniqueConstraintViolation(err error) bool {
+	if driverErr, ok := err.(sqlite3.Error); ok {
+		if driverErr.ExtendedCode == sqlite3.ErrConstraintUnique {
+			return true
+		}
+	}
+
+	return false
+}

vendor/github.com/VividCortex/mysqlerr/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 VividCortex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/VividCortex/mysqlerr/mysqlerr.go

@@ -0,0 +1,1080 @@
+package mysqlerr
+
+const (
+	ER_HASHCHK                                                                       = 1000
+	ER_NISAMCHK                                                                      = 1001
+	ER_NO                                                                            = 1002
+	ER_YES                                                                           = 1003
+	ER_CANT_CREATE_FILE                                                              = 1004
+	ER_CANT_CREATE_TABLE                                                             = 1005
+	ER_CANT_CREATE_DB                                                                = 1006
+	ER_DB_CREATE_EXISTS                                                              = 1007
+	ER_DB_DROP_EXISTS                                                                = 1008
+	ER_DB_DROP_DELETE                                                                = 1009
+	ER_DB_DROP_RMDIR                                                                 = 1010
+	ER_CANT_DELETE_FILE                                                              = 1011
+	ER_CANT_FIND_SYSTEM_REC                                                          = 1012
+	ER_CANT_GET_STAT                                                                 = 1013
+	ER_CANT_GET_WD                                                                   = 1014
+	ER_CANT_LOCK                                                                     = 1015
+	ER_CANT_OPEN_FILE                                                                = 1016
+	ER_FILE_NOT_FOUND                                                                = 1017
+	ER_CANT_READ_DIR                                                                 = 1018
+	ER_CANT_SET_WD                                                                   = 1019
+	ER_CHECKREAD                                                                     = 1020
+	ER_DISK_FULL                                                                     = 1021
+	ER_DUP_KEY                                                                       = 1022
+	ER_ERROR_ON_CLOSE                                                                = 1023
+	ER_ERROR_ON_READ                                                                 = 1024
+	ER_ERROR_ON_RENAME                                                               = 1025
+	ER_ERROR_ON_WRITE                                                                = 1026
+	ER_FILE_USED                                                                     = 1027
+	ER_FILSORT_ABORT                                                                 = 1028
+	ER_FORM_NOT_FOUND                                                                = 1029
+	ER_GET_ERRNO                                                                     = 1030
+	ER_ILLEGAL_HA                                                                    = 1031
+	ER_KEY_NOT_FOUND                                                                 = 1032
+	ER_NOT_FORM_FILE                                                                 = 1033
+	ER_NOT_KEYFILE                                                                   = 1034
+	ER_OLD_KEYFILE                                                                   = 1035
+	ER_OPEN_AS_READONLY                                                              = 1036
+	ER_OUTOFMEMORY                                                                   = 1037
+	ER_OUT_OF_SORTMEMORY                                                             = 1038
+	ER_UNEXPECTED_EOF                                                                = 1039
+	ER_CON_COUNT_ERROR                                                               = 1040
+	ER_OUT_OF_RESOURCES                                                              = 1041
+	ER_BAD_HOST_ERROR                                                                = 1042
+	ER_HANDSHAKE_ERROR                                                               = 1043
+	ER_DBACCESS_DENIED_ERROR                                                         = 1044
+	ER_ACCESS_DENIED_ERROR                                                           = 1045
+	ER_NO_DB_ERROR                                                                   = 1046
+	ER_UNKNOWN_COM_ERROR                                                             = 1047
+	ER_BAD_NULL_ERROR                                                                = 1048
+	ER_BAD_DB_ERROR                                                                  = 1049
+	ER_TABLE_EXISTS_ERROR                                                            = 1050
+	ER_BAD_TABLE_ERROR                                                               = 1051
+	ER_NON_UNIQ_ERROR                                                                = 1052
+	ER_SERVER_SHUTDOWN                                                               = 1053
+	ER_BAD_FIELD_ERROR                                                               = 1054
+	ER_WRONG_FIELD_WITH_GROUP                                                        = 1055
+	ER_WRONG_GROUP_FIELD                                                             = 1056
+	ER_WRONG_SUM_SELECT                                                              = 1057
+	ER_WRONG_VALUE_COUNT                                                             = 1058
+	ER_TOO_LONG_IDENT                                                                = 1059
+	ER_DUP_FIELDNAME                                                                 = 1060
+	ER_DUP_KEYNAME                                                                   = 1061
+	ER_DUP_ENTRY                                                                     = 1062
+	ER_WRONG_FIELD_SPEC                                                              = 1063
+	ER_PARSE_ERROR                                                                   = 1064
+	ER_EMPTY_QUERY                                                                   = 1065
+	ER_NONUNIQ_TABLE                                                                 = 1066
+	ER_INVALID_DEFAULT                                                               = 1067
+	ER_MULTIPLE_PRI_KEY                                                              = 1068
+	ER_TOO_MANY_KEYS                                                                 = 1069
+	ER_TOO_MANY_KEY_PARTS                                                            = 1070
+	ER_TOO_LONG_KEY                                                                  = 1071
+	ER_KEY_COLUMN_DOES_NOT_EXITS                                                     = 1072
+	ER_BLOB_USED_AS_KEY                                                              = 1073
+	ER_TOO_BIG_FIELDLENGTH                                                           = 1074
+	ER_WRONG_AUTO_KEY                                                                = 1075
+	ER_READY                                                                         = 1076
+	ER_NORMAL_SHUTDOWN                                                               = 1077
+	ER_GOT_SIGNAL                                                                    = 1078
+	ER_SHUTDOWN_COMPLETE                                                             = 1079
+	ER_FORCING_CLOSE                                                                 = 1080
+	ER_IPSOCK_ERROR                                                                  = 1081
+	ER_NO_SUCH_INDEX                                                                 = 1082
+	ER_WRONG_FIELD_TERMINATORS                                                       = 1083
+	ER_BLOBS_AND_NO_TERMINATED                                                       = 1084
+	ER_TEXTFILE_NOT_READABLE                                                         = 1085
+	ER_FILE_EXISTS_ERROR                                                             = 1086
+	ER_LOAD_INFO                                                                     = 1087
+	ER_ALTER_INFO                                                                    = 1088
+	ER_WRONG_SUB_KEY                                                                 = 1089
+	ER_CANT_REMOVE_ALL_FIELDS                                                        = 1090
+	ER_CANT_DROP_FIELD_OR_KEY                                                        = 1091
+	ER_INSERT_INFO                                                                   = 1092
+	ER_UPDATE_TABLE_USED                                                             = 1093
+	ER_NO_SUCH_THREAD                                                                = 1094
+	ER_KILL_DENIED_ERROR                                                             = 1095
+	ER_NO_TABLES_USED                                                                = 1096
+	ER_TOO_BIG_SET                                                                   = 1097
+	ER_NO_UNIQUE_LOGFILE                                                             = 1098
+	ER_TABLE_NOT_LOCKED_FOR_WRITE                                                    = 1099
+	ER_TABLE_NOT_LOCKED                                                              = 1100
+	ER_BLOB_CANT_HAVE_DEFAULT                                                        = 1101
+	ER_WRONG_DB_NAME                                                                 = 1102
+	ER_WRONG_TABLE_NAME                                                              = 1103
+	ER_TOO_BIG_SELECT                                                                = 1104
+	ER_UNKNOWN_ERROR                                                                 = 1105
+	ER_UNKNOWN_PROCEDURE                                                             = 1106
+	ER_WRONG_PARAMCOUNT_TO_PROCEDURE                                                 = 1107
+	ER_WRONG_PARAMETERS_TO_PROCEDURE                                                 = 1108
+	ER_UNKNOWN_TABLE                                                                 = 1109
+	ER_FIELD_SPECIFIED_TWICE                                                         = 1110
+	ER_INVALID_GROUP_FUNC_USE                                                        = 1111
+	ER_UNSUPPORTED_EXTENSION                                                         = 1112
+	ER_TABLE_MUST_HAVE_COLUMNS                                                       = 1113
+	ER_RECORD_FILE_FULL                                                              = 1114
+	ER_UNKNOWN_CHARACTER_SET                                                         = 1115
+	ER_TOO_MANY_TABLES                                                               = 1116
+	ER_TOO_MANY_FIELDS                                                               = 1117
+	ER_TOO_BIG_ROWSIZE                                                               = 1118
+	ER_STACK_OVERRUN                                                                 = 1119
+	ER_WRONG_OUTER_JOIN                                                              = 1120
+	ER_NULL_COLUMN_IN_INDEX                                                          = 1121
+	ER_CANT_FIND_UDF                                                                 = 1122
+	ER_CANT_INITIALIZE_UDF                                                           = 1123
+	ER_UDF_NO_PATHS                                                                  = 1124
+	ER_UDF_EXISTS                                                                    = 1125
+	ER_CANT_OPEN_LIBRARY                                                             = 1126
+	ER_CANT_FIND_DL_ENTRY                                                            = 1127
+	ER_FUNCTION_NOT_DEFINED                                                          = 1128
+	ER_HOST_IS_BLOCKED                                                               = 1129
+	ER_HOST_NOT_PRIVILEGED                                                           = 1130
+	ER_PASSWORD_ANONYMOUS_USER                                                       = 1131
+	ER_PASSWORD_NOT_ALLOWED                                                          = 1132
+	ER_PASSWORD_NO_MATCH                                                             = 1133
+	ER_UPDATE_INFO                                                                   = 1134
+	ER_CANT_CREATE_THREAD                                                            = 1135
+	ER_WRONG_VALUE_COUNT_ON_ROW                                                      = 1136
+	ER_CANT_REOPEN_TABLE                                                             = 1137
+	ER_INVALID_USE_OF_NULL                                                           = 1138
+	ER_REGEXP_ERROR                                                                  = 1139
+	ER_MIX_OF_GROUP_FUNC_AND_FIELDS                                                  = 1140
+	ER_NONEXISTING_GRANT                                                             = 1141
+	ER_TABLEACCESS_DENIED_ERROR                                                      = 1142
+	ER_COLUMNACCESS_DENIED_ERROR                                                     = 1143
+	ER_ILLEGAL_GRANT_FOR_TABLE                                                       = 1144
+	ER_GRANT_WRONG_HOST_OR_USER                                                      = 1145
+	ER_NO_SUCH_TABLE                                                                 = 1146
+	ER_NONEXISTING_TABLE_GRANT                                                       = 1147
+	ER_NOT_ALLOWED_COMMAND                                                           = 1148
+	ER_SYNTAX_ERROR                                                                  = 1149
+	ER_DELAYED_CANT_CHANGE_LOCK                                                      = 1150
+	ER_TOO_MANY_DELAYED_THREADS                                                      = 1151
+	ER_ABORTING_CONNECTION                                                           = 1152
+	ER_NET_PACKET_TOO_LARGE                                                          = 1153
+	ER_NET_READ_ERROR_FROM_PIPE                                                      = 1154
+	ER_NET_FCNTL_ERROR                                                               = 1155
+	ER_NET_PACKETS_OUT_OF_ORDER                                                      = 1156
+	ER_NET_UNCOMPRESS_ERROR                                                          = 1157
+	ER_NET_READ_ERROR                                                                = 1158
+	ER_NET_READ_INTERRUPTED                                                          = 1159
+	ER_NET_ERROR_ON_WRITE                                                            = 1160
+	ER_NET_WRITE_INTERRUPTED                                                         = 1161
+	ER_TOO_LONG_STRING                                                               = 1162
+	ER_TABLE_CANT_HANDLE_BLOB                                                        = 1163
+	ER_TABLE_CANT_HANDLE_AUTO_INCREMENT                                              = 1164
+	ER_DELAYED_INSERT_TABLE_LOCKED                                                   = 1165
+	ER_WRONG_COLUMN_NAME                                                             = 1166
+	ER_WRONG_KEY_COLUMN                                                              = 1167
+	ER_WRONG_MRG_TABLE                                                               = 1168
+	ER_DUP_UNIQUE                                                                    = 1169
+	ER_BLOB_KEY_WITHOUT_LENGTH                                                       = 1170
+	ER_PRIMARY_CANT_HAVE_NULL                                                        = 1171
+	ER_TOO_MANY_ROWS                                                                 = 1172
+	ER_REQUIRES_PRIMARY_KEY                                                          = 1173
+	ER_NO_RAID_COMPILED                                                              = 1174
+	ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE                                               = 1175
+	ER_KEY_DOES_NOT_EXITS                                                            = 1176
+	ER_CHECK_NO_SUCH_TABLE                                                           = 1177
+	ER_CHECK_NOT_IMPLEMENTED                                                         = 1178
+	ER_CANT_DO_THIS_DURING_AN_TRANSACTION                                            = 1179
+	ER_ERROR_DURING_COMMIT                                                           = 1180
+	ER_ERROR_DURING_ROLLBACK                                                         = 1181
+	ER_ERROR_DURING_FLUSH_LOGS                                                       = 1182
+	ER_ERROR_DURING_CHECKPOINT                                                       = 1183
+	ER_NEW_ABORTING_CONNECTION                                                       = 1184
+	ER_DUMP_NOT_IMPLEMENTED                                                          = 1185
+	ER_FLUSH_MASTER_BINLOG_CLOSED                                                    = 1186
+	ER_INDEX_REBUILD                                                                 = 1187
+	ER_MASTER                                                                        = 1188
+	ER_MASTER_NET_READ                                                               = 1189
+	ER_MASTER_NET_WRITE                                                              = 1190
+	ER_FT_MATCHING_KEY_NOT_FOUND                                                     = 1191
+	ER_LOCK_OR_ACTIVE_TRANSACTION                                                    = 1192
+	ER_UNKNOWN_SYSTEM_VARIABLE                                                       = 1193
+	ER_CRASHED_ON_USAGE                                                              = 1194
+	ER_CRASHED_ON_REPAIR                                                             = 1195
+	ER_WARNING_NOT_COMPLETE_ROLLBACK                                                 = 1196
+	ER_TRANS_CACHE_FULL                                                              = 1197
+	ER_SLAVE_MUST_STOP                                                               = 1198
+	ER_SLAVE_NOT_RUNNING                                                             = 1199
+	ER_BAD_SLAVE                                                                     = 1200
+	ER_MASTER_INFO                                                                   = 1201
+	ER_SLAVE_THREAD                                                                  = 1202
+	ER_TOO_MANY_USER_CONNECTIONS                                                     = 1203
+	ER_SET_CONSTANTS_ONLY                                                            = 1204
+	ER_LOCK_WAIT_TIMEOUT                                                             = 1205
+	ER_LOCK_TABLE_FULL                                                               = 1206
+	ER_READ_ONLY_TRANSACTION                                                         = 1207
+	ER_DROP_DB_WITH_READ_LOCK                                                        = 1208
+	ER_CREATE_DB_WITH_READ_LOCK                                                      = 1209
+	ER_WRONG_ARGUMENTS                                                               = 1210
+	ER_NO_PERMISSION_TO_CREATE_USER                                                  = 1211
+	ER_UNION_TABLES_IN_DIFFERENT_DIR                                                 = 1212
+	ER_LOCK_DEADLOCK                                                                 = 1213
+	ER_TABLE_CANT_HANDLE_FT                                                          = 1214
+	ER_CANNOT_ADD_FOREIGN                                                            = 1215
+	ER_NO_REFERENCED_ROW                                                             = 1216
+	ER_ROW_IS_REFERENCED                                                             = 1217
+	ER_CONNECT_TO_MASTER                                                             = 1218
+	ER_QUERY_ON_MASTER                                                               = 1219
+	ER_ERROR_WHEN_EXECUTING_COMMAND                                                  = 1220
+	ER_WRONG_USAGE                                                                   = 1221
+	ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT                                             = 1222
+	ER_CANT_UPDATE_WITH_READLOCK                                                     = 1223
+	ER_MIXING_NOT_ALLOWED                                                            = 1224
+	ER_DUP_ARGUMENT                                                                  = 1225
+	ER_USER_LIMIT_REACHED                                                            = 1226
+	ER_SPECIFIC_ACCESS_DENIED_ERROR                                                  = 1227
+	ER_LOCAL_VARIABLE                                                                = 1228
+	ER_GLOBAL_VARIABLE                                                               = 1229
+	ER_NO_DEFAULT                                                                    = 1230
+	ER_WRONG_VALUE_FOR_VAR                                                           = 1231
+	ER_WRONG_TYPE_FOR_VAR                                                            = 1232
+	ER_VAR_CANT_BE_READ                                                              = 1233
+	ER_CANT_USE_OPTION_HERE                                                          = 1234
+	ER_NOT_SUPPORTED_YET                                                             = 1235
+	ER_MASTER_FATAL_ERROR_READING_BINLOG                                             = 1236
+	ER_SLAVE_IGNORED_TABLE                                                           = 1237
+	ER_INCORRECT_GLOBAL_LOCAL_VAR                                                    = 1238
+	ER_WRONG_FK_DEF                                                                  = 1239
+	ER_KEY_REF_DO_NOT_MATCH_TABLE_REF                                                = 1240
+	ER_OPERAND_COLUMNS                                                               = 1241
+	ER_SUBQUERY_NO_1_ROW                                                             = 1242
+	ER_UNKNOWN_STMT_HANDLER                                                          = 1243
+	ER_CORRUPT_HELP_DB                                                               = 1244
+	ER_CYCLIC_REFERENCE                                                              = 1245
+	ER_AUTO_CONVERT                                                                  = 1246
+	ER_ILLEGAL_REFERENCE                                                             = 1247
+	ER_DERIVED_MUST_HAVE_ALIAS                                                       = 1248
+	ER_SELECT_REDUCED                                                                = 1249
+	ER_TABLENAME_NOT_ALLOWED_HERE                                                    = 1250
+	ER_NOT_SUPPORTED_AUTH_MODE                                                       = 1251
+	ER_SPATIAL_CANT_HAVE_NULL                                                        = 1252
+	ER_COLLATION_CHARSET_MISMATCH                                                    = 1253
+	ER_SLAVE_WAS_RUNNING                                                             = 1254
+	ER_SLAVE_WAS_NOT_RUNNING                                                         = 1255
+	ER_TOO_BIG_FOR_UNCOMPRESS                                                        = 1256
+	ER_ZLIB_Z_MEM_ERROR                                                              = 1257
+	ER_ZLIB_Z_BUF_ERROR                                                              = 1258
+	ER_ZLIB_Z_DATA_ERROR                                                             = 1259
+	ER_CUT_VALUE_GROUP_CONCAT                                                        = 1260
+	ER_WARN_TOO_FEW_RECORDS                                                          = 1261
+	ER_WARN_TOO_MANY_RECORDS                                                         = 1262
+	ER_WARN_NULL_TO_NOTNULL                                                          = 1263
+	ER_WARN_DATA_OUT_OF_RANGE                                                        = 1264
+	WARN_DATA_TRUNCATED                                                              = 1265
+	ER_WARN_USING_OTHER_HANDLER                                                      = 1266
+	ER_CANT_AGGREGATE_2COLLATIONS                                                    = 1267
+	ER_DROP_USER                                                                     = 1268
+	ER_REVOKE_GRANTS                                                                 = 1269
+	ER_CANT_AGGREGATE_3COLLATIONS                                                    = 1270
+	ER_CANT_AGGREGATE_NCOLLATIONS                                                    = 1271
+	ER_VARIABLE_IS_NOT_STRUCT                                                        = 1272
+	ER_UNKNOWN_COLLATION                                                             = 1273
+	ER_SLAVE_IGNORED_SSL_PARAMS                                                      = 1274
+	ER_SERVER_IS_IN_SECURE_AUTH_MODE                                                 = 1275
+	ER_WARN_FIELD_RESOLVED                                                           = 1276
+	ER_BAD_SLAVE_UNTIL_COND                                                          = 1277
+	ER_MISSING_SKIP_SLAVE                                                            = 1278
+	ER_UNTIL_COND_IGNORED                                                            = 1279
+	ER_WRONG_NAME_FOR_INDEX                                                          = 1280
+	ER_WRONG_NAME_FOR_CATALOG                                                        = 1281
+	ER_WARN_QC_RESIZE                                                                = 1282
+	ER_BAD_FT_COLUMN                                                                 = 1283
+	ER_UNKNOWN_KEY_CACHE                                                             = 1284
+	ER_WARN_HOSTNAME_WONT_WORK                                                       = 1285
+	ER_UNKNOWN_STORAGE_ENGINE                                                        = 1286
+	ER_WARN_DEPRECATED_SYNTAX                                                        = 1287
+	ER_NON_UPDATABLE_TABLE                                                           = 1288
+	ER_FEATURE_DISABLED                                                              = 1289
+	ER_OPTION_PREVENTS_STATEMENT                                                     = 1290
+	ER_DUPLICATED_VALUE_IN_TYPE                                                      = 1291
+	ER_TRUNCATED_WRONG_VALUE                                                         = 1292
+	ER_TOO_MUCH_AUTO_TIMESTAMP_COLS                                                  = 1293
+	ER_INVALID_ON_UPDATE                                                             = 1294
+	ER_UNSUPPORTED_PS                                                                = 1295
+	ER_GET_ERRMSG                                                                    = 1296
+	ER_GET_TEMPORARY_ERRMSG                                                          = 1297
+	ER_UNKNOWN_TIME_ZONE                                                             = 1298
+	ER_WARN_INVALID_TIMESTAMP                                                        = 1299
+	ER_INVALID_CHARACTER_STRING                                                      = 1300
+	ER_WARN_ALLOWED_PACKET_OVERFLOWED                                                = 1301
+	ER_CONFLICTING_DECLARATIONS                                                      = 1302
+	ER_SP_NO_RECURSIVE_CREATE                                                        = 1303
+	ER_SP_ALREADY_EXISTS                                                             = 1304
+	ER_SP_DOES_NOT_EXIST                                                             = 1305
+	ER_SP_DROP_FAILED                                                                = 1306
+	ER_SP_STORE_FAILED                                                               = 1307
+	ER_SP_LILABEL_MISMATCH                                                           = 1308
+	ER_SP_LABEL_REDEFINE                                                             = 1309
+	ER_SP_LABEL_MISMATCH                                                             = 1310
+	ER_SP_UNINIT_VAR                                                                 = 1311
+	ER_SP_BADSELECT                                                                  = 1312
+	ER_SP_BADRETURN                                                                  = 1313
+	ER_SP_BADSTATEMENT                                                               = 1314
+	ER_UPDATE_LOG_DEPRECATED_IGNORED                                                 = 1315
+	ER_UPDATE_LOG_DEPRECATED_TRANSLATED                                              = 1316
+	ER_QUERY_INTERRUPTED                                                             = 1317
+	ER_SP_WRONG_NO_OF_ARGS                                                           = 1318
+	ER_SP_COND_MISMATCH                                                              = 1319
+	ER_SP_NORETURN                                                                   = 1320
+	ER_SP_NORETURNEND                                                                = 1321
+	ER_SP_BAD_CURSOR_QUERY                                                           = 1322
+	ER_SP_BAD_CURSOR_SELECT                                                          = 1323
+	ER_SP_CURSOR_MISMATCH                                                            = 1324
+	ER_SP_CURSOR_ALREADY_OPEN                                                        = 1325
+	ER_SP_CURSOR_NOT_OPEN                                                            = 1326
+	ER_SP_UNDECLARED_VAR                                                             = 1327
+	ER_SP_WRONG_NO_OF_FETCH_ARGS                                                     = 1328
+	ER_SP_FETCH_NO_DATA                                                              = 1329
+	ER_SP_DUP_PARAM                                                                  = 1330
+	ER_SP_DUP_VAR                                                                    = 1331
+	ER_SP_DUP_COND                                                                   = 1332
+	ER_SP_DUP_CURS                                                                   = 1333
+	ER_SP_CANT_ALTER                                                                 = 1334
+	ER_SP_SUBSELECT_NYI                                                              = 1335
+	ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG                                                 = 1336
+	ER_SP_VARCOND_AFTER_CURSHNDLR                                                    = 1337
+	ER_SP_CURSOR_AFTER_HANDLER                                                       = 1338
+	ER_SP_CASE_NOT_FOUND                                                             = 1339
+	ER_FPARSER_TOO_BIG_FILE                                                          = 1340
+	ER_FPARSER_BAD_HEADER                                                            = 1341
+	ER_FPARSER_EOF_IN_COMMENT                                                        = 1342
+	ER_FPARSER_ERROR_IN_PARAMETER                                                    = 1343
+	ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER                                              = 1344
+	ER_VIEW_NO_EXPLAIN                                                               = 1345
+	ER_FRM_UNKNOWN_TYPE                                                              = 1346
+	ER_WRONG_OBJECT                                                                  = 1347
+	ER_NONUPDATEABLE_COLUMN                                                          = 1348
+	ER_VIEW_SELECT_DERIVED                                                           = 1349
+	ER_VIEW_SELECT_CLAUSE                                                            = 1350
+	ER_VIEW_SELECT_VARIABLE                                                          = 1351
+	ER_VIEW_SELECT_TMPTABLE                                                          = 1352
+	ER_VIEW_WRONG_LIST                                                               = 1353
+	ER_WARN_VIEW_MERGE                                                               = 1354
+	ER_WARN_VIEW_WITHOUT_KEY                                                         = 1355
+	ER_VIEW_INVALID                                                                  = 1356
+	ER_SP_NO_DROP_SP                                                                 = 1357
+	ER_SP_GOTO_IN_HNDLR                                                              = 1358
+	ER_TRG_ALREADY_EXISTS                                                            = 1359
+	ER_TRG_DOES_NOT_EXIST                                                            = 1360
+	ER_TRG_ON_VIEW_OR_TEMP_TABLE                                                     = 1361
+	ER_TRG_CANT_CHANGE_ROW                                                           = 1362
+	ER_TRG_NO_SUCH_ROW_IN_TRG                                                        = 1363
+	ER_NO_DEFAULT_FOR_FIELD                                                          = 1364
+	ER_DIVISION_BY_ZERO                                                              = 1365
+	ER_TRUNCATED_WRONG_VALUE_FOR_FIELD                                               = 1366
+	ER_ILLEGAL_VALUE_FOR_TYPE                                                        = 1367
+	ER_VIEW_NONUPD_CHECK                                                             = 1368
+	ER_VIEW_CHECK_FAILED                                                             = 1369
+	ER_PROCACCESS_DENIED_ERROR                                                       = 1370
+	ER_RELAY_LOG_FAIL                                                                = 1371
+	ER_PASSWD_LENGTH                                                                 = 1372
+	ER_UNKNOWN_TARGET_BINLOG                                                         = 1373
+	ER_IO_ERR_LOG_INDEX_READ                                                         = 1374
+	ER_BINLOG_PURGE_PROHIBITED                                                       = 1375
+	ER_FSEEK_FAIL                                                                    = 1376
+	ER_BINLOG_PURGE_FATAL_ERR                                                        = 1377
+	ER_LOG_IN_USE                                                                    = 1378
+	ER_LOG_PURGE_UNKNOWN_ERR                                                         = 1379
+	ER_RELAY_LOG_INIT                                                                = 1380
+	ER_NO_BINARY_LOGGING                                                             = 1381
+	ER_RESERVED_SYNTAX                                                               = 1382
+	ER_WSAS_FAILED                                                                   = 1383
+	ER_DIFF_GROUPS_PROC                                                              = 1384
+	ER_NO_GROUP_FOR_PROC                                                             = 1385
+	ER_ORDER_WITH_PROC                                                               = 1386
+	ER_LOGGING_PROHIBIT_CHANGING_OF                                                  = 1387
+	ER_NO_FILE_MAPPING                                                               = 1388
+	ER_WRONG_MAGIC                                                                   = 1389
+	ER_PS_MANY_PARAM                                                                 = 1390
+	ER_KEY_PART_0                                                                    = 1391
+	ER_VIEW_CHECKSUM                                                                 = 1392
+	ER_VIEW_MULTIUPDATE                                                              = 1393
+	ER_VIEW_NO_INSERT_FIELD_LIST                                                     = 1394
+	ER_VIEW_DELETE_MERGE_VIEW                                                        = 1395
+	ER_CANNOT_USER                                                                   = 1396
+	ER_XAER_NOTA                                                                     = 1397
+	ER_XAER_INVAL                                                                    = 1398
+	ER_XAER_RMFAIL                                                                   = 1399
+	ER_XAER_OUTSIDE                                                                  = 1400
+	ER_XAER_RMERR                                                                    = 1401
+	ER_XA_RBROLLBACK                                                                 = 1402
+	ER_NONEXISTING_PROC_GRANT                                                        = 1403
+	ER_PROC_AUTO_GRANT_FAIL                                                          = 1404
+	ER_PROC_AUTO_REVOKE_FAIL                                                         = 1405
+	ER_DATA_TOO_LONG                                                                 = 1406
+	ER_SP_BAD_SQLSTATE                                                               = 1407
+	ER_STARTUP                                                                       = 1408
+	ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR                                              = 1409
+	ER_CANT_CREATE_USER_WITH_GRANT                                                   = 1410
+	ER_WRONG_VALUE_FOR_TYPE                                                          = 1411
+	ER_TABLE_DEF_CHANGED                                                             = 1412
+	ER_SP_DUP_HANDLER                                                                = 1413
+	ER_SP_NOT_VAR_ARG                                                                = 1414
+	ER_SP_NO_RETSET                                                                  = 1415
+	ER_CANT_CREATE_GEOMETRY_OBJECT                                                   = 1416
+	ER_FAILED_ROUTINE_BREAK_BINLOG                                                   = 1417
+	ER_BINLOG_UNSAFE_ROUTINE                                                         = 1418
+	ER_BINLOG_CREATE_ROUTINE_NEED_SUPER                                              = 1419
+	ER_EXEC_STMT_WITH_OPEN_CURSOR                                                    = 1420
+	ER_STMT_HAS_NO_OPEN_CURSOR                                                       = 1421
+	ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG                                               = 1422
+	ER_NO_DEFAULT_FOR_VIEW_FIELD                                                     = 1423
+	ER_SP_NO_RECURSION                                                               = 1424
+	ER_TOO_BIG_SCALE                                                                 = 1425
+	ER_TOO_BIG_PRECISION                                                             = 1426
+	ER_M_BIGGER_THAN_D                                                               = 1427
+	ER_WRONG_LOCK_OF_SYSTEM_TABLE                                                    = 1428
+	ER_CONNECT_TO_FOREIGN_DATA_SOURCE                                                = 1429
+	ER_QUERY_ON_FOREIGN_DATA_SOURCE                                                  = 1430
+	ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST                                              = 1431
+	ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE                                       = 1432
+	ER_FOREIGN_DATA_STRING_INVALID                                                   = 1433
+	ER_CANT_CREATE_FEDERATED_TABLE                                                   = 1434
+	ER_TRG_IN_WRONG_SCHEMA                                                           = 1435
+	ER_STACK_OVERRUN_NEED_MORE                                                       = 1436
+	ER_TOO_LONG_BODY                                                                 = 1437
+	ER_WARN_CANT_DROP_DEFAULT_KEYCACHE                                               = 1438
+	ER_TOO_BIG_DISPLAYWIDTH                                                          = 1439
+	ER_XAER_DUPID                                                                    = 1440
+	ER_DATETIME_FUNCTION_OVERFLOW                                                    = 1441
+	ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG                                           = 1442
+	ER_VIEW_PREVENT_UPDATE                                                           = 1443
+	ER_PS_NO_RECURSION                                                               = 1444
+	ER_SP_CANT_SET_AUTOCOMMIT                                                        = 1445
+	ER_MALFORMED_DEFINER                                                             = 1446
+	ER_VIEW_FRM_NO_USER                                                              = 1447
+	ER_VIEW_OTHER_USER                                                               = 1448
+	ER_NO_SUCH_USER                                                                  = 1449
+	ER_FORBID_SCHEMA_CHANGE                                                          = 1450
+	ER_ROW_IS_REFERENCED_2                                                           = 1451
+	ER_NO_REFERENCED_ROW_2                                                           = 1452
+	ER_SP_BAD_VAR_SHADOW                                                             = 1453
+	ER_TRG_NO_DEFINER                                                                = 1454
+	ER_OLD_FILE_FORMAT                                                               = 1455
+	ER_SP_RECURSION_LIMIT                                                            = 1456
+	ER_SP_PROC_TABLE_CORRUPT                                                         = 1457
+	ER_SP_WRONG_NAME                                                                 = 1458
+	ER_TABLE_NEEDS_UPGRADE                                                           = 1459
+	ER_SP_NO_AGGREGATE                                                               = 1460
+	ER_MAX_PREPARED_STMT_COUNT_REACHED                                               = 1461
+	ER_VIEW_RECURSIVE                                                                = 1462
+	ER_NON_GROUPING_FIELD_USED                                                       = 1463
+	ER_TABLE_CANT_HANDLE_SPKEYS                                                      = 1464
+	ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA                                                  = 1465
+	ER_REMOVED_SPACES                                                                = 1466
+	ER_AUTOINC_READ_FAILED                                                           = 1467
+	ER_USERNAME                                                                      = 1468
+	ER_HOSTNAME                                                                      = 1469
+	ER_WRONG_STRING_LENGTH                                                           = 1470
+	ER_NON_INSERTABLE_TABLE                                                          = 1471
+	ER_ADMIN_WRONG_MRG_TABLE                                                         = 1472
+	ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT                                          = 1473
+	ER_NAME_BECOMES_EMPTY                                                            = 1474
+	ER_AMBIGUOUS_FIELD_TERM                                                          = 1475
+	ER_FOREIGN_SERVER_EXISTS                                                         = 1476
+	ER_FOREIGN_SERVER_DOESNT_EXIST                                                   = 1477
+	ER_ILLEGAL_HA_CREATE_OPTION                                                      = 1478
+	ER_PARTITION_REQUIRES_VALUES_ERROR                                               = 1479
+	ER_PARTITION_WRONG_VALUES_ERROR                                                  = 1480
+	ER_PARTITION_MAXVALUE_ERROR                                                      = 1481
+	ER_PARTITION_SUBPARTITION_ERROR                                                  = 1482
+	ER_PARTITION_SUBPART_MIX_ERROR                                                   = 1483
+	ER_PARTITION_WRONG_NO_PART_ERROR                                                 = 1484
+	ER_PARTITION_WRONG_NO_SUBPART_ERROR                                              = 1485
+	ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR                                            = 1486
+	ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR                                          = 1487
+	ER_FIELD_NOT_FOUND_PART_ERROR                                                    = 1488
+	ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR                                             = 1489
+	ER_INCONSISTENT_PARTITION_INFO_ERROR                                             = 1490
+	ER_PARTITION_FUNC_NOT_ALLOWED_ERROR                                              = 1491
+	ER_PARTITIONS_MUST_BE_DEFINED_ERROR                                              = 1492
+	ER_RANGE_NOT_INCREASING_ERROR                                                    = 1493
+	ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR                                          = 1494
+	ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR                                         = 1495
+	ER_PARTITION_ENTRY_ERROR                                                         = 1496
+	ER_MIX_HANDLER_ERROR                                                             = 1497
+	ER_PARTITION_NOT_DEFINED_ERROR                                                   = 1498
+	ER_TOO_MANY_PARTITIONS_ERROR                                                     = 1499
+	ER_SUBPARTITION_ERROR                                                            = 1500
+	ER_CANT_CREATE_HANDLER_FILE                                                      = 1501
+	ER_BLOB_FIELD_IN_PART_FUNC_ERROR                                                 = 1502
+	ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF                                              = 1503
+	ER_NO_PARTS_ERROR                                                                = 1504
+	ER_PARTITION_MGMT_ON_NONPARTITIONED                                              = 1505
+	ER_FOREIGN_KEY_ON_PARTITIONED                                                    = 1506
+	ER_DROP_PARTITION_NON_EXISTENT                                                   = 1507
+	ER_DROP_LAST_PARTITION                                                           = 1508
+	ER_COALESCE_ONLY_ON_HASH_PARTITION                                               = 1509
+	ER_REORG_HASH_ONLY_ON_SAME_NO                                                    = 1510
+	ER_REORG_NO_PARAM_ERROR                                                          = 1511
+	ER_ONLY_ON_RANGE_LIST_PARTITION                                                  = 1512
+	ER_ADD_PARTITION_SUBPART_ERROR                                                   = 1513
+	ER_ADD_PARTITION_NO_NEW_PARTITION                                                = 1514
+	ER_COALESCE_PARTITION_NO_PARTITION                                               = 1515
+	ER_REORG_PARTITION_NOT_EXIST                                                     = 1516
+	ER_SAME_NAME_PARTITION                                                           = 1517
+	ER_NO_BINLOG_ERROR                                                               = 1518
+	ER_CONSECUTIVE_REORG_PARTITIONS                                                  = 1519
+	ER_REORG_OUTSIDE_RANGE                                                           = 1520
+	ER_PARTITION_FUNCTION_FAILURE                                                    = 1521
+	ER_PART_STATE_ERROR                                                              = 1522
+	ER_LIMITED_PART_RANGE                                                            = 1523
+	ER_PLUGIN_IS_NOT_LOADED                                                          = 1524
+	ER_WRONG_VALUE                                                                   = 1525
+	ER_NO_PARTITION_FOR_GIVEN_VALUE                                                  = 1526
+	ER_FILEGROUP_OPTION_ONLY_ONCE                                                    = 1527
+	ER_CREATE_FILEGROUP_FAILED                                                       = 1528
+	ER_DROP_FILEGROUP_FAILED                                                         = 1529
+	ER_TABLESPACE_AUTO_EXTEND_ERROR                                                  = 1530
+	ER_WRONG_SIZE_NUMBER                                                             = 1531
+	ER_SIZE_OVERFLOW_ERROR                                                           = 1532
+	ER_ALTER_FILEGROUP_FAILED                                                        = 1533
+	ER_BINLOG_ROW_LOGGING_FAILED                                                     = 1534
+	ER_BINLOG_ROW_WRONG_TABLE_DEF                                                    = 1535
+	ER_BINLOG_ROW_RBR_TO_SBR                                                         = 1536
+	ER_EVENT_ALREADY_EXISTS                                                          = 1537
+	ER_EVENT_STORE_FAILED                                                            = 1538
+	ER_EVENT_DOES_NOT_EXIST                                                          = 1539
+	ER_EVENT_CANT_ALTER                                                              = 1540
+	ER_EVENT_DROP_FAILED                                                             = 1541
+	ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG                                        = 1542
+	ER_EVENT_ENDS_BEFORE_STARTS                                                      = 1543
+	ER_EVENT_EXEC_TIME_IN_THE_PAST                                                   = 1544
+	ER_EVENT_OPEN_TABLE_FAILED                                                       = 1545
+	ER_EVENT_NEITHER_M_EXPR_NOR_M_AT                                                 = 1546
+	ER_OBSOLETE_COL_COUNT_DOESNT_MATCH_CORRUPTED                                     = 1547
+	ER_OBSOLETE_CANNOT_LOAD_FROM_TABLE                                               = 1548
+	ER_EVENT_CANNOT_DELETE                                                           = 1549
+	ER_EVENT_COMPILE_ERROR                                                           = 1550
+	ER_EVENT_SAME_NAME                                                               = 1551
+	ER_EVENT_DATA_TOO_LONG                                                           = 1552
+	ER_DROP_INDEX_FK                                                                 = 1553
+	ER_WARN_DEPRECATED_SYNTAX_WITH_VER                                               = 1554
+	ER_CANT_WRITE_LOCK_LOG_TABLE                                                     = 1555
+	ER_CANT_LOCK_LOG_TABLE                                                           = 1556
+	ER_FOREIGN_DUPLICATE_KEY_OLD_UNUSED                                              = 1557
+	ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE                                          = 1558
+	ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR                                         = 1559
+	ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT                                 = 1560
+	ER_NDB_CANT_SWITCH_BINLOG_FORMAT                                                 = 1561
+	ER_PARTITION_NO_TEMPORARY                                                        = 1562
+	ER_PARTITION_CONST_DOMAIN_ERROR                                                  = 1563
+	ER_PARTITION_FUNCTION_IS_NOT_ALLOWED                                             = 1564
+	ER_DDL_LOG_ERROR                                                                 = 1565
+	ER_NULL_IN_VALUES_LESS_THAN                                                      = 1566
+	ER_WRONG_PARTITION_NAME                                                          = 1567
+	ER_CANT_CHANGE_TX_CHARACTERISTICS                                                = 1568
+	ER_DUP_ENTRY_AUTOINCREMENT_CASE                                                  = 1569
+	ER_EVENT_MODIFY_QUEUE_ERROR                                                      = 1570
+	ER_EVENT_SET_VAR_ERROR                                                           = 1571
+	ER_PARTITION_MERGE_ERROR                                                         = 1572
+	ER_CANT_ACTIVATE_LOG                                                             = 1573
+	ER_RBR_NOT_AVAILABLE                                                             = 1574
+	ER_BASE64_DECODE_ERROR                                                           = 1575
+	ER_EVENT_RECURSION_FORBIDDEN                                                     = 1576
+	ER_EVENTS_DB_ERROR                                                               = 1577
+	ER_ONLY_INTEGERS_ALLOWED                                                         = 1578
+	ER_UNSUPORTED_LOG_ENGINE                                                         = 1579
+	ER_BAD_LOG_STATEMENT                                                             = 1580
+	ER_CANT_RENAME_LOG_TABLE                                                         = 1581
+	ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT                                                = 1582
+	ER_WRONG_PARAMETERS_TO_NATIVE_FCT                                                = 1583
+	ER_WRONG_PARAMETERS_TO_STORED_FCT                                                = 1584
+	ER_NATIVE_FCT_NAME_COLLISION                                                     = 1585
+	ER_DUP_ENTRY_WITH_KEY_NAME                                                       = 1586
+	ER_BINLOG_PURGE_EMFILE                                                           = 1587
+	ER_EVENT_CANNOT_CREATE_IN_THE_PAST                                               = 1588
+	ER_EVENT_CANNOT_ALTER_IN_THE_PAST                                                = 1589
+	ER_SLAVE_INCIDENT                                                                = 1590
+	ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT                                           = 1591
+	ER_BINLOG_UNSAFE_STATEMENT                                                       = 1592
+	ER_SLAVE_FATAL_ERROR                                                             = 1593
+	ER_SLAVE_RELAY_LOG_READ_FAILURE                                                  = 1594
+	ER_SLAVE_RELAY_LOG_WRITE_FAILURE                                                 = 1595
+	ER_SLAVE_CREATE_EVENT_FAILURE                                                    = 1596
+	ER_SLAVE_MASTER_COM_FAILURE                                                      = 1597
+	ER_BINLOG_LOGGING_IMPOSSIBLE                                                     = 1598
+	ER_VIEW_NO_CREATION_CTX                                                          = 1599
+	ER_VIEW_INVALID_CREATION_CTX                                                     = 1600
+	ER_SR_INVALID_CREATION_CTX                                                       = 1601
+	ER_TRG_CORRUPTED_FILE                                                            = 1602
+	ER_TRG_NO_CREATION_CTX                                                           = 1603
+	ER_TRG_INVALID_CREATION_CTX                                                      = 1604
+	ER_EVENT_INVALID_CREATION_CTX                                                    = 1605
+	ER_TRG_CANT_OPEN_TABLE                                                           = 1606
+	ER_CANT_CREATE_SROUTINE                                                          = 1607
+	ER_NEVER_USED                                                                    = 1608
+	ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT                           = 1609
+	ER_SLAVE_CORRUPT_EVENT                                                           = 1610
+	ER_LOAD_DATA_INVALID_COLUMN_UNUSED                                               = 1611
+	ER_LOG_PURGE_NO_FILE                                                             = 1612
+	ER_XA_RBTIMEOUT                                                                  = 1613
+	ER_XA_RBDEADLOCK                                                                 = 1614
+	ER_NEED_REPREPARE                                                                = 1615
+	ER_DELAYED_NOT_SUPPORTED                                                         = 1616
+	WARN_NO_MASTER_INFO                                                              = 1617
+	WARN_OPTION_IGNORED                                                              = 1618
+	ER_PLUGIN_DELETE_BUILTIN                                                         = 1619
+	WARN_PLUGIN_BUSY                                                                 = 1620
+	ER_VARIABLE_IS_READONLY                                                          = 1621
+	ER_WARN_ENGINE_TRANSACTION_ROLLBACK                                              = 1622
+	ER_SLAVE_HEARTBEAT_FAILURE                                                       = 1623
+	ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE                                            = 1624
+	ER_NDB_REPLICATION_SCHEMA_ERROR                                                  = 1625
+	ER_CONFLICT_FN_PARSE_ERROR                                                       = 1626
+	ER_EXCEPTIONS_WRITE_ERROR                                                        = 1627
+	ER_TOO_LONG_TABLE_COMMENT                                                        = 1628
+	ER_TOO_LONG_FIELD_COMMENT                                                        = 1629
+	ER_FUNC_INEXISTENT_NAME_COLLISION                                                = 1630
+	ER_DATABASE_NAME                                                                 = 1631
+	ER_TABLE_NAME                                                                    = 1632
+	ER_PARTITION_NAME                                                                = 1633
+	ER_SUBPARTITION_NAME                                                             = 1634
+	ER_TEMPORARY_NAME                                                                = 1635
+	ER_RENAMED_NAME                                                                  = 1636
+	ER_TOO_MANY_CONCURRENT_TRXS                                                      = 1637
+	WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED                                         = 1638
+	ER_DEBUG_SYNC_TIMEOUT                                                            = 1639
+	ER_DEBUG_SYNC_HIT_LIMIT                                                          = 1640
+	ER_DUP_SIGNAL_SET                                                                = 1641
+	ER_SIGNAL_WARN                                                                   = 1642
+	ER_SIGNAL_NOT_FOUND                                                              = 1643
+	ER_SIGNAL_EXCEPTION                                                              = 1644
+	ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER                                               = 1645
+	ER_SIGNAL_BAD_CONDITION_TYPE                                                     = 1646
+	WARN_COND_ITEM_TRUNCATED                                                         = 1647
+	ER_COND_ITEM_TOO_LONG                                                            = 1648
+	ER_UNKNOWN_LOCALE                                                                = 1649
+	ER_SLAVE_IGNORE_SERVER_IDS                                                       = 1650
+	ER_QUERY_CACHE_DISABLED                                                          = 1651
+	ER_SAME_NAME_PARTITION_FIELD                                                     = 1652
+	ER_PARTITION_COLUMN_LIST_ERROR                                                   = 1653
+	ER_WRONG_TYPE_COLUMN_VALUE_ERROR                                                 = 1654
+	ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR                                          = 1655
+	ER_MAXVALUE_IN_VALUES_IN                                                         = 1656
+	ER_TOO_MANY_VALUES_ERROR                                                         = 1657
+	ER_ROW_SINGLE_PARTITION_FIELD_ERROR                                              = 1658
+	ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD                                     = 1659
+	ER_PARTITION_FIELDS_TOO_LONG                                                     = 1660
+	ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE                                             = 1661
+	ER_BINLOG_ROW_MODE_AND_STMT_ENGINE                                               = 1662
+	ER_BINLOG_UNSAFE_AND_STMT_ENGINE                                                 = 1663
+	ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE                                          = 1664
+	ER_BINLOG_STMT_MODE_AND_ROW_ENGINE                                               = 1665
+	ER_BINLOG_ROW_INJECTION_AND_STMT_MODE                                            = 1666
+	ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE                               = 1667
+	ER_BINLOG_UNSAFE_LIMIT                                                           = 1668
+	ER_UNUSED4                                                                       = 1669
+	ER_BINLOG_UNSAFE_SYSTEM_TABLE                                                    = 1670
+	ER_BINLOG_UNSAFE_AUTOINC_COLUMNS                                                 = 1671
+	ER_BINLOG_UNSAFE_UDF                                                             = 1672
+	ER_BINLOG_UNSAFE_SYSTEM_VARIABLE                                                 = 1673
+	ER_BINLOG_UNSAFE_SYSTEM_FUNCTION                                                 = 1674
+	ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS                                            = 1675
+	ER_MESSAGE_AND_STATEMENT                                                         = 1676
+	ER_SLAVE_CONVERSION_FAILED                                                       = 1677
+	ER_SLAVE_CANT_CREATE_CONVERSION                                                  = 1678
+	ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT                              = 1679
+	ER_PATH_LENGTH                                                                   = 1680
+	ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT                                         = 1681
+	ER_WRONG_NATIVE_TABLE_STRUCTURE                                                  = 1682
+	ER_WRONG_PERFSCHEMA_USAGE                                                        = 1683
+	ER_WARN_I_S_SKIPPED_TABLE                                                        = 1684
+	ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT                              = 1685
+	ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT                                 = 1686
+	ER_SPATIAL_MUST_HAVE_GEOM_COL                                                    = 1687
+	ER_TOO_LONG_INDEX_COMMENT                                                        = 1688
+	ER_LOCK_ABORTED                                                                  = 1689
+	ER_DATA_OUT_OF_RANGE                                                             = 1690
+	ER_WRONG_SPVAR_TYPE_IN_LIMIT                                                     = 1691
+	ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE                        = 1692
+	ER_BINLOG_UNSAFE_MIXED_STATEMENT                                                 = 1693
+	ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN                                = 1694
+	ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN                                   = 1695
+	ER_FAILED_READ_FROM_PAR_FILE                                                     = 1696
+	ER_VALUES_IS_NOT_INT_TYPE_ERROR                                                  = 1697
+	ER_ACCESS_DENIED_NO_PASSWORD_ERROR                                               = 1698
+	ER_SET_PASSWORD_AUTH_PLUGIN                                                      = 1699
+	ER_GRANT_PLUGIN_USER_EXISTS                                                      = 1700
+	ER_TRUNCATE_ILLEGAL_FK                                                           = 1701
+	ER_PLUGIN_IS_PERMANENT                                                           = 1702
+	ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN                                        = 1703
+	ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX                                        = 1704
+	ER_STMT_CACHE_FULL                                                               = 1705
+	ER_MULTI_UPDATE_KEY_CONFLICT                                                     = 1706
+	ER_TABLE_NEEDS_REBUILD                                                           = 1707
+	WARN_OPTION_BELOW_LIMIT                                                          = 1708
+	ER_INDEX_COLUMN_TOO_LONG                                                         = 1709
+	ER_ERROR_IN_TRIGGER_BODY                                                         = 1710
+	ER_ERROR_IN_UNKNOWN_TRIGGER_BODY                                                 = 1711
+	ER_INDEX_CORRUPT                                                                 = 1712
+	ER_UNDO_RECORD_TOO_BIG                                                           = 1713
+	ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT                                            = 1714
+	ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE                                            = 1715
+	ER_BINLOG_UNSAFE_REPLACE_SELECT                                                  = 1716
+	ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT                                            = 1717
+	ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT                                           = 1718
+	ER_BINLOG_UNSAFE_UPDATE_IGNORE                                                   = 1719
+	ER_PLUGIN_NO_UNINSTALL                                                           = 1720
+	ER_PLUGIN_NO_INSTALL                                                             = 1721
+	ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT                                            = 1722
+	ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC                                           = 1723
+	ER_BINLOG_UNSAFE_INSERT_TWO_KEYS                                                 = 1724
+	ER_TABLE_IN_FK_CHECK                                                             = 1725
+	ER_UNSUPPORTED_ENGINE                                                            = 1726
+	ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST                                               = 1727
+	ER_CANNOT_LOAD_FROM_TABLE_V2                                                     = 1728
+	ER_MASTER_DELAY_VALUE_OUT_OF_RANGE                                               = 1729
+	ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT                            = 1730
+	ER_PARTITION_EXCHANGE_DIFFERENT_OPTION                                           = 1731
+	ER_PARTITION_EXCHANGE_PART_TABLE                                                 = 1732
+	ER_PARTITION_EXCHANGE_TEMP_TABLE                                                 = 1733
+	ER_PARTITION_INSTEAD_OF_SUBPARTITION                                             = 1734
+	ER_UNKNOWN_PARTITION                                                             = 1735
+	ER_TABLES_DIFFERENT_METADATA                                                     = 1736
+	ER_ROW_DOES_NOT_MATCH_PARTITION                                                  = 1737
+	ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX                                            = 1738
+	ER_WARN_INDEX_NOT_APPLICABLE                                                     = 1739
+	ER_PARTITION_EXCHANGE_FOREIGN_KEY                                                = 1740
+	ER_NO_SUCH_KEY_VALUE                                                             = 1741
+	ER_RPL_INFO_DATA_TOO_LONG                                                        = 1742
+	ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE                                           = 1743
+	ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE                                            = 1744
+	ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX                                       = 1745
+	ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT                                      = 1746
+	ER_PARTITION_CLAUSE_ON_NONPARTITIONED                                            = 1747
+	ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET                                        = 1748
+	ER_NO_SUCH_PARTITION__UNUSED                                                     = 1749
+	ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE                                            = 1750
+	ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE                         = 1751
+	ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE                         = 1752
+	ER_MTS_FEATURE_IS_NOT_SUPPORTED                                                  = 1753
+	ER_MTS_UPDATED_DBS_GREATER_MAX                                                   = 1754
+	ER_MTS_CANT_PARALLEL                                                             = 1755
+	ER_MTS_INCONSISTENT_DATA                                                         = 1756
+	ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING                                      = 1757
+	ER_DA_INVALID_CONDITION_NUMBER                                                   = 1758
+	ER_INSECURE_PLAIN_TEXT                                                           = 1759
+	ER_INSECURE_CHANGE_MASTER                                                        = 1760
+	ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO                                         = 1761
+	ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO                                      = 1762
+	ER_SQLTHREAD_WITH_SECURE_SLAVE                                                   = 1763
+	ER_TABLE_HAS_NO_FT                                                               = 1764
+	ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER                                        = 1765
+	ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION                                          = 1766
+	ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST                                            = 1767
+	ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION                                          = 1768
+	ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION                                          = 1769
+	ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL                     = 1770
+	ER_SKIPPING_LOGGED_TRANSACTION                                                   = 1771
+	ER_MALFORMED_GTID_SET_SPECIFICATION                                              = 1772
+	ER_MALFORMED_GTID_SET_ENCODING                                                   = 1773
+	ER_MALFORMED_GTID_SPECIFICATION                                                  = 1774
+	ER_GNO_EXHAUSTED                                                                 = 1775
+	ER_BAD_SLAVE_AUTO_POSITION                                                       = 1776
+	ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF                                      = 1777
+	ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET                          = 1778
+	ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON                             = 1779
+	ER_GTID_MODE_REQUIRES_BINLOG                                                     = 1780
+	ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF                              = 1781
+	ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON                          = 1782
+	ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF                     = 1783
+	ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF__UNUSED                                = 1784
+	ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE                                           = 1785
+	ER_GTID_UNSAFE_CREATE_SELECT                                                     = 1786
+	ER_GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION                        = 1787
+	ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME                                  = 1788
+	ER_MASTER_HAS_PURGED_REQUIRED_GTIDS                                              = 1789
+	ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID                                           = 1790
+	ER_UNKNOWN_EXPLAIN_FORMAT                                                        = 1791
+	ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION                                         = 1792
+	ER_TOO_LONG_TABLE_PARTITION_COMMENT                                              = 1793
+	ER_SLAVE_CONFIGURATION                                                           = 1794
+	ER_INNODB_FT_LIMIT                                                               = 1795
+	ER_INNODB_NO_FT_TEMP_TABLE                                                       = 1796
+	ER_INNODB_FT_WRONG_DOCID_COLUMN                                                  = 1797
+	ER_INNODB_FT_WRONG_DOCID_INDEX                                                   = 1798
+	ER_INNODB_ONLINE_LOG_TOO_BIG                                                     = 1799
+	ER_UNKNOWN_ALTER_ALGORITHM                                                       = 1800
+	ER_UNKNOWN_ALTER_LOCK                                                            = 1801
+	ER_MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS                                          = 1802
+	ER_MTS_RECOVERY_FAILURE                                                          = 1803
+	ER_MTS_RESET_WORKERS                                                             = 1804
+	ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2                                           = 1805
+	ER_SLAVE_SILENT_RETRY_TRANSACTION                                                = 1806
+	ER_DISCARD_FK_CHECKS_RUNNING                                                     = 1807
+	ER_TABLE_SCHEMA_MISMATCH                                                         = 1808
+	ER_TABLE_IN_SYSTEM_TABLESPACE                                                    = 1809
+	ER_IO_READ_ERROR                                                                 = 1810
+	ER_IO_WRITE_ERROR                                                                = 1811
+	ER_TABLESPACE_MISSING                                                            = 1812
+	ER_TABLESPACE_EXISTS                                                             = 1813
+	ER_TABLESPACE_DISCARDED                                                          = 1814
+	ER_INTERNAL_ERROR                                                                = 1815
+	ER_INNODB_IMPORT_ERROR                                                           = 1816
+	ER_INNODB_INDEX_CORRUPT                                                          = 1817
+	ER_INVALID_YEAR_COLUMN_LENGTH                                                    = 1818
+	ER_NOT_VALID_PASSWORD                                                            = 1819
+	ER_MUST_CHANGE_PASSWORD                                                          = 1820
+	ER_FK_NO_INDEX_CHILD                                                             = 1821
+	ER_FK_NO_INDEX_PARENT                                                            = 1822
+	ER_FK_FAIL_ADD_SYSTEM                                                            = 1823
+	ER_FK_CANNOT_OPEN_PARENT                                                         = 1824
+	ER_FK_INCORRECT_OPTION                                                           = 1825
+	ER_FK_DUP_NAME                                                                   = 1826
+	ER_PASSWORD_FORMAT                                                               = 1827
+	ER_FK_COLUMN_CANNOT_DROP                                                         = 1828
+	ER_FK_COLUMN_CANNOT_DROP_CHILD                                                   = 1829
+	ER_FK_COLUMN_NOT_NULL                                                            = 1830
+	ER_DUP_INDEX                                                                     = 1831
+	ER_FK_COLUMN_CANNOT_CHANGE                                                       = 1832
+	ER_FK_COLUMN_CANNOT_CHANGE_CHILD                                                 = 1833
+	ER_UNUSED5                                                                       = 1834
+	ER_MALFORMED_PACKET                                                              = 1835
+	ER_READ_ONLY_MODE                                                                = 1836
+	ER_GTID_NEXT_TYPE_UNDEFINED_GROUP                                                = 1837
+	ER_VARIABLE_NOT_SETTABLE_IN_SP                                                   = 1838
+	ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF                                    = 1839
+	ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY                          = 1840
+	ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY                            = 1841
+	ER_GTID_PURGED_WAS_CHANGED                                                       = 1842
+	ER_GTID_EXECUTED_WAS_CHANGED                                                     = 1843
+	ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES                                           = 1844
+	ER_ALTER_OPERATION_NOT_SUPPORTED                                                 = 1845
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON                                          = 1846
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY                                     = 1847
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION                                = 1848
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME                                = 1849
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE                              = 1850
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK                                 = 1851
+	ER_UNUSED6                                                                       = 1852
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK                                     = 1853
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC                                  = 1854
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS                               = 1855
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS                               = 1856
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS                                      = 1857
+	ER_SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE                              = 1858
+	ER_DUP_UNKNOWN_IN_INDEX                                                          = 1859
+	ER_IDENT_CAUSES_TOO_LONG_PATH                                                    = 1860
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL                                 = 1861
+	ER_MUST_CHANGE_PASSWORD_LOGIN                                                    = 1862
+	ER_ROW_IN_WRONG_PARTITION                                                        = 1863
+	ER_MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX                                        = 1864
+	ER_INNODB_NO_FT_USES_PARSER                                                      = 1865
+	ER_BINLOG_LOGICAL_CORRUPTION                                                     = 1866
+	ER_WARN_PURGE_LOG_IN_USE                                                         = 1867
+	ER_WARN_PURGE_LOG_IS_ACTIVE                                                      = 1868
+	ER_AUTO_INCREMENT_CONFLICT                                                       = 1869
+	WARN_ON_BLOCKHOLE_IN_RBR                                                         = 1870
+	ER_SLAVE_MI_INIT_REPOSITORY                                                      = 1871
+	ER_SLAVE_RLI_INIT_REPOSITORY                                                     = 1872
+	ER_ACCESS_DENIED_CHANGE_USER_ERROR                                               = 1873
+	ER_INNODB_READ_ONLY                                                              = 1874
+	ER_STOP_SLAVE_SQL_THREAD_TIMEOUT                                                 = 1875
+	ER_STOP_SLAVE_IO_THREAD_TIMEOUT                                                  = 1876
+	ER_TABLE_CORRUPT                                                                 = 1877
+	ER_TEMP_FILE_WRITE_FAILURE                                                       = 1878
+	ER_INNODB_FT_AUX_NOT_HEX_ID                                                      = 1879
+	ER_OLD_TEMPORALS_UPGRADED                                                        = 1880
+	ER_INNODB_FORCED_RECOVERY                                                        = 1881
+	ER_AES_INVALID_IV                                                                = 1882
+	ER_PLUGIN_CANNOT_BE_UNINSTALLED                                                  = 1883
+	ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_GTID_GROUP                        = 1884
+	ER_SLAVE_HAS_MORE_GTIDS_THAN_MASTER                                              = 1885
+	ER_FILE_CORRUPT                                                                  = 3000
+	ER_ERROR_ON_MASTER                                                               = 3001
+	ER_INCONSISTENT_ERROR                                                            = 3002
+	ER_STORAGE_ENGINE_NOT_LOADED                                                     = 3003
+	ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER                                         = 3004
+	ER_WARN_LEGACY_SYNTAX_CONVERTED                                                  = 3005
+	ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN                                                 = 3006
+	ER_CANNOT_DISCARD_TEMPORARY_TABLE                                                = 3007
+	ER_FK_DEPTH_EXCEEDED                                                             = 3008
+	ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2                                       = 3009
+	ER_WARN_TRIGGER_DOESNT_HAVE_CREATED                                              = 3010
+	ER_REFERENCED_TRG_DOES_NOT_EXIST                                                 = 3011
+	ER_EXPLAIN_NOT_SUPPORTED                                                         = 3012
+	ER_INVALID_FIELD_SIZE                                                            = 3013
+	ER_MISSING_HA_CREATE_OPTION                                                      = 3014
+	ER_ENGINE_OUT_OF_MEMORY                                                          = 3015
+	ER_PASSWORD_EXPIRE_ANONYMOUS_USER                                                = 3016
+	ER_SLAVE_SQL_THREAD_MUST_STOP                                                    = 3017
+	ER_NO_FT_MATERIALIZED_SUBQUERY                                                   = 3018
+	ER_INNODB_UNDO_LOG_FULL                                                          = 3019
+	ER_INVALID_ARGUMENT_FOR_LOGARITHM                                                = 3020
+	ER_SLAVE_CHANNEL_IO_THREAD_MUST_STOP                                             = 3021
+	ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO                                            = 3022
+	ER_WARN_ONLY_MASTER_LOG_FILE_NO_POS                                              = 3023
+	ER_QUERY_TIMEOUT                                                                 = 3024
+	ER_NON_RO_SELECT_DISABLE_TIMER                                                   = 3025
+	ER_DUP_LIST_ENTRY                                                                = 3026
+	ER_SQL_MODE_NO_EFFECT                                                            = 3027
+	ER_AGGREGATE_ORDER_FOR_UNION                                                     = 3028
+	ER_AGGREGATE_ORDER_NON_AGG_QUERY                                                 = 3029
+	ER_SLAVE_WORKER_STOPPED_PREVIOUS_THD_ERROR                                       = 3030
+	ER_DONT_SUPPORT_SLAVE_PRESERVE_COMMIT_ORDER                                      = 3031
+	ER_SERVER_OFFLINE_MODE                                                           = 3032
+	ER_GIS_DIFFERENT_SRIDS                                                           = 3033
+	ER_GIS_UNSUPPORTED_ARGUMENT                                                      = 3034
+	ER_GIS_UNKNOWN_ERROR                                                             = 3035
+	ER_GIS_UNKNOWN_EXCEPTION                                                         = 3036
+	ER_GIS_INVALID_DATA                                                              = 3037
+	ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION                                          = 3038
+	ER_BOOST_GEOMETRY_CENTROID_EXCEPTION                                             = 3039
+	ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION                                = 3040
+	ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION                                            = 3041
+	ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION                              = 3042
+	ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION                                              = 3043
+	ER_STD_BAD_ALLOC_ERROR                                                           = 3044
+	ER_STD_DOMAIN_ERROR                                                              = 3045
+	ER_STD_LENGTH_ERROR                                                              = 3046
+	ER_STD_INVALID_ARGUMENT                                                          = 3047
+	ER_STD_OUT_OF_RANGE_ERROR                                                        = 3048
+	ER_STD_OVERFLOW_ERROR                                                            = 3049
+	ER_STD_RANGE_ERROR                                                               = 3050
+	ER_STD_UNDERFLOW_ERROR                                                           = 3051
+	ER_STD_LOGIC_ERROR                                                               = 3052
+	ER_STD_RUNTIME_ERROR                                                             = 3053
+	ER_STD_UNKNOWN_EXCEPTION                                                         = 3054
+	ER_GIS_DATA_WRONG_ENDIANESS                                                      = 3055
+	ER_CHANGE_MASTER_PASSWORD_LENGTH                                                 = 3056
+	ER_USER_LOCK_WRONG_NAME                                                          = 3057
+	ER_USER_LOCK_DEADLOCK                                                            = 3058
+	ER_REPLACE_INACCESSIBLE_ROWS                                                     = 3059
+	ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS                                      = 3060
+	ER_ILLEGAL_USER_VAR                                                              = 3061
+	ER_GTID_MODE_OFF                                                                 = 3062
+	ER_UNSUPPORTED_BY_REPLICATION_THREAD                                             = 3063
+	ER_INCORRECT_TYPE                                                                = 3064
+	ER_FIELD_IN_ORDER_NOT_SELECT                                                     = 3065
+	ER_AGGREGATE_IN_ORDER_NOT_SELECT                                                 = 3066
+	ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN                                         = 3067
+	ER_NET_OK_PACKET_TOO_LARGE                                                       = 3068
+	ER_INVALID_JSON_DATA                                                             = 3069
+	ER_INVALID_GEOJSON_MISSING_MEMBER                                                = 3070
+	ER_INVALID_GEOJSON_WRONG_TYPE                                                    = 3071
+	ER_INVALID_GEOJSON_UNSPECIFIED                                                   = 3072
+	ER_DIMENSION_UNSUPPORTED                                                         = 3073
+	ER_SLAVE_CHANNEL_DOES_NOT_EXIST                                                  = 3074
+	ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT                                             = 3075
+	ER_SLAVE_CHANNEL_NAME_INVALID_OR_TOO_LONG                                        = 3076
+	ER_SLAVE_NEW_CHANNEL_WRONG_REPOSITORY                                            = 3077
+	ER_SLAVE_CHANNEL_DELETE                                                          = 3078
+	ER_SLAVE_MULTIPLE_CHANNELS_CMD                                                   = 3079
+	ER_SLAVE_MAX_CHANNELS_EXCEEDED                                                   = 3080
+	ER_SLAVE_CHANNEL_MUST_STOP                                                       = 3081
+	ER_SLAVE_CHANNEL_NOT_RUNNING                                                     = 3082
+	ER_SLAVE_CHANNEL_WAS_RUNNING                                                     = 3083
+	ER_SLAVE_CHANNEL_WAS_NOT_RUNNING                                                 = 3084
+	ER_SLAVE_CHANNEL_SQL_THREAD_MUST_STOP                                            = 3085
+	ER_SLAVE_CHANNEL_SQL_SKIP_COUNTER                                                = 3086
+	ER_WRONG_FIELD_WITH_GROUP_V2                                                     = 3087
+	ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2                                               = 3088
+	ER_WARN_DEPRECATED_SYSVAR_UPDATE                                                 = 3089
+	ER_WARN_DEPRECATED_SQLMODE                                                       = 3090
+	ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID                                    = 3091
+	ER_GROUP_REPLICATION_CONFIGURATION                                               = 3092
+	ER_GROUP_REPLICATION_RUNNING                                                     = 3093
+	ER_GROUP_REPLICATION_APPLIER_INIT_ERROR                                          = 3094
+	ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT                                 = 3095
+	ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR                           = 3096
+	ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR                              = 3097
+	ER_BEFORE_DML_VALIDATION_ERROR                                                   = 3098
+	ER_PREVENTS_VARIABLE_WITHOUT_RBR                                                 = 3099
+	ER_RUN_HOOK_ERROR                                                                = 3100
+	ER_TRANSACTION_ROLLBACK_DURING_COMMIT                                            = 3101
+	ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED                                      = 3102
+	ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN                                   = 3103
+	ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN                                          = 3104
+	ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN                                        = 3105
+	ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN                                        = 3106
+	ER_GENERATED_COLUMN_NON_PRIOR                                                    = 3107
+	ER_DEPENDENT_BY_GENERATED_COLUMN                                                 = 3108
+	ER_GENERATED_COLUMN_REF_AUTO_INC                                                 = 3109
+	ER_FEATURE_NOT_AVAILABLE                                                         = 3110
+	ER_CANT_SET_GTID_MODE                                                            = 3111
+	ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF                                     = 3112
+	ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION                                   = 3113
+	ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON                                    = 3114
+	ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF                                        = 3115
+	ER_CANT_SET_ENFORCE_GTID_CONSISTENCY_ON_WITH_ONGOING_GTID_VIOLATING_TRANSACTIONS = 3116
+	ER_SET_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TRANSACTIONS    = 3117
+	ER_ACCOUNT_HAS_BEEN_LOCKED                                                       = 3118
+	ER_WRONG_TABLESPACE_NAME                                                         = 3119
+	ER_TABLESPACE_IS_NOT_EMPTY                                                       = 3120
+	ER_WRONG_FILE_NAME                                                               = 3121
+	ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION                                   = 3122
+	ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR                                              = 3123
+	ER_WARN_BAD_MAX_EXECUTION_TIME                                                   = 3124
+	ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME                                           = 3125
+	ER_WARN_CONFLICTING_HINT                                                         = 3126
+	ER_WARN_UNKNOWN_QB_NAME                                                          = 3127
+	ER_UNRESOLVED_HINT_NAME                                                          = 3128
+	ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE                                         = 3129
+	ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED                                      = 3130
+	ER_LOCKING_SERVICE_WRONG_NAME                                                    = 3131
+	ER_LOCKING_SERVICE_DEADLOCK                                                      = 3132
+	ER_LOCKING_SERVICE_TIMEOUT                                                       = 3133
+	ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED                                         = 3134
+	ER_SQL_MODE_MERGED                                                               = 3135
+	ER_VTOKEN_PLUGIN_TOKEN_MISMATCH                                                  = 3136
+	ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND                                                 = 3137
+	ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID                                            = 3138
+	ER_SLAVE_CHANNEL_OPERATION_NOT_ALLOWED                                           = 3139
+	ER_INVALID_JSON_TEXT                                                             = 3140
+	ER_INVALID_JSON_TEXT_IN_PARAM                                                    = 3141
+	ER_INVALID_JSON_BINARY_DATA                                                      = 3142
+	ER_INVALID_JSON_PATH                                                             = 3143
+	ER_INVALID_JSON_CHARSET                                                          = 3144
+	ER_INVALID_JSON_CHARSET_IN_FUNCTION                                              = 3145
+	ER_INVALID_TYPE_FOR_JSON                                                         = 3146
+	ER_INVALID_CAST_TO_JSON                                                          = 3147
+	ER_INVALID_JSON_PATH_CHARSET                                                     = 3148
+	ER_INVALID_JSON_PATH_WILDCARD                                                    = 3149
+	ER_JSON_VALUE_TOO_BIG                                                            = 3150
+	ER_JSON_KEY_TOO_BIG                                                              = 3151
+	ER_JSON_USED_AS_KEY                                                              = 3152
+	ER_JSON_VACUOUS_PATH                                                             = 3153
+	ER_JSON_BAD_ONE_OR_ALL_ARG                                                       = 3154
+	ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE                                               = 3155
+	ER_INVALID_JSON_VALUE_FOR_CAST                                                   = 3156
+	ER_JSON_DOCUMENT_TOO_DEEP                                                        = 3157
+	ER_JSON_DOCUMENT_NULL_KEY                                                        = 3158
+	ER_SECURE_TRANSPORT_REQUIRED                                                     = 3159
+	ER_NO_SECURE_TRANSPORTS_CONFIGURED                                               = 3160
+	ER_DISABLED_STORAGE_ENGINE                                                       = 3161
+	ER_USER_DOES_NOT_EXIST                                                           = 3162
+	ER_USER_ALREADY_EXISTS                                                           = 3163
+	ER_AUDIT_API_ABORT                                                               = 3164
+	ER_INVALID_JSON_PATH_ARRAY_CELL                                                  = 3165
+	ER_BUFPOOL_RESIZE_INPROGRESS                                                     = 3166
+	ER_FEATURE_DISABLED_SEE_DOC                                                      = 3167
+	ER_SERVER_ISNT_AVAILABLE                                                         = 3168
+	ER_SESSION_WAS_KILLED                                                            = 3169
+	ER_CAPACITY_EXCEEDED                                                             = 3170
+	ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER                                          = 3171
+	ER_TABLE_NEEDS_UPG_PART                                                          = 3172
+	ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID                           = 3173
+	ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL                                           = 3174
+	ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT                                        = 3175
+	ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE                                        = 3176
+	ER_LOCK_REFUSED_BY_ENGINE                                                        = 3177
+	ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN                                    = 3178
+	ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE                                       = 3179
+	ER_MASTER_KEY_ROTATION_ERROR_BY_SE                                               = 3180
+	ER_MASTER_KEY_ROTATION_BINLOG_FAILED                                             = 3181
+	ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE                                            = 3182
+	ER_TABLESPACE_CANNOT_ENCRYPT                                                     = 3183
+	ER_INVALID_ENCRYPTION_OPTION                                                     = 3184
+	ER_CANNOT_FIND_KEY_IN_KEYRING                                                    = 3185
+	ER_CAPACITY_EXCEEDED_IN_PARSER                                                   = 3186
+	ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE                                          = 3187
+	ER_KEYRING_UDF_KEYRING_SERVICE_ERROR                                             = 3188
+	ER_USER_COLUMN_OLD_LENGTH                                                        = 3189
+)