Gerenciamento de dados com Python, SQLite e SQLAlchemy

• Arquivos simples para armazenamento de dados
• SQL para melhorar o acesso a dados persistentes
• SQLite para armazenamento de dados
• SQLAlchemy para trabalhar com dados como objetos Python

Usando arquivos simples para armazenamento de dados

first_name,last_name,title,publisher
Isaac,Asimov,Foundation,Random House
Pearl,Buck,The Good Earth,Random House
Pearl,Buck,The Good Earth,Simon & Schuster
Tom,Clancy,The Hunt For Red October,Berkley
Tom,Clancy,Patriot Games,Simon & Schuster
Stephen,King,It,Random House
Stephen,King,It,Penguin Random House
Stephen,King,Dead Zone,Random House
Stephen,King,The Shining,Penguin Random House
John,Le Carre,"Tinker, Tailor, Soldier, Spy: A George Smiley Novel",Berkley
Alex,Michaelides,The Silent Patient,Simon & Schuster
Carol,Shaben,Into The Abyss,Simon & Schuster

Vantagens dos arquivos simples

Desvantagens dos arquivos simples

Exemplo de arquivo simples

• 
  Os autores Stephen King e Tom Clancy aparecem mais de uma vez porque vários livros que publicaram estão representados nos dados.
  
• 
  Os autores Stephen King e Pearl Buck têm o mesmo livro publicado por mais de uma editora.
  

 1def main():
 2    """The main entry point of the program"""
 3    # Get the resources for the program
 4    with resources.path(
 5        "project.data", "author_book_publisher.csv"
 6    ) as filepath:
 7        data = get_data(filepath)
 8
 9    # Get the number of books printed by each publisher
10    books_by_publisher = get_books_by_publisher(data, ascending=False)
11    for publisher, total_books in books_by_publisher.items():
12        print(f"Publisher: {publisher}, total books: {total_books}")
13    print()
14
15    # Get the number of authors each publisher publishes
16    authors_by_publisher = get_authors_by_publisher(data, ascending=False)
17    for publisher, total_authors in authors_by_publisher.items():
18        print(f"Publisher: {publisher}, total authors: {total_authors}")
19    print()
20
21    # Output hierarchical authors data
22    output_author_hierarchy(data)
23
24    # Add a new book to the data structure
25    data = add_new_book(
26        data,
27        author_name="Stephen King",
28        book_title="The Stand",
29        publisher_name="Random House",
30    )
31
32    # Output the updated hierarchical authors data
33    output_author_hierarchy(data)

• Linhas 4 a 7 leia o author_book_publisher.csv arquivo em um DataFrame pandas.
• Linhas 10 a 13 imprimir o número de livros publicados por cada editora.
• Linhas 16 a 19 imprima o número de autores associados a cada editora.
• Linha 22 gera os dados do livro como uma hierarquia classificada por autores.
• Linhas 25 a 30 adicione um novo livro à estrutura na memória.
• Linha 33 gera os dados do livro como uma hierarquia classificada por autores, incluindo o livro recém-adicionado.

$ python main.py
Publisher: Simon & Schuster, total books: 4
Publisher: Random House, total books: 4
Publisher: Penguin Random House, total books: 2
Publisher: Berkley, total books: 2

Publisher: Simon & Schuster, total authors: 4
Publisher: Random House, total authors: 3
Publisher: Berkley, total authors: 2
Publisher: Penguin Random House, total authors: 1

Authors
├── Alex Michaelides
│   └── The Silent Patient
│       └── Simon & Schuster
├── Carol Shaben
│   └── Into The Abyss
│       └── Simon & Schuster
├── Isaac Asimov
│   └── Foundation
│       └── Random House
├── John Le Carre
│   └── Tinker, Tailor, Soldier, Spy: A George Smiley Novel
│       └── Berkley
├── Pearl Buck
│   └── The Good Earth
│       ├── Random House
│       └── Simon & Schuster
├── Stephen King
│   ├── Dead Zone
│   │   └── Random House
│   ├── It
│   │   ├── Penguin Random House
│   │   └── Random House
│   └── The Shining
│       └── Penguin Random House
└── Tom Clancy
    ├── Patriot Games
    │   └── Simon & Schuster
    └── The Hunt For Red October
        └── Berkley

