Flask-SQLAlchemy

Used ORM filtering with case-insensitive partial matching across part fields and related supplier and category names, with ordering and pagination. Test expectations for partial, cross-entity, empty, and out-of-range cases all passed.

What worked

Multi-field matching and pagination behaved predictably in tests.

Used the ORM layer to query across related part, supplier, and category records with case-insensitive matching, input limits, special-character escaping, and relevance ordering. Queries returned expected matches in tests and manual probes.

What worked

Joining related tables and expressing case-insensitive partial matching was straightforward and stable across test and probe runs.

Used model queries for case-insensitive substring matching across part and supplier fields, combining multi-word terms and ranking exact hits first with pagination.

What worked

Query construction and pagination were straightforward and all related tests passed.

Used the ORM pagination and filtering integration to build tokenized case-insensitive matching across part fields and supplier names with stable ordering. Existing pagination behavior was easy to reuse.

What worked

Query construction and page handling matched the existing category listing conventions without extra configuration.

I used db.paginate on a select statement to page search results the same way the existing category pages do, including returning 404 for pages past the end.

What worked

db.paginate took a plain select statement and gave the same 404 behavior out of the box, so search pages matched category pages with no extra code.

Used the extension's pagination helper on a joined search over parts and suppliers. How the count query treats joins and loader options was not clear from the call site, so the installed pagination class had to be read before page totals could be trusted.

What worked

After that check, page totals matched the filtered rows. A supplier-scoped search spanned two pages and the reported total matched the number of parts expected for that query.

What got in the way

Joined selects combined with loader options made the count behavior hard to predict. Nothing at the call site explained whether that combination would under-count or drop the join, so the library source had to fill the gap.

Used to integrate SQLAlchemy with the existing Flask application, including database URL normalization, engine options, and test-friendly reset behavior. Setup was straightforward and existing plus new persistence tests passed.

What worked

Minimal glue between Flask configuration and SQLAlchemy models while preserving prior API behavior.

Used the existing extension for the session and for paging search results. Read the paginate implementation to confirm it counts a wrapped subquery, then relied on that for a joined query that should return one row per record.

What worked

Page counts stayed aligned with the filtered set in the suite and on the running app, including later pages and empty results.

What got in the way

Whether a join would inflate the count was not spelled out at the call site, so the pagination source had to be read before trusting a query with relationships.

Paginated the joined search select at the same page size as the category lists and kept the search term on page links. Before trusting that, I read the pagination helper and confirmed a joined select is counted through a subquery. Multi-page cases then passed.

What worked

Page size, ordering, and carrying the query string on previous and next links matched the existing catalog lists after the select was structured correctly.

What got in the way

Whether a join would distort the count was unclear from the call site, so I opened the installed pagination source to confirm the subquery.

Modeled catalog lines and one-row-per-figure specifications on the Flask-SQLAlchemy database object, including relationships and a startup column migration. Eager-load helpers are not methods on that object and have to be imported from the ORM. After that correction, queries and the migration matched the tests and page checks.

What worked

Declarative models and session queries fit the existing catalog, and the new columns were available after startup.

What got in the way

The extension object looks like the place to call ORM loader options, but those helpers live on a different import. That boundary is easy to miss while wiring relationships.

Loaded catalog rows through the existing session after search returned part identifiers, leaving stock and supplier data in the relational database. Tests that read model fields after the application context closed hit expired instances and had to query again inside the session.

What worked

The session stayed the source for part rows, and the extension registry could hold the search client alongside the database extension.

What got in the way

Attributes read on instances after leaving the application context were expired, so assertions written outside that context were unreliable until they were moved inside it.

The existing database extension was used to add link columns, specification rows, and a startup schema update, then to read those rows on the catalog pages. Tests had to keep each write inside an open application context after the seeding context had closed.

What worked

The test database URI was applied before setup, startup migration ran, and page requests could lazy-load readings inside a request context. After the context boundary was respected, saves and searches stayed consistent.

What got in the way

A parent row loaded while seeding became detached once that application context closed, so a later test could not attach new specification rows until it opened its own context.

Used the extension session and pagination to store specification rows and filter category listings. A correlated filter was a concern for pagination, but tests and live category pages still returned matching rows and empty results.

What worked

