enhanced error handling

Author: adranwit

io/errx/errors.go

@@ -0,0 +1,136 @@
+package errx
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+var (
+	// ErrMissingIdentity indicates SQL generation/execution cannot proceed because
+	// identity (primary key) columns were not detected.
+	ErrMissingIdentity = errors.New("missing identity")
+
+	// ErrDuplicateKey indicates an insert/update violated a unique constraint.
+	// Note: many drivers return opaque error types; use IsDuplicateKey to detect.
+	ErrDuplicateKey = errors.New("duplicate key")
+
+	// ErrConstraint indicates a generic constraint violation (FK/CK/NOT NULL/etc).
+	ErrConstraint = errors.New("constraint violation")
+)
+
+// Error carries structured context while remaining compatible with errors.Is().
+type Error struct {
+	Kind          error
+	Op            string
+	Table         string
+	Columns       []string
+	IdentityIndex int
+	Cause         error
+}
+
+func (e *Error) Error() string {
+	sb := &strings.Builder{}
+	sb.WriteString("sqlx")
+	if e.Op != "" {
+		sb.WriteString(" ")
+		sb.WriteString(e.Op)
+	}
+	sb.WriteString(": ")
+	if e.Kind != nil {
+		sb.WriteString(e.Kind.Error())
+	} else {
+		sb.WriteString("error")
+	}
+	if e.Table != "" {
+		sb.WriteString(" table=")
+		sb.WriteString(e.Table)
+	}
+	if e.IdentityIndex != 0 {
+		sb.WriteString(fmt.Sprintf(" identityIndex=%d", e.IdentityIndex))
+	}
+	if len(e.Columns) > 0 {
+		sb.WriteString(" columns=[")
+		sb.WriteString(strings.Join(e.Columns, ","))
+		sb.WriteString("]")
+	}
+	if e.Cause != nil {
+		sb.WriteString(": ")
+		sb.WriteString(e.Cause.Error())
+	}
+	return sb.String()
+}
+
+func (e *Error) Unwrap() error { return e.Cause }
+
+func (e *Error) Is(target error) bool {
+	if target == nil {
+		return false
+	}
+	if e.Kind != nil && target == e.Kind {
+		return true
+	}
+	if e.Cause != nil {
+		return errors.Is(e.Cause, target)
+	}
+	return false
+}
+
+func MissingIdentity(op, table string, columns []string, identityIndex int) error {
+	return &Error{
+		Kind:          ErrMissingIdentity,
+		Op:            op,
+		Table:         table,
+		Columns:       columns,
+		IdentityIndex: identityIndex,
+	}
+}
+
+func DuplicateKey(op, table string, cause error) error {
+	return &Error{
+		Kind:  ErrDuplicateKey,
+		Op:    op,
+		Table: table,
+		Cause: cause,
+	}
+}
+
+func Constraint(op, table string, cause error) error {
+	return &Error{
+		Kind:  ErrConstraint,
+		Op:    op,
+		Table: table,
+		Cause: cause,
+	}
+}
+
+func IsMissingIdentity(err error) bool { return errors.Is(err, ErrMissingIdentity) }
+
+func IsDuplicateKey(err error) bool {
+	if errors.Is(err, ErrDuplicateKey) {
+		return true
+	}
+	msg := strings.ToLower(errString(err))
+	return strings.Contains(msg, "unique constraint") ||
+		strings.Contains(msg, "duplicate key") ||
+		strings.Contains(msg, "duplicate entry")
+}
+
+func IsConstraint(err error) bool {
+	if errors.Is(err, ErrConstraint) {
+		return true
+	}
+	msg := strings.ToLower(errString(err))
+	return strings.Contains(msg, "constraint failed") ||
+		strings.Contains(msg, "violates") ||
+		strings.Contains(msg, "not null constraint") ||
+		strings.Contains(msg, "foreign key constraint") ||
+		strings.Contains(msg, "check constraint")
+}
+
+func errString(err error) string {
+	if err == nil {
+		return ""
+	}
+	return err.Error()
+}

