fix comments

protos/pb.proto

@@ -93,7 +93,7 @@ message Result {
   repeated FacetsList facet_matrix = 5;
   repeated LangList lang_matrix = 6;
   bool list = 7;
-  map<string, uint64> extra_metrics = 8;
+  map<string, uint64> vector_metrics = 8;
 }
 
 message Order {
@@ -526,7 +526,7 @@ message SchemaUpdate {
 message VectorSpec {
   // This names the kind of Vector Index, e.g.,
   //    hnsw, lsh, hypertree, ...
-  string name = 1;
+  string indexName = 1;
   repeated OptionPair options = 2;
 }
 

query/math.go

@@ -17,8 +17,6 @@
 package query
 
 import (
-	"testing"
-
 	"github.com/golang/glog"
 	"github.com/pkg/errors"
 
@@ -31,7 +29,6 @@ type mathTree struct {
 	Const types.Val // If its a const value node.
 	Val   map[uint64]types.Val
 	Child []*mathTree
-	t     *testing.T
 }
 
 var (

query/math_test.go

@@ -222,6 +222,20 @@ func TestProcessBinary(t *testing.T) {
 			}},
 			out: types.Val{Tid: types.FloatID, Value: 8.0},
 		},
+		{in: &mathTree{
+			Fn: "+",
+			Child: []*mathTree{
+				{Const: types.Val{
+					Tid:   types.VFloatID,
+					Value: []float32{0.0005, 0.25001, 0.7500001}}},
+				{Const: types.Val{
+					Tid:   types.VFloatID,
+					Value: []float32{0.0005, 0.25001, 0.7500001}}},
+			}},
+			out: types.Val{
+				Tid:   types.VFloatID,
+				Value: []float32{0.001, 0.50002, 1.5000002}},
+		},
 		{in: &mathTree{
 			Fn: "+",
 			Child: []*mathTree{
@@ -269,14 +283,11 @@ func TestProcessBinary(t *testing.T) {
 			Child: []*mathTree{
 				{Const: types.Val{
 					Tid:   types.IntID,
-					Value: int64(2)},
-					t: t},
+					Value: int64(2)}},
 				{Const: types.Val{
 					Tid:   types.VFloatID,
-					Value: []float32{0.25, 0.5, 0.75}},
-					t: t},
-			},
-			t: t},
+					Value: []float32{0.25, 0.5, 0.75}}},
+			}},
 			out: types.Val{
 				Tid:   types.VFloatID,
 				Value: []float32{0.5, 1.0, 1.5}},

schema/parse_test.go

@@ -42,8 +42,7 @@ func checkSchema(t *testing.T, h map[string]*pb.SchemaUpdate, expected []nameTyp
 	for _, nt := range expected {
 		typ, found := h[nt.name]
 		require.True(t, found, nt)
-		require.EqualValuesf(t, *nt.typ, *typ, "found in map: %+v\n expected: %+v",
-			*typ, *nt.typ)
+		require.EqualValuesf(t, *nt.typ, *typ, "found in map: %+v\n expected: %+v", *typ, *nt.typ)
 	}
 }
 
@@ -53,7 +52,7 @@ age:int .
 name: string .
  address: string .
 <http://scalar.com/helloworld/> : string .
