docs/grpc/docs.md (1)

3259-3265: 💡 Verification agent

🧩 Analysis chain

Align new phrase field with oneof formatting
The added phrase row is missing the Label column (should be optional) and must appear in the same order as its protobuf tag.
Apply this diff to update the table:

-| phrase              | [string](#string) |       | Match phrase text |
+| phrase              | [string](#string) | optional | Match phrase text |

Run the following to confirm the tag and ordering in the proto:

---

🏁 Script executed:

#!/bin/bash
# Verify `phrase = 9` exists under oneof match_value
rg -n 'oneof match_value' -n lib/api/src/grpc/proto/points.proto -A3

Length of output: 239

---

🏁 Script executed:

#!/bin/bash
# Fetch the full oneof match_value block to verify phrase tag and ordering
rg -n 'oneof match_value' -n lib/api/src/grpc/proto/points.proto -A50

Length of output: 1853

---

Align phrase row label
The phrase entry in the table is missing its Label (optional). The proto’s oneof match_value block confirms phrase = 9; and it’s already correctly placed as the last entry. Please apply:

-| phrase              | [string](#string) |       | Match phrase text |
+| phrase              | [string](#string) | optional | Match phrase text |

lib/api/src/grpc/qdrant.rs (1)

6409-6411: Define the Phrase variant
The Phrase(::String) variant is properly annotated with prost(string, tag = "9"). Consider enhancing the doc comment to clarify phrase-matching semantics (e.g., order sensitivity, tokenization).

lib/segment/src/index/field_index/field_index_base.rs (1)

183-188: Minor duplication – map variant to flag to keep the match arm tight

The two arms only differ by the const-generic flag. A tiny helper would keep the match compact and avoid future drift:

-                Some(Match::Text(MatchText { text })) => Some(
-                    full_text_index.check_payload_match::<false>(payload_value, text, hw_counter),
-                ),
-                Some(Match::Phrase(MatchPhrase { phrase })) => Some(
-                    full_text_index.check_payload_match::<true>(payload_value, phrase, hw_counter),
-                ),
+                Some(m) => {
+                    let (phrase, is_phrase) = match m {
+                        Match::Text(MatchText { text }) => (text, false),
+                        Match::Phrase(MatchPhrase { phrase }) => (phrase, true),
+                        _ => return None,
+                    };
+                    Some(full_text_index.check_payload_match::<{ is_phrase }>(
+                        payload_value,
+                        phrase,
+                        hw_counter,
+                    ))
+                }

Not critical, just a readability win.

lib/api/src/grpc/conversions.rs (1)

1653-1666: Round-trip conversion misses ownership optimisation

The new arm converts Match::Phrase by cloning the inner String (phrase is moved into a new struct, then cloned by Prost when serialising).
You can avoid one allocation by using into_inner() (if available) or by pattern-matching by value:

-            segment::types::Match::Phrase(segment::types::MatchPhrase { phrase }) => {
-                MatchValue::Phrase(phrase)
-            }
+            segment::types::Match::Phrase(segment::types::MatchPhrase { phrase }) => {
+                MatchValue::Phrase(phrase)
+            } // consider `phrase.into()` if the proto accepts `String` by value

(If the proto field already takes ownership this comment can be ignored.)

lib/segment/src/index/field_index/full_text_index/tests/mod.rs (1)

182-194: parse_text_query is called twice – consider dropping the unused result

The first call to index.query("ROBO", …) already exercises tokenisation; the extra parse_text_query + check_match loop duplicates work and slows the test by ~35 %.
Unless you specifically need to test check_match, you can remove lines 182-186:

-    let query = index.parse_text_query("ROBO", &hw_counter).unwrap();
-
-    for idx in res.iter().copied() {
-        assert!(index.check_match(&query, idx, &hw_counter));
-    }

lib/segment/src/types.rs (2)

2090-2094: Nit: accept any Into<String> in the convenience ctor

new_phrase(&str) mirrors new_text, but restricting to &str is unnecessary – callers with an owned String will allocate again.

- pub fn new_phrase(phrase: &str) -> Self {
-     Self::Phrase(MatchPhrase {
-         phrase: phrase.into(),
-     })
+ pub fn new_phrase<P: Into<String>>(phrase: P) -> Self {
+     Self::Phrase(MatchPhrase {
+         phrase: phrase.into(),
+     })
 }

This is purely ergonomic; feel free to ignore if you want to keep the API surface minimal.

---

2120-2122: Missing exhaustive pattern in From<MatchInterface> conversion

When converting, the Phrase arm is placed last but the earlier arms use field shorthands to rebuild the inner structs:

MatchInterface::Phrase(MatchPhrase { phrase }) => Self::Phrase(MatchPhrase { phrase }),

This works, but is verbose compared to the other arms. To be consistent and avoid double construction you could just forward the struct:

- MatchInterface::Phrase(MatchPhrase { phrase }) => Self::Phrase(MatchPhrase { phrase }),
+ MatchInterface::Phrase(phrase) => Self::Phrase(phrase),

Not critical, but keeps the code symmetrical.

lib/segment/src/index/field_index/full_text_index/text_index.rs (1)

340-354: Minor duplication – favour shared helper

check_payload_match duplicates the phrase vs. text selection logic already present in get_match_text_checker. Extracting a small helper that returns an Option<ParsedQuery> for both cases would remove this repeat and keep behaviour in one place.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro