Finish draft of hybrid search, improvements to find enumerators, update find to be fully fluent for consistency

Author: stephenatsembit

src/DataStax.AstraDB.DataApi/Collections/Collection.cs

@@ -0,0 +1,55 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+
+namespace DataStax.AstraDB.DataApi.Core;
+
+/// <summary>
+/// Configuration for the analyzer
+/// </summary>
+public class AnalyzerOptions
+{
+    /// <summary>
+    /// Tokenizer configuration
+    /// </summary>
+    [JsonPropertyName("tokenizer")]
+    public TokenizerOptions Tokenizer { get; set; } = new();
+
+    /// <summary>
+    /// List of filters to apply
+    /// </summary>
+    [JsonIgnore]
+    public List<string> Filters { get; set; } = new();
+
+    /// <summary>
+    /// List of character filters to apply
+    /// </summary>
+    [JsonPropertyName("charFilters")]
+    public List<string> CharacterFilters { get; set; } = new();
+
+    [JsonPropertyName("filters")]
+    [JsonInclude]
+    internal List<FilterOptions> FilterOptions
+    {
+        get
+        {
+            return Filters.Select(f => new FilterOptions() { Name = f }).ToList();
+        }
+    }
+}

src/DataStax.AstraDB.DataApi/Core/AnalyzerOptions.cs

@@ -44,30 +44,48 @@ public class CollectionDefinition
     [JsonPropertyName("indexing")]
     public IndexingOptions Indexing { get; set; }
 
+    /// <summary>
+    /// Lexical analysis options for the collection
+    /// </summary>
+    [JsonPropertyName("lexical")]
+    public LexicalOptions Lexical { get; set; }
+
+    /// <summary>
+    /// Reranking options for the collection
+    /// </summary>
+    [JsonPropertyName("rerank")]
+    public RerankOptions Rerank { get; set; }
+
     internal static CollectionDefinition Create<T>()
+    {
+        return CheckAddDefinitionsFromAttributes<T>(new CollectionDefinition());
+    }
+
+    internal static CollectionDefinition CheckAddDefinitionsFromAttributes<T>(CollectionDefinition definition)
     {
         Type type = typeof(T);
         PropertyInfo idProperty = null;
         DocumentIdAttribute idAttribute = null;
 
-        CollectionDefinition definition = new();
-
-        foreach (var property in type.GetProperties())
+        if (definition.DefaultId == null)
         {
-            var attr = property.GetCustomAttribute<DocumentIdAttribute>();
-            if (attr != null)
+            foreach (var property in type.GetProperties())
             {
-                idProperty = property;
-                idAttribute = attr;
-                break;
+                var attr = property.GetCustomAttribute<DocumentIdAttribute>();
+                if (attr != null)
+                {
+                    idProperty = property;
+                    idAttribute = attr;
+                    break;
+                }
             }
-        }
 
-        if (idProperty != null)
-        {
-            if (idAttribute.DefaultIdType.HasValue)
+            if (idProperty != null)
             {
-                definition.DefaultId = new DefaultIdOptions() { Type = idAttribute.DefaultIdType.Value };
+                if (idAttribute.DefaultIdType.HasValue)
+                {
+                    definition.DefaultId = new DefaultIdOptions() { Type = idAttribute.DefaultIdType.Value };
+                }
             }
         }
 

src/DataStax.AstraDB.DataApi/Core/CollectionDefinition.cs

@@ -202,6 +202,7 @@ internal T Deserialize<T>(string input)
             deserializeOptions.Converters.Add(new DateTimeConverter<DateTime>());
         }
         deserializeOptions.Converters.Add(new IpAddressConverter());
+        deserializeOptions.Converters.Add(new AnalyzerOptionsConverter());
 
         return JsonSerializer.Deserialize<T>(input, deserializeOptions);
     }
@@ -302,6 +303,9 @@ private async Task<T> RunCommandAsync<T>(HttpMethod method, bool runSynchronousl
                     }
                     else
                     {
+                        responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+                        MaybeLogDebugMessage("Response Status Code: {StatusCode}", response.StatusCode);
+                        MaybeLogDebugMessage("Content: {Content}", responseContent);
                         throw new HttpRequestException($"Request to failed with status code {response.StatusCode}.");
                     }
                 }

src/DataStax.AstraDB.DataApi/Core/Commands/Command.cs

@@ -28,6 +28,8 @@ internal static class DataApiKeywords
     internal const string Slice = "$slice";
     internal const string Similarity = "$similarity";
     internal const string Vector = "$vector";
+    internal const string Lexical = "$lexical";
+    internal const string Hybrid = "$hybrid";
     internal const string SortVector = "sortVector";
     internal const string Vectorize = "$vectorize";
     internal const string Binary = "$binary";