SQLModel Dynamic Creation with Multiple Inheritance Issue #1638

Louisfrn · 2025-11-04T16:36:26Z

Louisfrn
Nov 4, 2025

First Check

I added a very descriptive title here.
I used the GitHub search to find a similar question and didn't find it.
I searched the SQLModel documentation, with the integrated search.
I already searched in Google "How to X in SQLModel" and didn't find any information.
I already read and followed all the tutorial in the docs and didn't find an answer.
I already checked if it is not related to SQLModel but to Pydantic.
I already checked if it is not related to SQLModel but to SQLAlchemy.

Commit to Help

I commit to help with one of those options 👆

Example Code

"""
Minimal reproducible example for SQLModel dynamic creation issue.

Problem: Creating a SQLModel dynamically with pydantic.create_model() and multiple inheritance
fails on second call with "Table already defined" error, even when trying to pass extend_existing=True.

Run this file to see the error:
    python sqlmodel_issues.py
"""

from typing import Optional
from datetime import datetime
from pydantic import BaseModel, create_model, Field as PydanticField
from sqlmodel import SQLModel, Field


# ============================================================================
# Step 1: Base Model (static, shared across all dynamic models)
# ============================================================================

class GenericRecordModel(SQLModel):
    """Base SQLModel with standard database fields for all tables."""
    id: int = Field(primary_key=True)
    azureDestination: Optional[str] = Field(default=None, max_length=100)
    timestamp: Optional[datetime] = Field(default=None)


# ============================================================================
# Step 2: Simulated LLM Model (in real app, this comes from JSON Schema)
# ============================================================================

class SimulatedLLMModel(BaseModel):
    """
    In production, this is generated from JSON Schema using json-schema-to-pydantic.
    Contains validation constraints (maxLength, etc.) that must be preserved.
    """
    usdot: Optional[str] = PydanticField(default=None, max_length=50)
    vehicleType: Optional[str] = PydanticField(default=None, max_length=50)


# ============================================================================
# Step 3: Dynamic Model Creation Function
# ============================================================================

def create_dynamic_table_model(table_name: str, llm_model: type[BaseModel]) -> type[SQLModel]:
    """
    Create a SQLModel dynamically with multiple inheritance.
    
    Goal: Combine llm_model validation + GenericRecordModel fields + SQLModel ORM
    
    Issue: Second call fails with "Table 'table_name' is already defined" error.
    """
    
    # CURRENT ATTEMPT - FAILS ON SECOND CALL
    output_model = create_model(
        table_name,  # Model name = table name
        __base__=(llm_model, GenericRecordModel, SQLModel),  # Multiple inheritance
        __cls_kwargs__={"table": True}  # Enable SQLModel table mode
    )
    
    # Tried setting __table_args__ here, but error occurs DURING create_model()
    # output_model.__table_args__ = {"extend_existing": True}  # ❌ Too late
    
    return output_model


# ============================================================================
# Step 4: Demonstrate the Problem
# ============================================================================

if __name__ == "__main__":
    print("="*80)
    print("SQLModel Dynamic Creation Issue - Minimal Reproducible Example")
    print("="*80)
    print()
    
    table_name = "ge_snapshot_side_truck"
    
    # First call - works fine
    print("Step 1: Creating model for the FIRST time...")
    try:
        model1 = create_dynamic_table_model(table_name, SimulatedLLMModel)
        print(f"✅ SUCCESS: Model '{model1.__name__}' created")
        print(f"   Table: {getattr(model1, '__tablename__', 'N/A')}")
        print(f"   Fields: {list(model1.model_fields.keys())}")
        print()
    except Exception as e:
        print(f"❌ FAILED: {e}")
        print()
    
    # Second call - FAILS
    print("Step 2: Creating the SAME model again (simulates hot reload / test re-run)...")
    try:
        model2 = create_dynamic_table_model(table_name, SimulatedLLMModel)
        print(f"✅ SUCCESS: Model '{model2.__name__}' created")
        print(f"   This should work but currently fails!")
        print()
    except Exception as e:
        print(f"❌ FAILED with error:")
        print(f"   {type(e).__name__}: {e}")
        print()
        print("This is the problem we need to solve!")
        print()
    
    print("="*80)
    print("Expected Behavior:")
    print("="*80)
    print("Both calls should succeed. The second call should either:")
    print("1. Reuse the existing table definition (extend_existing=True)")
    print("2. Or properly override it without errors")
    print()
    print("Question: How to properly pass extend_existing=True when using")
    print("          pydantic.create_model() with SQLModel and multiple inheritance?")
    print("="*80)