def get_data(filepath):
    """Get book data from the csv file"""
    return pd.read_csv(filepath)

def get_books_by_publisher(data, ascending=True):
    """Return the number of books by each publisher as a pandas series"""
    return data.groupby("publisher").size().sort_values(ascending=ascending)

def get_authors_by_publisher(data, ascending=True):
    """Returns the number of authors by each publisher as a pandas series"""
    return (
        data.assign(name=data.first_name.str.cat(data.last_name, sep=" "))
        .groupby("publisher")
        .nunique()
        .loc[:, "name"]
        .sort_values(ascending=ascending)
    )

def add_new_book(data, author_name, book_title, publisher_name):
    """Adds a new book to the system"""
    # Does the book exist?
    first_name, _, last_name = author_name.partition(" ")
    if any(
        (data.first_name == first_name)
        & (data.last_name == last_name)
        & (data.title == book_title)
        & (data.publisher == publisher_name)
    ):
        return data
    # Add the new book
    return data.append(
        {
            "first_name": first_name,
            "last_name": last_name,
            "title": book_title,
            "publisher": publisher_name,
        },
        ignore_index=True,
    )

def output_author_hierarchy(data):
    """Output the data as a hierarchy list of authors"""
    authors = data.assign(
        name=data.first_name.str.cat(data.last_name, sep=" ")
    )
    authors_tree = Tree()
    authors_tree.create_node("Authors", "authors")
    for author, books in authors.groupby("name"):
        authors_tree.create_node(author, author, parent="authors")
        for book, publishers in books.groupby("title")["publisher"]:
            book_id = f"{author}:{book}"
            authors_tree.create_node(book, book_id, parent=author)
            for publisher in publishers:
                authors_tree.create_node(publisher, parent=book_id)

    # Output the hierarchical authors data
    authors_tree.show()

Usando SQLite para persistir dados

Criando uma estrutura de banco de dados

Interagindo com um banco de dados com SQL

Estruturando um banco de dados com SQL

Criando tabelas com SQL

CREATE TABLE author (
    author_id INTEGER NOT NULL PRIMARY KEY,
    first_name VARCHAR,
    last_name VARCHAR
);

CREATE TABLE book (
    book_id INTEGER NOT NULL PRIMARY KEY,
    author_id INTEGER REFERENCES author,
    title VARCHAR
);

CREATE TABLE publisher (
    publisher_id INTEGER NOT NULL PRIMARY KEY,
    name VARCHAR
);

SELECT * FROM author;

$ sqlite3 author_book_publisher.db

sqlite> SELECT * FROM author;
1|Isaac|Asimov
2|Pearl|Buck
3|Tom|Clancy
4|Stephen|King
5|John|Le Carre
6|Alex|Michaelides
7|Carol|Shaben

sqlite> .q

Mantendo um banco de dados com SQL

INSERT INTO author
    (first_name, last_name)
VALUES ('Paul', 'Mendez');

UPDATE author
SET first_name = 'Richard', last_name = 'Bachman'
WHERE first_name = 'Stephen' AND last_name = 'King';

DELETE FROM author
WHERE first_name = 'Paul'
AND last_name = 'Mendez';

SELECT
  *
FROM some_table
WHERE active = 1;

Construindo relacionamentos

Relacionamentos de um para muitos

1. 
   Os pequenos ícones de teclas amarelos e azuis indicam as chaves primárias e estrangeiras para a tabela, respectivamente.
   
2. 
   A seta conectando book para author indica a relação entre as tabelas com base no author_id chave estrangeira no book tabela.
   

sqlite> SELECT
   ...> a.first_name || ' ' || a.last_name AS author_name,
   ...> b.title AS book_title
   ...> FROM author a
   ...> JOIN book b ON b.author_id = a.author_id
   ...> ORDER BY a.last_name ASC;
