Fast ApI SQLAIchemy
FastAPI and SQLAlchemy are two popular Python libraries used for web development and database interaction. FastAPI is a modern, fast, web framework for building APIs with Python, while SQLAlchemy is an Object-Relational Mapping (ORM) library that provides a high-level interface for interacting with relational databases.
Using FastAPI with SQLAlchemy allows you to quickly build web APIs with database integration. The combination of these two libraries provides a robust and efficient solution for creating RESTful APIs.
Here’s a brief overview of how to use FastAPI with SQLAlchemy:
- Install the required libraries: You’ll need to install both FastAPI and SQLAlchemy, along with a database adapter such as psycopg2 for PostgreSQL or pymysql for MySQL.
pip install fastapi
pip install sqlalchemy
pip install psycopg2 # for PostgreSQL
# or
pip install pymysql # for MySQL
- Set up the database connection: Using SQLAlchemy, you define a database engine that connects to your chosen database. This engine will handle the connection and communication with the database.
from sqlalchemy import create_engine
# Replace 'your_database_url' with your actual database URL.
# For example, for PostgreSQL: 'postgresql://username:password@localhost/dbname'
# For MySQL: 'mysql+pymysql://username:password@localhost/dbname'
db_url = 'your_database_url'
engine = create_engine(db_url)
- Create a SQLAlchemy model: Define your database schema using SQLAlchemy ORM models. Each model class represents a table in the database.
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True, index=True)
username = Column(String, unique=True, index=True)
email = Column(String, unique=True, index=True)
# Add more columns as needed
- Create FastAPI routes: Define your API endpoints using FastAPI, and interact with the database using SQLAlchemy.
from fastapi import FastAPI, HTTPException
from sqlalchemy.orm import Session
from sqlalchemy.exc import IntegrityError
from . import models
app = FastAPI()
@app.post("/users/", response_model=models.User)
def create_user(user: models.UserCreate, db: Session = Depends(get_db)):
db_user = models.User(username=user.username, email=user.email)
try:
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except IntegrityError:
raise HTTPException(status_code=400, detail="Username or email already exists.")
In the example above, we defined a route to create a new user in the database. The UserCreate model represents the data received from the client, while the User model represents the database schema. The db parameter in the route function is a dependency that provides the SQLAlchemy session to interact with the database.
Remember that this is just a basic example, and you can build more complex APIs and interactions with the database as needed.
By combining FastAPI and SQLAlchemy, you can create powerful and efficient web APIs with database support in Python.
Python Training Demo Day 1
Conclusion:
Unogeeks is the No.1 IT Training Institute for Python Training. Anyone Disagree? Please drop in a comment
You can check out our other latest blogs on Python here – Python Blogs
You can check out our Best In Class Python Training Details here – Python Training
Follow & Connect with us:
———————————-
For Training inquiries:
Call/Whatsapp: +91 73960 33555
Mail us at: info@unogeeks.com
Our Website ➜ https://unogeeks.com
Follow us:
Instagram: https://www.instagram.com/unogeeks
Facebook: https://www.facebook.com/UnogeeksSoftwareTrainingInstitute
Twitter: https://twitter.com/unogeeks