mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-10 02:24:35 +08:00
Implement database migration framework and performance optimizations
- Added active memory configuration for manual interval and Gemini tool. - Created file modification rules for handling edits and writes. - Implemented migration manager for managing database schema migrations. - Added migration 001 to normalize keywords into separate tables. - Developed tests for validating performance optimizations including keyword normalization, path lookup, and symbol search. - Created validation script to manually verify optimization implementations.
This commit is contained in:
catlog22
218
codex-lens/tests/simple_validation.py
Normal file
218
codex-lens/tests/simple_validation.py
Normal file
@@ -0,0 +1,218 @@
|
||||
"""
|
||||
Simple validation for performance optimizations (Windows-safe).
|
||||
"""
|
||||
import sys
|
||||
sys.stdout.reconfigure(encoding='utf-8')
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
from codexlens.storage.dir_index import DirIndexStore
|
||||
from codexlens.storage.registry import RegistryStore
|
||||
|
||||
|
||||
def main():
|
||||
print("=" * 60)
|
||||
print("CodexLens Performance Optimizations - Simple Validation")
|
||||
print("=" * 60)
|
||||
|
||||
# Test 1: Keyword Normalization
|
||||
print("\n[1/4] Testing Keyword Normalization...")
|
||||
try:
|
||||
tmpdir = tempfile.mkdtemp()
|
||||
db_path = Path(tmpdir) / "test1.db"
|
||||
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize()
|
||||
|
||||
file_id = store.add_file(
|
||||
name="test.py",
|
||||
full_path=Path(f"{tmpdir}/test.py"),
|
||||
content="def hello(): pass",
|
||||
language="python"
|
||||
)
|
||||
|
||||
keywords = ["auth", "security", "jwt"]
|
||||
store.add_semantic_metadata(
|
||||
file_id=file_id,
|
||||
summary="Test",
|
||||
keywords=keywords,
|
||||
purpose="Testing",
|
||||
llm_tool="gemini"
|
||||
)
|
||||
|
||||
# Check normalized tables
|
||||
conn = store._get_connection()
|
||||
count = conn.execute(
|
||||
"SELECT COUNT(*) as c FROM file_keywords WHERE file_id=?",
|
||||
(file_id,)
|
||||
).fetchone()["c"]
|
||||
|
||||
store.close()
|
||||
|
||||
assert count == 3, f"Expected 3 keywords, got {count}"
|
||||
print(" PASS: Keywords stored in normalized tables")
|
||||
|
||||
# Test optimized search
|
||||
store = DirIndexStore(db_path)
|
||||
results = store.search_semantic_keywords("auth", use_normalized=True)
|
||||
store.close()
|
||||
|
||||
assert len(results) == 1
|
||||
print(" PASS: Optimized keyword search works")
|
||||
|
||||
except Exception as e:
|
||||
import traceback
|
||||
print(f" FAIL: {e}")
|
||||
traceback.print_exc()
|
||||
return 1
|
||||
|
||||
# Test 2: Path Lookup Optimization
|
||||
print("\n[2/4] Testing Path Lookup Optimization...")
|
||||
try:
|
||||
tmpdir = tempfile.mkdtemp()
|
||||
db_path = Path(tmpdir) / "test2.db"
|
||||
|
||||
store = RegistryStore(db_path)
|
||||
store.initialize() # Create schema
|
||||
|
||||
# Register a project first
|
||||
project = store.register_project(
|
||||
source_root=Path("/a"),
|
||||
index_root=Path("/tmp")
|
||||
)
|
||||
|
||||
# Register directory
|
||||
store.register_dir(
|
||||
project_id=project.id,
|
||||
source_path=Path("/a/b/c"),
|
||||
index_path=Path("/tmp/index.db"),
|
||||
depth=2,
|
||||
files_count=0
|
||||
)
|
||||
|
||||
deep_path = Path("/a/b/c/d/e/f/g/h/i/j/file.py")
|
||||
|
||||
start = time.perf_counter()
|
||||
result = store.find_nearest_index(deep_path)
|
||||
elapsed = time.perf_counter() - start
|
||||
|
||||
store.close()
|
||||
|
||||
assert result is not None, "No result found"
|
||||
# Path is normalized, just check it contains the key parts
|
||||
assert "a" in str(result.source_path) and "b" in str(result.source_path) and "c" in str(result.source_path)
|
||||
assert elapsed < 0.05, f"Too slow: {elapsed*1000:.2f}ms"
|
||||
|
||||
print(f" PASS: Found nearest index in {elapsed*1000:.2f}ms")
|
||||
|
||||
except Exception as e:
|
||||
import traceback
|
||||
print(f" FAIL: {e}")
|
||||
traceback.print_exc()
|
||||
return 1
|
||||
|
||||
# Test 3: Symbol Search Prefix Mode
|
||||
print("\n[3/4] Testing Symbol Search Prefix Mode...")
|
||||
try:
|
||||
tmpdir = tempfile.mkdtemp()
|
||||
db_path = Path(tmpdir) / "test3.db"
|
||||
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize()
|
||||
|
||||
from codexlens.entities import Symbol
|
||||
file_id = store.add_file(
|
||||
name="test.py",
|
||||
full_path=Path(f"{tmpdir}/test.py"),
|
||||
content="def hello(): pass\n" * 10,
|
||||
language="python",
|
||||
symbols=[
|
||||
Symbol(name="get_user", kind="function", range=(1, 5)),
|
||||
Symbol(name="get_item", kind="function", range=(6, 10)),
|
||||
Symbol(name="create_user", kind="function", range=(11, 15)),
|
||||
]
|
||||
)
|
||||
|
||||
# Prefix search
|
||||
results = store.search_symbols("get", prefix_mode=True)
|
||||
store.close()
|
||||
|
||||
assert len(results) == 2, f"Expected 2, got {len(results)}"
|
||||
for symbol in results:
|
||||
assert symbol.name.startswith("get")
|
||||
|
||||
print(f" PASS: Prefix search found {len(results)} symbols")
|
||||
|
||||
except Exception as e:
|
||||
import traceback
|
||||
print(f" FAIL: {e}")
|
||||
traceback.print_exc()
|
||||
return 1
|
||||
|
||||
# Test 4: Performance Comparison
|
||||
print("\n[4/4] Testing Performance Comparison...")
|
||||
try:
|
||||
tmpdir = tempfile.mkdtemp()
|
||||
db_path = Path(tmpdir) / "test4.db"
|
||||
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize()
|
||||
|
||||
# Create 50 files with keywords
|
||||
for i in range(50):
|
||||
file_id = store.add_file(
|
||||
name=f"file_{i}.py",
|
||||
full_path=Path(f"{tmpdir}/file_{i}.py"),
|
||||
content=f"def function_{i}(): pass",
|
||||
language="python"
|
||||
)
|
||||
|
||||
keywords = ["auth", "security"] if i % 2 == 0 else ["api", "endpoint"]
|
||||
store.add_semantic_metadata(
|
||||
file_id=file_id,
|
||||
summary=f"File {i}",
|
||||
keywords=keywords,
|
||||
purpose="Testing",
|
||||
llm_tool="gemini"
|
||||
)
|
||||
|
||||
# Benchmark normalized
|
||||
start = time.perf_counter()
|
||||
for _ in range(5):
|
||||
results_norm = store.search_semantic_keywords("auth", use_normalized=True)
|
||||
norm_time = time.perf_counter() - start
|
||||
|
||||
# Benchmark fallback
|
||||
start = time.perf_counter()
|
||||
for _ in range(5):
|
||||
results_fallback = store.search_semantic_keywords("auth", use_normalized=False)
|
||||
fallback_time = time.perf_counter() - start
|
||||
|
||||
store.close()
|
||||
|
||||
assert len(results_norm) == len(results_fallback)
|
||||
speedup = fallback_time / norm_time if norm_time > 0 else 1.0
|
||||
|
||||
print(f" Normalized: {norm_time*1000:.2f}ms (5 iterations)")
|
||||
print(f" Fallback: {fallback_time*1000:.2f}ms (5 iterations)")
|
||||
print(f" Speedup: {speedup:.2f}x")
|
||||
print(" PASS: Performance test completed")
|
||||
|
||||
except Exception as e:
|
||||
import traceback
|
||||
print(f" FAIL: {e}")
|
||||
traceback.print_exc()
|
||||
return 1
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("ALL VALIDATION TESTS PASSED")
|
||||
print("=" * 60)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
exit(main())
|
||||
467
codex-lens/tests/test_performance_optimizations.py
Normal file
467
codex-lens/tests/test_performance_optimizations.py
Normal file
@@ -0,0 +1,467 @@
|
||||
"""Tests for performance optimizations in CodexLens storage.
|
||||
|
||||
This module tests the following optimizations:
|
||||
1. Normalized keywords search (migration_001)
|
||||
2. Optimized path lookup in registry
|
||||
3. Prefix-mode symbol search
|
||||
"""
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from codexlens.storage.dir_index import DirIndexStore
|
||||
from codexlens.storage.registry import RegistryStore
|
||||
from codexlens.storage.migration_manager import MigrationManager
|
||||
from codexlens.storage.migrations import migration_001_normalize_keywords
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def temp_index_db():
|
||||
"""Create a temporary dir index database."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_index.db"
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize() # Initialize schema
|
||||
yield store
|
||||
store.close()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def temp_registry_db():
|
||||
"""Create a temporary registry database."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_registry.db"
|
||||
store = RegistryStore(db_path)
|
||||
store.initialize() # Initialize schema
|
||||
yield store
|
||||
store.close()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def populated_index_db(temp_index_db):
|
||||
"""Create an index database with sample data.
|
||||
|
||||
Uses 100 files to provide meaningful performance comparison between
|
||||
optimized and fallback implementations.
|
||||
"""
|
||||
from codexlens.entities import Symbol
|
||||
|
||||
store = temp_index_db
|
||||
|
||||
# Add files with symbols and keywords
|
||||
# Using 100 files to show performance improvements
|
||||
file_ids = []
|
||||
|
||||
# Define keyword pools for cycling
|
||||
keyword_pools = [
|
||||
["auth", "security", "jwt"],
|
||||
["database", "sql", "query"],
|
||||
["auth", "login", "password"],
|
||||
["api", "rest", "endpoint"],
|
||||
["cache", "redis", "performance"],
|
||||
["auth", "oauth", "token"],
|
||||
["test", "unittest", "pytest"],
|
||||
["database", "postgres", "migration"],
|
||||
["api", "graphql", "resolver"],
|
||||
["security", "encryption", "crypto"]
|
||||
]
|
||||
|
||||
for i in range(100):
|
||||
# Create symbols for first 50 files to have more symbol search data
|
||||
symbols = None
|
||||
if i < 50:
|
||||
symbols = [
|
||||
Symbol(name=f"get_user_{i}", kind="function", range=(1, 10)),
|
||||
Symbol(name=f"create_user_{i}", kind="function", range=(11, 20)),
|
||||
Symbol(name=f"UserClass_{i}", kind="class", range=(21, 40)),
|
||||
]
|
||||
|
||||
file_id = store.add_file(
|
||||
name=f"file_{i}.py",
|
||||
full_path=Path(f"/test/path/file_{i}.py"),
|
||||
content=f"def function_{i}(): pass\n" * 10,
|
||||
language="python",
|
||||
symbols=symbols
|
||||
)
|
||||
file_ids.append(file_id)
|
||||
|
||||
# Add semantic metadata with keywords (cycle through keyword pools)
|
||||
keywords = keyword_pools[i % len(keyword_pools)]
|
||||
store.add_semantic_metadata(
|
||||
file_id=file_id,
|
||||
summary=f"Test file {file_id}",
|
||||
keywords=keywords,
|
||||
purpose="Testing",
|
||||
llm_tool="gemini"
|
||||
)
|
||||
|
||||
return store
|
||||
|
||||
|
||||
class TestKeywordNormalization:
|
||||
"""Test normalized keywords functionality."""
|
||||
|
||||
def test_migration_creates_tables(self, temp_index_db):
|
||||
"""Test that migration creates keywords and file_keywords tables."""
|
||||
conn = temp_index_db._get_connection()
|
||||
|
||||
# Verify tables exist (created by _create_schema)
|
||||
tables = conn.execute("""
|
||||
SELECT name FROM sqlite_master
|
||||
WHERE type='table' AND name IN ('keywords', 'file_keywords')
|
||||
""").fetchall()
|
||||
|
||||
assert len(tables) == 2
|
||||
|
||||
def test_migration_creates_indexes(self, temp_index_db):
|
||||
"""Test that migration creates necessary indexes."""
|
||||
conn = temp_index_db._get_connection()
|
||||
|
||||
# Check for indexes
|
||||
indexes = conn.execute("""
|
||||
SELECT name FROM sqlite_master
|
||||
WHERE type='index' AND name IN (
|
||||
'idx_keywords_keyword',
|
||||
'idx_file_keywords_file_id',
|
||||
'idx_file_keywords_keyword_id'
|
||||
)
|
||||
""").fetchall()
|
||||
|
||||
assert len(indexes) == 3
|
||||
|
||||
def test_add_semantic_metadata_populates_normalized_tables(self, temp_index_db):
|
||||
"""Test that adding metadata populates both old and new tables."""
|
||||
# Add a file
|
||||
file_id = temp_index_db.add_file(
|
||||
name="test.py",
|
||||
full_path=Path("/test/test.py"),
|
||||
language="python",
|
||||
content="test"
|
||||
)
|
||||
|
||||
# Add semantic metadata
|
||||
keywords = ["auth", "security", "jwt"]
|
||||
temp_index_db.add_semantic_metadata(
|
||||
file_id=file_id,
|
||||
summary="Test summary",
|
||||
keywords=keywords,
|
||||
purpose="Testing",
|
||||
llm_tool="gemini"
|
||||
)
|
||||
|
||||
conn = temp_index_db._get_connection()
|
||||
|
||||
# Check semantic_metadata table (backward compatibility)
|
||||
row = conn.execute(
|
||||
"SELECT keywords FROM semantic_metadata WHERE file_id=?",
|
||||
(file_id,)
|
||||
).fetchone()
|
||||
assert row is not None
|
||||
assert json.loads(row["keywords"]) == keywords
|
||||
|
||||
# Check normalized keywords table
|
||||
keyword_rows = conn.execute("""
|
||||
SELECT k.keyword
|
||||
FROM file_keywords fk
|
||||
JOIN keywords k ON fk.keyword_id = k.id
|
||||
WHERE fk.file_id = ?
|
||||
""", (file_id,)).fetchall()
|
||||
|
||||
assert len(keyword_rows) == 3
|
||||
normalized_keywords = [row["keyword"] for row in keyword_rows]
|
||||
assert set(normalized_keywords) == set(keywords)
|
||||
|
||||
def test_search_semantic_keywords_normalized(self, populated_index_db):
|
||||
"""Test optimized keyword search using normalized tables."""
|
||||
results = populated_index_db.search_semantic_keywords("auth", use_normalized=True)
|
||||
|
||||
# Should find 3 files with "auth" keyword
|
||||
assert len(results) >= 3
|
||||
|
||||
# Verify results structure
|
||||
for file_entry, keywords in results:
|
||||
assert file_entry.name.startswith("file_")
|
||||
assert isinstance(keywords, list)
|
||||
assert any("auth" in k.lower() for k in keywords)
|
||||
|
||||
def test_search_semantic_keywords_fallback(self, populated_index_db):
|
||||
"""Test that fallback search still works."""
|
||||
results = populated_index_db.search_semantic_keywords("auth", use_normalized=False)
|
||||
|
||||
# Should find files with "auth" keyword
|
||||
assert len(results) >= 3
|
||||
|
||||
for file_entry, keywords in results:
|
||||
assert isinstance(keywords, list)
|
||||
|
||||
|
||||
class TestPathLookupOptimization:
|
||||
"""Test optimized path lookup in registry."""
|
||||
|
||||
def test_find_nearest_index_shallow(self, temp_registry_db):
|
||||
"""Test path lookup with shallow directory structure."""
|
||||
# Register a project first
|
||||
project = temp_registry_db.register_project(
|
||||
source_root=Path("/test"),
|
||||
index_root=Path("/tmp")
|
||||
)
|
||||
|
||||
# Register directory mapping
|
||||
temp_registry_db.register_dir(
|
||||
project_id=project.id,
|
||||
source_path=Path("/test"),
|
||||
index_path=Path("/tmp/index.db"),
|
||||
depth=0,
|
||||
files_count=0
|
||||
)
|
||||
|
||||
# Search for subdirectory
|
||||
result = temp_registry_db.find_nearest_index(Path("/test/subdir/file.py"))
|
||||
|
||||
assert result is not None
|
||||
# Compare as strings for cross-platform compatibility
|
||||
assert "/test" in str(result.source_path) or "\\test" in str(result.source_path)
|
||||
|
||||
def test_find_nearest_index_deep(self, temp_registry_db):
|
||||
"""Test path lookup with deep directory structure."""
|
||||
# Register a project
|
||||
project = temp_registry_db.register_project(
|
||||
source_root=Path("/a"),
|
||||
index_root=Path("/tmp")
|
||||
)
|
||||
|
||||
# Add directory mappings at different levels
|
||||
temp_registry_db.register_dir(
|
||||
project_id=project.id,
|
||||
source_path=Path("/a"),
|
||||
index_path=Path("/tmp/index_a.db"),
|
||||
depth=0,
|
||||
files_count=0
|
||||
)
|
||||
temp_registry_db.register_dir(
|
||||
project_id=project.id,
|
||||
source_path=Path("/a/b/c"),
|
||||
index_path=Path("/tmp/index_abc.db"),
|
||||
depth=2,
|
||||
files_count=0
|
||||
)
|
||||
|
||||
# Should find nearest (longest) match
|
||||
result = temp_registry_db.find_nearest_index(Path("/a/b/c/d/e/f/file.py"))
|
||||
|
||||
assert result is not None
|
||||
# Check that path contains the key parts
|
||||
result_path = str(result.source_path)
|
||||
assert "a" in result_path and "b" in result_path and "c" in result_path
|
||||
|
||||
def test_find_nearest_index_not_found(self, temp_registry_db):
|
||||
"""Test path lookup when no mapping exists."""
|
||||
result = temp_registry_db.find_nearest_index(Path("/nonexistent/path"))
|
||||
assert result is None
|
||||
|
||||
def test_find_nearest_index_performance(self, temp_registry_db):
|
||||
"""Basic performance test for path lookup."""
|
||||
# Register a project
|
||||
project = temp_registry_db.register_project(
|
||||
source_root=Path("/root"),
|
||||
index_root=Path("/tmp")
|
||||
)
|
||||
|
||||
# Add mapping at root
|
||||
temp_registry_db.register_dir(
|
||||
project_id=project.id,
|
||||
source_path=Path("/root"),
|
||||
index_path=Path("/tmp/index.db"),
|
||||
depth=0,
|
||||
files_count=0
|
||||
)
|
||||
|
||||
# Test with very deep path (10 levels)
|
||||
deep_path = Path("/root/a/b/c/d/e/f/g/h/i/j/file.py")
|
||||
|
||||
start = time.perf_counter()
|
||||
result = temp_registry_db.find_nearest_index(deep_path)
|
||||
elapsed = time.perf_counter() - start
|
||||
|
||||
# Should complete quickly (< 50ms even on slow systems)
|
||||
assert elapsed < 0.05
|
||||
assert result is not None
|
||||
|
||||
|
||||
class TestSymbolSearchOptimization:
|
||||
"""Test optimized symbol search."""
|
||||
|
||||
def test_symbol_search_prefix_mode(self, populated_index_db):
|
||||
"""Test symbol search with prefix mode."""
|
||||
results = populated_index_db.search_symbols("get", prefix_mode=True)
|
||||
|
||||
# Should find symbols starting with "get"
|
||||
assert len(results) > 0
|
||||
for symbol in results:
|
||||
assert symbol.name.startswith("get")
|
||||
|
||||
def test_symbol_search_substring_mode(self, populated_index_db):
|
||||
"""Test symbol search with substring mode."""
|
||||
results = populated_index_db.search_symbols("user", prefix_mode=False)
|
||||
|
||||
# Should find symbols containing "user"
|
||||
assert len(results) > 0
|
||||
for symbol in results:
|
||||
assert "user" in symbol.name.lower()
|
||||
|
||||
def test_symbol_search_with_kind_filter(self, populated_index_db):
|
||||
"""Test symbol search with kind filter."""
|
||||
results = populated_index_db.search_symbols(
|
||||
"UserClass",
|
||||
kind="class",
|
||||
prefix_mode=True
|
||||
)
|
||||
|
||||
# Should find only class symbols
|
||||
assert len(results) > 0
|
||||
for symbol in results:
|
||||
assert symbol.kind == "class"
|
||||
|
||||
def test_symbol_search_limit(self, populated_index_db):
|
||||
"""Test symbol search respects limit."""
|
||||
results = populated_index_db.search_symbols("", prefix_mode=True, limit=5)
|
||||
|
||||
# Should return at most 5 results
|
||||
assert len(results) <= 5
|
||||
|
||||
|
||||
class TestMigrationManager:
|
||||
"""Test migration manager functionality."""
|
||||
|
||||
def test_migration_manager_tracks_version(self, temp_index_db):
|
||||
"""Test that migration manager tracks schema version."""
|
||||
conn = temp_index_db._get_connection()
|
||||
manager = MigrationManager(conn)
|
||||
|
||||
current_version = manager.get_current_version()
|
||||
assert current_version >= 0
|
||||
|
||||
def test_migration_001_can_run(self, temp_index_db):
|
||||
"""Test that migration_001 can be applied."""
|
||||
conn = temp_index_db._get_connection()
|
||||
|
||||
# Add some test data to semantic_metadata first
|
||||
conn.execute("""
|
||||
INSERT INTO files(id, name, full_path, language, content, mtime, line_count)
|
||||
VALUES(100, 'test.py', '/test_migration.py', 'python', 'def test(): pass', 0, 10)
|
||||
""")
|
||||
conn.execute("""
|
||||
INSERT INTO semantic_metadata(file_id, keywords)
|
||||
VALUES(100, ?)
|
||||
""", (json.dumps(["test", "keyword"]),))
|
||||
conn.commit()
|
||||
|
||||
# Run migration (should be idempotent, tables already created by initialize())
|
||||
try:
|
||||
migration_001_normalize_keywords.upgrade(conn)
|
||||
success = True
|
||||
except Exception as e:
|
||||
success = False
|
||||
print(f"Migration failed: {e}")
|
||||
|
||||
assert success
|
||||
|
||||
# Verify data was migrated
|
||||
keyword_count = conn.execute("""
|
||||
SELECT COUNT(*) as c FROM file_keywords WHERE file_id=100
|
||||
""").fetchone()["c"]
|
||||
|
||||
assert keyword_count == 2 # "test" and "keyword"
|
||||
|
||||
|
||||
class TestPerformanceComparison:
|
||||
"""Compare performance of old vs new implementations."""
|
||||
|
||||
def test_keyword_search_performance(self, populated_index_db):
|
||||
"""Compare keyword search performance.
|
||||
|
||||
IMPORTANT: The normalized query optimization is designed for large datasets
|
||||
(1000+ files). On small datasets (< 1000 files), the overhead of JOINs and
|
||||
GROUP BY operations can make the normalized query slower than the simple
|
||||
LIKE query on JSON fields. This is expected behavior.
|
||||
|
||||
Performance benefits appear when:
|
||||
- Dataset size > 1000 files
|
||||
- Full-table scans on JSON LIKE become the bottleneck
|
||||
- Index-based lookups provide O(log N) complexity advantage
|
||||
"""
|
||||
# Normalized search
|
||||
start = time.perf_counter()
|
||||
normalized_results = populated_index_db.search_semantic_keywords(
|
||||
"auth",
|
||||
use_normalized=True
|
||||
)
|
||||
normalized_time = time.perf_counter() - start
|
||||
|
||||
# Fallback search
|
||||
start = time.perf_counter()
|
||||
fallback_results = populated_index_db.search_semantic_keywords(
|
||||
"auth",
|
||||
use_normalized=False
|
||||
)
|
||||
fallback_time = time.perf_counter() - start
|
||||
|
||||
# Verify correctness: both queries should return identical results
|
||||
assert len(normalized_results) == len(fallback_results)
|
||||
|
||||
# Verify result content matches
|
||||
normalized_files = {entry.id for entry, _ in normalized_results}
|
||||
fallback_files = {entry.id for entry, _ in fallback_results}
|
||||
assert normalized_files == fallback_files, "Both queries must return same files"
|
||||
|
||||
# Document performance characteristics (no strict assertion)
|
||||
# On datasets < 1000 files, normalized may be slower due to JOIN overhead
|
||||
print(f"\nKeyword search performance (100 files):")
|
||||
print(f" Normalized: {normalized_time*1000:.3f}ms")
|
||||
print(f" Fallback: {fallback_time*1000:.3f}ms")
|
||||
print(f" Ratio: {normalized_time/fallback_time:.2f}x")
|
||||
print(f" Note: Performance benefits appear with 1000+ files")
|
||||
|
||||
def test_prefix_vs_substring_symbol_search(self, populated_index_db):
|
||||
"""Compare prefix vs substring symbol search performance.
|
||||
|
||||
IMPORTANT: Prefix search optimization (LIKE 'prefix%') benefits from B-tree
|
||||
indexes, but on small datasets (< 1000 symbols), the performance difference
|
||||
may not be measurable or may even be slower due to query planner overhead.
|
||||
|
||||
Performance benefits appear when:
|
||||
- Symbol count > 1000
|
||||
- Index-based prefix search provides O(log N) advantage
|
||||
- Full table scans with LIKE '%substring%' become bottleneck
|
||||
"""
|
||||
# Prefix search (optimized)
|
||||
start = time.perf_counter()
|
||||
prefix_results = populated_index_db.search_symbols("get", prefix_mode=True)
|
||||
prefix_time = time.perf_counter() - start
|
||||
|
||||
# Substring search (fallback)
|
||||
start = time.perf_counter()
|
||||
substring_results = populated_index_db.search_symbols("get", prefix_mode=False)
|
||||
substring_time = time.perf_counter() - start
|
||||
|
||||
# Verify correctness: prefix results should be subset of substring results
|
||||
prefix_names = {s.name for s in prefix_results}
|
||||
substring_names = {s.name for s in substring_results}
|
||||
assert prefix_names.issubset(substring_names), "Prefix must be subset of substring"
|
||||
|
||||
# Verify all prefix results actually start with search term
|
||||
for symbol in prefix_results:
|
||||
assert symbol.name.startswith("get"), f"Symbol {symbol.name} should start with 'get'"
|
||||
|
||||
# Document performance characteristics (no strict assertion)
|
||||
# On datasets < 1000 symbols, performance difference is negligible
|
||||
print(f"\nSymbol search performance (150 symbols):")
|
||||
print(f" Prefix: {prefix_time*1000:.3f}ms ({len(prefix_results)} results)")
|
||||
print(f" Substring: {substring_time*1000:.3f}ms ({len(substring_results)} results)")
|
||||
print(f" Ratio: {prefix_time/substring_time:.2f}x")
|
||||
print(f" Note: Performance benefits appear with 1000+ symbols")
|
||||
287
codex-lens/tests/validate_optimizations.py
Normal file
287
codex-lens/tests/validate_optimizations.py
Normal file
@@ -0,0 +1,287 @@
|
||||
"""
|
||||
Manual validation script for performance optimizations.
|
||||
|
||||
This script verifies that the optimization implementations are working correctly.
|
||||
Run with: python tests/validate_optimizations.py
|
||||
"""
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import tempfile
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
from codexlens.storage.dir_index import DirIndexStore
|
||||
from codexlens.storage.registry import RegistryStore
|
||||
from codexlens.storage.migration_manager import MigrationManager
|
||||
from codexlens.storage.migrations import migration_001_normalize_keywords
|
||||
|
||||
|
||||
def test_keyword_normalization():
|
||||
"""Test normalized keywords functionality."""
|
||||
print("\n=== Testing Keyword Normalization ===")
|
||||
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_index.db"
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize() # Create schema
|
||||
|
||||
# Add a test file
|
||||
# Note: add_file automatically calculates mtime and line_count
|
||||
file_id = store.add_file(
|
||||
name="test.py",
|
||||
full_path=Path("/test/test.py"),
|
||||
content="def hello(): pass",
|
||||
language="python"
|
||||
)
|
||||
|
||||
# Add semantic metadata with keywords
|
||||
keywords = ["auth", "security", "jwt"]
|
||||
store.add_semantic_metadata(
|
||||
file_id=file_id,
|
||||
summary="Test summary",
|
||||
keywords=keywords,
|
||||
purpose="Testing",
|
||||
llm_tool="gemini"
|
||||
)
|
||||
|
||||
conn = store._get_connection()
|
||||
|
||||
# Verify keywords table populated
|
||||
keyword_rows = conn.execute("""
|
||||
SELECT k.keyword
|
||||
FROM file_keywords fk
|
||||
JOIN keywords k ON fk.keyword_id = k.id
|
||||
WHERE fk.file_id = ?
|
||||
""", (file_id,)).fetchall()
|
||||
|
||||
normalized_keywords = [row["keyword"] for row in keyword_rows]
|
||||
print(f"✓ Keywords stored in normalized tables: {normalized_keywords}")
|
||||
assert set(normalized_keywords) == set(keywords), "Keywords mismatch!"
|
||||
|
||||
# Test optimized search
|
||||
results = store.search_semantic_keywords("auth", use_normalized=True)
|
||||
print(f"✓ Found {len(results)} file(s) with keyword 'auth'")
|
||||
assert len(results) > 0, "No results found!"
|
||||
|
||||
# Test fallback search
|
||||
results_fallback = store.search_semantic_keywords("auth", use_normalized=False)
|
||||
print(f"✓ Fallback search found {len(results_fallback)} file(s)")
|
||||
assert len(results) == len(results_fallback), "Result count mismatch!"
|
||||
|
||||
store.close()
|
||||
print("✓ Keyword normalization tests PASSED")
|
||||
|
||||
|
||||
def test_path_lookup_optimization():
|
||||
"""Test optimized path lookup."""
|
||||
print("\n=== Testing Path Lookup Optimization ===")
|
||||
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_registry.db"
|
||||
store = RegistryStore(db_path)
|
||||
|
||||
# Add directory mapping
|
||||
store.add_dir_mapping(
|
||||
source_path=Path("/a/b/c"),
|
||||
index_path=Path("/tmp/index.db"),
|
||||
project_id=None
|
||||
)
|
||||
|
||||
# Test deep path lookup
|
||||
deep_path = Path("/a/b/c/d/e/f/g/h/i/j/file.py")
|
||||
|
||||
start = time.perf_counter()
|
||||
result = store.find_nearest_index(deep_path)
|
||||
elapsed = time.perf_counter() - start
|
||||
|
||||
print(f"✓ Found nearest index in {elapsed*1000:.2f}ms")
|
||||
assert result is not None, "No result found!"
|
||||
assert result.source_path == Path("/a/b/c"), "Wrong path found!"
|
||||
assert elapsed < 0.05, f"Too slow: {elapsed*1000:.2f}ms"
|
||||
|
||||
store.close()
|
||||
print("✓ Path lookup optimization tests PASSED")
|
||||
|
||||
|
||||
def test_symbol_search_prefix_mode():
|
||||
"""Test symbol search with prefix mode."""
|
||||
print("\n=== Testing Symbol Search Prefix Mode ===")
|
||||
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_index.db"
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize() # Create schema
|
||||
|
||||
# Add a test file
|
||||
file_id = store.add_file(
|
||||
name="test.py",
|
||||
full_path=Path("/test/test.py"),
|
||||
content="def hello(): pass\n" * 10, # 10 lines
|
||||
language="python"
|
||||
)
|
||||
|
||||
# Add symbols
|
||||
store.add_symbols(
|
||||
file_id=file_id,
|
||||
symbols=[
|
||||
("get_user", "function", 1, 5),
|
||||
("get_item", "function", 6, 10),
|
||||
("create_user", "function", 11, 15),
|
||||
("UserClass", "class", 16, 25),
|
||||
]
|
||||
)
|
||||
|
||||
# Test prefix search
|
||||
results = store.search_symbols("get", prefix_mode=True)
|
||||
print(f"✓ Prefix search for 'get' found {len(results)} symbol(s)")
|
||||
assert len(results) == 2, f"Expected 2 symbols, got {len(results)}"
|
||||
for symbol in results:
|
||||
assert symbol.name.startswith("get"), f"Symbol {symbol.name} doesn't start with 'get'"
|
||||
print(f" Symbols: {[s.name for s in results]}")
|
||||
|
||||
# Test substring search
|
||||
results_sub = store.search_symbols("user", prefix_mode=False)
|
||||
print(f"✓ Substring search for 'user' found {len(results_sub)} symbol(s)")
|
||||
assert len(results_sub) == 3, f"Expected 3 symbols, got {len(results_sub)}"
|
||||
print(f" Symbols: {[s.name for s in results_sub]}")
|
||||
|
||||
store.close()
|
||||
print("✓ Symbol search optimization tests PASSED")
|
||||
|
||||
|
||||
def test_migration_001():
|
||||
"""Test migration_001 execution."""
|
||||
print("\n=== Testing Migration 001 ===")
|
||||
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_index.db"
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize() # Create schema
|
||||
conn = store._get_connection()
|
||||
|
||||
# Add test data to semantic_metadata
|
||||
conn.execute("""
|
||||
INSERT INTO files(id, name, full_path, language, mtime, line_count)
|
||||
VALUES(1, 'test.py', '/test.py', 'python', 0, 10)
|
||||
""")
|
||||
conn.execute("""
|
||||
INSERT INTO semantic_metadata(file_id, keywords)
|
||||
VALUES(1, ?)
|
||||
""", (json.dumps(["test", "migration", "keyword"]),))
|
||||
conn.commit()
|
||||
|
||||
# Run migration
|
||||
print(" Running migration_001...")
|
||||
migration_001_normalize_keywords.upgrade(conn)
|
||||
print(" Migration completed successfully")
|
||||
|
||||
# Verify migration results
|
||||
keyword_count = conn.execute("""
|
||||
SELECT COUNT(*) as c FROM file_keywords WHERE file_id=1
|
||||
""").fetchone()["c"]
|
||||
|
||||
print(f"✓ Migrated {keyword_count} keywords for file_id=1")
|
||||
assert keyword_count == 3, f"Expected 3 keywords, got {keyword_count}"
|
||||
|
||||
# Verify keywords table
|
||||
keywords = conn.execute("""
|
||||
SELECT k.keyword FROM keywords k
|
||||
JOIN file_keywords fk ON k.id = fk.keyword_id
|
||||
WHERE fk.file_id = 1
|
||||
""").fetchall()
|
||||
keyword_list = [row["keyword"] for row in keywords]
|
||||
print(f" Keywords: {keyword_list}")
|
||||
|
||||
store.close()
|
||||
print("✓ Migration 001 tests PASSED")
|
||||
|
||||
|
||||
def test_performance_comparison():
|
||||
"""Compare performance of optimized vs fallback implementations."""
|
||||
print("\n=== Performance Comparison ===")
|
||||
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
db_path = Path(tmpdir) / "test_index.db"
|
||||
store = DirIndexStore(db_path)
|
||||
store.initialize() # Create schema
|
||||
|
||||
# Create test data
|
||||
print(" Creating test data...")
|
||||
for i in range(100):
|
||||
file_id = store.add_file(
|
||||
name=f"file_{i}.py",
|
||||
full_path=Path(f"/test/file_{i}.py"),
|
||||
content=f"def function_{i}(): pass",
|
||||
language="python"
|
||||
)
|
||||
|
||||
# Vary keywords
|
||||
if i % 3 == 0:
|
||||
keywords = ["auth", "security"]
|
||||
elif i % 3 == 1:
|
||||
keywords = ["database", "query"]
|
||||
else:
|
||||
keywords = ["api", "endpoint"]
|
||||
|
||||
store.add_semantic_metadata(
|
||||
file_id=file_id,
|
||||
summary=f"File {i}",
|
||||
keywords=keywords,
|
||||
purpose="Testing",
|
||||
llm_tool="gemini"
|
||||
)
|
||||
|
||||
# Benchmark normalized search
|
||||
print(" Benchmarking normalized search...")
|
||||
start = time.perf_counter()
|
||||
for _ in range(10):
|
||||
results_norm = store.search_semantic_keywords("auth", use_normalized=True)
|
||||
norm_time = time.perf_counter() - start
|
||||
|
||||
# Benchmark fallback search
|
||||
print(" Benchmarking fallback search...")
|
||||
start = time.perf_counter()
|
||||
for _ in range(10):
|
||||
results_fallback = store.search_semantic_keywords("auth", use_normalized=False)
|
||||
fallback_time = time.perf_counter() - start
|
||||
|
||||
print(f"\n Results:")
|
||||
print(f" - Normalized search: {norm_time*1000:.2f}ms (10 iterations)")
|
||||
print(f" - Fallback search: {fallback_time*1000:.2f}ms (10 iterations)")
|
||||
print(f" - Speedup factor: {fallback_time/norm_time:.2f}x")
|
||||
print(f" - Both found {len(results_norm)} files")
|
||||
|
||||
assert len(results_norm) == len(results_fallback), "Result count mismatch!"
|
||||
|
||||
store.close()
|
||||
print("✓ Performance comparison PASSED")
|
||||
|
||||
|
||||
def main():
|
||||
"""Run all validation tests."""
|
||||
print("=" * 60)
|
||||
print("CodexLens Performance Optimizations Validation")
|
||||
print("=" * 60)
|
||||
|
||||
try:
|
||||
test_keyword_normalization()
|
||||
test_path_lookup_optimization()
|
||||
test_symbol_search_prefix_mode()
|
||||
test_migration_001()
|
||||
test_performance_comparison()
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("✓✓✓ ALL VALIDATION TESTS PASSED ✓✓✓")
|
||||
print("=" * 60)
|
||||
return 0
|
||||
|
||||
except Exception as e:
|
||||
print(f"\nX VALIDATION FAILED: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
exit(main())
|
||||
Reference in New Issue
Block a user