Description

SQLModel Dynamic Creation: Is Multiple Inheritance the Right Approach?

Problem Overview

I need to dynamically generate SQLModel classes that combine:

Validation fields from a JSON Schema (dynamic, stored in database)
Common database fields (id, timestamp, etc.) - shared across all tables
SQLModel ORM functionality for database persistence

My current approach uses multiple inheritance with pydantic.create_model(), but I'm not sure if this is the correct pattern.

I'm encountering this error when recreating the same model (tests, hot reload):

sqlalchemy.exc.InvalidRequestError: Table 'my_table_name' is already defined for this MetaData instance.  
Specify 'extend_existing=True' to redefine options and columns on an existing Table object.

However, my main concern is: Am I using the right architecture to merge these two models?

Current Code

Base Model (Static)

from typing import Optional
from datetime import datetime
from sqlmodel import SQLModel, Field

class GenericRecordModel(SQLModel):
    """Base SQLModel with standard database fields."""
    id: int = Field(primary_key=True)
    azureDestination: Optional[str] = Field(default=None, max_length=100)
    timestamp: Optional[datetime] = Field(default=None)

Dynamic Model Creation

from pydantic import BaseModel, create_model
from sqlmodel import SQLModel
from json_schema_to_pydantic import create_model as json_schema_create_model

def create_dynamic_sqlmodel(table_name: str, json_schema: dict) -> type[SQLModel]:
    """
    Creates a SQLModel dynamically from JSON Schema with multiple inheritance.
    
    Goal: OutputModel should inherit from:
    - llm_model (Pydantic validation from JSON Schema)
    - GenericRecordModel (database fields: id, timestamp, etc.)
    - SQLModel (ORM functionality)
    """
    
    # Step 1: Generate Pydantic model from JSON Schema
    # This model contains validated fields with constraints (maxLength, etc.)
    llm_model = json_schema_create_model(json_schema)
    
    # Step 2: Create SQLModel with multiple inheritance
    # Problem: How to properly pass extend_existing=True?
    output_model = create_model(
        table_name,  # Model name = table name
        __base__=(llm_model, GenericRecordModel, SQLModel),
        __cls_kwargs__={"table": True}
    )
    
    return output_model

Example Usage

# JSON Schema from database
schema = {
    "type": "object",
    "properties": {
        "usdot": {"type": ["string", "null"], "maxLength": 50},
        "vehicleType": {"type": ["string", "null"], "maxLength": 50}
    }
}

# First call - works fine
model1 = create_dynamic_sqlmodel("ge_snapshot_side_truck", schema)

# Second call - FAILS with "Table already defined" error
model2 = create_dynamic_sqlmodel("ge_snapshot_side_truck", schema)

What I've Tried

Attempt 1: Setting `__table_args__` after creation

output_model = create_model(
    table_name,
    __base__=(llm_model, GenericRecordModel, SQLModel),
    __cls_kwargs__={"table": True}
)
output_model.__table_args__ = {"extend_existing": True}  # ❌ Too late - error occurs during create_model()

Result: Error occurs during create_model() execution, so this line is never reached.

Attempt 2: Passing `__table_args` in `cls_kwargs__`

output_model = create_model(
    table_name,
    __base__=(llm_model, GenericRecordModel, SQLModel),
    __cls_kwargs__={
        "table": True,
        "__table_args__": {"extend_existing": True}
    }
)

Result: Still fails with the same error. __table_args__ seems to be ignored when passed this way.

Attempt 3: Passing `__table_args__` as field definition

output_model = create_model(
    table_name,
    __base__=(llm_model, GenericRecordModel, SQLModel),
    __cls_kwargs__={"table": True},
    __table_args__={"extend_existing": True}  # As a field, not cls_kwargs
)

Result: Same error persists.

Core Questions

1. Is multiple inheritance the right pattern here?

I'm using __base__=(llm_model, GenericRecordModel, SQLModel) to merge:

Fields from the dynamically generated llm_model (with Pydantic validation constraints)
Fields from GenericRecordModel (id, timestamp, etc.)
SQLModel ORM capabilities

Is this the recommended way to combine a dynamic Pydantic model with a static SQLModel base?

Alternative approaches I've considered:

Manually copying fields from llm_model to a new SQLModel (loses metadata?)
Using field definitions instead of inheritance: **llm_model.model_fields
Creating the model differently (but how?)

2. How to properly merge GenericRecordModel + LLM Model?

