file_query_text 0.1.0__tar.gz

file_query_text-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: file_query_text
+Version: 0.1.0
+Summary: SQL-like interface for querying files in your filesystem
+Author-email: nik <42a11b@nikdav.is>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nikdavis/file_query_text
+Project-URL: Bug Tracker, https://github.com/nikdavis/file_query_text/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pyparsing>=3.2.3
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+
+# File Query
+
+A SQL-like interface for querying files in your filesystem.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/file-query.git
+cd file-query
+
+# Install with pip
+pip install -e .
+
+# Or use UV
+uv run python -m src.cli "your query"
+
+# Install as a permanent tool with UV
+uv tool install .
+# This will install the 'fq' command
+```
+
+## Usage
+
+### Command Line
+
+The quickest way to run file-query is with UV:
+
+```bash
+uv run python -m src.cli "your query here"
+```
+
+After installation, you can use the shorthand command:
+
+```bash
+fq "your query here"
+```
+
+#### Basic Usage
+
+```bash
+# Find all Python files
+fq "extension == 'py'"
+
+# Find all text files and show their content
+fq "extension == 'txt'" --show-content
+```
+
+#### Advanced Queries
+
+File Query supports full SQL-like syntax:
+
+```bash
+# Find all Python files in the src directory
+fq "SELECT * FROM 'src' WHERE extension == 'py'"
+
+# Find all files larger than 100KB
+fq "SELECT * FROM '.' WHERE size > 102400"
+
+# Complex conditions
+fq "SELECT * FROM '.' WHERE (extension == 'pdf' AND size > 1000000) OR (extension == 'txt' AND NOT name == 'README.txt')"
+```
+
+## Query Syntax
+
+File Query uses a SQL-like syntax:
+
+```sql
+SELECT * FROM 'directory_path' WHERE condition
+```
+
+### Available Attributes
+
+- `extension`: File extension (without the dot)
+- `name`: Filename with extension
+- `size`: File size in bytes
+
+### Operators
+
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Logical: `AND`, `OR`, `NOT`
+
+## Examples
+
+```bash
+# Find all PDF files
+fq "extension == 'pdf'"
+
+# Find all files not named "main.py"
+fq "NOT name == 'main.py'"
+
+# Find all large image files
+fq "SELECT * FROM '.' WHERE (extension == 'jpg' OR extension == 'png') AND size > 500000"
+```

file_query_text-0.1.0/README.md

@@ -0,0 +1,94 @@
+# File Query
+
+A SQL-like interface for querying files in your filesystem.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/file-query.git
+cd file-query
+
+# Install with pip
+pip install -e .
+
+# Or use UV
+uv run python -m src.cli "your query"
+
+# Install as a permanent tool with UV
+uv tool install .
+# This will install the 'fq' command
+```
+
+## Usage
+
+### Command Line
+
+The quickest way to run file-query is with UV:
+
+```bash
+uv run python -m src.cli "your query here"
+```
+
+After installation, you can use the shorthand command:
+
+```bash
+fq "your query here"
+```
+
+#### Basic Usage
+
+```bash
+# Find all Python files
+fq "extension == 'py'"
+
+# Find all text files and show their content
+fq "extension == 'txt'" --show-content
+```
+
+#### Advanced Queries
+
+File Query supports full SQL-like syntax:
+
+```bash
+# Find all Python files in the src directory
+fq "SELECT * FROM 'src' WHERE extension == 'py'"
+
+# Find all files larger than 100KB
+fq "SELECT * FROM '.' WHERE size > 102400"
+
+# Complex conditions
+fq "SELECT * FROM '.' WHERE (extension == 'pdf' AND size > 1000000) OR (extension == 'txt' AND NOT name == 'README.txt')"
+```
+
+## Query Syntax
+
+File Query uses a SQL-like syntax:
+
+```sql
+SELECT * FROM 'directory_path' WHERE condition
+```
+
+### Available Attributes
+
+- `extension`: File extension (without the dot)
+- `name`: Filename with extension
+- `size`: File size in bytes
+
+### Operators
+
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Logical: `AND`, `OR`, `NOT`
+
+## Examples
+
+```bash
+# Find all PDF files
+fq "extension == 'pdf'"
+
+# Find all files not named "main.py"
+fq "NOT name == 'main.py'"
+
+# Find all large image files
+fq "SELECT * FROM '.' WHERE (extension == 'jpg' OR extension == 'png') AND size > 500000"
+```

