Get entity by ID asynchronously. Args: id_value: Primary key value Returns: Entity or None if not f

根据用户名获取用户

Get chat session by ID asynchronously. Args: id: Chat session ID Returns: Chat session if found, No

Get a database connection with proper lifecycle management. Args: db_type: Database type enum connection_inf

Get the current connection or create a new one if needed. Returns: A DuckDB connection Raises: Data

Get datasource by ID. Args: datasource_id: Datasource ID Returns: Datasource or None if not found

Get schema metadata with enhanced caching support. Uses the repository pattern and optimized ConnectionManager with improved

Get the database schema. Args: datasource_id: Optional ID of specific datasource to fetch schema from Returns:

生成密码哈希

Check if session has expired

Convert a dictionary object to a base64-encoded string. This function serializes a dictionary object to a JSON-formatted byte string using th

Run SQL query and return results. Args: request: FastAPI request object id: ChatSession ID sql:

Context manager for SQLAlchemy sessions. Yields: SQLAlchemy session with automatic commit/rollback Example:

Convert data source to dictionary representation. Args: include_secrets: Whether to include secret values (default: Fals

Convert model instance to dictionary. Returns: Dictionary representation of model

Update the last_used_at timestamp for a datasource. Args: datasource_id: ID of the datasource to update Returns

Retry async database operations on connection errors. Args: coro_func: Async function to execute max_retries: Maximum number

Count total number of entities asynchronously.

Create new entity asynchronously.

Delete entity by ID asynchronously.

Get all entities with pagination asynchronously.

Update existing entity asynchronously.

Auto-detect chart type based on data structure Args: query_metadata: Query Metadata result_data: Result data

Check rate limit for a specific time window. Args: identifier: Unique identifier (user:xxx or ip:xxx) window_

Check rate limit using Redis (sliding window with sorted sets). Redis keys: ratelimit:{identifier}:{window} Sorted set: times

Check if we need to clean up idle connections.

Clean up stale records and enforce maximum tracked clients. This prevents memory growth by: 1. Removing records for clients

生成 Access Token

Create a new SQLite connection with optimized settings.

生成 Refresh Token

Internal method to execute SQL, serialize results, and handle basics.

Extract JSON from LLM response

Format search results into LLM-friendly context

Format search results as string

Generate embedding vector for text using LLM provider

Generate deterministic point ID from question ID

Get clarification request message

Generate a unique identifier for the client based on IP and other attributes. This creates a composite key that can distinguish betw

Extract client IP from request (considering proxies). Args: request: FastAPI request Returns:

Get the oldest timestamp still in the current window

Generate chart generation prompt

Get remaining requests allowed in the current window

Handle non-query intents

Check if connection is valid and responsive with timeout.

Check if client has exceeded rate limit using sliding window algorithm. Args: client_id: Unique client identifier

Determine if an error is potentially transient and retryable. Args: error: The exception to check Returns:

Search Qdrant for similar MDL documents

Determine if LLM is needed for chart selection

Add a new chat message. Args: message_data: Dictionary containing message attributes Returns: Creat

Register all exception handlers with the FastAPI app.

Add a message to session

Auto-discover and register database adapters. This function finds all adapter classes in the current package that follow the naming conv

Check if the database exists.

Check async database connection health. Returns: Dictionary with health check results

FastAPI dependency for checking rate limits. Usage: ```python @router.post("/api/v1/ask", dependencies=[Depends(check_rate_li

Clear all cache entries.

Close the database connection.

Close the database connection and cleanup resources. Raises: DatabaseError: If connection cannot be closed properly

Close all database connections.

Close all connections in the pool.

Close all database connections properly. This function should be called during application shutdown. Returns: bool: True if cle

Create a new migration.

Downgrade by a specific number of steps.

Show migration history.

Reset the database.

Show current migration status.

Upgrade to a specific version or head.

Connect to SQLite database with connection pooling and validation. Args: connection_info: Connection parameters

Count total number of datasources with optional filtering. Args: type_filter: Optional filter by datasource type

Create new entity. Args: entity: Entity to create Returns: Created entity with ID populated

* Create a new datasource * @param data - Datasource creation data * @returns Created datasource

Create a new chat session. Args: session_data: Dictionary containing session attributes Returns: Cr

Create collection if it doesn't exist

Create a new datasource with optimized connection validation. Args: db: Database session data: Datasource cr

Create a new MDL model

Create a new MDL project

创建用户（仅管理员）

Delete a value from the cache. Args: id: Unique identifier for the cached item Returns: bool: True

* Delete a datasource * @param id - Datasource ID * @returns Deletion status

Delete a collection

Delete a datasource with proper cleanup. Args: db: Database session datasource_id: ID of the datasource to d

Delete an MDL model

Delete an MDL project

删除用户（仅管理员）

Drop the database if it exists.

Generate SSE events

* Execute a SQL query against a datasource * @param id - Datasource ID * @param query - SQL query string * @param timeout - Query timeout in

Execute a SQL script with multiple statements. Args: script: SQL script string with multiple statements Returns