Add PrefixSearch for full-text prefix matching (GH-1327)

src/DocumentDbTests/Indexes/full_text_index.cs

@@ -923,6 +923,39 @@ await conn.CreateCommand(
         });
         await Should.NotThrowAsync(async () => await store2.Storage.Database.AssertDatabaseMatchesConfigurationAsync());
     }
+
+    [Fact]
+    public async Task prefix_search_matches_partial_enum_value_GH_1327()
+    {
+        StoreOptions(_ => _.RegisterDocumentType<BlogPost>());
+
+        var expectedId = Guid.NewGuid();
+
+        using (var session = theStore.LightweightSession())
+        {
+            session.Store(new BlogPost { Id = expectedId, EnglishText = "PricedIdeaScreening" });
+            session.Store(new BlogPost { Id = Guid.NewGuid(), EnglishText = "UnrelatedContent" });
+            await session.SaveChangesAsync();
+        }
+
+        using (var session = theStore.QuerySession())
+        {
+            // Standard Search does NOT match a partial prefix of a concatenated word
+            var noMatch = session.Query<BlogPost>()
+                .Where(x => x.Search("Priced"))
+                .ToList();
+
+            noMatch.ShouldBeEmpty();
+
+            // PrefixSearch DOES match because it uses the :* prefix operator
+            var results = session.Query<BlogPost>()
+                .Where(x => x.PrefixSearch("Priced"))
+                .ToList();
+
+            results.Count.ShouldBe(1);
+            results[0].Id.ShouldBe(expectedId);
+        }
+    }
 }
 
 public static class FullTextIndexTestsExtension

src/Marten/IQuerySession.cs

@@ -478,6 +478,24 @@ Task<IReadOnlyList<TDoc>> PhraseSearchAsync<TDoc>(string searchTerm,
     Task<IReadOnlyList<TDoc>> WebStyleSearchAsync<TDoc>(string searchTerm,
         string regConfig = FullTextIndexDefinition.DefaultRegConfig, CancellationToken token = default);
 
+    /// <summary>
+    ///     Performs an asynchronous full text search against <typeparamref name="TDoc" /> using prefix matching.
+    ///     Each word in the search term is treated as a prefix, so "Priced" will match "PricedIdeaScreening".
+    ///     This is useful for searching enum values stored as strings or other concatenated identifiers.
+    /// </summary>
+    /// <param name="searchTerm">The text to search for. Each word is treated as a prefix.</param>
+    /// <param name="regConfig">
+    ///     The dictionary config passed to the 'to_tsquery' function, must match the config parameter used
+    ///     by <seealso cref="DocumentMapping.AddFullTextIndex(string)" />
+    /// </param>
+    /// <param name="token"></param>
+    /// <remarks>
+    ///     Uses PostgreSQL's to_tsquery with the :* prefix matching operator.
+    ///     See: https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+    /// </remarks>
+    Task<IReadOnlyList<TDoc>> PrefixSearchAsync<TDoc>(string searchTerm,
+        string regConfig = FullTextIndexDefinition.DefaultRegConfig, CancellationToken token = default);
+
     /// <summary>
     ///     Fetch the entity version and last modified time from the database
     /// </summary>

src/Marten/Internal/Sessions/QuerySession.FullTextSearch.cs

@@ -33,4 +33,10 @@ public Task<IReadOnlyList<TDoc>> WebStyleSearchAsync<TDoc>(string searchTerm,
     {
         return Query<TDoc>().Where(d => d.WebStyleSearch(searchTerm, regConfig)).ToListAsync(token);
     }
+
+    public Task<IReadOnlyList<TDoc>> PrefixSearchAsync<TDoc>(string searchTerm,
+        string regConfig = FullTextIndexDefinition.DefaultRegConfig, CancellationToken token = default)
+    {
+        return Query<TDoc>().Where(d => d.PrefixSearch(searchTerm, regConfig)).ToListAsync(token);
+    }
 }

src/Marten/Linq/Parsing/Methods/FullText/FullTextSearchMethodCallParser.cs

@@ -54,6 +54,7 @@ public ISqlFragment Parse(IQueryableMemberCollection memberCollection, IReadOnly
         }
 
         var searchTerm = (string)expression.Arguments[1].Value();
+        searchTerm = TransformSearchTerm(searchTerm);
 
         var regConfig = expression.Arguments.Count > 2
             ? (expression.Arguments[2].Value() as string)!
@@ -65,4 +66,6 @@ public ISqlFragment Parse(IQueryableMemberCollection memberCollection, IReadOnly
             searchTerm,
             regConfig);
     }
