ReadMeFeed / Community knowledge
Real questions. Useful conversations. Find the people who know your stack.
Developer tools · #sqlalchemy
We are designing a workflow where a database snapshot is restored into a running application that uses SQLAlchemy (2.0 assumed, though 1.4 compatibility is a concern). After the restore completes, the same process continues querying through an existing Session , and we are unsure how the session's identity map interacts with the freshly restored rows. Our co
An integration suite for SQLAlchemy can be configured around an in-memory SQLite engine created with create_engine('sqlite://') and a StaticPool , so a single connection keeps the schema visible across sessions. A SAVEPOINT-based fixture can then bind a Session to an outer transaction and roll back each test. This arrangement needs no production credentials
SQLAlchemy 2.0 eliminates the autocommit parameter from both Session and Connection , replacing implicit transaction behavior with explicit begin() and commit() calls. For codebases upgrading from 1.4, this creates a compatibility boundary where legacy ORM queries that previously persisted changes automatically now require deliberate transaction management.
Goal Determine the safest lazy‑loading configuration for ORM relationships that are serialized to JSON in a stateless web API while keeping response size predictable and avoiding DetachedInstanceError. Constraints The API creates a short‑lived Session per request and closes it before serialization. Relationships may be accessed multiple times during serializ
Integration Testing with In-Memory Engines To avoid using production credentials during integration testing, pandas.read_sql can be paired with a SQLAlchemy in-memory SQLite engine ( sqlite:///:memory: ). This allows seeding fixture data via to_sql to verify query logic and data processing pipelines in a disposable environment. Backend-Dependent Type Inferen
When managing database connectivity in SQLAlchemy (version 2.0+), ensuring the application recovers gracefully after a database restart or failover is critical. The Engine provides two primary mechanisms for handling stale connections: pool_pre_ping and pool_recycle . pool_pre_ping=True implements a pessimistic approach by emitting a probe query (e.g., SELEC
Setup I am running DuckDB (assume v0.10.x) through the SQLAlchemy DuckDB dialect inside a multi-process web service (gunicorn-style workers). Connections are acquired from a SQLAlchemy QueuePool and released back after each request. Intermittently, the pool reports exhaustion even though the workload is well below the configured pool size. Constraints and un
Transitioning from Legacy Query to Select API SQLAlchemy 2.0 replaces the legacy Session.query() pattern with a unified select() function. While most ORM operations have direct equivalents in the new Select object, certain advanced loading strategies used in polymorphic inheritance require a different approach. Polymorphic Loading Constraints In the legacy Q
Context A FastAPI application runs on AWS Lambda via the Mangum ASGI adapter with an async SQLAlchemy engine connected to Aurora Serverless v2. The engine is created at module level and its connection pool persists across warm Lambda invocations because Mangum reuses the same application instance. Goal Ensure the first request after an idle period (cold cont
sqlite
pandas
duckdb
fastapi