Data stream synchronization is now smarter and more efficient! With this update, data streams are reset automatically only when the columns of a source table actually change—such as when columns are added, removed, or modified. Changes to table metadata that don’t affect columns (like adding tags or enabling change tracking) no longer cause unnecessary stream resets.
You can now configure a maximum query execution time in the RelationalAI Python client using the new query_timeout_mins setting. By default, queries time out after 24 hours, but you can reduce this limit in your config file or per query to better control long-running operations.
If a query exceeds the specified timeout, a clear QueryTimeoutExceededException is raised with guidance on how to resolve the issue—replacing the previous behavior where timeouts returned empty results without explanation.
Example usage:
In you raiconfig.toml file:
query_timeout_mins = 30# Set max query time to 30 minutes
As a query-specific override:
from relationalai.errors import QueryTimeoutExceededException
import relationalai as rai
model = rai.Model("MyModel")
try:
# Set a 10-minute timeout for this specific query
with model.query(query_timeout_mins=10) as select:
# ... some long-running query logic ...
except QueryTimeoutExceededException as e:
print(e)
This enhancement helps prevent runaway queries to control costs and resource usage, while providing clear feedback when timeouts occur.
Improved the CLI progress indicator to better detect continuous integration (CI) environments by disabling certain terminal features. When running queries in CI, the progress display now shows a single, clean progress line instead of multiple lines, preventing cluttered logs.
Improved error messages for internal system errors encountered during query execution. When such errors occur, the message now includes clear troubleshooting steps to help you resolve the issue:
Retry using a new model name to work around possible state-related problems.
If the error persists, set the use_lqp flag to False when creating your model (e.g., model = Model(..., use_lqp=False)) to switch to the legacy backend, which may avoid the error at some performance cost.
These enhancements provide actionable guidance directly in the error output, making it easier to diagnose and work around internal engine errors without needing additional support.
Fixed a bug where failed some transactions could incorrectly update the internal model cache when using use_lqp=True. Now, if a transaction or its result processing fails, the model cache is reverted to its previous valid state. This ensures that only successful transactions update the model cache, preventing future queries from using an inconsistent or partially updated model.
This release adds a new optional Snowflake privilege for all RelationalAI (RAI) Native App installations.
The privilege is IMPORTED PRIVILEGES ON SNOWFLAKE DB.
It supports upcoming features that integrate with Snowflake Cortex AI.
Existing installations will continue to operate without this privilege.
However, to take advantage of new features that require it, you must grant this privilege to the RAI Native App.
To grant this privilege to your RAI Native App, execute the following SQL command in a Snowflake worksheet:
GRANT IMPORTED PRIVILEGES ONDATABASE SNOWFLAKE TOAPPLICATION RELATIONALAI;
We have improved how RAI engines estimate available memory.
Previously, engines were overly conservative and treated reclaimable kernel memory as unavailable.
This could lead to underused resources.
The new approach provides a more accurate lower bound, allowing better resource utilization.
There are no changes to user-facing APIs or commands, but you may notice improved engine performance.
User-initiated transactions now have a default timeout of 24 hours (1,440 minutes).
Currently there is no way to change this timeout globally, but Python API users can adjust it for their models by specifying the query_timeout_mins parameter in their raiconfig.toml file.
See Changing the Query Timeout for more information about setting this parameter.
This breaking change improves resource management by preventing long-running transactions from consuming system resources indefinitely.