io/errx/errors_test.go

@@ -0,0 +1,29 @@
+package errx
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestIsDuplicateKey(t *testing.T) {
+	if !IsDuplicateKey(errors.New("constraint failed: UNIQUE constraint failed: user_oauth_token.user_id, user_oauth_token.provider (1555)")) {
+		t.Fatalf("expected duplicate key match")
+	}
+}
+
+func TestIsConstraint(t *testing.T) {
+	if !IsConstraint(errors.New("constraint failed: NOT NULL constraint failed: foo.bar (1299)")) {
+		t.Fatalf("expected constraint match")
+	}
+}
+
+func TestWrappedErrors_Is(t *testing.T) {
+	dup := DuplicateKey("insert", "foo", errors.New("duplicate key value violates unique constraint"))
+	if !errors.Is(dup, ErrDuplicateKey) {
+		t.Fatalf("expected errors.Is(ErrDuplicateKey)")
+	}
+	missing := MissingIdentity("update", "foo", []string{"c1", "c2"}, 0)
+	if !errors.Is(missing, ErrMissingIdentity) {
+		t.Fatalf("expected errors.Is(ErrMissingIdentity)")
+	}
+}

io/insert/session.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"github.com/viant/sqlx/io"
 	"github.com/viant/sqlx/io/config"
+	"github.com/viant/sqlx/io/errx"
 	"github.com/viant/sqlx/metadata/info/dialect"
 	"github.com/viant/sqlx/metadata/sink"
 	"github.com/viant/sqlx/option"
@@ -163,6 +164,12 @@ func (s *session) flush(ctx context.Context, values []interface{}, identities []
 	}
 	result, err := s.stmt.ExecContext(ctx, values...)
 	if err != nil {
+		if errx.IsDuplicateKey(err) {
+			return 0, 0, errx.DuplicateKey("insert", s.TableName, err)
+		}
+		if errx.IsConstraint(err) {
+			return 0, 0, errx.Constraint("insert", s.TableName, err)
+		}
 		return 0, 0, err
 	}
 
@@ -197,6 +204,12 @@ func (s *session) flushQuery(ctx context.Context, values []interface{}, identiti
 	var rowsAffected, newLastInsertedID int64
 	rows, err := s.stmt.QueryContext(ctx, values...)
 	if err != nil {
+		if errx.IsDuplicateKey(err) {
+			return 0, 0, errx.DuplicateKey("insert", s.TableName, err)
+		}
+		if errx.IsConstraint(err) {
+			return 0, 0, errx.Constraint("insert", s.TableName, err)
+		}
 		return 0, 0, err
 	}
 	defer io.RunWithError(rows.Close, &err)

io/read/reader.go

@@ -352,7 +352,7 @@ func (r *Reader) ensureStmt(ctx context.Context) error {
 		fmt.Println(r.query)
 	}
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to prepare context: %w", err)
 	}
 
 	r.stmt = stmt

io/update/service_test.go

@@ -337,3 +337,60 @@ outer:
 		assertly.AssertValues(t, actual, testCase.expect)
 	}
 }