+
+    protected virtual string TransformSearchTerm(string searchTerm) => searchTerm;
 }

src/Marten/Linq/Parsing/Methods/FullText/PrefixSearch.cs

@@ -0,0 +1,18 @@
+#nullable enable
+using System;
+using System.Linq;
+
+namespace Marten.Linq.Parsing.Methods.FullText;
+
+internal class PrefixSearch: FullTextSearchMethodCallParser
+{
+    public PrefixSearch(): base(nameof(LinqExtensions.PrefixSearch), FullTextSearchFunction.to_tsquery)
+    {
+    }
+
+    protected override string TransformSearchTerm(string searchTerm)
+    {
+        var words = searchTerm.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+        return string.Join(" & ", words.Select(w => w + ":*"));
+    }
+}

src/Marten/LinqExtensions.cs

@@ -300,6 +300,42 @@ public static bool WebStyleSearch<T>(this T variable, string searchTerm, string
             $"{nameof(WebStyleSearch)} extension method can only be used in Marten Linq queries.");
     }
 
+    /// <summary>
+    ///     Performs a full text search against <typeparamref name="T" /> using prefix matching.
+    ///     Each word in the search term is treated as a prefix, so "Priced" will match "PricedIdeaScreening".
+    ///     This is useful for searching enum values stored as strings or other concatenated identifiers.
+    /// </summary>
+    /// <param name="searchTerm">The text to search for. Each word is treated as a prefix.</param>
+    /// <remarks>
+    ///     Uses PostgreSQL's to_tsquery with the :* prefix matching operator.
+    ///     See: https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+    /// </remarks>
+    public static bool PrefixSearch<T>(this T variable, string searchTerm)
+    {
+        throw new NotSupportedException(
+            $"{nameof(PrefixSearch)} extension method can only be used in Marten Linq queries.");
+    }
+
+    /// <summary>
+    ///     Performs a full text search against <typeparamref name="T" /> using prefix matching.
+    ///     Each word in the search term is treated as a prefix, so "Priced" will match "PricedIdeaScreening".
+    ///     This is useful for searching enum values stored as strings or other concatenated identifiers.
+    /// </summary>
+    /// <param name="searchTerm">The text to search for. Each word is treated as a prefix.</param>
+    /// <param name="regConfig">
+    ///     The dictionary config passed to the 'to_tsquery' function, must match the config parameter used
+    ///     by <seealso cref="DocumentMapping.AddFullTextIndex(string)" />
+    /// </param>
+    /// <remarks>
+    ///     Uses PostgreSQL's to_tsquery with the :* prefix matching operator.
+    ///     See: https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+    /// </remarks>
+    public static bool PrefixSearch<T>(this T variable, string searchTerm, string regConfig)
+    {
+        throw new NotSupportedException(
+            $"{nameof(PrefixSearch)} extension method can only be used in Marten Linq queries.");
+    }
+
     /// <summary>
     ///     Performs a ngram search against <typeparamref name="T" /> using a custom ngram search function
     /// </summary>

src/Marten/LinqParsing.cs

@@ -95,7 +95,8 @@ public class LinqParsing: IReadOnlyLinqParsing
         new PhraseSearch(),
         new PlainTextSearch(),
         new WebStyleSearch(),
-        new NgramSearch()
+        new NgramSearch(),
+        new PrefixSearch()
     };
 
     private readonly StoreOptions _options;