My GenericRecordModel is a SQLModel (not table=True) that I want to be inherited by all dynamic models. Is this correct, or should it be:

A regular Pydantic BaseModel?
A mixin without SQLModel?
Defined differently?

3. The `extend_existing=True` issue

As a secondary issue, I can't figure out how to pass extend_existing=True to SQLModel when using pydantic.create_model():

❌ Setting __table_args__ after creation is too late (error occurs during create_model())
❌ Passing in __cls_kwargs__ doesn't work
❌ Passing as a field definition doesn't work

But more importantly: Is the multiple inheritance approach fundamentally correct, or am I solving the problem the wrong way?

What I'm Really Asking

I feel like I might be fighting against the framework instead of using it correctly.

What's the proper/idiomatic way to:

Generate a Pydantic model from JSON Schema (with all validation constraints)
Add common database fields (id, timestamp, etc.)
Make it a SQLModel table for persistence
Allow the model to be recreated (tests, hot reload)

Any guidance on the architecture would be greatly appreciated! 🙏

Environment

Python: 3.11+
Pydantic: v2.x
SQLModel: latest
SQLAlchemy: 2.x (via SQLModel)
json-schema-to-pydantic: latest

Reproducible Example

See attached sqlmodel_issues.py for a minimal standalone example that demonstrates the issue.

Operating System

Windows

Operating System Details

SQLModel Dynamic Creation: Is Multiple Inheritance the Right Approach?

Problem Overview

I need to dynamically generate SQLModel classes that combine:

Validation fields from a JSON Schema (dynamic, stored in database)
Common database fields (id, timestamp, etc.) - shared across all tables
SQLModel ORM functionality for database persistence

My current approach uses multiple inheritance with pydantic.create_model(), but I'm not sure if this is the correct pattern.

I'm encountering this error when recreating the same model (tests, hot reload):

sqlalchemy.exc.InvalidRequestError: Table 'my_table_name' is already defined for this MetaData instance.  
Specify 'extend_existing=True' to redefine options and columns on an existing Table object.

However, my main concern is: Am I using the right architecture to merge these two models?

Current Code

Base Model (Static)

from typing import Optional
from datetime import datetime
from sqlmodel import SQLModel, Field

class GenericRecordModel(SQLModel):
    """Base SQLModel with standard database fields."""
    id: int = Field(primary_key=True)
    azureDestination: Optional[str] = Field(default=None, max_length=100)
    timestamp: Optional[datetime] = Field(default=None)

Dynamic Model Creation

from pydantic import BaseModel, create_model
from sqlmodel import SQLModel
from json_schema_to_pydantic import create_model as json_schema_create_model

def create_dynamic_sqlmodel(table_name: str, json_schema: dict) -> type[SQLModel]:
    """
    Creates a SQLModel dynamically from JSON Schema with multiple inheritance.
    
    Goal: OutputModel should inherit from:
    - llm_model (Pydantic validation from JSON Schema)
    - GenericRecordModel (database fields: id, timestamp, etc.)
    - SQLModel (ORM functionality)
    """
    
    # Step 1: Generate Pydantic model from JSON Schema
    # This model contains validated fields with constraints (maxLength, etc.)
    llm_model = json_schema_create_model(json_schema)
    
    # Step 2: Create SQLModel with multiple inheritance
    # Problem: How to properly pass extend_existing=True?
    output_model = create_model(
        table_name,  # Model name = table name
        __base__=(llm_model, GenericRecordModel, SQLModel),
        __cls_kwargs__={"table": True}
    )
    
    return output_model

Example Usage

# JSON Schema from database
schema = {
    "type": "object",
    "properties": {
        "usdot": {"type": ["string", "null"], "maxLength": 50},
        "vehicleType": {"type": ["string", "null"], "maxLength": 50}
    }
}

# First call - works fine
model1 = create_dynamic_sqlmodel("ge_snapshot_side_truck", schema)

# Second call - FAILS with "Table already defined" error
model2 = create_dynamic_sqlmodel("ge_snapshot_side_truck", schema)

What I've Tried

Attempt 1: Setting `__table_args__` after creation

output_model = create_model(
    table_name,
    __base__=(llm_model, GenericRecordModel, SQLModel),
    __cls_kwargs__={"table": True}
)
output_model.__table_args__ = {"extend_existing": True}  # ❌ Too late - error occurs during create_model()

Result: Error occurs during create_model() execution, so this line is never reached.

Attempt 2: Passing `__table_args` in `cls_kwargs__`

