Merge pull request valkey-io#3407 from niharikabhavaraju/niharika-bitposcmd

GO: Implement Bitpos command

Author: niharikabhavaraju

CHANGELOG.md

@@ -19,6 +19,7 @@
 * Go: Fix unsafe precondition violation for the slice::from_raw_parts ([#3350](https://github.com/valkey-io/valkey-glide/issues/3350))
 * Go: Add `GeoAdd` and the Geospatial interface ([#3366](https://github.com/valkey-io/valkey-glide/pull/3366))
 * Go: Add `LOLWUT` ([#3355](https://github.com/valkey-io/valkey-glide/pull/3355))
+* Go: Add `BITPOS` ([#3407](https://github.com/valkey-io/valkey-glide/pull/3407))
 * Go: Add `FLUSHALL` ([#3117](https://github.com/valkey-io/valkey-glide/pull/3117))
 * Go: Add `FLUSHDB` ([#3117](https://github.com/valkey-io/valkey-glide/pull/3117))
 * Go: Add password update api ([#3346](https://github.com/valkey-io/valkey-glide/pull/3346))

go/api/base_client.go

@@ -5713,6 +5713,54 @@ func (client *baseClient) XClaimJustIdWithOptions(
 	return handleStringArrayResponse(result)
 }
 
+// Returns the position of the first bit matching the given bit value.
+//
+// Parameters:
+//
+//	key - The key of the string.
+//	bit - The bit value to match. The value must be 0 or 1.
+//
+// Return value:
+//
+//	The position of the first occurrence matching bit in the binary value of
+//	the string held at key. If bit is not found, a -1 is returned.
+//
+// [valkey.io]: https://valkey.io/commands/bitpos/
+func (client *baseClient) BitPos(key string, bit int64) (int64, error) {
+	result, err := client.executeCommand(C.BitPos, []string{key, utils.IntToString(bit)})
+	if err != nil {
+		return defaultIntResponse, err
+	}
+	return handleIntResponse(result)
+}
+
+// Returns the position of the first bit matching the given bit value.
+//
+// Parameters:
+//
+//	key - The key of the string.
+//	bit - The bit value to match. The value must be 0 or 1.
+//	bitposOptions  - The [BitPosOptions] type.
+//
+// Return value:
+//
+//	The position of the first occurrence matching bit in the binary value of
+//	the string held at key. If bit is not found, a -1 is returned.
+//
+// [valkey.io]: https://valkey.io/commands/bitpos/
+func (client *baseClient) BitPosWithOptions(key string, bit int64, bitposOptions options.BitPosOptions) (int64, error) {
+	optionArgs, err := bitposOptions.ToArgs()
+	if err != nil {
+		return defaultIntResponse, err
+	}
+	commandArgs := append([]string{key, utils.IntToString(bit)}, optionArgs...)
+	result, err := client.executeCommand(C.BitPos, commandArgs)
+	if err != nil {
+		return defaultIntResponse, err
+	}
+	return handleIntResponse(result)
+}
+
 // Copies the value stored at the source to the destination key if the
 // destination key does not yet exist.
 //

go/api/bitmap_commands.go

@@ -18,6 +18,10 @@ type BitmapCommands interface {
 
 	BitCountWithOptions(key string, options options.BitCountOptions) (int64, error)
 
+	BitPos(key string, bit int64) (int64, error)
+
+	BitPosWithOptions(key string, bit int64, options options.BitPosOptions) (int64, error)
+
 	BitField(key string, subCommands []options.BitFieldSubCommands) ([]Result[int64], error)
 
 	BitFieldRO(key string, commands []options.BitFieldROCommands) ([]Result[int64], error)

go/api/bitmap_commands_test.go

@@ -300,3 +300,68 @@ func ExampleGlideClusterClient_BitOp() {
 	// BitOp XOR Result: 6
 	// BitOp NOT Result: 6
 }
+
+func ExampleGlideClient_BitPos() {
+	var client *GlideClient = getExampleGlideClient() // example helper function
+
+	client.SetBit("my_key", 7, 1)
+
+	result, err := client.BitPos("my_key", 1)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+	}
+	fmt.Println(result)
+
+	// Output: 7
+}
+
+func ExampleGlideClusterClient_BitPos() {
+	var client *GlideClusterClient = getExampleGlideClusterClient() // example helper function
+
+	client.SetBit("my_key", 7, 1)
+
+	result, err := client.BitPos("my_key", 1)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+	}
+	fmt.Println(result)
+
+	// Output: 7
+}
+
+func ExampleGlideClient_BitPosWithOptions() {
+	var client *GlideClient = getExampleGlideClient() // example helper function
+
+	client.Set("my_key", "\x00\x01\x00")
+
+	options := options.NewBitPosOptions().
+		SetStart(0).
+		SetEnd(1)
+
+	result, err := client.BitPosWithOptions("my_key", 1, *options)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+	}
+	fmt.Println(result)
+
+	// Output: 15
+}
+
+func ExampleGlideClusterClient_BitPosWithOptions() {
+	var client *GlideClusterClient = getExampleGlideClusterClient() // example helper function
+
+	client.Set("my_key", "\x00\x10\x00")
+
+	options := options.NewBitPosOptions().
+		SetStart(10).
+		SetEnd(14).
+		SetBitmapIndexType(options.BIT)
+
+	result, err := client.BitPosWithOptions("my_key", 1, *options)
+	if err != nil {
+		fmt.Println("Glide example failed with an error: ", err)
+	}
+	fmt.Println(result)
+
+	// Output: 11
+}

go/api/options/bitpos_options.go

@@ -0,0 +1,59 @@
+// Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+
+package options
+
+import (
+	"github.com/valkey-io/valkey-glide/go/utils"
+)
+
+// Optional arguments to `BitPos` in [BitMapCommands]
+type BitPosOptions struct {
+	start           *int64
+	end             *int64
+	bitMapIndexType BitmapIndexType
+}
+
+func NewBitPosOptions() *BitPosOptions {
+	return &BitPosOptions{}
+}
+
+// SetStart defines start byte to calculate bitpos in bitpos command.
+func (options *BitPosOptions) SetStart(start int64) *BitPosOptions {
+	options.start = &start
+	return options
+}
+
+// SetEnd defines end byte to calculate bitpos in bitpos command.
+func (options *BitPosOptions) SetEnd(end int64) *BitPosOptions {
+	options.end = &end
+	return options
+}
+
+// SetBitmapIndexType to specify start and end are in BYTE or BIT
+func (options *BitPosOptions) SetBitmapIndexType(bitMapIndexType BitmapIndexType) *BitPosOptions {
+	options.bitMapIndexType = bitMapIndexType
+	return options
+}
+
+// ToArgs converts the options to a list of arguments.
+func (opts *BitPosOptions) ToArgs() ([]string, error) {
+	args := []string{}
+
+	if opts.start == nil {
+		return args, nil
+	}
+
+	args = append(args, utils.IntToString(*opts.start))
+
+	if opts.end == nil {
+		return args, nil
+	}
+
+	args = append(args, utils.IntToString(*opts.end))
+
+	if opts.bitMapIndexType == BIT || opts.bitMapIndexType == BYTE {
+		args = append(args, string(opts.bitMapIndexType))
+	}
+
+	return args, nil
+}

go/integTest/shared_commands_test.go

@@ -8352,6 +8352,100 @@ func (suite *GlideTestSuite) TestBitField_MultipleOperations() {
 	})
 }
 
+func (suite *GlideTestSuite) TestBitPos_ExistingKey() {
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		client.Set(key, "\x10")
+		result, err := client.BitPos(key, 1)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(3), result)
+	})
+}
+
+func (suite *GlideTestSuite) TestBitPos_NonExistingKey() {
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		result, err := client.BitPos(key, 0)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(0), result)
+	})
+}
+
+func (suite *GlideTestSuite) TestBitPosWithOptions_StartEnd() {
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		client.Set(key, "\x00\x01\x80")
+
+		opts := options.NewBitPosOptions().
+			SetStart(0).
+			SetEnd(1)
+
+		result, err := client.BitPosWithOptions(key, 1, *opts)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(15), result)
+	})
+}
+
+func (suite *GlideTestSuite) TestBitPosWithOptions_BitmapIndexType() {
+	suite.SkipIfServerVersionLowerThanBy("7.0.0")
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		client.Set(key, "\x00\x02\x00")
+
+		opts := options.NewBitPosOptions().
+			SetStart(1).
+			SetEnd(2).
+			SetBitmapIndexType(options.BYTE)
+
+		result, err := client.BitPosWithOptions(key, 1, *opts)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(14), result)
+	})
+}
+
+func (suite *GlideTestSuite) TestBitPosWithOptions_BitIndexType() {
+	suite.SkipIfServerVersionLowerThanBy("7.0.0")
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		client.Set(key, "\x00\x10\x00")
+
+		opts := options.NewBitPosOptions().
+			SetStart(10).
+			SetEnd(14).
+			SetBitmapIndexType(options.BIT)
+
+		result, err := client.BitPosWithOptions(key, 1, *opts)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(11), result)
+	})
+}
+
+func (suite *GlideTestSuite) TestBitPos_FindBitZero() {
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		client.Set(key, "\xFF\xF7")
+
+		result, err := client.BitPos(key, 0)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(12), result)
+	})
+}
+
+func (suite *GlideTestSuite) TestBitPosWithOptions_NegativeEnd() {
+	suite.runWithDefaultClients(func(client api.BaseClient) {
+		key := uuid.New().String()
+		client.Set(key, "\x00\x01\x80")
+
+		opts := options.NewBitPosOptions().
+			SetStart(0).
+			SetEnd(-2)
+
+		result, err := client.BitPosWithOptions(key, 1, *opts)
+		assert.NoError(suite.T(), err)
+		assert.Equal(suite.T(), int64(15), result)
+	})
+}
+
 func (suite *GlideTestSuite) TestBitField_Failures() {
 	suite.runWithDefaultClients(func(client api.BaseClient) {
 		key := uuid.New().String()