SQLModel doesn't raise ValidationError

[elben10]

First Check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue 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

from typing import Optional

from pydantic import BaseModel
from sqlmodel import Field, SQLModel

class User1(SQLModel, table=True):
 id: Optional[int] = Field(primary_key=True)
 name: str

class User2(BaseModel):
 name: str

User1()
User2()

Description

• Create SQLModel
• Create equivalent pydantic model
• Create instance of SQLModel without providing required arguments
• Create instance of pydantic model without providing required arguments

The pydantic model raises an ValidationError whereas the SQLModel doesn't raise a ValidationError even though an required argument is not provided. I would expect a ValidationError if not all required arguments is provided.

Operating System

macOS

Operating System Details

No response

SQLModel Version

0.0.4

Python Version

Python 3.8.5

Additional Context

No response

[obassett]

I was just going through this aswell!

If the model as table=True then validations are disabled, and it assume SQLalchemy will pick up any issues. It then basically drops those values.

I haven't figured out the best way to handle this.

[sathoune]

I just checked and I experience the same behaviour with Ubuntu 20.04.03 and python 3.10

[maku2903]

May it have connection with pydantic's class config: validate_assignment = True? Still discovering sqlmodel and i dont know how to setup "pydantic things" from classes inheriting SQLModel so cant check hypothesis empirically.

[obassett]

Ok so I have been looking at work-arounds for this - as I don't want to double up on models just to do validation.

If the model is defined with table=True then when you create an instance it doesn't raise the validations. This is probably fine if you are reading from a database, but if you are writing to one, then it drops the fields that fail validation, which is challenging, and could lead to some silently dropping data errors.

From the init of the SQL Model Class:

 # Only raise errors if not a SQLModel model
 if (
 not getattr(__pydantic_self__.__config__, "table", False)
 and validation_error
 ):
 raise validation_error

You can manually validate when importing the data using the 'Model.validate()` class method for assignment, but for that we need to pass in a dict with all the values, but at least at this point in will validate the data.

from typing import Optional
from sqlmodel import SQLModel, Field, Column, VARCHAR
from pydantic import EmailStr


class UserExample(SQLModel, table=True):
 id: Optional[int] = Field(primary_key=True)
 username: EmailStr = Field(sa_column=Column("username", VARCHAR, unique=True))
 full_name: Optional[str] = None
 disabled: Optional[bool] = None


# Create and instance
test_user1 = UserExample(
 username="jdoe", # oops this should be an email address
 full_name="John Doe",
 disabled=False,
)
print("Test User 1:", test_user1)

Which gives us

Test User 1: id=None full_name='John Doe' disabled=False

