Literal and cast clean up.

postgres/cast.go

@@ -3,13 +3,13 @@ package postgres
 import (
 	"fmt"
 	"github.com/go-jet/jet/internal/jet"
+	"strconv"
 )
 
 type cast interface {
-	jet.Cast
+	AS(castType string) Expression
 	// Cast expression AS bool type
 	AS_BOOL() BoolExpression
-
 	// Cast expression AS smallint type
 	AS_SMALLINT() IntegerExpression
 	// Cast expression AS integer type
@@ -18,16 +18,22 @@ type cast interface {
 	AS_BIGINT() IntegerExpression
 	// Cast expression AS numeric type, using precision and optionally scale
 	AS_NUMERIC(precisionAndScale ...int) FloatExpression
-
 	// Cast expression AS real type
 	AS_REAL() FloatExpression
 	// Cast expression AS double precision type
 	AS_DOUBLE() FloatExpression
+	// Cast expression AS char with optional length
+	AS_CHAR(length ...int) StringExpression
+	// Cast expression AS date type
+	AS_DATE() DateExpression
+	// Cast expression AS numeric type, using precision and optionally scale
+	AS_DECIMAL() FloatExpression
+	// Cast expression AS time type
+	AS_TIME() TimeExpression
 	// Cast expression AS text type
 	AS_TEXT() StringExpression
 
 	AS_BYTEA() StringExpression
-
 	// Cast expression AS time with time timezone type
 	AS_TIMEZ() TimezExpression
 	// Cast expression AS timestamp type
@@ -48,22 +54,26 @@ func CAST(expr Expression) cast {
 	return castImpl
 }
 
+func (b *castImpl) AS(castType string) Expression {
+	return b.Cast.AS(castType)
+}
+
 func (b *castImpl) AS_BOOL() BoolExpression {
-	return jet.BoolExp(b.AS("boolean"))
+	return BoolExp(b.AS("boolean"))
 }
 
 func (b *castImpl) AS_SMALLINT() IntegerExpression {
-	return jet.IntExp(b.AS("smallint"))
+	return IntExp(b.AS("smallint"))
 }
 
 // Cast expression AS integer type
 func (b *castImpl) AS_INTEGER() IntegerExpression {
-	return jet.IntExp(b.AS("integer"))
+	return IntExp(b.AS("integer"))
 }
 
 // Cast expression AS bigint type
 func (b *castImpl) AS_BIGINT() IntegerExpression {
-	return jet.IntExp(b.AS("bigint"))
+	return IntExp(b.AS("bigint"))
 }
 
 // Cast expression AS numeric type, using precision and optionally scale
@@ -77,45 +87,63 @@ func (b *castImpl) AS_NUMERIC(precisionAndScale ...int) FloatExpression {
 		castArgs = fmt.Sprintf("(%d)", precisionAndScale[0])
 	}
 
-	return jet.FloatExp(b.AS("numeric" + castArgs))
+	return FloatExp(b.AS("numeric" + castArgs))
 }
 
 // Cast expression AS real type
 func (b *castImpl) AS_REAL() FloatExpression {
-	return jet.FloatExp(b.AS("real"))
+	return FloatExp(b.AS("real"))
 }
 
 // Cast expression AS double precision type
 func (b *castImpl) AS_DOUBLE() FloatExpression {
-	return jet.FloatExp(b.AS("double precision"))
+	return FloatExp(b.AS("double precision"))
 }
 
 // Cast expression AS text type
 func (b *castImpl) AS_TEXT() StringExpression {
-	return jet.StringExp(b.AS("text"))
+	return StringExp(b.AS("text"))
+}
+
+func (b *castImpl) AS_CHAR(lenght ...int) StringExpression {
+	if len(lenght) > 0 {
+		return StringExp(b.AS("char(" + strconv.Itoa(lenght[0]) + ")"))
+	}
+
+	return StringExp(b.AS("char"))
+}
+
+// Cast expression AS date type
+func (b *castImpl) AS_DATE() DateExpression {
+	return DateExp(b.AS("date"))
+}
+
+// Cast expression AS date type
+func (b *castImpl) AS_DECIMAL() FloatExpression {
+	return FloatExp(b.AS("decimal"))
 }
 
 // Cast expression AS text type
 func (b *castImpl) AS_BYTEA() StringExpression {
-	return jet.StringExp(b.AS("bytea"))
+	return StringExp(b.AS("bytea"))
 }
 
 // Cast expression AS date type
-func (b *castImpl) AS_TIME() jet.TimeExpression {
+func (b *castImpl) AS_TIME() TimeExpression {
 	return TimeExp(b.AS("time without time zone"))
 }
 
 // Cast expression AS time with time timezone type
 func (b *castImpl) AS_TIMEZ() TimezExpression {
-	return jet.TimezExp(b.AS("time with time zone"))
+	return TimezExp(b.AS("time with time zone"))
 }
 
 // Cast expression AS timestamp type
 func (b *castImpl) AS_TIMESTAMP() TimestampExpression {
-	return jet.TimestampExp(b.AS("timestamp without time zone"))
+	return TimestampExp(b.AS("timestamp without time zone"))
 }
 
 // Cast expression AS timestamp with timezone type
 func (b *castImpl) AS_TIMESTAMPZ() TimestampzExpression {
-	return jet.TimestampzExp(b.AS("timestamp with time zone"))
+	return TimestampzExp(b.AS("timestamp with time zone"))
 }