Added unsigned integer literals.

internal/jet/literal_expression.go

@@ -67,8 +67,7 @@ type integerLiteralExpression struct {
 	integerInterfaceImpl
 }
 
-// Int creates new integer literal
+func intLiteral(value interface{}) IntegerExpression {
-func Int(value int64) IntegerExpression {
 	numLiteral := &integerLiteralExpression{}
 
 	numLiteral.literalExpressionImpl = *literal(value)
@@ -79,6 +78,46 @@ func Int(value int64) IntegerExpression {
 	return numLiteral
 }
 
+// Int creates a new 64 bit signed integer literal
+func Int(value int64) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Int8 creates a new 8 bit signed integer literal
+func Int8(value int8) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Int16 creates a new 16 bit signed integer literal
+func Int16(value int16) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Int32 creates a new 32 bit signed integer literal
+func Int32(value int32) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Uint8 creates a new 8 bit unsigned integer literal
+func Uint8(value uint8) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Uint16 creates a new 16 bit unsigned integer literal
+func Uint16(value uint16) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Uint32 creates a new 32 bit unsigned integer literal
+func Uint32(value uint32) IntegerExpression {
+	return intLiteral(value)
+}
+
+// Uint64 creates a new 64 bit unsigned integer literal
+func Uint64(value uint64) IntegerExpression {
+	return intLiteral(value)
+}
+
 //---------------------------------------------------//
 type boolLiteralExpression struct {
 	boolInterfaceImpl

mysql/expressions.go

@@ -3,7 +3,7 @@ package mysql
 import "github.com/go-jet/jet/v2/internal/jet"
 
 // Expression is common interface for all expressions.
-// Can be Bool, Int, Float, String, Date, Time, Timez, Timestamp or Timestampz expressions.
+// Can be Bool, Int, Float, String, Date, Time or Timestamp expressions.
 type Expression = jet.Expression
 
 // BoolExpression interface

mysql/literal.go

@@ -15,9 +15,33 @@ var (
 // Bool creates new bool literal expression
 var Bool = jet.Bool
 
-// Int is constructor for integer expressions literals.
+// Int is constructor for 64 bit signed integer expressions literals.
 var Int = jet.Int
 
+// Int8 is constructor for 8 bit signed integer expressions literals.
+var Int8 = jet.Int8
+
+// Int16 is constructor for 16 bit signed integer expressions literals.
+var Int16 = jet.Int16
+
+// Int32 is constructor for 32 bit signed integer expressions literals.
+var Int32 = jet.Int32
+
+// Int64 is constructor for 64 bit signed integer expressions literals.
+var Int64 = jet.Int
+
+// Uint8 is constructor for 8 bit unsigned integer expressions literals.
+var Uint8 = jet.Uint8
+
+// Uint16 is constructor for 16 bit unsigned integer expressions literals.
+var Uint16 = jet.Uint16
+
+// Uint32 is constructor for 32 bit unsigned integer expressions literals.
+var Uint32 = jet.Uint32
+
+// Uint64 is constructor for 64 bit unsigned integer expressions literals.
+var Uint64 = jet.Uint64
+
 // Float creates new float literal expression
 var Float = jet.Float
 

mysql/literal_test.go

@@ -1,6 +1,7 @@
 package mysql
 
 import (
+	"math"
 	"testing"
 	"time"
 )
@@ -13,6 +14,46 @@ func TestInt(t *testing.T) {
 	assertSerialize(t, Int(11), `?`, int64(11))
 }
 
+func TestInt8(t *testing.T) {
+	val := int8(math.MinInt8)
+	assertSerialize(t, Int8(val), `?`, val)
+}
+
+func TestInt16(t *testing.T) {
+	val := int16(math.MinInt16)
+	assertSerialize(t, Int16(val), `?`, val)
+}
+
+func TestInt32(t *testing.T) {
+	val := int32(math.MinInt32)
+	assertSerialize(t, Int32(val), `?`, val)
+}
+
+func TestInt64(t *testing.T) {
+	val := int64(math.MinInt64)
+	assertSerialize(t, Int64(val), `?`, val)
+}
+
+func TestUint8(t *testing.T) {
+	val := uint8(math.MaxUint8)
+	assertSerialize(t, Uint8(val), `?`, val)
+}
+
+func TestUint16(t *testing.T) {
+	val := uint16(math.MaxUint16)
+	assertSerialize(t, Uint16(val), `?`, val)
+}
+
+func TestUint32(t *testing.T) {
+	val := uint32(math.MaxUint32)
+	assertSerialize(t, Uint32(val), `?`, val)
+}
+
+func TestUint64(t *testing.T) {
+	val := uint64(math.MaxUint64)
+	assertSerialize(t, Uint64(val), `?`, val)
+}
+
 func TestFloat(t *testing.T) {
 	assertSerialize(t, Float(12.34), `?`, float64(12.34))
 }

postgres/literal.go

@@ -8,9 +8,33 @@ import (
 // Bool creates new bool literal expression
 var Bool = jet.Bool
 
-// Int creates new integer literal expression
+// Int is constructor for 64 bit signed integer expressions literals.
 var Int = jet.Int
 
+// Int8 is constructor for 8 bit signed integer expressions literals.
+var Int8 = jet.Int8
+
+// Int16 is constructor for 16 bit signed integer expressions literals.
+var Int16 = jet.Int16
+
+// Int32 is constructor for 32 bit signed integer expressions literals.
+var Int32 = jet.Int32
+
+// Int64 is constructor for 64 bit signed integer expressions literals.
+var Int64 = jet.Int
+
+// Uint8 is constructor for 8 bit unsigned integer expressions literals.
+var Uint8 = jet.Uint8
+
+// Uint16 is constructor for 16 bit unsigned integer expressions literals.
+var Uint16 = jet.Uint16
+
+// Uint32 is constructor for 32 bit unsigned integer expressions literals.
+var Uint32 = jet.Uint32
+
+// Uint64 is constructor for 64 bit unsigned integer expressions literals.
+var Uint64 = jet.Uint64
+
 // Float creates new float literal expression
 var Float = jet.Float
 

postgres/literal_test.go

@@ -1,6 +1,7 @@
 package postgres
 
 import (
+	"math"
 	"testing"
 	"time"
 )
@@ -13,6 +14,46 @@ func TestInt(t *testing.T) {
 	assertSerialize(t, Int(11), `$1`, int64(11))
 }
 
+func TestInt8(t *testing.T) {
+	val := int8(math.MinInt8)
+	assertSerialize(t, Int8(val), `$1`, val)
+}
+
+func TestInt16(t *testing.T) {
+	val := int16(math.MinInt16)
+	assertSerialize(t, Int16(val), `$1`, val)
+}
+
+func TestInt32(t *testing.T) {
+	val := int32(math.MinInt32)
+	assertSerialize(t, Int32(val), `$1`, val)
+}
+
+func TestInt64(t *testing.T) {
+	val := int64(math.MinInt64)
+	assertSerialize(t, Int64(val), `$1`, val)
+}
+
+func TestUint8(t *testing.T) {
+	val := uint8(math.MaxUint8)
+	assertSerialize(t, Uint8(val), `$1`, val)
+}
+
+func TestUint16(t *testing.T) {
+	val := uint16(math.MaxUint16)
+	assertSerialize(t, Uint16(val), `$1`, val)
+}
+
+func TestUint32(t *testing.T) {
+	val := uint32(math.MaxUint32)
+	assertSerialize(t, Uint32(val), `$1`, val)
+}
+
+func TestUint64(t *testing.T) {
+	val := uint64(math.MaxUint64)
+	assertSerialize(t, Uint64(val), `$1`, val)
+}
+
 func TestFloat(t *testing.T) {
 	assertSerialize(t, Float(12.34), `$1`, float64(12.34))
 }