result = db.records.find({

print(f"Found {len(result)} records out of {result.total} total")

for record in result:

print(f"User: {record.get('name')} (Age: {record.get('age')})")

if result.has_more:

print("There are more records available")

first_user = result[0] if result else None

RushDB Python SDK uses a modern `SearchResult` container that follows Python SDK best practices similar to boto3, google-cloud libraries, and other popular SDKs.

- **Generic type support**: Uses Python's typing generics (`SearchResult[T]`) with `RecordSearchResult` as a type alias for `SearchResult[Record]`

- **List-like access**: Index, slice, and iterate like a regular list

- **Search context**: Access total count, pagination info, and the original search query

- **Boolean conversion**: Use in if statements naturally (returns `True` if the result contains any items)

- **Pagination support**: Built-in pagination information and `has_more` property

result = db.records.find({

"where": {"status": "active"},

"limit": 10,

"skip": 20

})

if result:

print(f"Found {len(result)} records")

print(f"Total matching records: {result.total}")

print(f"Current page size: {result.count}")

print(f"Records skipped: {result.skip}")

print(f"Has more results: {result.has_more}")

print(f"Search query: {result.search_query}")

for record in result:

print(f"Record: {record.get('name')}")

names = [r.get('name') for r in result]

first_record = result[0] if result else None

first_five = result[:5]

print(repr(result)) # SearchResult(count=10, total=42)

def __init__(

self,

data: List[T],

total: Optional[int] = None,

search_query: Optional[SearchQuery] = None,

):

"""

| Property | Type | Description |

| -------------- | --------------- | ---------------------------------------- |

| `data` | `List[T]` | The list of result items (generic type) |

| `total` | `int` | Total number of matching records |

| `count` | `int` | Number of records in current result set |

| `limit` | `Optional[int]` | Limit that was applied to the search |

| `skip` | `int` | Number of records that were skipped |

| `has_more` | `bool` | Whether there are more records available |

| `search_query` | `SearchQuery` | The search query used to generate result |

page_size = 10

current_page = 0

while True:

result = db.records.find({

"where": {"category": "electronics"},

"limit": page_size,

"skip": current_page * page_size,

"orderBy": {"created_at": "desc"}

})

if not result:

break

print(f"Page {current_page + 1}: {len(result)} records")

for record in result:

process_record(record)

if not result.has_more:

break

current_page += 1

The SDK provides a specialized type alias for search results containing Record objects:

RecordSearchResult = SearchResult[Record]

This type is what's returned by methods like `db.records.find()`, providing type safety and specialized handling for Record objects while leveraging all the functionality of the generic SearchResult class.

The Record class has been enhanced with better data access patterns and utility methods.

user = db.records.create("User", {

"name": "John Doe",

"email": "john@example.com",

"age": 30,

"department": "Engineering"

})

name = user.get("name") # "John Doe"

phone = user.get("phone", "Not provided") # "Not provided"

user_data = user.get_data()

full_data = user.get_data(exclude_internal=False)

fields = user.fields # Same as user.get_data()

user_dict = user.to_dict() # Clean user data

full_dict = user.to_dict(exclude_internal=False) # All data

user_name = user["name"] # Direct access

user_id = user["__id"] # Internal field access

if user.exists():

print("Record is valid and accessible")

user.update({"status": "active"})

else:

print("Record doesn't exist or is not accessible")

def process_record_safely(record):

if not record.exists():

return None

return record.get_data()

records = db.records.find({"where": {"status": "pending"}})

for record in records:

if record.exists():

record.update({"processed_at": datetime.now()})

user = db.records.create("User", {"name": "Alice Johnson"})

print(repr(user)) # Record(id='abc-123', label='User')

print(str(user)) # User: Alice Johnson

product = db.records.create("Product", {"sku": "ABC123"})

print(str(product)) # Product (product-id-here)

) -> RecordSearchResult

- `search_query` (Optional[SearchQuery]): Search query parameters

- `RecordSearchResult`: SearchResult container with matching records and metadata

result = db.records.find(query=query)

print(f"Found {len(result)} out of {result.total} total records")

for record in result:

print(f"Employee: {record.get('name')} - {record.get('department')}")

if result.has_more:

print("More results available")

first_employee = result[0] if result else None

senior_employees = [r for r in result if r.get('age', 0) > 30]

version = "1.5.0"

homepage = "https://github.com/rush-db/rushdb-python"

repository = "https://github.com/rush-db/rushdb-python"

from .models.result import RecordSearchResult, SearchResult

"RecordSearchResult",

"SearchResult",