PfAdd fix return type from int to bool (valkey-io#4094)

Author: edlng

CHANGELOG.md

@@ -112,6 +112,7 @@
 * Java: Shadow netty dependencies. ([#3004](https://github.com/valkey-io/valkey-glide/pull/3004))
 * Go: Modify `requestTimeout` and `connectionTimeout` to be of type `time.Duration` ([#3857](https://github.com/valkey-io/valkey-glide/pull/3857))
 * Go: XRead and XReadGroup response update ([#4085](https://github.com/valkey-io/valkey-glide/pull/4085))
+* Modify `PFADD` to return a boolean rather than an integer ([#4094](https://github.com/valkey-io/valkey-glide/pull/4094))
 
 #### Fixes
 

glide-core/src/client/value_conversion.rs

@@ -1458,6 +1458,7 @@ pub(crate) fn expected_type_for_cmd(cmd: &Cmd) -> Option<ExpectedReturnType> {
         | b"SISMEMBER"
         | b"PERSIST"
         | b"SMOVE"
+        | b"PFADD"
         | b"RENAMENX"
         | b"MOVE"
         | b"COPY"
@@ -3168,6 +3169,14 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn convert_pfadd_to_bool() {
+        assert!(matches!(
+            expected_type_for_cmd(redis::cmd("PFADD").arg("key1").arg("a").arg("b")),
+            Some(ExpectedReturnType::Boolean)
+        ));
+    }
+
     #[test]
     fn test_convert_to_map_of_string_to_double() {
         assert_eq!(

go/base_client.go

@@ -3780,16 +3780,16 @@ func (client *baseClient) PTTL(ctx context.Context, key string) (int64, error) {
 // Return value:
 //
 //	If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
-//	altered, then returns `1`. Otherwise, returns `0`.
+//	altered, then returns `true`. Otherwise, returns `false`.
 //
 // [valkey.io]: https://valkey.io/commands/pfadd/
-func (client *baseClient) PfAdd(ctx context.Context, key string, elements []string) (int64, error) {
+func (client *baseClient) PfAdd(ctx context.Context, key string, elements []string) (bool, error) {
 	result, err := client.executeCommand(ctx, C.PfAdd, append([]string{key}, elements...))
 	if err != nil {
-		return models.DefaultIntResponse, err
+		return models.DefaultBoolResponse, err
 	}
 
-	return handleIntResponse(result)
+	return handleBoolResponse(result)
 }
 
 // Estimates the cardinality of the data stored in a HyperLogLog structure for a single key or

go/hyperloglog_commands_test.go

@@ -17,7 +17,7 @@ func ExampleClient_PfAdd() {
 	}
 	fmt.Println(result)
 
-	// Output: 1
+	// Output: true
 }
 
 func ExampleClusterClient_PfAdd() {
@@ -28,7 +28,7 @@ func ExampleClusterClient_PfAdd() {
 	}
 	fmt.Println(result)
 
-	// Output: 1
+	// Output: true
 }
 
 func ExampleClient_PfCount() {
@@ -43,7 +43,7 @@ func ExampleClient_PfCount() {
 	fmt.Println(result1)
 
 	// Output:
-	// 1
+	// true
 	// 3
 }
 
@@ -59,7 +59,7 @@ func ExampleClusterClient_PfCount() {
 	fmt.Println(result1)
 
 	// Output:
-	// 1
+	// true
 	// 3
 }
 

go/integTest/batch_test.go

@@ -1165,13 +1165,13 @@ func CreateHyperLogLogTest(batch *pipeline.ClusterBatch, isAtomic bool, serverVe
 	dest := atomicPrefix + "dest-" + uuid.NewString()
 
 	batch.PfAdd(key1, []string{"val"})
-	testData = append(testData, CommandTestData{ExpectedResponse: int64(1), TestName: "PfAdd(key1, [val])"})
+	testData = append(testData, CommandTestData{ExpectedResponse: true, TestName: "PfAdd(key1, [val])"})
 
 	batch.PfCount([]string{key1})
 	testData = append(testData, CommandTestData{ExpectedResponse: int64(1), TestName: "PfCount([key1])"})
 
 	batch.PfAdd(key1, []string{"val2"})
-	testData = append(testData, CommandTestData{ExpectedResponse: int64(1), TestName: "PfAdd(key2, [val2])"})
+	testData = append(testData, CommandTestData{ExpectedResponse: true, TestName: "PfAdd(key2, [val2])"})
 	batch.PfMerge(prefix+dest, []string{prefix + key1, prefix + key2})
 	testData = append(testData, CommandTestData{ExpectedResponse: "OK", TestName: "PfMerge(dest, [key1 key2])"})
 

go/integTest/shared_commands_test.go

@@ -4117,7 +4117,7 @@ func (suite *GlideTestSuite) TestPfAdd_SuccessfulAddition() {
 		key := uuid.New().String()
 		res, err := client.PfAdd(context.Background(), key, []string{"a", "b", "c", "d", "e"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 	})
 }
 
@@ -4128,25 +4128,25 @@ func (suite *GlideTestSuite) TestPfAdd_DuplicateElements() {
 		// case : Add elements and add same elements again
 		res, err := client.PfAdd(context.Background(), key, []string{"a", "b", "c", "d", "e"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		res2, err := client.PfAdd(context.Background(), key, []string{"a", "b", "c", "d", "e"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(0), res2)
+		assert.False(suite.T(), res2)
 
 		// case : (mixed elements) add new elements with 1 duplicate elements
 		res1, err := client.PfAdd(context.Background(), key, []string{"f", "g", "h"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res1)
+		assert.True(suite.T(), res1)
 
 		res2, err = client.PfAdd(context.Background(), key, []string{"i", "j", "g"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res2)
+		assert.True(suite.T(), res2)
 
 		// case : add empty array(no elements to the HyperLogLog)
 		res, err = client.PfAdd(context.Background(), key, []string{})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(0), res)
+		assert.False(suite.T(), res)
 	})
 }
 
@@ -4155,7 +4155,7 @@ func (suite *GlideTestSuite) TestPfCount_SingleKey() {
 		key := uuid.New().String()
 		res, err := client.PfAdd(context.Background(), key, []string{"i", "j", "g"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		resCount, err := client.PfCount(context.Background(), []string{key})
 		assert.Nil(suite.T(), err)
@@ -4170,11 +4170,11 @@ func (suite *GlideTestSuite) TestPfCount_MultipleKeys() {
 
 		res, err := client.PfAdd(context.Background(), key1, []string{"a", "b", "c"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		res, err = client.PfAdd(context.Background(), key2, []string{"c", "d", "e"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		resCount, err := client.PfCount(context.Background(), []string{key1, key2})
 		assert.Nil(suite.T(), err)
@@ -4201,11 +4201,11 @@ func (suite *GlideTestSuite) TestPfMerge() {
 
 		res, err := client.PfAdd(context.Background(), source1, []string{"a", "b", "c"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		res, err = client.PfAdd(context.Background(), source2, []string{"c", "d", "e"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		result, err := client.PfMerge(context.Background(), destination, []string{source1, source2})
 		assert.Nil(suite.T(), err)
@@ -4224,7 +4224,7 @@ func (suite *GlideTestSuite) TestPfMerge_SingleSource() {
 
 		res, err := client.PfAdd(context.Background(), source, []string{"a", "b", "c"})
 		assert.Nil(suite.T(), err)
-		assert.Equal(suite.T(), int64(1), res)
+		assert.True(suite.T(), res)
 
 		result, err := client.PfMerge(context.Background(), destination, []string{source})
 		assert.Nil(suite.T(), err)

go/internal/interfaces/hyperloglog_commands.go

@@ -10,7 +10,7 @@ import "context"
 //
 // [valkey.io]: https://valkey.io/commands/#hyperloglog
 type HyperLogLogCommands interface {
-	PfAdd(ctx context.Context, key string, elements []string) (int64, error)
+	PfAdd(ctx context.Context, key string, elements []string) (bool, error)
 
 	PfCount(ctx context.Context, keys []string) (int64, error)
 

go/pipeline/base_batch.go

@@ -2350,11 +2350,11 @@ func (b *BaseBatch[T]) PTTL(key string) *T {
 // Command Response:
 //
 //	If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
-//	altered, then returns `1`. Otherwise, returns `0`.
+//	altered, then returns `true`. Otherwise, returns `false`.
 //
 // [valkey.io]: https://valkey.io/commands/pfadd/
 func (b *BaseBatch[T]) PfAdd(key string, elements []string) *T {
-	return b.addCmdAndTypeChecker(C.PfAdd, append([]string{key}, elements...), reflect.Int64, false)
+	return b.addCmdAndTypeChecker(C.PfAdd, append([]string{key}, elements...), reflect.Bool, false)
 }
 
 // Estimates the cardinality of the data stored in a HyperLogLog structure for a single key or

java/client/src/main/java/glide/api/BaseClient.java

@@ -3804,15 +3804,16 @@ public CompletableFuture<Map<GlideString, Object>> bzmpop(
     }
 
     @Override
-    public CompletableFuture<Long> pfadd(@NonNull String key, @NonNull String[] elements) {
+    public CompletableFuture<Boolean> pfadd(@NonNull String key, @NonNull String[] elements) {
         String[] arguments = ArrayUtils.addFirst(elements, key);
-        return commandManager.submitNewCommand(PfAdd, arguments, this::handleLongResponse);
+        return commandManager.submitNewCommand(PfAdd, arguments, this::handleBooleanResponse);
     }
 
     @Override
-    public CompletableFuture<Long> pfadd(@NonNull GlideString key, @NonNull GlideString[] elements) {
+    public CompletableFuture<Boolean> pfadd(
+            @NonNull GlideString key, @NonNull GlideString[] elements) {
         GlideString[] arguments = ArrayUtils.addFirst(elements, key);
-        return commandManager.submitNewCommand(PfAdd, arguments, this::handleLongResponse);
+        return commandManager.submitNewCommand(PfAdd, arguments, this::handleBooleanResponse);
     }
 
     @Override

java/client/src/main/java/glide/api/commands/HyperLogLogBaseCommands.java

@@ -27,14 +27,14 @@ public interface HyperLogLogBaseCommands {
      *     altered, then returns <code>1</code>. Otherwise, returns <code>0</code>.
      * @example
      *     <pre>{@code
-     * Long result = client.pfadd("hll_1", new String[] { "a", "b", "c" }).get();
-     * assert result == 1L; // A data structure was created or modified
+     * Boolean result = client.pfadd("hll_1", new String[] { "a", "b", "c" }).get();
+     * assert result; // A data structure was created or modified
      *
      * result = client.pfadd("hll_2", new String[0]).get();
-     * assert result == 1L; // A new empty data structure was created
+     * assert result; // A new empty data structure was created
      * }</pre>
      */
-    CompletableFuture<Long> pfadd(String key, String[] elements);
+    CompletableFuture<Boolean> pfadd(String key, String[] elements);
 
     /**
      * Adds all elements to the HyperLogLog data structure stored at the specified <code>key</code>.
@@ -49,17 +49,17 @@ public interface HyperLogLogBaseCommands {
      * @param key The <code>key</code> of the HyperLogLog data structure to add elements into.
      * @param elements An array of members to add to the HyperLogLog stored at <code>key</code>.
      * @return If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
-     *     altered, then returns <code>1</code>. Otherwise, returns <code>0</code>.
+     *     altered, then returns <code>true</code>. Otherwise, returns <code>false</code>.
      * @example
      *     <pre>{@code
-     * Long result = client.pfadd(gs("hll_1"), new GlideString[] { gs("a"), gs("b"), gs("c") }).get();
-     * assert result == 1L; // A data structure was created or modified
+     * Boolean result = client.pfadd(gs("hll_1"), new GlideString[] { gs("a"), gs("b"), gs("c") }).get();
+     * assert result; // A data structure was created or modified
      *
      * result = client.pfadd(gs("hll_2"), new GlideString[0]).get();
-     * assert result == 1L; // A new empty data structure was created
+     * assert result; // A new empty data structure was created
      * }</pre>
      */
-    CompletableFuture<Long> pfadd(GlideString key, GlideString[] elements);
+    CompletableFuture<Boolean> pfadd(GlideString key, GlideString[] elements);
 
     /**
      * Estimates the cardinality of the data stored in a HyperLogLog structure for a single key or