Base32 encoding and decoding

execution/functions/functions.go

@@ -1,6 +1,7 @@
 package functions
 
 import (
+	"encoding/base32"
 	"fmt"
 	"log"
 	"math"
@@ -1266,6 +1267,28 @@ var FuncParseTime = execution.Function{
 	},
 }
 
+var FuncDecodeBase32 = execution.Function{
+	Name: "decode_base32",
+	ArgumentNames: [][]string{
+		{"text"},
+	},
+	Description: docs.List(
+		docs.Text("Decodes the text from Base32. Especially useful when using a datasource which stores text as byte fields."),
+	),
+	Validator: All(
+		ExactlyNArgs(1),
+		AllArgs(TypeOf(ZeroString())),
+	),
+	Logic: func(args ...Value) (Value, error) {
+		data, err := base32.StdEncoding.DecodeString(args[0].AsString())
+		if err != nil {
+			return ZeroValue(), errors.Wrap(err, "couldn't decode base32")
+		}
+
+		return MakeString(string(data)), nil
+	},
+}
+
 /* Auxiliary functions */
 func intMin(x, y int) int {
 	if x <= y {

execution/functions/table.go

@@ -48,6 +48,7 @@ var usableFunctions = []execution.Function{
 	FuncCoalesce,
 	FuncNullIf,
 	FuncParseTime,
+	FuncDecodeBase32,
 }
 
 func init() {

storage/parquet/datasource_test.go

@@ -2,6 +2,7 @@ package parquet
 
 import (
 	"context"
+	"encoding/base32"
 	"testing"
 
 	"github.com/cube2222/octosql"
@@ -37,19 +38,19 @@ func TestParquetRecordStream_Get(t *testing.T) {
 				[]*execution.Record{
 					execution.NewRecordFromSliceWithNormalize(
 						[]octosql.VariableName{"b.color", "b.id", "b.ownerid", "b.wheels", "b.year"},
-						[]interface{}{"green", 1, 152849, 3, 2014},
+						[]interface{}{base32.StdEncoding.EncodeToString([]byte("green")), 1, 152849, 3, 2014},
 					),
 					execution.NewRecordFromSliceWithNormalize(
 						[]octosql.VariableName{"b.color", "b.id", "b.ownerid", "b.wheels", "b.year"},
-						[]interface{}{"black", 2, 106332, 2, 1988},
+						[]interface{}{base32.StdEncoding.EncodeToString([]byte("black")), 2, 106332, 2, 1988},
 					),
 					execution.NewRecordFromSliceWithNormalize(
 						[]octosql.VariableName{"b.color", "b.id", "b.ownerid", "b.wheels", "b.year"},
-						[]interface{}{"purple", 3, 99148, 2, 2009},
+						[]interface{}{base32.StdEncoding.EncodeToString([]byte("purple")), 3, 99148, 2, 2009},
 					),
 					execution.NewRecordFromSliceWithNormalize(
 						[]octosql.VariableName{"b.color", "b.id", "b.ownerid", "b.wheels", "b.year"},
-						[]interface{}{"orange", 4, 97521, 2, 1979},
+						[]interface{}{base32.StdEncoding.EncodeToString([]byte("orange")), 4, 97521, 2, 1979},
 					),
 				},
 			),

values.go

@@ -1,7 +1,6 @@
 package octosql
 
 import (
-	"bytes"
 	"encoding/base32"
 	"fmt"
 	"log"
@@ -149,19 +148,7 @@ func NormalizeType(value interface{}) Value {
 	case float64:
 		return MakeFloat(value)
 	case []byte:
-		var buf bytes.Buffer
-		enc := base32.NewEncoder(base32.StdEncoding, &buf)
-		n, err := enc.Write(value)
-		if err != nil {
-			panic(fmt.Sprintf("couldn't base64 encode bytes: %s", err.Error()))
-		}
-		if n != len(value) {
-			panic(fmt.Sprintf("couldn't base64 encode bytes: wrote only %d of %d bytes", n, len(value)))
-		}
-		if err := enc.Close(); err != nil {
-			panic(fmt.Sprintf("couldn't close base64 encode bytes: %s", err.Error()))
-		}
-		return MakeString(buf.String())
+		return MakeString(base32.StdEncoding.EncodeToString(value))
 	case string:
 		return MakeString(value)
 	case []interface{}:

values_test.go

@@ -1,32 +1,14 @@
 package octosql
 
 import (
-	"bytes"
 	"encoding/base32"
-	"fmt"
 	"math"
 	"testing"
 	"time"
 
 	"github.com/golang/protobuf/proto"
 )
 
-func stringToBase32(str string) string {
-	var buf bytes.Buffer
-	enc := base32.NewEncoder(base32.StdEncoding, &buf)
-	n, err := enc.Write([]byte(str))
-	if err != nil {
-		panic(fmt.Sprintf("couldn't base64 encode bytes: %s", err.Error()))
-	}
-	if n != len(str) {
-		panic(fmt.Sprintf("couldn't base64 encode bytes: wrote only %d of %d bytes", n, len(str)))
-	}
-	if err := enc.Close(); err != nil {
-		panic(fmt.Sprintf("couldn't close base64 encode bytes: %s", err.Error()))
-	}
-	return buf.String()
-}
-
 func TestNormalizeType(t *testing.T) {
 	tests := []struct {
 		name  string
@@ -45,7 +27,7 @@ func TestNormalizeType(t *testing.T) {
 				"array": []interface{}{[]interface{}{float32(1), uint8(2), int64(3)}, true},
 			},
 			want: MakeObject(map[string]Value{
-				"name": MakeString(stringToBase32("Jakub")),
+				"name": MakeString(base32.StdEncoding.EncodeToString([]byte("Jakub"))),
 				"age":  MakeInt(3),
 				"city": MakeObject(map[string]Value{
 					"name":       MakeString("warsaw"),