jet/sqlbuilder/utils.go

package sqlbuilder

import (
	"database/sql"
	"errors"
	"github.com/go-jet/jet/sqlbuilder/execution"
	"github.com/serenize/snaker"
	"reflect"
)

func serializeOrderByClauseList(statement statementType, orderByClauses []OrderByClause, out *queryData) error {

	for i, value := range orderByClauses {
		if i > 0 {
			out.writeString(", ")
		}

		err := value.serializeForOrderBy(statement, out)

		if err != nil {
			return err
		}
	}

	return nil
}

func serializeGroupByClauseList(statement statementType, clauses []groupByClause, out *queryData) (err error) {

	for i, c := range clauses {
		if i > 0 {
			out.writeString(", ")
		}

		if c == nil {
			return errors.New("nil clause.")
		}

		if err = c.serializeForGroupBy(statement, out); err != nil {
			return
		}
	}

	return nil
}

func serializeClauseList(statement statementType, clauses []clause, out *queryData) (err error) {

	for i, c := range clauses {
		if i > 0 {
			out.writeString(", ")
		}

		if c == nil {
			return errors.New("nil clause.")
		}

		if err = c.serialize(statement, out); err != nil {
			return
		}
	}

	return nil
}

func serializeExpressionList(statement statementType, expressions []Expression, separator string, out *queryData) error {

	for i, value := range expressions {
		if i > 0 {
			out.writeString(separator)
		}

		err := value.serialize(statement, out)

		if err != nil {
			return err
		}
	}

	return nil
}

func serializeProjectionList(statement statementType, projections []projection, out *queryData) error {
	for i, col := range projections {
		if i > 0 {
			out.writeString(",")
			out.newLine()
		}

		if col == nil {
			return errors.New("projection is nil")
		}

		if err := col.serializeForProjection(statement, out); err != nil {
			return err
		}
	}

	return nil
}

func serializeColumnNames(columns []column, out *queryData) error {
	for i, col := range columns {
		if i > 0 {
			out.writeString(", ")
		}

		if col == nil {
			return errors.New("nil column in columns list")
		}

		out.writeString(col.Name())
	}

	return nil
}

func columnListToProjectionList(columns []Column) []projection {
	var ret []projection

	for _, column := range columns {
		ret = append(ret, column)
	}

	return ret
}

func isNil(v interface{}) bool {
	return v == nil || (reflect.ValueOf(v).Kind() == reflect.Ptr && reflect.ValueOf(v).IsNil())
}

func valueToClause(value interface{}) clause {
	if clause, ok := value.(clause); ok {
		return clause
	} else {
		return literal(value)
	}
}

func unwindRowFromModel(columns []column, data interface{}) []clause {
	structValue := reflect.Indirect(reflect.ValueOf(data))

	row := []clause{}

	mustBe(structValue, reflect.Struct)

	for _, column := range columns {
		columnName := column.Name()
		structFieldName := snaker.SnakeToCamel(columnName)

		structField := structValue.FieldByName(structFieldName)

		if !structField.IsValid() {
			panic("missing struct field for column : " + column.Name())
		}

		var field interface{}

		if structField.Kind() == reflect.Ptr && structField.IsNil() {
			field = nil
		} else {
			field = reflect.Indirect(structField).Interface()
		}

		row = append(row, literal(field))
	}

	return row
}

func unwindRowFromValues(value interface{}, values []interface{}) []clause {
	row := []clause{}

	allValues := append([]interface{}{value}, values...)

	for _, val := range allValues {
		row = append(row, valueToClause(val))
	}

	return row
}

func mustBe(v reflect.Value, expected reflect.Kind) {
	if k := v.Kind(); k != expected {
		panic("argument mismatch: expected " + expected.String() + ", got " + v.Type().String())
	}
}

func Query(statement Statement, db execution.Db, destination interface{}) error {
	query, args, err := statement.Sql()

	if err != nil {
		return err
	}

	return execution.Query(db, query, args, destination)
}

func Exec(statement Statement, db execution.Db) (res sql.Result, err error) {
	query, args, err := statement.Sql()

	if err != nil {
		return
	}

	return db.Exec(query, args...)
}