Isaac Asimov|Foundation
Pearl Buck|The Good Earth
Tom Clancy|The Hunt For Red October
Tom Clancy|Patriot Games
Stephen King|It
Stephen King|Dead Zone
Stephen King|The Shining
John Le Carre|Tinker, Tailor, Soldier, Spy: A George Smiley Novel
Alex Michaelides|The Silent Patient
Carol Shaben|Into The Abyss

Relações de muitos para muitos

CREATE TABLE author_publisher (
    author_id INTEGER REFERENCES author,
    publisher_id INTEGER REFERENCES publisher
);

1. JOIN the author table with the author_publisher table.
2. JOIN the author_publisher table with the publisher table.

 1sqlite> SELECT
 2   ...> a.first_name || ' ' || a.last_name AS author_name,
 3   ...> p.name AS publisher_name
 4   ...> FROM author a
 5   ...> JOIN author_publisher ap ON ap.author_id = a.author_id
 6   ...> JOIN publisher p ON p.publisher_id = ap.publisher_id
 7   ...> ORDER BY a.last_name ASC;
 8Isaac Asimov|Random House
 9Pearl Buck|Random House
10Pearl Buck|Simon & Schuster
11Tom Clancy|Berkley
12Tom Clancy|Simon & Schuster
13Stephen King|Random House
14Stephen King|Penguin Random House
15John Le Carre|Berkley
16Alex Michaelides|Simon & Schuster
17Carol Shaben|Simon & Schuster

• 
  Line 1 starts a SELECT statement to get data from the database.
  
• 
  Line 2 selects the first and last name from the author table using the a alias for the author table and concatenates them together with a space character.
  
• 
  Line 3 selects the publisher’s name aliased to publisher_name .
  
• 
  Line 4 uses the author table as the first source from which to retrieve data and assigns it to the alias a .
  
• 
  Line 5 is the first step of the process outlined above for connecting the author table to the publisher table. It uses the alias ap for the author_publisher association table and performs a JOIN operation to connect the ap.author_id foreign key reference to the a.author_id primary key in the author table.
  
• 
  Line 6 is the second step in the two-step process mentioned above. It uses the alias p for the publisher table and performs a JOIN operation to relate the ap.publisher_id foreign key reference to the p.publisher_id primary key in the publisher table.
  
• 
  Line 7 sorts the data by the author’s last name in ascending alphabetical order and ends the SQL query.
  
• 
  Lines 8 to 17 are the output of the SQL query.
  

 1sqlite> SELECT
 2   ...> a.first_name || ' ' || a.last_name AS author_name,
 3   ...> COUNT(b.title) AS total_books
 4   ...> FROM author a
 5   ...> JOIN book b ON b.author_id = a.author_id
 6   ...> GROUP BY author_name
 7   ...> ORDER BY total_books DESC, a.last_name ASC;
 8Stephen King|3
 9Tom Clancy|2
10Isaac Asimov|1
11Pearl Buck|1
12John Le Carre|1
13Alex Michaelides|1
14Carol Shaben|1

• 
  Line 1 begins the SQL query with the SELECT keyword.
  
• 
  Line 2 selects the author’s first and last names, separated by a space character, and creates the alias author_name .
  
• 
  Line 3 counts the number of books written by each author, which will be used later by the ORDER BY clause to sort the list.
  
• 
  Line 4 selects the author table to get data from and creates the a alias.
  
• 
  Line 5 connects to the related book table through a JOIN to the author_id and creates the b alias for the book table.
  
• 
  Line 6 generates the aggregated author and total number of books data by using the GROUP BY keyword. GROUP BY is what groups each author_name and controls what books are tallied by COUNT() for that author.
  
• 
  Line 7 sorts the output first by number of books in descending order, then by the author’s last name in ascending alphabetical order.
  
• 
  Lines 8 to 14 are the output of the SQL query.
  

Entity Relationship Diagrams

Working With SQLAlchemy and Python Objects

