sqliter-py 0.12.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

sqliter/tui/demos/results.py

@@ -0,0 +1,241 @@
+"""Query Results & Aggregation demos."""
+
+from __future__ import annotations
+
+import io
+
+from sqliter import SqliterDB
+from sqliter.model import BaseDBModel
+from sqliter.tui.demos.base import Demo, DemoCategory, extract_demo_code
+
+
+def _run_fetch_all() -> str:
+    """Fetch all records matching a query.
+
+    Use fetch_all() to get a list of all matching records.
+    """
+    output = io.StringIO()
+
+    class User(BaseDBModel):
+        name: str
+        age: int
+
+    db = SqliterDB(memory=True)
+    db.create_table(User)
+
+    for i in range(5):
+        db.insert(User(name=f"User {i}", age=20 + i))
+
+    results = db.select(User).fetch_all()
+    output.write(f"Total users: {len(results)}\n")
+    for user in results:
+        output.write(f"  - {user.name}, age {user.age}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_fetch_one() -> str:
+    """Fetch a single record or return None if not found.
+
+    Use fetch_one() to get one matching record, returning None if
+    no records match the query.
+    """
+    output = io.StringIO()
+
+    class Task(BaseDBModel):
+        title: str
+        priority: int
+
+    db = SqliterDB(memory=True)
+    db.create_table(Task)
+
+    db.insert(Task(title="High priority", priority=1))
+    db.insert(Task(title="Medium priority", priority=2))
+    db.insert(Task(title="Low priority", priority=3))
+
+    task = db.select(Task).filter(priority__eq=1).fetch_one()
+    if task is not None:
+        output.write(f"Single result: {task.title}\n")
+
+    # Also test no results case
+    no_task = db.select(Task).filter(priority__eq=999).fetch_one()
+    if no_task is None:
+        output.write("No task found with priority 999\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_fetch_first_last() -> str:
+    """Fetch the first or last record from results.
+
+    Use fetch_first() or fetch_last() to get a single record
+    from the beginning or end of the result set.
+    """
+    output = io.StringIO()
+
+    class Item(BaseDBModel):
+        name: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(Item)
+
+    for name in ["Alpha", "Beta", "Gamma", "Delta"]:
+        db.insert(Item(name=name))
+
+    first = db.select(Item).fetch_first()
+    if first is not None:
+        output.write(f"First: {first.name}\n")
+
+    last = db.select(Item).fetch_last()
+    if last is not None:
+        output.write(f"Last: {last.name}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_count() -> str:
+    """Count the number of matching records.
+
+    Use count() to efficiently count records without fetching them.
+    """
+    output = io.StringIO()
+
+    class Product(BaseDBModel):
+        name: str
+        category: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(Product)
+
+    db.insert(Product(name="Laptop", category="electronics"))
+    db.insert(Product(name="Phone", category="electronics"))
+    db.insert(Product(name="Desk", category="furniture"))
+
+    total = db.select(Product).count()
+    output.write(f"Total products: {total}\n")
+
+    electronics = db.select(Product).filter(category__eq="electronics").count()
+    output.write(f"Electronics: {electronics}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_exists() -> str:
+    """Check if any records match the query.
+
+    Use exists() to efficiently check for matching records without
+    fetching them - returns True/False.
+    """
+    output = io.StringIO()
+
+    class User(BaseDBModel):
+        username: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(User)
+
+    db.insert(User(username="alice"))
+    db.insert(User(username="bob"))
+
+    exists = db.select(User).filter(username__eq="alice").exists()
+    output.write(f"User 'alice' exists: {exists}\n")
+
+    not_exists = db.select(User).filter(username__eq="charlie").exists()
+    output.write(f"User 'charlie' exists: {not_exists}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_aggregates() -> str:
+    """Calculate aggregates using Python after fetching data.
+
+    SQLiter doesn't support SQL-level aggregates (GROUP BY, HAVING).
+    Use Python's sum(), len(), etc. after fetching results.
+    """
+    output = io.StringIO()
+
+    class Sale(BaseDBModel):
+        amount: float
+
+    db = SqliterDB(memory=True)
+    db.create_table(Sale)
+
+    for amount in [10.0, 20.0, 30.0, 40.0, 50.0]:
+        db.insert(Sale(amount=amount))
+
+    # Note: SQLiter doesn't support SQL-level aggregates (GROUP BY, HAVING)
+    # Use Python for calculations after fetching data
+    results = db.select(Sale).fetch_all()
+    total = sum(s.amount for s in results)
+    average = total / len(results)
+    output.write(f"Total sales: ${total:.2f}\n")
+    output.write(f"Average sale: ${average:.2f}\n")
+    output.write(f"Count: {len(results)}\n")
+    output.write("\n(Aggregates calculated in Python, not SQL)\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def get_category() -> DemoCategory:
+    """Get the Query Results demo category."""
+    return DemoCategory(
+        id="results",
+        title="Query Results",
+        icon="",
+        demos=[
+            Demo(
+                id="result_fetch_all",
+                title="Fetch All",
+                description="Get all matching records",
+                category="results",
+                code=extract_demo_code(_run_fetch_all),
+                execute=_run_fetch_all,
+            ),
+            Demo(
+                id="result_fetch_one",
+                title="Fetch One",
+                description="Get single record or None",
+                category="results",
+                code=extract_demo_code(_run_fetch_one),
+                execute=_run_fetch_one,
+            ),
+            Demo(
+                id="result_first_last",
+                title="Fetch First/Last",
+                description="Get first or last record",
+                category="results",
+                code=extract_demo_code(_run_fetch_first_last),
+                execute=_run_fetch_first_last,
+            ),
+            Demo(
+                id="result_count",
+                title="Count",
+                description="Count matching records",
+                category="results",
+                code=extract_demo_code(_run_count),
+                execute=_run_count,
+            ),
+            Demo(
+                id="result_exists",
+                title="Exists",
+                description="Check if any records match",
+                category="results",
+                code=extract_demo_code(_run_exists),
+                execute=_run_exists,
+            ),
+            Demo(
+                id="result_aggregates",
+                title="Aggregates",
+                description="Calculate sum, average, etc.",
+                category="results",
+                code=extract_demo_code(_run_aggregates),
+                execute=_run_aggregates,
+            ),
+        ],
+    )

sqliter/tui/demos/string_filters.py

@@ -0,0 +1,210 @@
+"""String Filter demos."""
+
+from __future__ import annotations
+
+import io
+
+from sqliter import SqliterDB
+from sqliter.model import BaseDBModel
+from sqliter.tui.demos.base import Demo, DemoCategory, extract_demo_code
+
+
+def _run_startswith() -> str:
+    """Filter strings that start with a specific prefix.
+
+    Use __startswith to match records where a field begins with
+    the specified value.
+    """
+    output = io.StringIO()
+
+    class User(BaseDBModel):
+        username: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(User)
+
+    db.insert(User(username="alice_wonder"))
+    db.insert(User(username="alice_smith"))
+    db.insert(User(username="bob_builder"))
+
+    # Find usernames starting with "alice"
+    results = db.select(User).filter(username__startswith="alice").fetch_all()
+    output.write(f"Users starting with 'alice': {len(results)}\n")
+    for user in results:
+        output.write(f"  - {user.username}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_endswith() -> str:
+    """Filter strings that end with a specific suffix.
+
+    Use __endswith to match records where a field ends with
+    the specified value.
+    """
+    output = io.StringIO()
+
+    class File(BaseDBModel):
+        filename: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(File)
+
+    db.insert(File(filename="document.txt"))
+    db.insert(File(filename="image.png"))
+    db.insert(File(filename="notes.txt"))
+    db.insert(File(filename="data.csv"))
+
+    # Find files ending with ".txt"
+    results = db.select(File).filter(filename__endswith=".txt").fetch_all()
+    output.write(f"Text files: {len(results)}\n")
+    for file in results:
+        output.write(f"  - {file.filename}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_contains() -> str:
+    """Filter strings that contain a specific substring.
+
+    Use __contains to match records where a field contains
+    the specified value anywhere within it.
+    """
+    output = io.StringIO()
+
+    class Product(BaseDBModel):
+        name: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(Product)
+
+    db.insert(Product(name="Apple iPhone"))
+    db.insert(Product(name="Samsung Galaxy"))
+    db.insert(Product(name="Apple iPad"))
+    db.insert(Product(name="Google Pixel"))
+
+    # Find products containing "Apple"
+    results = db.select(Product).filter(name__contains="Apple").fetch_all()
+    output.write(f"Products containing 'Apple': {len(results)}\n")
+    for product in results:
+        output.write(f"  - {product.name}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_case_insensitive() -> str:
+    """Filter strings ignoring case with __istartswith and __iendswith.
+
+    Use case-insensitive operators to match strings regardless of
+    capitalization.
+    """
+    output = io.StringIO()
+
+    class User(BaseDBModel):
+        email: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(User)
+
+    db.insert(User(email="ALICE@example.com"))
+    db.insert(User(email="bob@EXAMPLE.com"))
+    db.insert(User(email="charlie@test.com"))
+
+    # Find emails ending with "@example.com" (case-insensitive)
+    results = (
+        db.select(User).filter(email__iendswith="@example.com").fetch_all()
+    )
+    output.write(f"Emails ending with '@example.com': {len(results)}\n")
+    for user in results:
+        output.write(f"  - {user.email}\n")
+
+    # Find emails starting with "BOB" (case-insensitive)
+    bob_results = db.select(User).filter(email__istartswith="BOB").fetch_all()
+    output.write(f"\nEmails starting with 'BOB': {len(bob_results)}\n")
+    for user in bob_results:
+        output.write(f"  - {user.email}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_icontains() -> str:
+    """Filter strings containing a substring, ignoring case.
+
+    Use __icontains for case-insensitive substring matching.
+    """
+    output = io.StringIO()
+
+    class Article(BaseDBModel):
+        title: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(Article)
+
+    db.insert(Article(title="Python Programming Guide"))
+    db.insert(Article(title="Advanced PYTHON Techniques"))
+    db.insert(Article(title="Web Development"))
+    db.insert(Article(title="python for Beginners"))
+
+    # Find articles containing "python" (case-insensitive)
+    results = db.select(Article).filter(title__icontains="python").fetch_all()
+    output.write(f"Articles containing 'python': {len(results)}\n")
+    for article in results:
+        output.write(f"  - {article.title}\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def get_category() -> DemoCategory:
+    """Get the String Filters demo category."""
+    return DemoCategory(
+        id="string_filters",
+        title="String Filters",
+        icon="",
+        demos=[
+            Demo(
+                id="string_startswith",
+                title="Starts With (__startswith)",
+                description="Match strings starting with prefix",
+                category="string_filters",
+                code=extract_demo_code(_run_startswith),
+                execute=_run_startswith,
+            ),
+            Demo(
+                id="string_endswith",
+                title="Ends With (__endswith)",
+                description="Match strings ending with suffix",
+                category="string_filters",
+                code=extract_demo_code(_run_endswith),
+                execute=_run_endswith,
+            ),
+            Demo(
+                id="string_contains",
+                title="Contains (__contains)",
+                description="Match strings containing substring",
+                category="string_filters",
+                code=extract_demo_code(_run_contains),
+                execute=_run_contains,
+            ),
+            Demo(
+                id="string_case_insensitive",
+                title="Case-Insensitive (__i*)",
+                description="Match strings ignoring case",
+                category="string_filters",
+                code=extract_demo_code(_run_case_insensitive),
+                execute=_run_case_insensitive,
+            ),
+            Demo(
+                id="string_icontains",
+                title="Contains Case-Insensitive",
+                description="Match substring ignoring case",
+                category="string_filters",
+                code=extract_demo_code(_run_icontains),
+                execute=_run_icontains,
+            ),
+        ],
+    )

sqliter/tui/demos/timestamps.py

@@ -0,0 +1,126 @@
+"""Auto Timestamp demos."""
+
+from __future__ import annotations
+
+import io
+import time
+from datetime import datetime, timezone
+
+from sqliter import SqliterDB
+from sqliter.model import BaseDBModel
+from sqliter.tui.demos.base import Demo, DemoCategory, extract_demo_code
+
+
+def _run_created_at() -> str:
+    """Automatically track when records are created.
+
+    The created_at field is set automatically when you insert a record.
+    """
+    output = io.StringIO()
+
+    class Article(BaseDBModel):
+        title: str
+
+    db = SqliterDB(memory=True)
+    db.create_table(Article)
+
+    article1 = db.insert(Article(title="First Post"))
+    dt1 = datetime.fromtimestamp(article1.created_at, tz=timezone.utc)
+    formatted_dt1 = dt1.strftime("%Y-%m-%d %H:%M:%S")
+    output.write(f"Article: {article1.title}\n")
+    output.write(f"Created: {article1.created_at} ({formatted_dt1} UTC)\n")
+
+    time.sleep(0.1)
+
+    article2 = db.insert(Article(title="Second Post"))
+    dt2 = datetime.fromtimestamp(article2.created_at, tz=timezone.utc)
+    formatted_dt2 = dt2.strftime("%Y-%m-%d %H:%M:%S")
+    output.write(f"\nArticle: {article2.title}\n")
+    output.write(f"Created: {article2.created_at} ({formatted_dt2} UTC)\n")
+
+    db.close()
+    return output.getvalue()
+
+
+def _run_updated_at() -> str:
+    """Automatically track when records are last modified.
+
+    The updated_at field changes automatically when you update a record.
+    """
+    output = io.StringIO()
+
+    class Task(BaseDBModel):
+        title: str
+        done: bool = False
+
+    db = SqliterDB(memory=True)
+    db.create_table(Task)
+
+    task = db.insert(Task(title="Original Task"))
+    created_dt = datetime.fromtimestamp(task.created_at, tz=timezone.utc)
+    updated_dt = datetime.fromtimestamp(task.updated_at, tz=timezone.utc)
+    formatted_created_dt = created_dt.strftime("%Y-%m-%d %H:%M:%S")
+    formatted_updated_dt = updated_dt.strftime("%Y-%m-%d %H:%M:%S")
+    output.write(f"Task: {task.title}\n")
+    output.write(f"Created: {task.created_at} ({formatted_created_dt} UTC)\n")
+    output.write(f"Updated: {task.updated_at} ({formatted_updated_dt} UTC)\n")
+
+    # Sleep for 1 second to ensure different timestamps on fast machines
+    time.sleep(1)
+
+    task.title = "Updated Task"
+    task.done = True
+    db.update(task)
+    updated_task = task
+    updated_created_dt = datetime.fromtimestamp(
+        updated_task.created_at, tz=timezone.utc
+    )
+    updated_updated_dt = datetime.fromtimestamp(
+        updated_task.updated_at, tz=timezone.utc
+    )
+    formatted_updated_created_dt = updated_created_dt.strftime(
+        "%Y-%m-%d %H:%M:%S"
+    )
+    formatted_updated_updated_dt = updated_updated_dt.strftime(
+        "%Y-%m-%d %H:%M:%S"
+    )
+    output.write("\nAfter update:\n")
+    output.write(f"Title: {updated_task.title}\n")
+    output.write(
+        f"Created: {updated_task.created_at} "
+        f"({formatted_updated_created_dt} UTC)\n"
+    )
+    output.write(
+        f"Updated: {updated_task.updated_at} "
+        f"({formatted_updated_updated_dt} UTC)\n"
+    )
+
+    db.close()
+    return output.getvalue()
+
+
+def get_category() -> DemoCategory:
+    """Get the Auto Timestamp demo category."""
+    return DemoCategory(
+        id="timestamps",
+        title="Auto Timestamps",
+        icon="",
+        demos=[
+            Demo(
+                id="timestamp_created",
+                title="Auto created_at",
+                description="Track when records are created",
+                category="timestamps",
+                code=extract_demo_code(_run_created_at),
+                execute=_run_created_at,
+            ),
+            Demo(
+                id="timestamp_updated",
+                title="Auto updated_at",
+                description="Track when records are modified",
+                category="timestamps",
+                code=extract_demo_code(_run_updated_at),
+                execute=_run_updated_at,
+            ),
+        ],
+    )