Package path refactor.

utils.go

@@ -0,0 +1,185 @@
+package jet
+
+import (
+	"errors"
+	"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())
+	}
+}