file_query_text-0.1.0/file_query_text/__init__.py

@@ -0,0 +1,3 @@
+"""SQL-like interface for querying files in your filesystem."""
+
+__version__ = "0.1.0"

file_query_text-0.1.0/file_query_text/cli.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+from pathlib import Path
+# Fix imports to work when installed as a package
+from file_query.main import parse_query, QueryVisitor, execute_query
+
+def main():
+    parser = argparse.ArgumentParser(description="SQL-like queries for your filesystem")
+    parser.add_argument("query", nargs="?", default="",
+                        help="SQL query for finding files (default: lists all files in current directory)")
+    parser.add_argument(
+        "--show-content", "-c",
+        action="store_true",
+        help="Display content of the matching files"
+    )
+    args = parser.parse_args()
+
+    # Get current working directory for the query
+    cwd = os.getcwd()
+
+    # Handle different query formats:
+    # 1. Full SQL format: "SELECT * FROM 'path' WHERE condition"
+    # 2. Simple condition: "extension == 'py'"
+    # 3. Simple path only: "SELECT * FROM 'path'"
+    # 4. Empty query: return all files in current directory
+    if not args.query.strip():
+        # Empty query - list all files in current directory
+        query_str = f"SELECT * FROM '{cwd}'"
+    elif args.query.strip().upper().startswith("SELECT"):
+        # Full SQL format or SELECT * FROM without WHERE - use as is
+        query_str = args.query
+    else:
+        # Simple condition format - assume it's a WHERE condition
+        query_str = f"SELECT * FROM '{cwd}' WHERE {args.query}"
+
+    # Parse and execute the query
+    parsed = parse_query(query_str)
+    if parsed:
+        visitor = QueryVisitor()
+        visitor.visit(parsed)
+        results = execute_query(visitor.select, visitor.from_dirs, visitor.where)
+
+        # Display results
+        if not results:
+            print("No matching files found.")
+            return
+
+        print(f"Found {len(results)} matching files:")
+        for file_path in results:
+            print(file_path)
+
+            # Optionally display file contents
+            if args.show_content:
+                try:
+                    with open(file_path, 'r') as f:
+                        content = f.read()
+                        print("\n--- File Content ---")
+                        print(content)
+                        print("--- End Content ---\n")
+                except Exception as e:
+                    print(f"Error reading file: {e}")
+
+if __name__ == "__main__":
+    main()

file_query_text-0.1.0/file_query_text/grammar.py

@@ -0,0 +1,63 @@
+from pyparsing import (
+    Word,
+    alphas,
+    alphanums,
+    QuotedString,
+    delimitedList,
+    Optional,
+    Group,
+    Suppress,
+    ZeroOrMore,
+    oneOf,
+    Forward,
+    Literal,
+    OneOrMore,
+    infixNotation,
+    opAssoc,
+    c_style_comment,
+    nums,
+    pyparsing_common,
+)
+
+# Define keywords
+SELECT = Suppress(Word("SELECT"))
+FROM = Suppress(Word("FROM"))
+WHERE = Suppress(Word("WHERE"))
+AND = Literal("AND")
+OR = Literal("OR")
+NOT = Literal("NOT")
+
+# Define identifiers and literals
+IDENTIFIER = Word(alphas + "_")
+STRING_LITERAL = QuotedString("'", unquoteResults=True)
+# Use pyparsing_common for numeric literals
+NUMERIC_LITERAL = pyparsing_common.integer
+DIRECTORY_LIST = Group(delimitedList(STRING_LITERAL))
+
+# Define comparison operators
+COMPARISON_OP = oneOf("== != < <= > >=")
+ATTRIBUTE = IDENTIFIER + Suppress("=") + STRING_LITERAL
+
+# Define basic condition with support for both string and numeric literals
+VALUE = STRING_LITERAL | NUMERIC_LITERAL
+basic_condition = Group(IDENTIFIER + COMPARISON_OP + VALUE)
+
+# Define logical expressions using infixNotation for better handling of AND and OR
+condition_expr = Forward()
+condition_expr <<= infixNotation(
+    basic_condition,
+    [
+        (NOT, 1, opAssoc.RIGHT),
+        (AND, 2, opAssoc.LEFT),
+        (OR, 2, opAssoc.LEFT),
+    ],
+)
+
+# Define the full query structure
+query = (
+    SELECT
+    + (Literal("*") | Group(OneOrMore(IDENTIFIER))).setResultsName("select")
+    + FROM
+    + DIRECTORY_LIST.setResultsName("from_dirs")
+    + Optional(WHERE + condition_expr.setResultsName("where"))
+)

