Added GEOPOS & GEOHASH as well

Author: bipoool

internal/cmd/cmd_geoadd.go

@@ -83,7 +83,7 @@ func evalGEOADD(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
 	if obj == nil {
 		gr = types.NewGeoRegistry()
 	} else {
-		if obj.Type != object.ObjTypeSortedSet {
+		if obj.Type != object.ObjTypeGeoRegistry {
 			return GEOADDResNilRes, errors.ErrWrongTypeOperation
 		}
 		gr = obj.Value.(*types.GeoRegistry)
@@ -109,7 +109,7 @@ func evalGEOADD(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
 		return GEOADDResNilRes, err
 	}
 
-	s.Put(key, s.NewObj(gr, -1, object.ObjTypeSortedSet), dsstore.WithPutCmd(dsstore.ZAdd))
+	s.Put(key, s.NewObj(gr, -1, object.ObjTypeGeoRegistry), dsstore.WithPutCmd(dsstore.ZAdd))
 	return newGEOADDRes(count), nil
 }
 

internal/cmd/cmd_geodist.go

@@ -31,7 +31,6 @@ localhost:7379> GEOADD Delhi 77.2096 28.6145 centralDelhi 77.2167 28.6315 CP 77.
 OK 3
 localhost:7379> GEODIST Delhi CP IndiaGate km
 OK 2.416700
-
 	`,
 	Eval:    evalGEODIST,
 	Execute: executeGEODIST,
@@ -79,7 +78,7 @@ func evalGEODIST(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
 	if obj == nil {
 		return GEODISTResNilRes, nil
 	}
-	if obj.Type != object.ObjTypeSortedSet {
+	if obj.Type != object.ObjTypeGeoRegistry {
 		return GEODISTResNilRes, errors.ErrWrongTypeOperation
 	}
 	gr = obj.Value.(*types.GeoRegistry)

internal/cmd/cmd_geohash.go

@@ -0,0 +1,89 @@
+// Copyright (c) 2022-present, DiceDB contributors
+// All rights reserved. Licensed under the BSD 3-Clause License. See LICENSE file in the project root for full license information.
+
+package cmd
+
+import (
+	"github.com/dicedb/dice/internal/errors"
+	"github.com/dicedb/dice/internal/object"
+	"github.com/dicedb/dice/internal/shardmanager"
+	dsstore "github.com/dicedb/dice/internal/store"
+	"github.com/dicedb/dice/internal/types"
+	"github.com/dicedb/dicedb-go/wire"
+)
+
+var cGEOHASH = &CommandMeta{
+	Name:      "GEOHASH",
+	Syntax:    "GEOHASH key [member [member ...]]",
+	HelpShort: "Returns valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index",
+	HelpLong: `
+	The command returns 11 characters Geohash strings, so no precision is lost compared to the Redis internal 52 bit representation
+	The returned Geohashes have the following properties:
+	1. They can be shortened removing characters from the right. It will lose precision but will still point to the same area.
+	2. Strings with a similar prefix are nearby, but the contrary is not true, it is possible that strings with different prefixes are nearby too.
+	3. It is possible to use them in geohash.org URLs such as http://geohash.org/<geohash-string>.
+	`,
+	Examples: `
+localhost:7379> GEOADD Delhi 77.2167 28.6315 CP 77.2295 28.6129 IndiaGate 77.1197 28.6412 Rajouri 77.1000 28.5562 Airport 77.1900 28.6517 KarolBagh
+OK 5
+localhost:7379> GEOHASh Delhi CP IndiaGate
+OK 
+0) ttnfvh5qxd0
+1) ttnfv2uf1z0
+	`,
+	Eval:    evalGEOHASH,
+	Execute: executeGEOHASH,
+}
+
+func init() {
+	CommandRegistry.AddCommand(cGEOHASH)
+}
+
+func newGEOHASHRes(hashArr []string) *CmdRes {
+	return &CmdRes{
+		Rs: &wire.Result{
+			Message: "OK",
+			Status:  wire.Status_OK,
+			Response: &wire.Result_GEOHASHRes{
+				GEOHASHRes: &wire.GEOHASHRes{
+					Hashes: hashArr,
+				},
+			},
+		},
+	}
+}
+
+var (
+	GEOHASHResNilRes = newGEOHASHRes([]string{})
+)
+
+func evalGEOHASH(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
+	if len(c.C.Args) < 2 {
+		return GEOHASHResNilRes, errors.ErrWrongArgumentCount("GEOHASH")
+	}
+
+	key := c.C.Args[0]
+	var gr *types.GeoRegistry
+	obj := s.Get(key)
+	if obj == nil {
+		return GEOHASHResNilRes, nil
+	}
+	if obj.Type != object.ObjTypeGeoRegistry {
+		return GEOHASHResNilRes, errors.ErrWrongTypeOperation
+	}
+	gr = obj.Value.(*types.GeoRegistry)
+
+	hashArr := gr.Get11BytesHash(c.C.Args[1:])
+
+	return newGEOHASHRes(hashArr), nil
+
+}
+
+func executeGEOHASH(c *Cmd, sm *shardmanager.ShardManager) (*CmdRes, error) {
+	if len(c.C.Args) < 2 {
+		return GEOHASHResNilRes, errors.ErrWrongArgumentCount("GEOHASH")
+	}
+
+	shard := sm.GetShardForKey(c.C.Args[0])
+	return evalGEOHASH(c, shard.Thread.Store())
+}

internal/cmd/cmd_geopos.go

@@ -0,0 +1,94 @@
+// Copyright (c) 2022-present, DiceDB contributors
+// All rights reserved. Licensed under the BSD 3-Clause License. See LICENSE file in the project root for full license information.
+
+package cmd
+
+import (
+	"github.com/dicedb/dice/internal/errors"
+	"github.com/dicedb/dice/internal/object"
+	"github.com/dicedb/dice/internal/shardmanager"
+	dsstore "github.com/dicedb/dice/internal/store"
+	"github.com/dicedb/dice/internal/types"
+	"github.com/dicedb/dicedb-go/wire"
+)
+
+var cGEOPOS = &CommandMeta{
+	Name:      "GEOPOS",
+	Syntax:    "GEOPOS key [member [member ...]]",
+	HelpShort: "Return the positions (longitude,latitude) of all the specified members of the geospatial index.",
+	HelpLong: `
+		Given a sorted set representing a geospatial index, populated using the GEOADD command, it is often useful to obtain back the coordinates of specified member. 
+		When the geospatial index is populated via GEOADD the coordinates are converted into a 52 bit geohash, 
+		so the coordinates returned may not be exactly the ones used in order to add the elements, but small errors may be introduced.
+	`,
+	Examples: `
+localhost:7379> GEOADD Delhi 77.2167 28.6315 CP 77.2295 28.6129 IndiaGate 77.1197 28.6412 Rajouri 77.1000 28.5562 Airport 77.1900 28.6517 KarolBagh
+OK 5
+localhost:7379> GEOPOS Delhi CP nonEx
+OK 
+0) 77.216700, 28.631498
+1) (nil)
+	`,
+	Eval:    evalGEOPOS,
+	Execute: executeGEOPOS,
+}
+
+func init() {
+	CommandRegistry.AddCommand(cGEOPOS)
+}
+
+func newGEOPOSRes(coordinates []*types.GeoCoordinate) *CmdRes {
+	reponseCoordinates := make([]*wire.GEOCoordinates, len(coordinates))
+	for i, coord := range coordinates {
+		if coord == nil {
+			continue
+		}
+		reponseCoordinates[i] = &wire.GEOCoordinates{
+			Longitude: coord.Longitude,
+			Latitude:  coord.Latitude,
+		}
+	}
+	return &CmdRes{
+		Rs: &wire.Result{
+			Message: "OK",
+			Status:  wire.Status_OK,
+			Response: &wire.Result_GEOPOSRes{
+				GEOPOSRes: &wire.GEOPOSRes{
+					Coordinates: reponseCoordinates,
+				},
+			},
+		},
+	}
+}
+
+var (
+	GEOPOSResNilRes = newGEOPOSRes([]*types.GeoCoordinate{})
+)
+
+func evalGEOPOS(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
+	if len(c.C.Args) < 2 {
+		return GEOPOSResNilRes, errors.ErrWrongArgumentCount("GEOPOS")
+	}
+
+	key := c.C.Args[0]
+	var gr *types.GeoRegistry
+	obj := s.Get(key)
+	if obj == nil {
+		return GEOPOSResNilRes, nil
+	}
+	if obj.Type != object.ObjTypeGeoRegistry {
+		return GEOPOSResNilRes, errors.ErrWrongTypeOperation
+	}
+	gr = obj.Value.(*types.GeoRegistry)
+	coordinates := gr.GetCoordinates(c.C.Args[1:])
+	return newGEOPOSRes(coordinates), nil
+}
+
+func executeGEOPOS(c *Cmd, sm *shardmanager.ShardManager) (*CmdRes, error) {
+	if len(c.C.Args) < 2 {
+		return GEOPOSResNilRes, errors.ErrWrongArgumentCount("GEOPOS")
+	}
+
+	shard := sm.GetShardForKey(c.C.Args[0])
+	return evalGEOPOS(c, shard.Thread.Store())
+}

internal/cmd/cmd_geosearch.go

@@ -110,7 +110,6 @@ func evalGEOSEARCH(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
 	key := c.C.Args[0]
 	params, nonParams := parseParams(c.C.Args[1:])
 
-	// Validate all the parameters
 	if len(nonParams) < 2 {
 		return GEOSEARCHResNilRes, errors.ErrInvalidSyntax("GEOSEARCH")
 	}
@@ -121,12 +120,12 @@ func evalGEOSEARCH(c *Cmd, s *dsstore.Store) (*CmdRes, error) {
 	if obj == nil {
 		return GEODISTResNilRes, nil
 	}
-	if obj.Type != object.ObjTypeSortedSet {
+	if obj.Type != object.ObjTypeGeoRegistry {
 		return GEOSEARCHResNilRes, errors.ErrWrongTypeOperation
 	}
 	gr = obj.Value.(*types.GeoRegistry)
 
-	geoElements, err := gr.GeoSearchElementsWithinShape(params, nonParams)
+	geoElements, err := gr.SearchElementsWithinShape(params, nonParams)
 
 	if err != nil {
 		return GEOSEARCHResNilRes, err

internal/object/object.go

@@ -89,6 +89,7 @@ const (
 	ObjTypeSet
 	ObjTypeSSMap
 	ObjTypeSortedSet
+	ObjTypeGeoRegistry
 	ObjTypeCountMinSketch
 	ObjTypeBF
 	ObjTypeDequeue

internal/types/geo.go

@@ -181,7 +181,7 @@ func (geoReg *GeoRegistry) GetDistanceBetweenMembers(member1 string, member2 str
 }
 
 // This returns all the nodes which are in the given shape
-func (geoReg *GeoRegistry) GeoSearchElementsWithinShape(params map[Param]string, nonParams []string) ([]*wire.GEOElement, error) {
+func (geoReg *GeoRegistry) SearchElementsWithinShape(params map[Param]string, nonParams []string) ([]*wire.GEOElement, error) {
 	unit := GetUnitTypeFromParsedParams(params)
 	if len(unit) == 0 {
 		return nil, errors.ErrInvalidUnit(string(unit))
@@ -490,6 +490,60 @@ func (geoReg *GeoRegistry) GeoSearchElementsWithinShape(params map[Param]string,
 	return resultGeoElements, nil
 }
 
+// This returns 11 characters geohash representation of the position of the specified elements.
+func (geoReg *GeoRegistry) Get11BytesHash(members []string) []string {
+
+	result := make([]string, len(members))
+	geoAlphabet := []rune("0123456789bcdefghjkmnpqrstuvwxyz")
+
+	for idx, member := range members {
+
+		// Get GEOHASH of the member
+		hashNode := geoReg.GetByKey(member)
+		if hashNode == nil {
+			continue
+		}
+		hash := uint64(hashNode.Score())
+
+		// Convert the hash to 11 character string (base32)
+		hashRune := make([]rune, 11)
+		for i := 0; i < 11; i++ {
+			var idx uint64
+			if i == 10 {
+				idx = 0 // pad last char due to only 52 bits
+			} else {
+				shift := 52 - ((i + 1) * 5)
+				idx = (hash >> shift) & 0x1F
+			}
+			hashRune[i] = geoAlphabet[idx]
+		}
+		result[idx] = string(hashRune)
+
+	}
+	return result
+}
+
+// This returns coordinates (longitute, latitude) of all the members
+func (geoReg *GeoRegistry) GetCoordinates(members []string) []*GeoCoordinate {
+	result := make([]*GeoCoordinate, len(members))
+	for i, member := range members {
+		// Get GEOHASH of the member
+		hashNode := geoReg.GetByKey(member)
+		if hashNode == nil {
+			continue
+		}
+		hash := uint64(hashNode.Score())
+		coordinate, _ := NewGeoCoordinateFromHash(hash)
+		result[i] = coordinate
+	}
+	return result
+}
+
+// /////////////////////////////////////////////////////
+// //////////// Utility Functions //////////////////////
+// /////////////////////////////////////////////////////
+
+// Filter dimensions based on flags for GEO Search
 func filterDimensionsBasedOnFlags(geoElements []*wire.GEOElement, withCoord, withDist, withHash bool) {
 	for _, ele := range geoElements {
 		if !withCoord {
@@ -506,10 +560,6 @@ func filterDimensionsBasedOnFlags(geoElements []*wire.GEOElement, withCoord, wit
 	}
 }
 
-// /////////////////////////////////////////////////////
-// //////////// Utility Functions //////////////////////
-// /////////////////////////////////////////////////////
-
 // Encode given Lon and Lat to GEOHASH
 func EncodeHash(longitude, latitude float64) uint64 {
 	return geohash.EncodeIntWithPrecision(latitude, longitude, BIT_PRECISION)
@@ -587,7 +637,7 @@ func ConvertToMeter(distance float64, unit Param) (float64, error) {
 	default:
 		return 0, errors.ErrInvalidUnit(string(unit))
 	}
-	// Round to 4 decimal places
+	// Round to 5 decimal places
 	return math.Round(result*10000) / 10000, nil
 }