add more expressions

Author: cherylEnkidu

Firestore/Swift/Source/ExpressionImplementation.swift

@@ -336,10 +336,10 @@ extension Expression {
   /// Field("content").stringReplace(Field("target"), Field("replacement"))
   /// ```
   ///
-  /// - Parameter find: An `Expr` (evaluating to a string) for the substring to search for.
-  /// - Parameter replace: An `Expr` (evaluating to a string) for the substring to replace all
+  /// - Parameter find: An `Expression` (evaluating to a string) for the substring to search for.
+  /// - Parameter replace: An `Expression` (evaluating to a string) for the substring to replace all
   /// occurrences with.
-  /// - Returns: A new `FunctionExpr` representing the string with all occurrences replaced.
+  /// - Returns: A new `FunctionExpression` representing the string with all occurrences replaced.
   func stringReplace(_ find: Expression, with replace: Expression) -> FunctionExpression{
     return FunctionExpression("string_replace", [self, find, replace])
   }
@@ -377,6 +377,14 @@ public extension Expression {
     return FunctionExpression("pow", [self, exponent])
   }
 
+  func round() -> FunctionExpression {
+    return FunctionExpression("round", [self])
+  }
+
+  func sqrt() -> FunctionExpression {
+    return FunctionExpression("sqrt", [self])
+  }
+
   func exp() -> FunctionExpression {
     return FunctionExpression("exp", [self])
   }
@@ -623,11 +631,11 @@ public extension Expression {
     return BooleanExpression("regex_match", [self, pattern])
   }
 
-  func strContains(_ substring: String) -> BooleanExpression {
+  func stringContains(_ substring: String) -> BooleanExpression {
     return BooleanExpression("string_contains", [self, Helper.sendableToExpr(substring)])
   }
 
-  func string_contains(_ expression: Expression) -> BooleanExpression {
+  func stringContains(_ expression: Expression) -> BooleanExpression {
     return BooleanExpression("string_contains", [self, expression])
   }
 
@@ -663,10 +671,19 @@ public extension Expression {
     return FunctionExpression("string_concat", [self] + strings)
   }
 
+  func stringConcat(_ strings: [Sendable]) -> FunctionExpression {
+    let exprs = [self] + strings.map { Helper.sendableToExpr($0) }
+    return FunctionExpression("string_concat", exprs)
+  }
+
   func reverse() -> FunctionExpression {
     return FunctionExpression("reverse", [self])
   }
 
+  func stringReverse() -> FunctionExpression {
+    return FunctionExpression("string_reverse", [self])
+  }
+
   func byteLength() -> FunctionExpression {
     return FunctionExpression("byte_length", [self])
   }

Firestore/Swift/Source/SwiftAPI/Pipeline/Expressions/Expression.swift

@@ -36,6 +36,26 @@ public protocol Expression: Sendable {
 
   // --- Added Mathematical Operations ---
 
+  /// Creates an expression that returns the value of self rounded to the nearest integer.
+  ///
+  /// ```swift
+  /// // Get the value of the "amount" field rounded to the nearest integer.
+  /// Field("amount").round()
+  /// ```
+  ///
+  /// - Returns: A new `FunctionExpression` representing the rounded number.
+  func round() -> FunctionExpression
+
+  /// Creates an expression that returns the square root of self.
+  ///
+  /// ```swift
+  /// // Get the square root of the "area" field.
+  /// Field("area").sqrt()
+  /// ```
+  ///
+  /// - Returns: A new `FunctionExpression` representing the square root of the number.
+  func sqrt() -> FunctionExpression
+
   /// Creates an expression that returns the value of self raised to the power of Y.
   ///
   /// Returns zero on underflow.
@@ -797,26 +817,26 @@ public protocol Expression: Sendable {
   ///
   /// ```swift
   /// // Check if the "description" field contains "example".
-  /// Field("description").string_contains("example")
+  /// Field("description").stringContains("example")
   /// ```
   ///
   /// - Parameter substring: The literal string substring to search for.
-  /// - Returns: A new `BooleanExpr` representing the "str_contains" comparison.
-  func strContains(_ substring: String) -> BooleanExpression
+  /// - Returns: A new `BooleanExpr` representing the "stringContains" comparison.
+  func stringContains(_ substring: String) -> BooleanExpression
 
   /// Creates an expression that checks if a string (from `self`) contains a specified substring
   /// from an expression (case-sensitive).
   /// Assumes `self` evaluates to a string, and `expr` evaluates to a string.
   ///
   /// ```swift
   /// // Check if the "message" field contains the value of the "keyword" field.
-  /// Field("message").string_contains(Field("keyword"))
+  /// Field("message").stringContains(Field("keyword"))
   /// ```
   ///
   /// - Parameter expr: An `Expression` (evaluating to a string) representing the substring to
   /// search for.
   /// - Returns: A new `BooleanExpr` representing the "str_contains" comparison.
-  func string_contains(_ expression: Expression) -> BooleanExpression
+  func stringContains(_ expression: Expression) -> BooleanExpression
 
   /// Creates an expression that checks if a string (from `self`) starts with a given literal prefix
   /// (case-sensitive).
@@ -906,6 +926,18 @@ public protocol Expression: Sendable {
   /// - Returns: A new `FunctionExpression` representing the trimmed string.
   func trim() -> FunctionExpression
 
+  /// Creates an expression that concatenates this string expression with other string expressions.
+  /// Assumes `self` and all parameters evaluate to strings.
+  ///
+  /// ```swift
+  /// // Combine "firstName", " ", and "lastName"
+  /// Field("firstName").stringConcat([" ", Field("lastName")])
+  /// ```
+  ///
+  /// - Parameter strings: An array of `Expression` or `String` to concatenate.
+  /// - Returns: A new `FunctionExpression` representing the concatenated string.
+  func stringConcat(_ strings: [Sendable]) -> FunctionExpression
+
   /// Creates an expression that concatenates this string expression with other string expressions.
   /// Assumes `self` and all parameters evaluate to strings.
   ///
@@ -931,6 +963,17 @@ public protocol Expression: Sendable {
   /// - Returns: A new `FunctionExpr` representing the reversed string.
   func reverse() -> FunctionExpression
 
+  /// Creates an expression that reverses this string expression.
+  /// Assumes `self` evaluates to a string.
+  ///
+  /// ```swift
+  /// // Reverse the value of the "myString" field.
+  /// Field("myString").stringReverse()
+  /// ```
+  ///
+  /// - Returns: A new `FunctionExpr` representing the reversed string.
+  func stringReverse() -> FunctionExpression
+
   /// Creates an expression that calculates the length of this string or bytes expression in bytes.
   /// Assumes `self` evaluates to a string or bytes.
   ///

Firestore/Swift/Tests/Integration/PipelineTests.swift

@@ -1831,6 +1831,25 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
     TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
   }
 
+  func testStringConcatWithSendable() async throws {
+    let collRef = collectionRef(withDocuments: bookDocs)
+    let db = collRef.firestore
+
+    let pipeline = db.pipeline()
+      .collection(collRef.path)
+      .sort([Field("author").ascending()])
+      .select([Field("author").stringConcat([" - ", Field("title")]).as("bookInfo")])
+      .limit(1)
+
+    let snapshot = try await pipeline.execute()
+
+    let expectedResults: [[String: Sendable]] = [
+      ["bookInfo": "Douglas Adams - The Hitchhiker's Guide to the Galaxy"],
+    ]
+
+    TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
+  }
+
   func testStartsWith() async throws {
     let collRef = collectionRef(withDocuments: bookDocs)
     let db = collRef.firestore
@@ -1879,7 +1898,7 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
 
     let pipeline = db.pipeline()
       .collection(collRef.path)
-      .where(Field("title").strContains("'s"))
+      .where(Field("title").stringContains("'s"))
       .select(["title"])
       .sort([Field("title").ascending()])
 
@@ -1944,6 +1963,58 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
     TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
   }
 
+  func testReverseWorksOnString() async throws {
+    let collRef = collectionRef(withDocuments: [
+      "doc1": ["value": "abc"],
+      "doc2": ["value": ""],
+      "doc3": ["value": "a"],
+    ])
+    let db = collRef.firestore
+
+    let pipeline = db.pipeline()
+      .collection(collRef.path)
+      .select([
+        Field("value").reverse().as("reversedValue"),
+      ])
+      .sort([Field("reversedValue").ascending()])
+
+    let snapshot = try await pipeline.execute()
+
+    let expectedResults: [[String: Sendable]] = [
+      ["reversedValue": ""],
+      ["reversedValue": "a"],
+      ["reversedValue": "cba"],
+    ]
+
+    TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
+  }
+  
+  func testReverseWorksOnArray() async throws {
+    let collRef = collectionRef(withDocuments: [
+      "doc1": ["tags": ["a", "b", "c"]],
+      "doc2": ["tags": [1, 2, 3]],
+      "doc3": ["tags": []],
+    ])
+    let db = collRef.firestore
+
+    let pipeline = db.pipeline()
+      .collection(collRef.path)
+      .select([
+        Field("tags").reverse().as("reversedTags"),
+      ])
+      .sort([Field("reversedTags").ascending()])
+
+    let snapshot = try await pipeline.execute()
+
+    let expectedResults: [[String: Sendable]] = [
+      ["reversedTags": []],
+      ["reversedTags": [3, 2, 1]],
+      ["reversedTags": ["c", "b", "a"]],
+    ]
+
+    TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
+  }
+
   func testLike() async throws {
     let collRef = collectionRef(withDocuments: bookDocs)
     let db = collRef.firestore
@@ -2156,6 +2227,58 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
     TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
   }
 
+  func testRoundWorks() async throws {
+    let collRef = collectionRef(withDocuments: [
+      "doc1": ["value": -10.8],
+      "doc2": ["value": 5.3],
+      "doc3": ["value": 0],
+    ])
+    let db = collRef.firestore
+
+    let pipeline = db.pipeline()
+      .collection(collRef.path)
+      .select([
+        Field("value").round().as("roundValue"),
+      ])
+      .sort([Field("roundValue").ascending()])
+
+    let snapshot = try await pipeline.execute()
+
+    let expectedResults: [[String: Sendable]] = [
+      ["roundValue": -11],
+      ["roundValue": 0],
+      ["roundValue": 5],
+    ]
+
+    TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
+  }
+
+  func testSqrtWorks() async throws {
+    let collRef = collectionRef(withDocuments: [
+      "doc1": ["value": 4],
+      "doc2": ["value": 9],
+      "doc3": ["value": 16],
+    ])
+    let db = collRef.firestore
+
+    let pipeline = db.pipeline()
+      .collection(collRef.path)
+      .select([
+        Field("value").sqrt().as("sqrtValue"),
+      ])
+      .sort([Field("sqrtValue").ascending()])
+
+    let snapshot = try await pipeline.execute()
+
+    let expectedResults: [[String: Sendable]] = [
+      ["sqrtValue": 2],
+      ["sqrtValue": 3],
+      ["sqrtValue": 4],
+    ]
+
+    TestHelper.compare(pipelineSnapshot: snapshot, expected: expectedResults, enforceOrder: true)
+  }
+
   func testExpWorks() async throws {
     let collRef = collectionRef(withDocuments: [
       "doc1": ["value": 1],