insert.go

package sqlbldr

// cspell: ignore pala, ivals

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

// InsertStatement a builder for insert statements
// insert into person (id,name, email)
// values (1, 'lala', 'lala@mail.com')
// Insert("person").
// 	Values([]Person{
// 	{1, "lala", "lala@mail.com"},
// 	{2, "pala", "pala@mail.com"},
// })
//
// Or
//
// Insert("person").
// 	Values(Person{1, "lala", "lala@mail.com"})
//
// Or
//
// Insert("person")
// 	Values(map[string]interface{})
//
// Or
//
// Insert("person")
// 	Values([]map[string]interface{})
type InsertStatement struct {
	sql     string
	table   string
	columns []string
	exclude []string
	values  interface{}
	args    []interface{}
	returns string
	err     error
	tag     string
}

// Insert creates an insert statement
func Insert(table string) *InsertStatement {
	stmt := new(InsertStatement)
	return stmt.Insert(table)
}

// Insert is used to specify the table to be used in the insert statement
func (s *InsertStatement) Insert(table string) *InsertStatement {
	s.table = table
	return s
}

// Exclude specify columns to be excluded from insert
// expects "a,b,c" or []string{"a", "b", "c"}
func (s *InsertStatement) Exclude(ex interface{}) *InsertStatement {
	// if err abort
	if s.err != nil {
		return s
	}

	if str, ok := ex.(string); ok {
		parts := strings.Split(str, ",")

		retv := make([]string, len(parts))
		for i, p := range parts {
			retv[i] = strings.TrimSpace(p)
		}

		s.exclude = retv
		return s
	}

	slStr, ok := ex.([]string)
	if !ok {
		s.err = fmt.Errorf("Exclude: accepts only string, []string received %T", ex)
		return s
	}

	s.exclude = slStr
	return s
}

// Returns specify column to be returned after insert (typically id)
func (s *InsertStatement) Returns(ret string) *InsertStatement {
	// if err abort
	if s.err != nil {
		return s
	}

	s.returns = ret
	return s
}

// Values used to specify data that is inserted into the database.
// Supports
// struct, []struct, map[string]interface{}, []map[string]interface{}
// example:
// stmt.Values([]struct {
//	 	ID   int
//	 	Name string `db:"full_name"`
//	 }{
//	 	{1, "chidi"},
//	 	{2, "bosman"},
//	 	{3, "nwa"},
//	 })
func (s *InsertStatement) Values(data interface{}) *InsertStatement {
	// if err abort
	if s.err != nil {
		return s
	}

	isStruct := IsStruct(data) || IsSliceStruct(data)
	isMap := IsMap(data) || IsSliceMap(data)
	if !isStruct && !isMap {
		s.err = fmt.Errorf("expecting struct, []struct, map[string]interface{}, []map[string]interface{}")
		return s
	}

	s.values = data
	return s
}

// Build ...
func (s *InsertStatement) Build() (qry string, sArgs []interface{}) {
	// if err abort
	if s.err != nil {
		return "error", nil
	}

	// set tag
	s.tag = tagName

	var err error
	// get column names
	if err = s.extractColumns(); err != nil {
		return "error", nil
	}

	// get values
	if sArgs, err = s.extractValues(); err != nil {
		return "error", nil
	}

	// build qry
	qCols := quotedStrings(s.columns)
	s.sql = fmt.Sprintf(
		`INSERT INTO "%s" (%s) VALUES `,
		s.table,
		strings.Join(qCols, ", "),
	)

	qs := make([]string, len(s.columns))
	for i := 0; i < len(s.columns); i++ {
		qs[i] = "?"
	}
	qStr := strings.Join(qs, ", ")

	vCnt := len(sArgs) / len(s.columns)
	vp := make([]string, vCnt)
	for i := 0; i < vCnt; i++ {
		vp[i] = fmt.Sprintf("(%s)", qStr)
	}
	s.sql += strings.Join(vp, ", ")

	// add returns if required
	if len(s.returns) > 0 {
		s.sql += fmt.Sprintf(` RETURNING "%s"`, s.returns)
	}

	// values
	// sArgs = values
	qry = s.sql
	return
}

// Exec ...
func (s *InsertStatement) Exec(ctx context.Context, db DBI, lastID interface{}) (int64, error) {
	qry, args := s.Build()
	if s.err != nil {
		return 0, s.err
	}

	affected, err := Exec(ctx, db, lastID, qry, args...)
	if err != nil {
		s.err = err
		return 0, err
	}

	return affected, nil
}

func (s *InsertStatement) extractValues() ([]interface{}, error) {

	values := []interface{}{}

	if IsStruct(s.values) {
		retv, err := GetStructValues(s.values, s.exclude)
		if err != nil {
			s.err = err

			return nil, err
		}

		values = append(values, retv...)
	} else if IsSliceStruct(s.values) {
		// convert s.values --> []interface{} so that we can use GetStructValues
		// to extract attribute values and append them to values

		v, err := StructToInterface(s.values)
		if err != nil {
			s.err = err
			return nil, err
		}

		// append the values of each struct to values
		ivals := v.([]interface{})
		for i := 0; i < len(ivals); i++ {
			retv, err := GetStructValues(ivals[i], s.exclude)
			if err != nil {
				s.err = err
				return nil, err
			}

			values = append(values, retv...)
		}
	} else if IsMap(s.values) {
		retv, err := GetMapValues(s.values)
		if err != nil {
			s.err = err
			return nil, err
		}

		values = append(values, retv...)
	} else if IsSliceMap(s.values) {

		var rErr error
		EachSliceItem(s.values, func(i int, v reflect.Value) bool {
			retv, rErr := GetMapValues(v.Interface())
			if rErr != nil {
				s.err = rErr
				return true
			}

			values = append(values, retv...)

			return false
		})
		if rErr != nil {
			s.err = rErr
			return nil, rErr
		}

	} else if v, ok := s.values.([]Map); ok {
		for i := range v {
			retv, err := GetMapValues(v[i])
			if err != nil {
				s.err = err
				return nil, err
			}

			values = append(values, retv...)
		}
	}

	return values, nil
}

func (s *InsertStatement) extractColumns() error {
	columns := []string{}
	if IsSliceStruct(s.values) || IsStruct(s.values) {
		s.err = nil
		columns, s.err = GetStructFields(s.values, s.tag, s.exclude)
		if s.err != nil {
			return s.err
		}

	} else if IsMap(s.values) {
		s.err = nil

		columns, s.err = GetMapKeys(s.values)
		if s.err != nil {
			return s.err
		}
	} else if IsSliceMap(s.values) {
		s.err = nil
		i := GetSliceItem(s.values, 0)
		if i == nil {
			return fmt.Errorf("empty slice")
		}

		columns, s.err = GetMapKeys(i)
		if s.err != nil {
			return s.err
		}
	}

	for i := range columns {
		columns[i] = Underscore(strings.TrimSpace(columns[i]))
	}

	s.columns = columns

	return nil
}