The Model

 1from sqlalchemy import Column, Integer, String, ForeignKey, Table
 2from sqlalchemy.orm import relationship, backref
 3from sqlalchemy.ext.declarative import declarative_base
 4
 5Base = declarative_base()
 6
 7author_publisher = Table(
 8    "author_publisher",
 9    Base.metadata,
10    Column("author_id", Integer, ForeignKey("author.author_id")),
11    Column("publisher_id", Integer, ForeignKey("publisher.publisher_id")),
12)
13
14book_publisher = Table(
15    "book_publisher",
16    Base.metadata,
17    Column("book_id", Integer, ForeignKey("book.book_id")),
18    Column("publisher_id", Integer, ForeignKey("publisher.publisher_id")),
19)
20
21class Author(Base):
22    __tablename__ = "author"
23    author_id = Column(Integer, primary_key=True)
24    first_name = Column(String)
25    last_name = Column(String)
26    books = relationship("Book", backref=backref("author"))
27    publishers = relationship(
28        "Publisher", secondary=author_publisher, back_populates="authors"
29    )
30
31class Book(Base):
32    __tablename__ = "book"
33    book_id = Column(Integer, primary_key=True)
34    author_id = Column(Integer, ForeignKey("author.author_id"))
35    title = Column(String)
36    publishers = relationship(
37        "Publisher", secondary=book_publisher, back_populates="books"
38    )
39
40class Publisher(Base):
41    __tablename__ = "publisher"
42    publisher_id = Column(Integer, primary_key=True)
43    name = Column(String)
44    authors = relationship(
45        "Author", secondary=author_publisher, back_populates="publishers"
46    )
47    books = relationship(
48        "Book", secondary=book_publisher, back_populates="publishers"
49    )

• 
  Line 1 imports the Column , Integer , String , ForeignKey , and Table classes from SQLAlchemy, which are used to help define the model attributes.
  
• 
  Line 2 imports the relationship() and backref objects, which are used to create the relationships between objects.
  
• 
  Line 3 imports the declarative_base object, which connects the database engine to the SQLAlchemy functionality of the models.
  
• 
  Line 5 creates the Base class, which is what all models inherit from and how they get SQLAlchemy ORM functionality.
  
• 
  Lines 7 to 12 create the author_publisher association table model.
  
• 
  Lines 14 to 19 create the book_publisher association table model.
  
• 
  Lines 21 to 29 define the Author class model to the author database table.
  
• 
  Lines 31 to 38 define the Book class model to the book database table.
  
• 
  Lines 40 to 49 define the Publisher class model to the publisher database table.
  

Table Creates Associations

ForeignKey Creates a Connection

Column("author_id", Integer, ForeignKey("author.author_id"))

relationship() Establishes a Collection

books = relationship("Book", backref=backref("author"))

author_id = Column(Integer, ForeignKey("author.author_id"))

publishers = relationship(
    "Publisher", secondary=author_publisher, back_populates="authors"
)

• 
  secondary tells SQLAlchemy that the relationship to the Publisher class is through a secondary table, which is the author_publisher association table created earlier in models.py . The secondary parameter makes SQLAlchemy find the publisher_id ForeignKey defined in the author_publisher association table.
  
• 
  back_populates is a convenience configuration telling SQLAlchemy that there’s a complementary collection in the Publisher class called authors .
  

backref Mirrors Attributes

book = session.query(Book).filter_by(Book.title == "The Stand").one_or_none()
print(f"Authors name: {book.author.first_name} {book.author.last_name}")

Queries Answer Questions

results = session.query(Author).all()

author_book_totals = (
    session.query(
        Author.first_name,
        Author.last_name,
        func.count(Book.title).label("book_total")
    )
    .join(Book)
    .group_by(Author.last_name)
    .order_by(desc("book_total"))
    .all()
)

Example Program

 1def main():
 2    """Main entry point of program"""
 3    # Connect to the database using SQLAlchemy
 4    with resources.path(
 5        "project.data", "author_book_publisher.db"
 6    ) as sqlite_filepath:
 7        engine = create_engine(f"sqlite:///{sqlite_filepath}")
 8    Session = sessionmaker()
 9    Session.configure(bind=engine)