This is bad, since we have silently dropped our required email address field - which also needs to be unique. If I write this to the database it will fail, which is fine but it would be nice to catch this at the assignment point rather than trying to write it to the DB. Also if this was an optional field, it would silently drop the data, and we wouldn't know until we tried to read it and it wasn't there ( it wouldn't break anything since it is optional, but it would be data loss)

so now if I do it this way:

from typing import Optional
from sqlmodel import SQLModel, Field, Column, VARCHAR
from pydantic import EmailStr


class UserExample(SQLModel, table=True):
 id: Optional[int] = Field(primary_key=True)
 username: EmailStr = Field(sa_column=Column("username", VARCHAR, unique=True))
 full_name: Optional[str] = None
 disabled: Optional[bool] = None

# This time create the instance and pass in a dict of the values by call .validate
test_user2 = UserExample.validate(
 {"username": "jdoe", "full_name": "John Doe", "disabled": False}
)
print("Test User 2:", test_user2)

I get this:

Traceback (most recent call last):
 File "/workspaces/thetattooedtechnologist.com/temp/example_validation.py", line 22, in <module>
 test_user2 = UserExample.validate(
 File "/workspaces/thetattooedtechnologist.com/.venv/lib/python3.9/site-packages/sqlmodel/main.py", line 580, in validate
 raise validation_error
pydantic.error_wrappers.ValidationError: 1 validation error for UserExample
username
 value is not a valid email address (type=value_error.email)

So this works and gives me my validation error.

So it can be used as a workaround for those times where you are getting data ready to put in the DB, though it does mean that data needs to be in a dict format - but most likely that wont be that much of a problem.

Hopefully this helps as a workaround.

[SunsetOrange]

My god @obassett, I've been pulling my hair out for hours trying to figure out why my validators were running, but doing nothing.

table=True

Much thanks

[lovetoburnswhen]

Ok so I have been looking at work-arounds for this - as I don't want to double up on models just to do validation.

If the model is defined with table=True then when you create an instance it doesn't raise the validations. This is probably fine if you are reading from a database, but if you are writing to one, then it drops the fields that fail validation, which is challenging, and could lead to some silently dropping data errors.

From the init of the SQL Model Class:

 # Only raise errors if not a SQLModel model
 if (
 not getattr(__pydantic_self__.__config__, "table", False)
 and validation_error
 ):
 raise validation_error

You can manually validate when importing the data using the 'Model.validate()` class method for assignment, but for that we need to pass in a dict with all the values, but at least at this point in will validate the data.

from typing import Optional
from sqlmodel import SQLModel, Field, Column, VARCHAR
from pydantic import EmailStr


class UserExample(SQLModel, table=True):
 id: Optional[int] = Field(primary_key=True)
 username: EmailStr = Field(sa_column=Column("username", VARCHAR, unique=True))
 full_name: Optional[str] = None
 disabled: Optional[bool] = None


# Create and instance
test_user1 = UserExample(
 username="jdoe", # oops this should be an email address
 full_name="John Doe",
 disabled=False,
)
print("Test User 1:", test_user1)

Which gives us

Test User 1: id=None full_name='John Doe' disabled=False

This is bad, since we have silently dropped our required email address field - which also needs to be unique. If I write this to the database it will fail, which is fine but it would be nice to catch this at the assignment point rather than trying to write it to the DB. Also if this was an optional field, it would silently drop the data, and we wouldn't know until we tried to read it and it wasn't there ( it wouldn't break anything since it is optional, but it would be data loss)

so now if I do it this way:

from typing import Optional
from sqlmodel import SQLModel, Field, Column, VARCHAR
from pydantic import EmailStr


class UserExample(SQLModel, table=True):
 id: Optional[int] = Field(primary_key=True)
 username: EmailStr = Field(sa_column=Column("username", VARCHAR, unique=True))
 full_name: Optional[str] = None
 disabled: Optional[bool] = None

# This time create the instance and pass in a dict of the values by call .validate
test_user2 = UserExample.validate(
 {"username": "jdoe", "full_name": "John Doe", "disabled": False}
)
print("Test User 2:", test_user2)

I get this:

Traceback (most recent call last):
 File "/workspaces/thetattooedtechnologist.com/temp/example_validation.py", line 22, in <module>
 test_user2 = UserExample.validate(
 File "/workspaces/thetattooedtechnologist.com/.venv/lib/python3.9/site-packages/sqlmodel/main.py", line 580, in validate
 raise validation_error
pydantic.error_wrappers.ValidationError: 1 validation error for UserExample
username
 value is not a valid email address (type=value_error.email)

So this works and gives me my validation error.

So it can be used as a workaround for those times where you are getting data ready to put in the DB, though it does mean that data needs to be in a dict format - but most likely that wont be that much of a problem.

Hopefully this helps as a workaround.

One caveat of using .validate() is for some reason it breaks passing related objects directly into the constructor as described here.

The team_id column will be None, and team doesn't get returned at all from .validate()

[alexferrari88]

In the documentation, it recommends to create a base model and inherit from it for the database model (table=True).
Please check here:

• https://sqlmodel.tiangolo.com/tutorial/fastapi/multiple-models/
• https://sqlmodel.tiangolo.com/tutorial/fastapi/relationships/

[memark]

This is really sad. A prime reason to use SQLModel is to be able to continue to use your Pydantic models, just with some added SQL goodness. But if all validation is ignored, the models are hardly useful as Pydantic models anymore.

Working around this limitation either by doubling the number of classes or passing all data as dictionaries is not particularly appealing.

Really hoping for a simpler way to enable the built-in validation. Recently chipped in a small sponsorship hoping this gets some well-deserved attention by @tiangolo!

😞

[andremmori]

Any updates on this issue? I found a workaround that raises the validation error while also having table=True:

from sqlmodel import SQLModel, Field


class BaseSQLModel(SQLModel):
 def __init__(self, **kwargs):
 self.__config__.table = False
 super().__init__(**kwargs)
 self.__config__.table = True

 class Config:
 validate_assignment = True



class MyTable1(BaseSQLModel, table=True):
 a: int = Field(primary_key=True)
 b: int

class MyTable2(BaseSQLModel, table=True):
 a: int = Field(primary_key=True)
 b: float


t1 = MyTable1(a=1, b=2) # ok
t2 = MyTable2(b="text") # Raises ValidationError
# pydantic.error_wrappers.ValidationError: 2 validation errors for MyTable2
# a
# field required (type=value_error.missing)
# b
# value is not a valid float (type=type_error.float)

By creating a base class and defining the __init__ method, we can set table to false and call the super __init__ method, validating the args passed. After that, we can set table back to true.

With this approach, creating multiple models for different classes to inherit or calling the .validate() method with a dict is not necessary.

Edit: Added Config class to BaseSQLModel with the validate_assignment option set to true so it validates fields when updated.

[memark]

@andremmori This works excellently and solves this long standing problem. Thank you!

[will-afs]

@andremmori This works excellently and solves this long standing problem. Thank you!

I personnaly don't feel this way. It's more of a hack, and actually doesn't even enable to validate fields on update (not at initialization of the model).

And defining a BaseModel, from which the SQLModel should inherit, seems a bit over-complexifying things to me...

I'd be glad if there was an actual clean and easy way to validate a SQLModel, the same way it is proposed for a BaseModel.