gateway_engine.go

package orm

import (
	"context"
	"fmt"
	"reflect"
	"strings"

	"github.com/go-openapi/inflect"
	"github.com/phogolabs/orm/dialect"
	"github.com/phogolabs/orm/dialect/sql"
	"github.com/phogolabs/orm/dialect/sql/scan"
	"github.com/phogolabs/prana/sqlexec"
)

var _ Querier = &engine{}

type engine struct {
	provider *sqlexec.Provider
	querier  dialect.ExecQuerier
	dialect  string
}

// All executes the query and returns a list of entities.
func (g *engine) All(ctx context.Context, q sql.Querier, v interface{}) error {
	rows, err := g.Query(ctx, q)
	if err != nil {
		return err
	}
	// close the rows
	defer rows.Close()

	// scan the rows into the target
	if err := scan.Rows(rows, v); err != nil {
		return g.wrap(err)
	}

	// if the query supports scannable interface
	if scanner, ok := q.(scan.Readable); ok {
		return scanner.Scan(v)
	}

	return nil
}

// Only returns the only entity in the query, returns an error if not
// exactly one entity was returned.
func (g *engine) Only(ctx context.Context, q sql.Querier, v interface{}) error {
	rows, err := g.Query(ctx, q)
	if err != nil {
		return err
	}
	// close the rows
	defer rows.Close()

	// scan the rows into the target
	err = scan.Row(rows, v)

	switch {
	case err == sql.ErrNoRows:
		return &NotFoundError{nameOf(reflect.TypeOf(v))}
	case err == scan.ErrOneRow:
		return &NotSingularError{nameOf(reflect.TypeOf(v))}
	default:
		return g.wrap(err)
	}
}

// First returns the first entity in the query. Returns *NotFoundError
// when no user was found.
func (g *engine) First(ctx context.Context, q sql.Querier, v interface{}) error {
	rows, err := g.Query(ctx, q)
	if err != nil {
		return g.wrap(err)
	}
	// close the rows
	defer rows.Close()

	// scan the rows into the target
	err = scan.Row(rows, v)

	switch {
	case err == sql.ErrNoRows:
		return &NotFoundError{nameOf(reflect.TypeOf(v))}
	case err == scan.ErrOneRow:
		return nil
	default:
		return g.wrap(err)
	}
}

// Query executes a query that returns rows, typically a SELECT in SQL.
// It scans the result into the pointer v. In SQL, you it's usually *sql.Rows.
func (g *engine) Query(ctx context.Context, q sql.Querier) (*sql.Rows, error) {
	// compile the query prior to execution
	query, params, err := g.compile(q)
	if err != nil {
		return nil, g.wrap(err)
	}

	rows := &sql.Rows{}
	// execute the query into the rows
	if err := g.querier.Query(ctx, query, params, rows); err != nil {
		return nil, g.wrap(err)
	}

	return rows, nil
}

// Exec executes a query that doesn't return rows. For example, in SQL, INSERT
// or UPDATE.  It scans the result into the pointer v. In SQL, you it's usually
// sql.Result.
func (g *engine) Exec(ctx context.Context, q sql.Querier) (sql.Result, error) {
	// compile the query prior to execution
	query, params, err := g.compile(q)
	if err != nil {
		return nil, g.wrap(err)
	}

	var result sql.Result
	// execute the query into the reslt
	if err := g.querier.Exec(ctx, query, params, &result); err != nil {
		return nil, g.wrap(err)
	}

	return result, nil
}

func (g *engine) compile(stmt sql.Querier) (string, []interface{}, error) {
	type QuerierRoutine interface {
		Name() string
		SetQuery(string)
	}

	// find the command if any
	if routine, ok := stmt.(QuerierRoutine); ok {
		// get the actual SQL query
		query, err := g.provider.Query(routine.Name())
		// if getting the query fails
		if err != nil {
			return "", nil, g.wrap(err)
		}
		// sets the routine's query
		routine.SetQuery(query)
	}

	type QuerierDialect interface {
		SetDialect(dialect string)
	}

	// set the dialect
	if query, ok := stmt.(QuerierDialect); ok {
		query.SetDialect(g.dialect)
	}

	// compile the query
	query, params := stmt.Query()

	type QuerierErr interface {
		Err() error
	}

	// check for errors
	if queryErr, ok := stmt.(QuerierErr); ok {
		if err := queryErr.Err(); err != nil {
			return "", nil, g.wrap(err)
		}
	}

	return query, params, nil
}

func (g *engine) wrap(err error) error {
	if err == nil {
		return nil
	}

	var (
		// error as string
		errm = err.Error()
		// known errors
		errors = [...]string{
			// MySQL 1062 error (ER_DUP_ENTRY).
			"Error 1062",
			// SQLite.
			"UNIQUE constraint failed: %s",
			// PostgreSQL.
			"pq: duplicate key value violates unique constraint %q",
			// check constraint
			"pq: violates check constraint %q",
			// new row check constraint
			"pq: new row for relation %q violates check constraint %q",
		}
	)

	for _, message := range errors {
		// name of the constrain
		var name string
		// scane the name
		fmt.Sscanf(errm, message, &name, &name)
		// check
		if len(name) > 0 || strings.Contains(errm, message) {
			// return the constraint
			return &ConstraintError{
				name: name,
				wrap: err,
			}
		}
	}

	return err
}

func nameOf(value reflect.Type) string {
	switch value.Kind() {
	case reflect.Ptr:
		return nameOf(value.Elem())
	case reflect.Slice:
		return nameOf(value.Elem())
	case reflect.Array:
		return nameOf(value.Elem())
	case reflect.Map:
		return "map"
	default:
		name := inflect.Underscore(value.Name())
		return strings.ToLower(name)
	}
}