10    session = Session()
11
12    # Get the number of books printed by each publisher
13    books_by_publisher = get_books_by_publishers(session, ascending=False)
14    for row in books_by_publisher:
15        print(f"Publisher: {row.name}, total books: {row.total_books}")
16    print()
17
18    # Get the number of authors each publisher publishes
19    authors_by_publisher = get_authors_by_publishers(session)
20    for row in authors_by_publisher:
21        print(f"Publisher: {row.name}, total authors: {row.total_authors}")
22    print()
23
24    # Output hierarchical author data
25    authors = get_authors(session)
26    output_author_hierarchy(authors)
27
28    # Add a new book
29    add_new_book(
30        session,
31        author_name="Stephen King",
32        book_title="The Stand",
33        publisher_name="Random House",
34    )
35    # Output the updated hierarchical author data
36    authors = get_authors(session)
37    output_author_hierarchy(authors)

• 
  Lines 4 to 7 first initialize the sqlite_filepath variable to the database file path. Then they create the engine variable to communicate with SQLite and the author_book_publisher.db database file, which is SQLAlchemy’s access point to the database.
  
• 
  Line 8 creates the Session class from the SQLAlchemy’s sessionmaker() .
  
• 
  Line 9 binds the Session to the engine created in line 8.
  
• 
  Line 10 creates the session instance, which is used by the program to communicate with SQLAlchemy.
  

 1def get_books_by_publishers(session, ascending=True):
 2    """Get a list of publishers and the number of books they've published"""
 3    if not isinstance(ascending, bool):
 4        raise ValueError(f"Sorting value invalid: {ascending}")
 5
 6    direction = asc if ascending else desc
 7
 8    return (
 9        session.query(
10            Publisher.name, func.count(Book.title).label("total_books")
11        )
12        .join(Publisher.books)
13        .group_by(Publisher.name)
14        .order_by(direction("total_books"))
15    )

• 
  Line 6 creates the direction variable and sets it equal to the SQLAlchemy desc or asc function depending on the value of the ascending parâmetro.
  
• 
  Lines 9 to 11 query the Publisher table for data to return, which in this case are Publisher.name and the aggregate total of Book objects associated with an author, aliased to total_books .
  
• 
  Line 12 joins to the Publisher.books coleção.
  
• 
  Line 13 aggregates the book counts by the Publisher.name attribute.
  
• 
  Line 14 sorts the output by the book counts according to the operator defined by direction .
  
• 
  Line 15 closes the object, executes the query, and returns the results to the caller.
  

def get_authors_by_publishers(session, ascending=True):
    """Get a list of publishers and the number of authors they've published"""
    if not isinstance(ascending, bool):
        raise ValueError(f"Sorting value invalid: {ascending}")

    direction = asc if ascending else desc

    return (
        session.query(
            Publisher.name,
            func.count(Author.first_name).label("total_authors"),
        )
        .join(Publisher.authors)
        .group_by(Publisher.name)
        .order_by(direction("total_authors"))
    )

def get_authors(session):
    """Get a list of author objects sorted by last name"""
    return session.query(Author).order_by(Author.last_name).all()

 1def add_new_book(session, author_name, book_title, publisher_name):
 2    """Adds a new book to the system"""
 3    # Get the author's first and last names
 4    first_name, _, last_name = author_name.partition(" ")
 5
 6    # Check if book exists
 7    book = (
 8        session.query(Book)
 9        .join(Author)
10        .filter(Book.title == book_title)
11        .filter(
12            and_(
13                Author.first_name == first_name, Author.last_name == last_name
14            )
15        )
16        .filter(Book.publishers.any(Publisher.name == publisher_name))
17        .one_or_none()
18    )
19    # Does the book by the author and publisher already exist?
20    if book is not None:
21        return
22
23    # Get the book by the author
24    book = (
25        session.query(Book)
26        .join(Author)
27        .filter(Book.title == book_title)
28        .filter(
29            and_(
30                Author.first_name == first_name, Author.last_name == last_name
31            )
32        )
33        .one_or_none()
34    )
35    # Create the new book if needed
36    if book is None:
37        book = Book(title=book_title)
38
39    # Get the author
40    author = (
41        session.query(Author)
42        .filter(
43            and_(
44                Author.first_name == first_name, Author.last_name == last_name
45            )
46        )
47        .one_or_none()
48    )
49    # Do we need to create the author?
50    if author is None:
51        author = Author(first_name=first_name, last_name=last_name)
52        session.add(author)
53
54    # Get the publisher
55    publisher = (
56        session.query(Publisher)
57        .filter(Publisher.name == publisher_name)
58        .one_or_none()
59    )
60    # Do we need to create the publisher?
61    if publisher is None:
62        publisher = Publisher(name=publisher_name)
63        session.add(publisher)
64
65    # Initialize the book relationships
66    book.author = author
67    book.publishers.append(publisher)
68    session.add(book)
69
70    # Commit to the database
71    session.commit()

