60 lines
2.8 KiB
Python
60 lines
2.8 KiB
Python
Sure, here's an example of a FastAPI endpoint that saves countries to a database using SQLAlchemy and Pydantic schemas:
|
|
|
|
```python
|
|
from typing import List
|
|
from fastapi import APIRouter, Depends
|
|
from sqlalchemy.orm import Session
|
|
from . import models, schemas
|
|
from .database import SessionLocal, engine
|
|
|
|
router = APIRouter()
|
|
|
|
# Create the database tables
|
|
models.Base.metadata.create_all(bind=engine)
|
|
|
|
# Dependency for getting a database session
|
|
|
|
@router.post("/countries", response_model=List[schemas.Country])
|
|
def create_countries(countries: List[schemas.CountryCreate], db: Session = Depends(get_db)):
|
|
db_countries = []
|
|
for country_data in countries:
|
|
db_country = models.Country(name=country_data.name, capital=country_data.capital)
|
|
db.add(db_country)
|
|
db.commit()
|
|
db.refresh(db_country)
|
|
db_countries.append(db_country)
|
|
return db_countries
|
|
```
|
|
|
|
Here's what's happening:
|
|
|
|
1. We import the necessary modules and create a router instance.
|
|
2. We create the database tables using `models.Base.metadata.create_all(bind=engine)`.
|
|
3. We define a dependency function `get_db()` that creates a new database session and yields it for use in the endpoint function. The session is closed after the function returns.
|
|
4. We define the endpoint function `create_countries()` that takes a list of `CountryCreate` Pydantic models as input and returns a list of `Country` Pydantic models.
|
|
5. Inside the endpoint function, we iterate over the input `countries` list and create a new `Country` model instance for each country data.
|
|
6. We add the new `Country` instance to the database session using `db.add(db_country)`.
|
|
7. We commit the changes to the database using `db.commit()`.
|
|
8. We refresh the `db_country` instance with the data from the database using `db.refresh(db_country)`.
|
|
9. We append the refreshed `db_country` instance to the `db_countries` list.
|
|
10. Finally, we return the `db_countries` list.
|
|
|
|
Here are the SQLAlchemy model and Pydantic schemas used in the example:
|
|
|
|
```python
|
|
from sqlalchemy import Column, Integer, String
|
|
from sqlalchemy.orm import declarative_base
|
|
from pydantic import BaseModel
|
|
|
|
from app.api.models.countries_model import *
|
|
from app.api.schemas.countries_schema import *
|
|
from app.api.dependencies.countries_deps import *
|
|
Base = declarative_base()
|
|
|
|
class Config:
|
|
orm_mode = True
|
|
```
|
|
|
|
In this example, we define an SQLAlchemy model `Country` with columns for `id`, `name`, and `capital`. We also define two Pydantic models: `CountryCreate` for creating new countries, and `Country` for representing existing countries in the database.
|
|
|
|
Note that the `Country` Pydantic model has an `orm_mode` configuration set to `True`, which allows Pydantic to automatically convert SQLAlchemy model instances to Pydantic model instances and vice versa. |