output_model = create_model(
    table_name,
    __base__=(llm_model, GenericRecordModel, SQLModel),
    __cls_kwargs__={
        "table": True,
        "__table_args__": {"extend_existing": True}
    }
)

Result: Still fails with the same error. __table_args__ seems to be ignored when passed this way.

Attempt 3: Passing `__table_args__` as field definition

output_model = create_model(
    table_name,
    __base__=(llm_model, GenericRecordModel, SQLModel),
    __cls_kwargs__={"table": True},
    __table_args__={"extend_existing": True}  # As a field, not cls_kwargs
)

Result: Same error persists.

Core Questions

1. Is multiple inheritance the right pattern here?

I'm using __base__=(llm_model, GenericRecordModel, SQLModel) to merge:

Fields from the dynamically generated llm_model (with Pydantic validation constraints)
Fields from GenericRecordModel (id, timestamp, etc.)
SQLModel ORM capabilities

Is this the recommended way to combine a dynamic Pydantic model with a static SQLModel base?

Alternative approaches I've considered:

Manually copying fields from llm_model to a new SQLModel (loses metadata?)
Using field definitions instead of inheritance: **llm_model.model_fields
Creating the model differently (but how?)

2. How to properly merge GenericRecordModel + LLM Model?

My GenericRecordModel is a SQLModel (not table=True) that I want to be inherited by all dynamic models. Is this correct, or should it be:

A regular Pydantic BaseModel?
A mixin without SQLModel?
Defined differently?

3. The `extend_existing=True` issue

As a secondary issue, I can't figure out how to pass extend_existing=True to SQLModel when using pydantic.create_model():

❌ Setting __table_args__ after creation is too late (error occurs during create_model())
❌ Passing in __cls_kwargs__ doesn't work
❌ Passing as a field definition doesn't work

But more importantly: Is the multiple inheritance approach fundamentally correct, or am I solving the problem the wrong way?

What I'm Really Asking

I feel like I might be fighting against the framework instead of using it correctly.

What's the proper/idiomatic way to:

Generate a Pydantic model from JSON Schema (with all validation constraints)
Add common database fields (id, timestamp, etc.)
Make it a SQLModel table for persistence
Allow the model to be recreated (tests, hot reload)

Any guidance on the architecture would be greatly appreciated! 🙏

Environment

Python: 3.11+
Pydantic: v2.x
SQLModel: latest
SQLAlchemy: 2.x (via SQLModel)
json-schema-to-pydantic: latest

Reproducible Example

See attached sqlmodel_issues.py for a minimal standalone example that demonstrates the issue.

SQLModel Version

0.0.25

Python Version

Python 3.12.9

Additional Context

No response

Answered by MentalOfCrow

Jul 18, 2026

The exception is telling you that the factory is creating a second ORM mapping for the same (schema, table_name) inside the same MetaData. That is different from the database table already existing: SQLAlchemy normally expects one in-memory Table identity per name in a MetaData collection.

I would not use extend_existing=True to make repeated model-class creation the normal path. It can merge new Table(...) arguments into the existing metadata object, but it does not turn two separately generated ORM classes into one coherent mapping, and it does not migrate the physical database schema. SQLAlchemy documents that distinction here:

https://docs.sqlalchemy.org/en/20/core/metadata.html#sqlal…

View full answer

MentalOfCrow · 2026-07-18T19:08:35Z

MentalOfCrow
Jul 18, 2026

The exception is telling you that the factory is creating a second ORM mapping for the same (schema, table_name) inside the same MetaData. That is different from the database table already existing: SQLAlchemy normally expects one in-memory Table identity per name in a MetaData collection.

I would not use extend_existing=True to make repeated model-class creation the normal path. It can merge new Table(...) arguments into the existing metadata object, but it does not turn two separately generated ORM classes into one coherent mapping, and it does not migrate the physical database schema. SQLAlchemy documents that distinction here:

https://docs.sqlalchemy.org/en/20/core/metadata.html#sqlalchemy.schema.Table.params.extend_existing

There are two architectural cases.

Arbitrary JSON Schema at runtime: keep validation and persistence separate

If fields can change based on a schema stored in the database, use the generated Pydantic model as a validator and persist the validated payload in one stable JSON column:

from datetime import datetime
from typing import Any

from sqlalchemy import Column, JSON
from sqlmodel import Field, SQLModel