• 
  Lines 7 to 18 set the book variable to an instance of a Book if a book with the same title, author, and publisher is found. Otherwise, they set book to None .
  
• 
  Lines 20 and 21 determine if the book already exists and return if it does.
  
• 
  Lines 24 to 37 set the book variable to an instance of a Book if a book with the same title and author is found. Otherwise, they create a new Book instance.
  
• 
  Lines 40 to 52 set the author variable to an existing author, if found, or create a new Author instance based on the passed-in author name.
  
• 
  Lines 55 to 63 set the publisher variable to an existing publisher, if found, or create a new Publisher instance based on the passed-in publisher name.
  
• 
  Line 66 sets the book.author instance to the author instance. This creates the relationship between the author and the book, which SQLAlchemy will create in the database when the session is committed.
  
• 
  Line 67 adds the publisher instance to the book.publishers coleção. This creates the many-to-many relationship between the book and publisher tables. SQLAlchemy will create references in the tables as well as in the book_publisher association table that connects the two.
  
• 
  Line 68 adds the Book instance to the session, making it part of the session’s unit of work.
  
• 
  Line 71 commits all the creations and updates to the database.
  

Providing Access to Multiple Users

Using Flask With Python, SQLite, and SQLAlchemy

• 
  Flask Blueprint is part of Flask and provides a good way to follow the separation of concerns design principle and create distinct modules to contain functionality.
  
• 
  Flask SQLAlchemy is an extension for Flask that adds support for SQLAlchemy in your web applications.
  
• 
  Flask_Bootstrap4 packages the Bootstrap front-end tool kit, integrating it with your Flask web applications.
  
• 
  Flask_WTF extends Flask with WTForms, giving your web applications a useful way to generate and validate web forms.
  
• 
  python_dotenv is a Python module that an application uses to read environment variables from a file and keep sensitive information out of program code.
  

SECRET_KEY = "you-will-never-guess"
SQLALCHEMY_TRACK_MODIFICATIONS = False
SQLAlCHEMY_ECHO = False
DEBUG = True

 1{% extends "base.html" %}
 2
 3{% block content %}
 4<div class="container-fluid">
 5  <div class="m-4">
 6    <div class="card" style="width: 18rem;">
 7      <div class="card-header">Create New Artist</div>
 8      <div class="card-body">
 9        <form method="POST" action="{{url_for('artists_bp.artists')}}">
10          {{ form.csrf_token }}
11          {{ render_field(form.name, placeholder=form.name.label.text) }}
12          <button type="submit" class="btn btn-primary">Create</button>
13        </form>
14      </div>
15    </div>
16    <table class="table table-striped table-bordered table-hover table-sm">
17      <caption>List of Artists</caption>
18      <thead>
19        <tr>
20          <th>Artist Name</th>
21        </tr>
22      </thead>
23      <tbody>
24        {% for artist in artists %}
25        <tr>
26          <td>
27            <a href="{{url_for('albums_bp.albums', artist_id=artist.artist_id)}}">
28              {{ artist.name }}
29            </a>
30          </td>
31        </tr>
32        {% endfor %}
33      </tbody>
34    </table>
35  </div>
36</div>
37{% endblock %}

• 
  Line 1 uses Jinja2 template inheritance to build this template from the base.html template. The base.html template contains all the HTML5 boilerplate code as well as the Bootstrap navigation bar consistent across all pages of the site.
  