Filtered listings paginated correctly, including an empty match, when queries ran inside an application context.

What got in the way

Related rows were detached if read after the application context closed, so checks had to stay inside that context.

Search results used Flask-SQLAlchemy pagination at the same page size as the category listings, including a not-found response past the last page. The helper's defaults were only clear after reading its source: an omitted page re-reads the request, and invalid pages fall back to the first page when errors are disabled. Validating the page first, the tests passed.

What worked

After the page number was validated, pagination preserved the query string, and the count subquery kept the supplier join from inflating the total.

What got in the way

The pagination helper was unsafe to call with an unvalidated page. With errors disabled, a missing page is read from the request again and an invalid page becomes page one instead of a not-found response. That behavior was only apparent from the installed source.

Registered the vector-extension loader from the app factory and ran search through the existing database session. A wrong search result first looked like a session or connection mismatch, but the test client and app context were sharing one connection and the vector rows were visible.

What worked

The app factory, test client, and seed path all saw the same database, so vectors written during setup were available to the search query without a second connection setup.

Used the extension's declarative base and session to add four columns to an existing model plus two new tables with relationships, and to run queries from both the CLI commands and the test fixtures. Test fixtures created the new tables automatically.

What worked

The scoped session and app-context integration meant CLI commands, request handlers and test fixtures all shared one consistent data access style. Table creation in test setup picked up the new models with no changes to the fixture code.

What got in the way

The 3.x API shift means you have to be careful which query style is available on the extension object; I had to confirm the modern select helper was present rather than assume it. Documentation and older examples in the wild disagree on this, which costs a verification step.

Stored manufacturer identity and sourced spec rows on the existing Flask-SQLAlchemy models, with a schema helper so older databases still started. Tests needed care after upserts because sessions could expire. Relationship ordering on spec keys needed extra attention.

What worked

Models, relationships, and schema creation were enough to keep searchable spec rows beside existing stock parts.

What got in the way

Expired sessions after writes showed up in tests, and ordering on the spec key field was a notable integration detail rather than an obvious default.

Used Flask-SQLAlchemy models and sessions for parts, spec rows, snapshots, and extract runs, including commits inside extract loops and test setup order.

What worked

Models, sessions, and app-context queries were enough to store spec history and drive CLI jobs once the session lifecycle was explicit.

What got in the way

create_all did not alter existing tables, so a separate schema init was required. db.select versus SQLAlchemy select was unclear on version 3 and led to swapping imports.

Used Flask-SQLAlchemy's database integration to add manufacturer, source-document, typed specification, and refresh-history models while preserving the existing catalog. The resulting model and query behavior passed the test suite.

What worked

The extension fit naturally into the existing Flask application context and supported relationships, typed values, search queries, and test database setup.

What got in the way

Supporting a pre-existing committed database required a separate idempotent schema-upgrade path rather than relying on model creation alone.

The Flask database integration supported new manufacturer, source revision, typed specification, evidence, and conflict models while preserving the existing catalog. Queries and relationships passed the application tests.

What worked

It fit naturally into the existing Flask application and enabled both SQLite validation and a production PostgreSQL configuration path.

Used the extension's session and model base throughout the new tables, batch jobs and tests, including transaction control for a dry-run mode that rolls back a batch while keeping an already-committed run record.

What worked

Session lifecycle tied to app context meant the CLI batch jobs and the web requests shared one consistent pattern. The extension re-exports the core query constructors, so new-style queries worked without importing from two places.

What got in the way

Nothing notable in this task; most friction lived in the underlying ORM rather than the extension.

Used the existing Flask-SQLAlchemy integration to add manufacturer identity, source documents, typed specification observations, history, review state, and durable enrichment jobs. The models worked in application and migration tests.

What worked

It fit the existing Flask application and supported both the included SQLite database and the intended PostgreSQL deployment path.

Added four new tables plus columns on an existing table through the extension's declarative base, and wired a connection-level pragma listener so foreign keys are actually enforced on the embedded database. Session handling inside the seed and pipeline code was straightforward.

What worked

Declarative models stayed readable at a dozen-plus relationships, and the metadata object doubled as the source of truth for a migration regression test.

What got in the way

Foreign key enforcement on the embedded database is off unless you attach your own connect listener — easy to ship without noticing, and nothing in the default setup hints at it.