153 lines
3.5 KiB
Go
153 lines
3.5 KiB
Go
package postgres
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/go-jet/jet/internal/jet"
|
|
"github.com/go-jet/jet/internal/utils"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type quantityAndUnit = float64
|
|
|
|
// Interval unit types
|
|
const (
|
|
YEAR quantityAndUnit = 123456789 + iota
|
|
MONTH
|
|
WEEK
|
|
DAY
|
|
HOUR
|
|
MINUTE
|
|
SECOND
|
|
MILLISECOND
|
|
MICROSECOND
|
|
DECADE
|
|
CENTURY
|
|
MILLENNIUM
|
|
)
|
|
|
|
type intervalExpressionImpl struct {
|
|
jet.Interval
|
|
jet.ExpressionInterfaceImpl
|
|
}
|
|
|
|
// IntervalExpression is representation of postgres INTERVAL
|
|
type IntervalExpression interface {
|
|
jet.IsInterval
|
|
jet.Expression
|
|
}
|
|
|
|
// INTERVAL creates new interval expression from the list of quantity-unit pairs.
|
|
// For example: INTERVAL(1, DAY, 3, MINUTE)
|
|
func INTERVAL(quantityAndUnit ...quantityAndUnit) IntervalExpression {
|
|
if len(quantityAndUnit)%2 != 0 {
|
|
panic("jet: invalid number of quantity and unit fields")
|
|
}
|
|
|
|
fields := []string{}
|
|
|
|
for i := 0; i < len(quantityAndUnit); i += 2 {
|
|
quantity := strconv.FormatFloat(float64(quantityAndUnit[i]), 'f', -1, 64)
|
|
unitString := unitToString(quantityAndUnit[i+1])
|
|
fields = append(fields, quantity+" "+unitString)
|
|
}
|
|
|
|
intervalStr := fmt.Sprintf("'%s'", strings.Join(fields, " "))
|
|
|
|
newInterval := &intervalExpressionImpl{
|
|
Interval: jet.NewInterval(jet.Raw(intervalStr)),
|
|
}
|
|
|
|
newInterval.ExpressionInterfaceImpl.Parent = newInterval
|
|
|
|
return newInterval
|
|
}
|
|
|
|
// INTERVALd creates interval expression from duration
|
|
func INTERVALd(duration time.Duration) IntervalExpression {
|
|
days, hours, minutes, seconds, microseconds := utils.ExtractDateTimeComponents(duration)
|
|
|
|
quantityAndUnits := []quantityAndUnit{}
|
|
|
|
if days > 0 {
|
|
quantityAndUnits = append(quantityAndUnits, quantityAndUnit(days))
|
|
quantityAndUnits = append(quantityAndUnits, DAY)
|
|
}
|
|
|
|
if hours > 0 {
|
|
quantityAndUnits = append(quantityAndUnits, quantityAndUnit(hours))
|
|
quantityAndUnits = append(quantityAndUnits, HOUR)
|
|
}
|
|
|
|
if minutes > 0 {
|
|
quantityAndUnits = append(quantityAndUnits, quantityAndUnit(minutes))
|
|
quantityAndUnits = append(quantityAndUnits, MINUTE)
|
|
}
|
|
|
|
if seconds > 0 {
|
|
quantityAndUnits = append(quantityAndUnits, quantityAndUnit(seconds))
|
|
quantityAndUnits = append(quantityAndUnits, SECOND)
|
|
}
|
|
|
|
if microseconds > 0 {
|
|
quantityAndUnits = append(quantityAndUnits, quantityAndUnit(microseconds))
|
|
quantityAndUnits = append(quantityAndUnits, MICROSECOND)
|
|
}
|
|
|
|
if len(quantityAndUnits) == 0 {
|
|
return INTERVAL(0, MICROSECOND)
|
|
}
|
|
|
|
return INTERVAL(quantityAndUnits...)
|
|
}
|
|
|
|
func unitToString(unit quantityAndUnit) string {
|
|
switch unit {
|
|
case YEAR:
|
|
return "YEAR"
|
|
case MONTH:
|
|
return "MONTH"
|
|
case WEEK:
|
|
return "WEEK"
|
|
case DAY:
|
|
return "DAY"
|
|
case HOUR:
|
|
return "HOUR"
|
|
case MINUTE:
|
|
return "MINUTE"
|
|
case SECOND:
|
|
return "SECOND"
|
|
case MILLISECOND:
|
|
return "MILLISECOND"
|
|
case MICROSECOND:
|
|
return "MICROSECOND"
|
|
case DECADE:
|
|
return "DECADE"
|
|
case CENTURY:
|
|
return "CENTURY"
|
|
case MILLENNIUM:
|
|
return "MILLENNIUM"
|
|
default:
|
|
panic("jet: invalid INTERVAL unit type")
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------//
|
|
|
|
type intervalWrapper struct {
|
|
jet.IsInterval
|
|
Expression
|
|
}
|
|
|
|
func newIntervalExpressionWrap(expression Expression) IntervalExpression {
|
|
intervalWrap := intervalWrapper{Expression: expression}
|
|
return &intervalWrap
|
|
}
|
|
|
|
// IntervalExp is interval expression wrapper around arbitrary expression.
|
|
// Allows go compiler to see any expression as interval expression.
|
|
// Does not add sql cast to generated sql builder output.
|
|
func IntervalExp(expression Expression) IntervalExpression {
|
|
return newIntervalExpressionWrap(expression)
|
|
}
|