+
+func TestService_Exec_CompositePK(t *testing.T) {
+	type SocialToken struct {
+		UserID   string `sqlx:"user_id,primaryKey" validate:"required"`
+		Provider string `sqlx:"provider,primaryKey" validate:"required"`
+		EncToken string `sqlx:"enc_token" validate:"required"`
+	}
+
+	description := "Update with composite primary key"
+	driver := "sqlite3"
+	dsn := "/tmp/sqllite.db"
+	table := "social_tokens"
+
+	initSQL := []string{
+		"DROP TABLE IF EXISTS social_tokens",
+		`CREATE TABLE social_tokens (
+user_id TEXT NOT NULL,
+provider TEXT NOT NULL,
+enc_token TEXT,
+PRIMARY KEY (user_id, provider)
+)`,
+		`INSERT INTO social_tokens (user_id, provider, enc_token) VALUES ('u1','google','old-token')`,
+		`INSERT INTO social_tokens (user_id, provider, enc_token) VALUES ('u1','github','keep-me')`,
+	}
+
+	db, err := sql.Open(driver, dsn)
+	if !assert.Nil(t, err, description) {
+		return
+	}
+	for _, SQL := range initSQL {
+		_, err := db.Exec(SQL)
+		if !assert.Nil(t, err, description) {
+			return
+		}
+	}
+
+	updater, err := update.New(context.TODO(), db, table)
+	if !assert.Nil(t, err, description) {
+		return
+	}
+
+	rec := &SocialToken{UserID: "u1", Provider: "google", EncToken: "new-token"}
+	affected, err := updater.Exec(context.TODO(), []interface{}{rec})
+	assert.Nil(t, err, description)
+	assert.EqualValues(t, 1, affected, description)
+
+	// Verify targeted row updated
+	var enc string
+	err = db.QueryRow(`SELECT enc_token FROM social_tokens WHERE user_id = ? AND provider = ?`, "u1", "google").Scan(&enc)
+	assert.Nil(t, err, description)
+	assert.Equal(t, "new-token", enc, description)
+
+	// Verify other row with same user but different provider unchanged
+	err = db.QueryRow(`SELECT enc_token FROM social_tokens WHERE user_id = ? AND provider = ?`, "u1", "github").Scan(&enc)
+	assert.Nil(t, err, description)
+	assert.Equal(t, "keep-me", enc, description)
+}

io/update/session.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"github.com/viant/sqlx/io"
 	"github.com/viant/sqlx/io/config"
+	"github.com/viant/sqlx/io/errx"
 	"github.com/viant/sqlx/option"
 	"reflect"
 )
@@ -91,6 +92,12 @@ func (s *session) update(ctx context.Context, record interface{}) (int64, error)
 	placeholders = s.setMarker.Placeholders(record, placeholders)
 	result, err := s.stmt.ExecContext(ctx, placeholders...)
 	if err != nil {
+		if errx.IsDuplicateKey(err) {
+			return 0, errx.DuplicateKey("update", s.TableName, err)
+		}
+		if errx.IsConstraint(err) {
+			return 0, errx.Constraint("update", s.TableName, err)
+		}
 		return 0, err
 	}
 	affected, _ := result.RowsAffected()

io/update/sql.go

@@ -3,6 +3,7 @@ package update
 import (
 	"bytes"
 	"fmt"
+	"github.com/viant/sqlx/io/errx"
 	"github.com/viant/sqlx/metadata/info"
 	"github.com/viant/sqlx/option"
 	"github.com/viant/xunsafe"
@@ -55,7 +56,7 @@ func NewBuilder(table string, columns []string, identityIndex int, dialect *info
 		return nil, fmt.Errorf("columns were empty")
 	}
 	if identityIndex <= 0 {
-		return nil, fmt.Errorf("identity index was empty")
+		return nil, errx.MissingIdentity("update", table, columns, identityIndex)
 	}
 	var fragments = make([]string, len(columns))
 	getter := dialect.PlaceholderGetter()

io/update/sql_test.go

@@ -1,7 +1,9 @@
 package update
 
 import (
+	"errors"
 	"github.com/stretchr/testify/assert"
+	"github.com/viant/sqlx/io/errx"
 	"github.com/viant/sqlx/metadata/info"
 	"testing"
 )
@@ -36,3 +38,10 @@ func TestUpdate_Build(t *testing.T) {
 	}
 
 }
+
+func TestUpdate_NewBuilder_MissingIdentity(t *testing.T) {
+	builder, err := NewBuilder("foo", []string{"c1", "c2"}, 0, &info.Dialect{Placeholder: "?"})
+	assert.Nil(t, builder)
+	assert.True(t, errors.Is(err, errx.ErrMissingIdentity))
+	assert.True(t, errx.IsMissingIdentity(err))
+}