class GenericRecord(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    schema_id: str = Field(index=True)
    azure_destination: str | None = Field(default=None, max_length=100)
    timestamp: datetime | None = None
    payload: dict[str, Any] = Field(sa_column=Column(JSON, nullable=False))


validator = json_schema_create_model(schema)
validated = validator.model_validate(raw_payload)

record = GenericRecord(
    schema_id=schema_id,
    payload=validated.model_dump(mode="json"),
)

On read, select the validator associated with schema_id and run model_validate(record.payload). This preserves the JSON-schema validation constraints without asking the ORM to invent or replace SQL columns at runtime.

Real SQL columns: generate once and migrate explicitly

If every generated property must be a queryable SQL column, the schema is no longer just runtime validation; it is database DDL. In that case:

turn the JSON schema into a deterministic set of SQLModel field definitions;
create the mapped class once and cache it by (table_name, schema_version/fingerprint);
use Alembic or explicit DDL when the schema changes;
return the cached class on subsequent calls instead of calling create_model() again.

Conceptually:

_models: dict[tuple[str, str], type[SQLModel]] = {}


def get_table_model(table_name: str, schema: dict) -> type[SQLModel]:
    fingerprint = canonical_schema_hash(schema)
    key = (table_name, fingerprint)
    if key in _models:
        return _models[key]

    # Convert the generated model's FieldInfo objects into field definitions,
    # then derive from GenericRecordModel only once.
    model = build_sqlmodel_once(table_name, schema)
    _models[key] = model
    return model

Also avoid __base__=(llm_model, GenericRecordModel, SQLModel): GenericRecordModel already derives from SQLModel, while llm_model derives from Pydantic's BaseModel. Combining two Pydantic model hierarchies plus SQLModel makes MRO/metaclass behavior and field ownership harder to reason about. Build one set of field definitions and use one SQLModel base.

For tests, create a fresh registry/MetaData (or a fresh process) per isolated model universe instead of clearing shared production metadata mid-run. Normal source-code hot reload should restart the process; an in-process factory should remain idempotent and return the same class.

So the direct answer is: the second call should reuse the existing model, not redefine its table. extend_existing is the wrong abstraction for schema versioning and hot reload.

If this gives you a workable direction, please mark it as the accepted answer so future readers can find the distinction quickly.

0 replies

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Uh oh!

SQLModel Dynamic Creation with Multiple Inheritance Issue #1638

Uh oh!

{{title}}

Uh oh!

Replies: 1 comment

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

SQLModel Dynamic Creation with Multiple Inheritance Issue #1638

Uh oh!

Louisfrn Nov 4, 2025

First Check

Commit to Help

Example Code

Description

SQLModel Dynamic Creation: Is Multiple Inheritance the Right Approach?

Problem Overview

Current Code

Base Model (Static)

Dynamic Model Creation

Example Usage

What I've Tried

Attempt 1: Setting __table_args__ after creation

Attempt 2: Passing __table_args__ in __cls_kwargs__

Attempt 3: Passing __table_args__ as field definition

Core Questions

1. Is multiple inheritance the right pattern here?

2. How to properly merge GenericRecordModel + LLM Model?

3. The extend_existing=True issue

What I'm Really Asking

Environment

Reproducible Example

Operating System

Operating System Details

SQLModel Dynamic Creation: Is Multiple Inheritance the Right Approach?

Problem Overview

Current Code

Base Model (Static)

Dynamic Model Creation

Example Usage

What I've Tried

Attempt 1: Setting __table_args__ after creation

Attempt 2: Passing __table_args__ in __cls_kwargs__

Attempt 3: Passing __table_args__ as field definition

Core Questions

1. Is multiple inheritance the right pattern here?

2. How to properly merge GenericRecordModel + LLM Model?

3. The extend_existing=True issue

What I'm Really Asking

Environment

Reproducible Example

SQLModel Version

Python Version

Additional Context

Replies: 1 comment

Uh oh!

MentalOfCrow Jul 18, 2026

Arbitrary JSON Schema at runtime: keep validation and persistence separate

Real SQL columns: generate once and migrate explicitly

Louisfrn
Nov 4, 2025

Attempt 1: Setting `__table_args__` after creation

Attempt 2: Passing `__table_args` in `cls_kwargs__`

Attempt 3: Passing `__table_args__` as field definition

3. The `extend_existing=True` issue

Attempt 1: Setting `__table_args__` after creation

Attempt 2: Passing `__table_args` in `cls_kwargs__`

Attempt 3: Passing `__table_args__` as field definition

3. The `extend_existing=True` issue

MentalOfCrow
Jul 18, 2026