[PERF] Decrease compaction RAM usage and increase speed (#2729)

*Summarize the changes made by this PR.*
 - Improvements & Bug fixes
- BTree of block deltas for postings list is now Vec<i32> instead of
IntArray since the overhead of IntArray was seen to be 2 KB per btree
add v/s 816 bytes for Vec<i32>
- When getting blocks from block deltas at commit time, the block deltas
are now drained. This reduces RAM consumption by about 50%
- Removed the intermediary postings list builder that was more of an
unnecessary complexity and also was doing clones
- Changed get() for postings list to read slices instead of Vec<i32>
getting rid of one more deep copy.

*How are these changes tested?*
- [x] Tests pass locally with `pytest` for python, `yarn test` for js,
`cargo test` for rust

None

rust/index/src/fulltext/types.rs

@@ -101,16 +101,44 @@ impl<'me> FullTextIndexWriter<'me> {
                     // Readers are uninitialized until the first compaction finishes
                     // so there is a case when this is none hence not an error.
                     None => 0,
-                    Some(reader) => {
-                        match reader.get_frequencies_for_token(token.text.as_str()).await {
-                            Ok(frequency) => frequency,
-                            // New token so start with frequency of 0.
-                            Err(_) => 0,
-                        }
-                    }
+                    Some(reader) => match reader.get_frequencies_for_token(token).await {
+                        Ok(frequency) => frequency,
+                        // New token so start with frequency of 0.
+                        Err(_) => 0,
+                    },
                 };
                 uncommitted_frequencies
-                    .insert(token.text.clone(), (frequency as i32, frequency as i32));
+                    .insert(token.to_string(), (frequency as i32, frequency as i32));
+            }
+        }
+        let mut uncommitted_postings = self.uncommitted_postings.lock().await;
+        match uncommitted_postings.positional_postings.get(token) {
+            Some(_) => {
+                // This should never happen -- if uncommitted has the token, then
+                // uncommitted_frequencies should have had it as well.
+                tracing::error!(
+                    "Error populating frequencies and posting lists from previous version"
+                );
+                return Err(FullTextIndexError::InvariantViolation);
+            }
+            None => {
+                let results = match &self.full_text_index_reader {
+                    // Readers are uninitialized until the first compaction finishes
+                    // so there is a case when this is none hence not an error.
+                    None => vec![],
+                    Some(reader) => match reader.get_all_results_for_token(token).await {
+                        Ok(results) => results,
+                        // New token so start with empty postings list.
+                        Err(_) => vec![],
+                    },
+                };
+                let mut doc_and_positions = HashMap::new();
+                for result in results {
+                    doc_and_positions.insert(result.0, result.1);
+                }
+                uncommitted_postings
+                    .positional_postings
+                    .insert(token.to_string(), doc_and_positions);
             }
         }