• 
  Lines 3 to 37 contain the block content of the page, which is incorporated into the Jinja2 macro of the same name in the base.html base template.
  
• 
  Lines 9 to 13 render the form to create a new artist. This uses the features of Flask-WTF to generate the form.
  
• 
  Lines 24 to 32 create a for loop that renders the table of artist names.
  
• 
  Lines 27 to 29 render the artist name as a link to the artist’s album page showing the songs associated with a particular artist.
  

 1from flask import Blueprint, render_template, redirect, url_for
 2from flask_wtf import FlaskForm
 3from wtforms import StringField
 4from wtforms.validators import InputRequired, ValidationError
 5from app import db
 6from app.models import Artist
 7
 8# Set up the blueprint
 9artists_bp = Blueprint(
10    "artists_bp", __name__, template_folder="templates", static_folder="static"
11)
12
13def does_artist_exist(form, field):
14    artist = (
15        db.session.query(Artist)
16        .filter(Artist.name == field.data)
17        .one_or_none()
18    )
19    if artist is not None:
20        raise ValidationError("Artist already exists", field.data)
21
22class CreateArtistForm(FlaskForm):
23    name = StringField(
24        label="Artist's Name", validators=[InputRequired(), does_artist_exist]
25    )
26
27@artists_bp.route("/")
28@artists_bp.route("/artists", methods=["GET", "POST"])
29def artists():
30    form = CreateArtistForm()
31
32    # Is the form valid?
33    if form.validate_on_submit():
34        # Create new artist
35        artist = Artist(name=form.name.data)
36        db.session.add(artist)
37        db.session.commit()
38        return redirect(url_for("artists_bp.artists"))
39
40    artists = db.session.query(Artist).order_by(Artist.name).all()
41    return render_template("artists.html", artists=artists, form=form,)

• 
  Lines 1 to 6 import all the modules necessary to render the page and initialize forms with data from the database.
  
• 
  Lines 9 to 11 create the blueprint for the artists page.
  
• 
  Lines 13 to 20 create a custom validator function for the Flask-WTF forms to make sure a request to create a new artist doesn’t conflict with an already existing artist.
  
• 
  Lines 22 to 25 create the form class to handle the artist form rendered in the browser and provide validation of the form field inputs.
  
• 
  Lines 27 to 28 connect two routes to the artists() function they decorate.
  
• 
  Line 30 creates an instance of the CreateArtistForm() aula.
  
• 
  Line 33 determines if the page was requested through the HTTP methods GET or POST (submit). If it was a POST, then it also validates the fields of the form and informs the user if the fields are invalid.
  
• 
  Lines 35 to 37 create a new artist object, add it to the SQLAlchemy session, and commit the artist object to the database, persisting it.
  
• 
  Line 38 redirects back to the artists page, which will be rerendered with the newly created artist.
  
• 
  Line 40 runs an SQLAlchemy query to get all the artists in the database and sort them by Artist.name .
  
• 
  Line 41 renders the artists page if the HTTP request method was a GET.
  

Creating a REST API Server

Conclusão

• Why an SQLite database can be a compelling alternative to flat-file data storage
• How to normalize data to reduce data redundancy and increase data integrity
• How to use SQLAlchemy to work with databases in an object-oriented manner
• How to build a web application to serve a database to multiple users

Further Reading

• 
  If your application will expose the database to users, then avoiding SQL injection attacks is an important skill. For more information, check out Preventing SQL Injection Attacks With Python.
  
• 
  Providing web access to a database is common in web-based single-page applications. To learn how, check out Python REST APIs With Flask, Connexion, and SQLAlchemy – Part 2.
  
• 
  Preparing for data engineering job interviews gives you a leg up in your career. To get started, check out Data Engineer Interview Questions With Python.
  
• 
  Migrating data and being able to roll back using Flask with Postgres and SQLAlchemy is an integral part of the Software Development Life Cycle (SDLC). You can learn more about it by checking out Flask by Example – Setting up Postgres, SQLAlchemy, and Alembic.