func (conflict *ConflictClause) Set(col string, val interface{}) *ConflictClause {
	return conflict.SetIf(col, val, true)
}
Set adds a column to update as part of the conflict resolution
package sqlz
import (
	"context"
	"database/sql"
	"fmt"
	"strings"
	"github.com/jmoiron/sqlx"
)
type InsertStmt struct {
	*Statement
	InsCols         []string
	InsVals         []interface{}
	InsMultipleVals [][]interface{}
	SelectStmt      *SelectStmt
	Table           string
	Return          []string
	Conflicts       []*ConflictClause
	execer          Ext
	sqliteConflict  string
}
func (db *DB) InsertInto(table string) *InsertStmt {
	return &InsertStmt{
		Table:     table,
		execer:    db.DB,
		Statement: &Statement{db.ErrHandlers},
	}
}
func (tx *Tx) InsertInto(table string) *InsertStmt {
	return &InsertStmt{
		Table:     table,
		execer:    tx.Tx,
		Statement: &Statement{tx.ErrHandlers},
	}
}
func (stmt *InsertStmt) Columns(cols ...string) *InsertStmt {
	stmt.InsCols = append(stmt.InsCols, cols...)
	return stmt
}
func (stmt *InsertStmt) Values(vals ...interface{}) *InsertStmt {
	stmt.InsVals = append(stmt.InsVals, vals...)
	return stmt
}
func (stmt *InsertStmt) ValueMap(vals map[string]interface{}) *InsertStmt {
	for _, col := range sortKeys(vals) {
		stmt.InsCols = append(stmt.InsCols, col)
		stmt.InsVals = append(stmt.InsVals, vals[col])
	}
	return stmt
}
func (stmt *InsertStmt) ValueMultiple(vals [][]interface{}) *InsertStmt {
	stmt.InsMultipleVals = append(stmt.InsMultipleVals, vals...)
	return stmt
}
func (stmt *InsertStmt) FromSelect(selStmt *SelectStmt) *InsertStmt {
	stmt.SelectStmt = selStmt
	return stmt
}
func (stmt *InsertStmt) Returning(cols ...string) *InsertStmt {
	stmt.Return = append(stmt.Return, cols...)
	return stmt
}
func (stmt *InsertStmt) OnConflictDoNothing() *InsertStmt {
	return stmt.OnConflict(OnConflict().DoNothing())
}
func (stmt *InsertStmt) OrIgnore() *InsertStmt {
	stmt.sqliteConflict = "IGNORE"
	return stmt
}
func (stmt *InsertStmt) OrReplace() *InsertStmt {
	stmt.sqliteConflict = "REPLACE"
	return stmt
}
func (stmt *InsertStmt) OrAbort() *InsertStmt {
	stmt.sqliteConflict = "ABORT"
	return stmt
}
func (stmt *InsertStmt) OrRollback() *InsertStmt {
	stmt.sqliteConflict = "ROLLBACK"
	return stmt
}
func (stmt *InsertStmt) OrFail() *InsertStmt {
	stmt.sqliteConflict = "FAIL"
	return stmt
}
func (stmt *InsertStmt) OnConflict(clause *ConflictClause) *InsertStmt {
	stmt.Conflicts = append(stmt.Conflicts, clause)
	return stmt
}
func (stmt *InsertStmt) ToSQL(rebind bool) (asSQL string, bindings []interface{}) {
	var clauses = []string{"INSERT", "INTO", stmt.Table}
	if stmt.sqliteConflict != "" {
		clauses[0] = fmt.Sprintf("INSERT OR %s", stmt.sqliteConflict)
	}
	if len(stmt.InsCols) > 0 {
		clauses = append(clauses, "("+strings.Join(stmt.InsCols, ", ")+")")
	}
	switch {
	case stmt.SelectStmt != nil:
		selectSQL, selectBindings := stmt.SelectStmt.ToSQL(false)
		clauses = append(clauses, selectSQL)
		bindings = append(bindings, selectBindings...)
	case len(stmt.InsVals) > 0:
		placeholders, bindingsToAdd := parseInsertValues(stmt.InsVals)
		bindings = append(bindings, bindingsToAdd...)
		clauses = append(clauses, "VALUES ("+strings.Join(placeholders, ", ")+")")
	case len(stmt.InsMultipleVals) > 0:
		var multipleValues []string
		for _, insVals := range stmt.InsMultipleVals {
			placeholders, bindingsToAdd := parseInsertValues(insVals)
			bindings = append(bindings, bindingsToAdd...)
			multipleValues = append(multipleValues, "("+strings.Join(placeholders, ", ")+")")
		}
		clauses = append(clauses, "VALUES "+strings.Join(multipleValues, ", "))
	}
	for _, conflict := range stmt.Conflicts {
		conflictSQL, conflictBindings := conflict.ToSQL()
		clauses = append(clauses, conflictSQL)
		bindings = append(bindings, conflictBindings...)
	}
	if len(stmt.Return) > 0 {
		clauses = append(clauses, "RETURNING "+strings.Join(stmt.Return, ", "))
	}
	asSQL = strings.Join(clauses, " ")
	if rebind {
		if db, ok := stmt.execer.(*sqlx.DB); ok {
			asSQL = db.Rebind(asSQL)
		} else if tx, ok := stmt.execer.(*sqlx.Tx); ok {
			asSQL = tx.Rebind(asSQL)
		}
	}
	return asSQL, bindings
}
func (stmt *InsertStmt) Exec() (res sql.Result, err error) {
	asSQL, bindings := stmt.ToSQL(true)
	res, err = stmt.execer.Exec(asSQL, bindings...)
	stmt.Statement.HandleError(err)
	return res, err
}
func (stmt *InsertStmt) ExecContext(ctx context.Context) (res sql.Result, err error) {
	asSQL, bindings := stmt.ToSQL(true)
	res, err = stmt.execer.ExecContext(ctx, asSQL, bindings...)
	stmt.Statement.HandleError(err)
	return res, err
}
func (stmt *InsertStmt) GetRow(into interface{}) error {
	asSQL, bindings := stmt.ToSQL(true)
	return sqlx.Get(stmt.execer, into, asSQL, bindings...)
}
func (stmt *InsertStmt) GetRowContext(ctx context.Context, into interface{}) error {
	asSQL, bindings := stmt.ToSQL(true)
	return sqlx.GetContext(ctx, stmt.execer, into, asSQL, bindings...)
}
func (stmt *InsertStmt) GetAll(into interface{}) error {
	asSQL, bindings := stmt.ToSQL(true)
	return sqlx.Select(stmt.execer, into, asSQL, bindings...)
}
func (stmt *InsertStmt) GetAllContext(ctx context.Context, into interface{}) error {
	asSQL, bindings := stmt.ToSQL(true)
	return sqlx.SelectContext(ctx, stmt.execer, into, asSQL, bindings...)
}
type ConflictAction string
const (
	DoNothing ConflictAction = "nothing"
	DoUpdate ConflictAction = "update"
)
type ConflictClause struct {
	Targets []string
	Action  ConflictAction
	SetCols []string
	SetVals []interface{}
	Updates map[string]interface{}
}
func OnConflict(targets ...string) *ConflictClause {
	return &ConflictClause{
		Targets: targets,
	}
}
func (conflict *ConflictClause) DoNothing() *ConflictClause {
	conflict.Action = DoNothing
	return conflict
}
func (conflict *ConflictClause) DoUpdate() *ConflictClause {
	conflict.Action = DoUpdate
	return conflict
}