file_query_text-0.1.0/file_query_text/main.py

@@ -0,0 +1,110 @@
+import os
+import sys
+from file_query_text.grammar import query  # Import the fixed grammar
+
+
+def parse_query(query_str):
+    try:
+        # Increase recursion limit temporarily to handle complex queries
+        old_limit = sys.getrecursionlimit()
+        sys.setrecursionlimit(2000)
+
+        parsed = query.parseString(query_str, parseAll=True)
+
+        # Restore original recursion limit
+        sys.setrecursionlimit(old_limit)
+        return parsed
+    except Exception as e:
+        print(f"Parse error: {e}")
+        return None
+
+class QueryVisitor:
+    def __init__(self):
+        self.select = []
+        self.from_dirs = []
+        self.where = None
+
+    def visit(self, parsed_query):
+        self.select = parsed_query.get("select", ["*"])
+        self.from_dirs = parsed_query.get("from_dirs", [])
+        self.where = parsed_query.get("where", None)
+
+def execute_query(select, from_dirs, where_conditions):
+    matched_files = []
+    for directory in from_dirs:
+        if not os.path.exists(directory):
+            continue
+        for root, _, files in os.walk(directory):
+            for filename in files:
+                file_path = os.path.join(root, filename)
+                if evaluate_conditions(file_path, where_conditions):
+                    matched_files.append(file_path)
+    return matched_files
+
+def evaluate_conditions(file_path, condition):
+    if not condition:
+        return True
+
+    def get_file_attr(attr_name):
+        if attr_name == "extension":
+            return os.path.splitext(file_path)[1][1:]
+        if attr_name == "name":
+            return os.path.basename(file_path)
+        if attr_name == "size":
+            return os.path.getsize(file_path)
+        # Add more attributes as needed
+        return None
+
+    # Evaluation function for expressions
+    def eval_expr(expr):
+        if not isinstance(expr, list):
+            return expr  # For simple terms like 'AND', 'OR'
+
+        if len(expr) == 3:
+            # Handle three types of expressions:
+
+            # 1. Basic condition: [attr, op, value]
+            if isinstance(expr[0], str) and isinstance(expr[1], str):
+                attr_val = get_file_attr(expr[0])
+                op = expr[1]
+                val = expr[2].strip("'") if isinstance(expr[2], str) else expr[2]  # Remove quotes if string
+
+                if op == "==": return str(attr_val) == val
+                if op == "!=": return str(attr_val) != val
+                if op == "<": return attr_val is not None and int(attr_val) < int(val)
+                if op == "<=": return attr_val is not None and int(attr_val) <= int(val)
+                if op == ">": return attr_val is not None and int(attr_val) > int(val)
+                if op == ">=": return attr_val is not None and int(attr_val) >= int(val)
+
+            # 2. Logical operations from infixNotation: [left, op, right]
+            elif expr[1] == "AND":
+                return eval_expr(expr[0]) and eval_expr(expr[2])
+            elif expr[1] == "OR":
+                return eval_expr(expr[0]) or eval_expr(expr[2])
+
+        # 3. NOT operation: ['NOT', expr]
+        elif len(expr) == 2 and expr[0] == "NOT":
+            return not eval_expr(expr[1])
+
+        return False
+
+    return eval_expr(condition.asList())
+
+# Example usage
+if __name__ == "__main__":
+    # Get project root directory for demonstration
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    src_dir = os.path.join(project_root, "src")
+    tests_dir = os.path.join(project_root, "tests")
+    query_str = f"SELECT * FROM '{src_dir}', '{tests_dir}' WHERE extension == 'py'"
+    parsed = parse_query(query_str)
+    if parsed:
+        visitor = QueryVisitor()
+        visitor.visit(parsed)
+        results = execute_query(visitor.select, visitor.from_dirs, visitor.where)
+        print("Matching files:")
+        for file in results:
+            # Skip files in .venv directory
+            if ".venv" not in file:
+                print(file)