-coordinates: vfloat .
+coordinates: float32vector .
 `
 
 func TestSchema(t *testing.T) {

types/conversion.go

@@ -98,7 +98,7 @@ func ParseVFloat(s string) ([]float32, error) {
 }
 
 func cannotConvertToVFloat(s string) error {
-	return errors.Errorf("Cannot convert %s to vfloat", s)
+	return errors.Errorf("cannot convert %s to vfloat", s)
 }
 
 // Convert converts the value to given scalar type.
@@ -108,7 +108,7 @@ func Convert(from Val, toID TypeID) (Val, error) {
 	// sanity: we expect a value
 	data, ok := from.Value.([]byte)
 	if !ok {
-		return to, errors.Errorf("Invalid data to convert to %s", toID.Name())
+		return to, errors.Errorf("invalid data to convert to %s", toID.Name())
 	}
 
 	fromID := from.Tid

types/scalar_types.go

@@ -68,17 +68,17 @@ const (
 )
 
 var typeNameMap = map[string]TypeID{
-	"default":  DefaultID,
-	"binary":   BinaryID,
-	"int":      IntID,
-	"float":    FloatID,
-	"bool":     BoolID,
-	"datetime": DateTimeID,
-	"geo":      GeoID,
-	"uid":      UidID,
-	"string":   StringID,
-	"password": PasswordID,
-	"vfloat":   VFloatID,
+	"default":       DefaultID,
+	"binary":        BinaryID,
+	"int":           IntID,
+	"float":         FloatID,
+	"bool":          BoolID,
+	"datetime":      DateTimeID,
+	"geo":           GeoID,
+	"uid":           UidID,
+	"string":        StringID,
+	"password":      PasswordID,
+	"float32vector": VFloatID,
 }
 
 // TypeID represents the type of the data.

types/value.go

@@ -21,50 +21,23 @@ import (
 	"math"
 	"strconv"
 	"strings"
+	"unsafe"
 )
 
 // BytesAsFloatArray(encoded) converts encoded into a []float32.
 // If len(encoded) % 4 is not 0, it will ignore any trailing
 // bytes, and simply convert 4 bytes at a time to generate the
 // float64 entries.
-// WARNING: Current implementation always requires a memory allocation!
+// Current implementation assuming littleEndian encoding
 func BytesAsFloatArray(encoded []byte) []float32 {
-	// Unfortunately, this is not as simple as casting the result,
-	// and it is also not possible to directly use the
-	// golang "unsafe" library to directly do the conversion.
-	// The operation:
-	//      []float32(encoded)  does not compile!
-	// Whereas:
-	//      []float32(unsafe.Slice(unsafe.Ptr(encoded), len(encoded)))
-	// might compile (actually have not tested it), but its success or
-	// failure depends on agreement of the serialization mechanism
-	// of the source data and the data as it exists on the machine where
-	// the operation is being performed.
-	// The machine where this operation gets run might prefer
-	// BigEndian/LittleEndian, but the machine that sent it may have
-	// preferred the other, and there is no way to tell!
-	//
-	// The solution below, unfortunately, requires another memory
-	// allocation.
-	// TODO Potential optimization: If we detect that current machine is
-	// using LittleEndian format, there might be a way of making this
-	// work with the golang "unsafe" library.
 
 	resultLen := len(encoded) / 4
 	if resultLen == 0 {
 		return []float32{}
 	}
 	retVal := make([]float32, resultLen)
 	for i := 0; i < resultLen; i++ {
-		// Assume LittleEndian for encoding since this is
-		// the assumption elsewhere when reading from client.
-		// See dgraph-io/dgo/protos/api.pb.go
-		// See also dgraph-io/dgraph/types/conversion.go
-		// This also seems to be the preference from many examples
-		// I have found via Google search. It's unclear why this
-		// should be a preference.
-		bits := binary.LittleEndian.Uint32(encoded)
-		retVal[i] = math.Float32frombits(bits)
+		retVal[i] = *(*float32)(unsafe.Pointer(&encoded[0]))
 		encoded = encoded[4:]
 	}
 	return retVal
@@ -86,15 +59,17 @@ func FloatArrayAsBytes(v []float32) []byte {
 }
 
 func FloatArrayAsString(v []float32) string {
-	retVal := "["
+	var sb strings.Builder
+
+	sb.WriteRune('[')
 	for i := range v {
-		retVal += strconv.FormatFloat(float64(v[i]), 'f', -1, 32)
+		sb.WriteString(strconv.FormatFloat(float64(v[i]), 'f', -1, 32))
 		if i != len(v)-1 {
-			retVal += ", "
+			sb.WriteRune(',')
 		}
 	}
-	retVal += "]"
-	return retVal
+	sb.WriteRune(']')
+	return sb.String()
 }
 
 // TypeForValue tries to determine the most likely type based on a value. We only want to use this