perf: compact entry blob ranges

apps/expert/lib/expert/search/store/backends/sqlite.ex

@@ -5,13 +5,15 @@ defmodule Expert.Search.Store.Backends.Sqlite do
 
   alias Expert.EngineApi
   alias Expert.Search.Store.Backend
+  alias Forge.Document.Position
+  alias Forge.Document.Range
   alias Forge.Project
   alias Forge.Search.Indexer.Entry
 
   require Entry
   require Logger
 
-  @schema_version 4
+  @schema_version 5
   @database_file "source.index.sqlite3"
   @slow_query_threshold_ms 500
   # NOTE(doorgan): SQLite has a variable limit of 32766. Entry batches use 7 params
@@ -1109,7 +1111,13 @@ defmodule Expert.Search.Store.Backends.Sqlite do
   defp build_entry_blob(%Entry{} = entry) do
     subject_override = if !is_binary(entry.subject), do: entry.subject
 
-    blob({subject_override, entry.application, entry.block_range, entry.range, entry.metadata})
+    blob({
+      subject_override,
+      entry.application,
+      compact_range(entry.block_range),
+      compact_range(entry.range),
+      entry.metadata
+    })
   end
 
   defp decode_entry([id, path, subject_key, type_blob, subtype, block_id, entry_blob]) do
@@ -1125,16 +1133,52 @@ defmodule Expert.Search.Store.Backends.Sqlite do
       application: application,
       id: id,
       block_id: block_id(block_id),
-      block_range: block_range,
+      block_range: expand_range(block_range),
       path: path,
-      range: range,
+      range: expand_range(range),
       subject: subject,
       subtype: String.to_existing_atom(subtype),
       type: decode_term(type_blob),
       metadata: metadata
     }
   end
 
+  defp compact_range(nil), do: nil
+
+  defp compact_range(%Range{start: start_position, end: end_position}) do
+    {compact_position(start_position), compact_position(end_position)}
+  end
+
+  defp compact_position(%Position{} = position) do
+    {
+      position.line,
+      position.character,
+      position.valid?,
+      position.context_line,
+      position.document_line_count,
+      position.starting_index
+    }
+  end
+
+  defp expand_range(nil), do: nil
+
+  defp expand_range({start_position, end_position}) do
+    %Range{start: expand_position(start_position), end: expand_position(end_position)}
+  end
+
+  defp expand_position(
+         {line, character, valid?, context_line, document_line_count, starting_index}
+       ) do
+    %Position{
+      line: line,
+      character: character,
+      valid?: valid?,
+      context_line: context_line,
+      document_line_count: document_line_count,
+      starting_index: starting_index
+    }
+  end
+
   defp blob(term), do: {:blob, encode_term(term)}
 
   defp encode_term(term), do: :erlang.term_to_binary(term, [:compressed])

apps/expert/test/expert/search/store/backends/sqlite_test.exs

@@ -4,6 +4,8 @@ defmodule Expert.Search.Store.Backends.SqliteTest do
   import Forge.Test.Fixtures
 
   alias Expert.Search.Store.Backends.Sqlite
+  alias Forge.Document.Position
+  alias Forge.Document.Range
   alias Forge.Search.Indexer.Entry
 
   setup do
@@ -105,13 +107,23 @@ defmodule Expert.Search.Store.Backends.SqliteTest do
     } do
       database_path = Sqlite.database_path(project, runtime_versions)
 
+      block_range = %Range{
+        start: %Position{line: 1, character: 1},
+        end: %Position{line: 2, character: 1}
+      }
+
+      range = %Range{
+        start: %Position{line: 3, character: 1},
+        end: %Position{line: 4, character: 1}
+      }
+
       entry = %Entry{
         application: :sample,
         id: 1,
         block_id: :root,
-        block_range: %{start: 1, end: 2},
+        block_range: block_range,
         path: "/a/path/that/must/not/be/duplicated.ex",
-        range: %{start: 3, end: 4},
+        range: range,
         subject: "Lean.Module.function/0",
         subtype: :definition,
         type: :module,
@@ -132,8 +144,13 @@ defmodule Expert.Search.Store.Backends.SqliteTest do
       assert {:ok, [[entry_blob]], _columns} = Exqlite.Basic.rows(result)
       assert :ok = Exqlite.Basic.close(conn)
 
-      assert {nil, :sample, %{start: 1, end: 2}, %{start: 3, end: 4}, %{detail: :kept}} =
-               :erlang.binary_to_term(entry_blob)
+      assert {
+               nil,
+               :sample,
+               {{1, 1, false, nil, 0, 1}, {2, 1, false, nil, 0, 1}},
+               {{3, 1, false, nil, 0, 1}, {4, 1, false, nil, 0, 1}},
+               %{detail: :kept}
+             } = :erlang.binary_to_term(entry_blob)
 
       assert [^entry] = Sqlite.find_by_subject(project, "Lean.Module.function/0", :_, :_)
     end
@@ -173,7 +190,7 @@ defmodule Expert.Search.Store.Backends.SqliteTest do
 
       {:ok, conn} = Exqlite.Basic.open(database_path)
       result = Exqlite.Basic.exec(conn, "SELECT version FROM schema")
-      assert {:ok, [[4]], ["version"]} = Exqlite.Basic.rows(result)
+      assert {:ok, [[5]], ["version"]} = Exqlite.Basic.rows(result)
       assert :ok = Exqlite.Basic.close(conn)
     end
   end