file_query_text-0.1.0/file_query_text.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: file_query_text
+Version: 0.1.0
+Summary: SQL-like interface for querying files in your filesystem
+Author-email: nik <42a11b@nikdav.is>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nikdavis/file_query_text
+Project-URL: Bug Tracker, https://github.com/nikdavis/file_query_text/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pyparsing>=3.2.3
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+
+# File Query
+
+A SQL-like interface for querying files in your filesystem.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/file-query.git
+cd file-query
+
+# Install with pip
+pip install -e .
+
+# Or use UV
+uv run python -m src.cli "your query"
+
+# Install as a permanent tool with UV
+uv tool install .
+# This will install the 'fq' command
+```
+
+## Usage
+
+### Command Line
+
+The quickest way to run file-query is with UV:
+
+```bash
+uv run python -m src.cli "your query here"
+```
+
+After installation, you can use the shorthand command:
+
+```bash
+fq "your query here"
+```
+
+#### Basic Usage
+
+```bash
+# Find all Python files
+fq "extension == 'py'"
+
+# Find all text files and show their content
+fq "extension == 'txt'" --show-content
+```
+
+#### Advanced Queries
+
+File Query supports full SQL-like syntax:
+
+```bash
+# Find all Python files in the src directory
+fq "SELECT * FROM 'src' WHERE extension == 'py'"
+
+# Find all files larger than 100KB
+fq "SELECT * FROM '.' WHERE size > 102400"
+
+# Complex conditions
+fq "SELECT * FROM '.' WHERE (extension == 'pdf' AND size > 1000000) OR (extension == 'txt' AND NOT name == 'README.txt')"
+```
+
+## Query Syntax
+
+File Query uses a SQL-like syntax:
+
+```sql
+SELECT * FROM 'directory_path' WHERE condition
+```
+
+### Available Attributes
+
+- `extension`: File extension (without the dot)
+- `name`: Filename with extension
+- `size`: File size in bytes
+
+### Operators
+
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Logical: `AND`, `OR`, `NOT`
+
+## Examples
+
+```bash
+# Find all PDF files
+fq "extension == 'pdf'"
+
+# Find all files not named "main.py"
+fq "NOT name == 'main.py'"
+
+# Find all large image files
+fq "SELECT * FROM '.' WHERE (extension == 'jpg' OR extension == 'png') AND size > 500000"
+```

file_query_text-0.1.0/file_query_text.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+file_query_text/__init__.py
+file_query_text/cli.py
+file_query_text/grammar.py
+file_query_text/main.py
+file_query_text.egg-info/PKG-INFO
+file_query_text.egg-info/SOURCES.txt
+file_query_text.egg-info/dependency_links.txt
+file_query_text.egg-info/entry_points.txt
+file_query_text.egg-info/requires.txt
+file_query_text.egg-info/top_level.txt
+tests/test_main.py

file_query_text-0.1.0/file_query_text.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

file_query_text-0.1.0/file_query_text.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fq = file_query_text.cli:main

file_query_text-0.1.0/file_query_text.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pyparsing>=3.2.3
+
+[dev]
+pytest>=8.3.5

file_query_text-0.1.0/file_query_text.egg-info/top_level.txt

@@ -0,0 +1 @@
+file_query_text

file_query_text-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "file_query_text"
+version = "0.1.0"
+description = "SQL-like interface for querying files in your filesystem"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [
+    {name = "nik", email = "42a11b@nikdav.is"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "pyparsing>=3.2.3",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/nikdavis/file_query_text"
+"Bug Tracker" = "https://github.com/nikdavis/file_query_text/issues"
+
+[project.scripts]
+fq = "file_query_text.cli:main"
+
+[tool.setuptools]
+packages = ["file_query_text"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.5",
+]
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true

file_query_text-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

file_query_text-0.1.0/tests/test_main.py

@@ -0,0 +1,376 @@
+import os
+import pytest
+import tempfile
+from pathlib import Path
+from file_query_text.main import parse_query, execute_query, QueryVisitor
+
+@pytest.fixture
+def temp_dir():
+    """Create a temporary directory with test files for each test case."""
+    temp_dir = tempfile.TemporaryDirectory()
+    root_path = Path(temp_dir.name)
+
+    # Create test directories
+    (root_path / "docs").mkdir()
+    (root_path / "downloads").mkdir()
+
+    # Create test files
+    with open(root_path / "docs/report.pdf", "w") as f:
+        f.write("Test PDF")
+    with open(root_path / "docs/note.txt", "w") as f:
+        f.write("Test TXT")
+    with open(root_path / "downloads/image.jpg", "w") as f:
+        f.write("Test JPG")
+
+    yield root_path  # Provide the path to the test
+
+    # Cleanup is handled automatically by TemporaryDirectory
+
+def test_basic_query(temp_dir):
+    """Test SELECT * FROM with a WHERE clause on extension."""
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/docs', '{temp_dir}/downloads'
+    WHERE extension == 'pdf'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Expected result (only the PDF file)
+    expected = [str(temp_dir / "docs/report.pdf")]
+
+    # Normalize paths for comparison (handle different OS path separators)
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected)
+
+def test_multiple_conditions(temp_dir):
+    """Test OR conditions."""
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}'
+    WHERE extension == 'pdf'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Check if we got at least one result
+    assert len(results) > 0
+
+def test_nonexistent_directory():
+    """Test query with a non-existent directory."""
+    query_str = """
+    SELECT * FROM '/nonexistent/path'
+    WHERE extension == 'pdf'
+    """
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(visitor.select, visitor.from_dirs, visitor.where)
+    assert len(results) == 0
+
+# Optional: Test AND / NOT conditions
+def test_combined_conditions(temp_dir):
+    """Test AND and NOT conditions."""
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/downloads'
+    WHERE extension == 'png'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # We don't have any png files
+    assert len(results) == 0
+
+def test_and_conditions(temp_dir):
+    """Test AND condition logic."""
+    # Create a specific file for this test
+    with open(temp_dir / "docs/report_2023.pdf", "w") as f:
+        f.write("Test PDF with year")
+
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/docs'
+    WHERE extension == 'pdf' AND name == 'report_2023.pdf'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Expected result (only the matching PDF file)
+    expected = [str(temp_dir / "docs/report_2023.pdf")]
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected)
+
+def test_or_conditions(temp_dir):
+    """Test OR condition logic."""
+    # Create specific files for this test
+    with open(temp_dir / "docs/report_2023.pdf", "w") as f:
+        f.write("Test PDF with year")
+    with open(temp_dir / "docs/presentation.ppt", "w") as f:
+        f.write("Test PPT")
+
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/docs'
+    WHERE extension == 'pdf' OR extension == 'ppt'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Get all files in the directory with the specified extensions
+    all_pdf_files = list((temp_dir / "docs").glob("*.pdf"))
+    all_ppt_files = list((temp_dir / "docs").glob("*.ppt"))
+    expected_files = all_pdf_files + all_ppt_files
+    expected = [str(p) for p in expected_files]
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected)
+
+def test_not_conditions(temp_dir):
+    """Test NOT condition logic."""
+    # Create specific files for this test
+    with open(temp_dir / "docs/report.pdf", "w") as f:
+        f.write("Test PDF")
+    with open(temp_dir / "docs/presentation.ppt", "w") as f:
+        f.write("Test PPT")
+    with open(temp_dir / "docs/document.txt", "w") as f:
+        f.write("Test TXT")
+
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/docs'
+    WHERE NOT extension == 'pdf'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Query should return all non-PDF files
+    all_non_pdf_files = []
+    for path in (temp_dir / "docs").glob("*"):
+        if path.suffix != ".pdf":
+            all_non_pdf_files.append(str(path))
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(all_non_pdf_files)
+
+def test_numeric_comparison(temp_dir):
+    """Test numerical comparison operators."""
+    # Create files with different sizes
+    with open(temp_dir / "docs/small.txt", "w") as f:
+        f.write("Small")  # Size is 5 bytes
+    with open(temp_dir / "docs/medium.txt", "w") as f:
+        f.write("Medium text" * 5)  # Size > 10 bytes
+    with open(temp_dir / "docs/large.txt", "w") as f:
+        f.write("Large text file" * 20)  # Size > 100 bytes
+
+    # Query: Find files larger than 100 bytes
+    query_str = f"SELECT * FROM '{temp_dir}/docs' WHERE size > 100"
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Filter files manually to compare
+    large_files = []
+    for path in (temp_dir / "docs").glob("*"):
+        if path.stat().st_size > 100:
+            large_files.append(str(path))
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(large_files)
+
+def test_complex_nested_conditions(temp_dir):
+    """Test complex nested logical conditions."""
+    # Create specific test files with various properties
+    with open(temp_dir / "docs/small_report.pdf", "w") as f:
+        f.write("Small PDF")  # Small PDF file
+    with open(temp_dir / "docs/large_report.pdf", "w") as f:
+        f.write("Large PDF file" * 20)  # Large PDF file
+    with open(temp_dir / "docs/small_note.txt", "w") as f:
+        f.write("Small TXT")  # Small TXT file
+    with open(temp_dir / "docs/large_note.txt", "w") as f:
+        f.write("Large TXT file" * 20)  # Large TXT file
+    with open(temp_dir / "docs/image.jpg", "w") as f:
+        f.write("Image file" * 5)  # JPG file
+
+    # Complex query: Find (PDF files that are large) OR (TXT files that are not small)
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/docs'
+    WHERE (extension == 'pdf' AND size > 100) OR (extension == 'txt' AND NOT size < 50)
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Manually determine expected results
+    expected_files = []
+    for path in (temp_dir / "docs").glob("*"):
+        ext = path.suffix[1:]  # Remove the dot
+        size = path.stat().st_size
+        if (ext == 'pdf' and size > 100) or (ext == 'txt' and size >= 50):
+            expected_files.append(str(path))
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected_files)
+
+def test_query_without_where_clause(temp_dir):
+    """Test SELECT * FROM without a WHERE clause."""
+    query_str = f"""
+    SELECT *
+    FROM '{temp_dir}/docs'
+    """
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # All files in the docs directory should be returned
+    expected_files = []
+    for path in (temp_dir / "docs").glob("*"):
+        if path.is_file():
+            expected_files.append(str(path))
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected_files)
+
+def test_empty_query(temp_dir):
+    """Test empty query which should return all files."""
+    # Create a test file structure
+    with open(temp_dir / "docs/extra_file.txt", "w") as f:
+        f.write("Extra test file")
+
+    # First, construct the query string that the CLI would create for an empty query
+    query_str = f"SELECT * FROM '{temp_dir}'"
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Count all files in all subdirectories
+    expected_files = []
+    for path in temp_dir.glob("**/*"):
+        if path.is_file():
+            expected_files.append(str(path))
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected_files)
+
+    # Ensure we're getting more than just one file type
+    extensions = {os.path.splitext(p)[1] for p in actual}
+    assert len(extensions) > 1, "Empty query should return files with different extensions"
+
+def test_no_argument_query(temp_dir):
+    """Test when no query argument is passed (None), should be treated as empty string."""
+    # Create a test file structure
+    with open(temp_dir / "docs/extra_file2.txt", "w") as f:
+        f.write("Another test file")
+
+    # Simulate what happens when no argument is passed (CLI would convert to empty string)
+    query_str = f"SELECT * FROM '{temp_dir}'"
+
+    parsed = parse_query(query_str)
+    visitor = QueryVisitor()
+    visitor.visit(parsed)
+
+    results = execute_query(
+        visitor.select,
+        visitor.from_dirs,
+        visitor.where
+    )
+
+    # Count all files in all subdirectories
+    expected_files = []
+    for path in temp_dir.glob("**/*"):
+        if path.is_file():
+            expected_files.append(str(path))
+
+    # Normalize paths for comparison
+    actual = [str(p) for p in results]
+    assert sorted(actual) == sorted(expected_files)
+
+    # Ensure we're getting more than just one file type
+    extensions = {os.path.splitext(p)[1] for p in actual}
+    assert len(extensions) > 1, "Query with no argument should return files with different extensions"