Add TimeExpression and TimeColumn types.

sqlbuilder/column_types.go

@@ -76,10 +76,28 @@ func NewStringColumn(name string, nullable NullableColumn) *StringColumn {
 
 	stringColumn := &StringColumn{}
 
-	stringColumn.stringInterfaceImpl.parent = stringColumn
 	stringColumn.stringInterfaceImpl.parent = stringColumn
 
 	stringColumn.baseColumn = newBaseColumn(name, nullable, "", stringColumn)
 
 	return stringColumn
 }
+
+//------------------------------------------------------//
+type TimeColumn struct {
+	timeInterfaceImpl
+
+	baseColumn
+}
+
+// Representation of any integer column
+// This function will panic if name is not valid
+func NewTimeColumn(name string, nullable NullableColumn) *TimeColumn {
+	stringColumn := &TimeColumn{}
+
+	stringColumn.timeInterfaceImpl.parent = stringColumn
+
+	stringColumn.baseColumn = newBaseColumn(name, nullable, "", stringColumn)
+
+	return stringColumn
+}

sqlbuilder/execution/execution.go

@@ -411,10 +411,11 @@ func mapRowToStruct(scanContext *scanContext, groupKey string, typesProcessed ma
 
 	for i := 0; i < structType.NumField(); i++ {
 		field := structType.Field(i)
-		//fieldTypeName := field.Name
+
 		fieldValue := structValue.Field(i)
-		//fmt.Println("---------------", fieldTypeName)
-		////spew.Dump(field.Type)
+		//fieldTypeName := field.Name
+		//fmt.Println("---------------", fieldTypeName,)
+		//spew.Dump(field.Type)
 
 		fieldName := field.Name
 
@@ -486,8 +487,8 @@ func isDbBaseType(objType reflect.Type) bool {
 	typeStr := objType.String()
 
 	switch typeStr {
-	case "string", "int32", "int16", "float32", "float64", "time.Time", "bool",
-		"*string", "*int32", "*int16", "*float32", "*float64", "*time.Time", "*bool":
+	case "string", "int32", "int16", "float32", "float64", "time.Time", "bool", "[]byte", "[]uint8",
+		"*string", "*int32", "*int16", "*float32", "*float64", "*time.Time", "*bool", "*[]byte", "*[]uint8":
 		return true
 	}
 

sqlbuilder/time_expression.go

@@ -0,0 +1,50 @@
+package sqlbuilder
+
+type TimeExpression interface {
+	Expression
+
+	Eq(expression TimeExpression) BoolExpression
+	EqL(literal string) BoolExpression
+	NotEq(expression TimeExpression) BoolExpression
+	NotEqL(literal string) BoolExpression
+	GtEq(rhs TimeExpression) BoolExpression
+	GtEqL(literal string) BoolExpression
+	LtEq(rhs TimeExpression) BoolExpression
+	LtEqL(literal string) BoolExpression
+}
+
+type timeInterfaceImpl struct {
+	parent TimeExpression
+}
+
+func (t *timeInterfaceImpl) Eq(expression TimeExpression) BoolExpression {
+	return Eq(t.parent, expression)
+}
+
+func (t *timeInterfaceImpl) EqL(literal string) BoolExpression {
+	return Eq(t.parent, Literal(literal))
+}
+
+func (t *timeInterfaceImpl) NotEq(expression TimeExpression) BoolExpression {
+	return NotEq(t.parent, expression)
+}
+
+func (t *timeInterfaceImpl) NotEqL(literal string) BoolExpression {
+	return NotEq(t.parent, Literal(literal))
+}
+
+func (t *timeInterfaceImpl) GtEq(expression TimeExpression) BoolExpression {
+	return GtEq(t.parent, expression)
+}
+
+func (t *timeInterfaceImpl) GtEqL(literal string) BoolExpression {
+	return GtEq(t.parent, Literal(literal))
+}
+
+func (t *timeInterfaceImpl) LtEq(expression TimeExpression) BoolExpression {
+	return LtEq(t.parent, expression)
+}
+
+func (t *timeInterfaceImpl) LtEqL(literal string) BoolExpression {
+	return LtEq(t.parent, Literal(literal))
+}