pgm/pgm_field.go

package pgm

import "strings"

// Field related to a table
type Field string

func (f Field) Name() string {
	return strings.Split(string(f), ".")[1]
}

func (f Field) String() string {
	return string(f)
}

// Count function wrapped field
func (f Field) Count() Field {
	return Field("COUNT(" + f.String() + ")")
}

// StringEscape will wrap field with:
//
// COALESCE(field, ”)
func (f Field) StringEscape() Field {
	return Field("COALESCE(" + f.String() + ", '')")
}

// NumberEscape will wrap field with:
//
// COALESCE(field, 0)
func (f Field) NumberEscape() Field {
	return Field("COALESCE(" + f.String() + ", 0)")
}

// BooleanEscape will wrap field with:
//
// COALESCE(field, FALSE)
func (f Field) BooleanEscape() Field {
	return Field("COALESCE(" + f.String() + ", FALSE)")
}

// Avg function wrapped field
func (f Field) Avg() Field {
	return Field("AVG(" + f.String() + ")")
}

// Sum function wrapped field
func (f Field) Sum() Field {
	return Field("SUM(" + f.String() + ")")
}

// Max function wrapped field
func (f Field) Max() Field {
	return Field("MAX(" + f.String() + ")")
}

// Min function wrapped field
func (f Field) Min() Field {
	return Field("Min(" + f.String() + ")")
}

// Lower function wrapped field
func (f Field) Lower() Field {
	return Field("LOWER(" + f.String() + ")")
}

// Upper function wrapped field
func (f Field) Upper() Field {
	return Field("UPPER(" + f.String() + ")")
}

// Trim function wrapped field
func (f Field) Trim() Field {
	return Field("TRIM(" + f.String() + ")")
}

// Asc suffixed field, supposed to be used with order by
func (f Field) Asc() Field {
	return Field(f.String() + " ASC")
}

// Desc suffixed field, supposed to be used with order by
func (f Field) Desc() Field {
	return Field(f.String() + " DESC")
}

func (f Field) RowNumber(as string) Field {
	return rowNumber(&f, nil, true, as)
}

func (f Field) RowNumberDesc(as string) Field {
	return rowNumber(&f, nil, true, as)
}

// RowNumberPartionBy in ascending order
func (f Field) RowNumberPartionBy(partition Field, as string) Field {
	return rowNumber(&f, &partition, true, as)
}

func (f Field) RowNumberDescPartionBy(partition Field, as string) Field {
	return rowNumber(&f, &partition, false, as)
}

func rowNumber(f, partition *Field, isAsc bool, as string) Field {
	var orderBy string
	if isAsc {
		orderBy = " ASC"
	} else {
		orderBy = " DESC"
	}

	if as == "" {
		as = "row_number"
	}

	col := f.String()
	if partition != nil {
		return Field("ROW_NUMBER() OVER (PARTITION BY " + partition.String() + " ORDER BY " + col + orderBy + ") AS " + as)
	}

	return Field("ROW_NUMBER() OVER (ORDER BY " + col + orderBy + ") AS " + as)
}

func (f Field) IsNull() Conditioner {
	col := f.String()
	return &Cond{Field: col, op: " IS NULL", len: len(col) + 8}
}

func (f Field) IsNotNull() Conditioner {
	col := f.String()
	return &Cond{Field: col, op: " IS NOT NULL", len: len(col) + 12}
}

// DateTrunc will truncate date or timestamp to specified level of precision
//
// Level values:
//   - microseconds, milliseconds, second, minute, hour
//   - day, week (Monday start), month, quarter, year
//   - decade, century, millennium
func (f Field) DateTrunc(level, as string) Field {
	return Field("DATE_TRUNC('" + level + "', " + f.String() + ") AS " + as)
}

// EqualFold will use LOWER(column_name) = LOWER(val) for comparision
func (f Field) EqFold(val string) Conditioner {
	col := f.String()
	return &Cond{Field: "LOWER(" + col + ")", Val: val, op: " = LOWER($", action: CondActionNeedToClose, len: len(col) + 5}
}

// Eq is equal
func (f Field) Eq(val any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " = $", len: len(col) + 5}
}

func (f Field) NotEq(val any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " != $", len: len(col) + 5}
}

func (f Field) Gt(val any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " > $", len: len(col) + 5}
}

func (f Field) Lt(val any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " < $", len: len(col) + 5}
}

func (f Field) Gte(val any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " >= $", len: len(col) + 5}
}

func (f Field) Lte(val any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " <= $", len: len(col) + 5}
}

func (f Field) Like(val string) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " LIKE $", len: len(f.String()) + 5}
}

func (f Field) LikeFold(val string) Conditioner {
	col := f.String()
	return &Cond{Field: "LOWER(" + col + ")", Val: val, op: " LIKE LOWER($", action: CondActionNeedToClose, len: len(col) + 5}
}

// ILIKE is case-insensitive
func (f Field) ILike(val string) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " ILIKE $", len: len(col) + 5}
}

func (f Field) Any(val ...any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " = ANY($", action: CondActionNeedToClose, len: len(col) + 5}
}

func (f Field) NotAny(val ...any) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: val, op: " != ANY($", action: CondActionNeedToClose, len: len(col) + 5}
}

// NotInSubQuery using ANY
func (f Field) NotInSubQuery(qry WhereClause) Conditioner {
	col := f.String()
	return &Cond{Field: col, Val: qry, op: " != ANY($)", action: CondActionSubQuery}
}

func ConcatWs(sep string, fields ...Field) Field {
	return Field("concat_ws('" + sep + "'," + joinFileds(fields) + ")")
}

func StringAgg(exp, sep string) Field {
	return Field("string_agg(" + exp + ",'" + sep + "')")
}

func StringAggCast(exp, sep string) Field {
	return Field("string_agg(cast(" + exp + " as varchar),'" + sep + "')")
}

func joinFileds(fields []Field) string {
	sb := getSB()
	defer putSB(sb)
	for i, f := range fields {
		if i == 0 {
			sb.WriteString(f.String())
		} else {
			sb.WriteString(", ")
			sb.WriteString(f.String())
		}
	}

	return sb.String()
}