{"id":21902,"date":"2022-10-28T08:02:44","date_gmt":"2022-10-28T15:02:44","guid":{"rendered":"https:\/\/coderpad.io\/?p=21902"},"modified":"2023-06-05T13:57:13","modified_gmt":"2023-06-05T20:57:13","slug":"understanding-transactions-in-sqlalchemy","status":"publish","type":"post","link":"https:\/\/coderpad.io\/blog\/development\/understanding-transactions-in-sqlalchemy\/","title":{"rendered":"Understanding Transactions in SQLAlchemy"},"content":{"rendered":"\n

Database transaction in SQLAlchemy follows the rule of ACID<\/a> in relational databases. This tutorial shows how to understand transactions in a practical application. You’re going to learn why SQLAlchemy transactions matter in building applications like getting orders from an inventory.<\/p>\n\n\n\n

You can use your own IDE and dependencies to try things out, and as always, this tutorial will use the already prepared environment, CoderPad sandbox<\/a>, which has all that you need from the dependencies in this application.<\/p>\n\n\n\n

Configure your sandbox by selecting the Python 3 language environment. On the top left corner, click on the three dots and select the SQLAlchemy ( Postgres ) adapter from the list of database adapters.<\/p>\n\n\n\n

\n

\u2139\ufe0f If this is your first time working with SQLAlchemy then you should check out How to Interact with Databases using SQLAlchemy with PostgreSQL<\/a>.<\/p>\n<\/blockquote>\n\n\n\n

Create the database engine<\/strong><\/h2>\n\n\n\n

Start with creating the SQLAlchemy database engine, which is the home base for the actual database<\/a> and the DBAPI. The DBAPI (Python Database API Specification) is the low-level API accessed by Python to be able to communicate with the database. <\/p>\n\n\n\n

In our case, we’ll use pyscopg2<\/code>, the DBAPI for PostgreSQL. See below how to establish the engine:<\/p>\n\n\n

from<\/span> sqlalchemy import<\/span> create_engine\nfrom<\/span> sqlalchemy.engine import<\/span> URL\n\nurl = URL.create(\n    drivername=\"postgresql\"<\/span>\n    username=\"coderpad\"<\/span>,\n    host=\"\/tmp\/postgresql\/socket\"<\/span>\n    database=\"coderpad\"<\/span>)\nengine = create_engine(url)<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
The url<\/code> instance has established the database configuration to talk to the CoderPad database. Feel free to update your own url<\/code> if you’re not using the CoderPad sandbox.<\/p>\n\n\n\n
Now, the engine is the starting point for our PostgreSQL database communication.<\/p>\n\n\n\n
Create the session instance<\/strong><\/h2>\n\n\n\n
To interact with the database through SELECT<\/code> statements and other queries, you need to instantiate an SQLAlchemy session<\/a>. Instantiate it with the engine that you defined earlier:<\/p>\n\n\n
from<\/span> sqlalchemy.orm import<\/span> sessionmaker\n\nSession = sessionmaker(bind=engine)\nsession = Session()<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Define the database model<\/strong><\/h2>\n\n\n\n
This inventory application is inspired by the Northwind database<\/a>. You can consult the GitHub repo to explore the schema. We need only four tables for our minimal version: customers<\/code>, products<\/code>, orders<\/code>, and order_details<\/code>.<\/p>\n\n\n\n
Create a new base class (Base instance) to initiate a declarative mapping to all classes that inherit from it. The example below shows how to inherit the first class representing the customers<\/code> table:<\/p>\n\n\n
from<\/span> sqlalchemy import<\/span> Column, String\nfrom<\/span> sqlalchemy.orm import<\/span> declarative_base, relationship\n\n\nBase = declarative_base()\n\n\nclass<\/span> Customer<\/span>(Base)<\/span>:<\/span>\n\u00a0 \u00a0 __tablename__ = 'customers'<\/span>\n\n\u00a0 \u00a0 customer_id = Column(String(5<\/span>), primary_key=True<\/span>)\n\u00a0 \u00a0 company_name = Column(String(30<\/span>))\n\u00a0 \u00a0 contact_name = Column(String(30<\/span>))\n\u00a0 \u00a0 country = Column(String(15<\/span>))\n\n\u00a0 \u00a0 orders = relationship('Order'<\/span>, backref='customer'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, the customers table is defined and has metadata of the customer info. This Customer class back-references customer into the orders table. We’ll see how to create a foreign key in the orders table.<\/p>\n\n\n\n
Below is the definition of the other three tables:<\/p>\n\n\n
from<\/span> sqlalchemy import<\/span> Integer, Boolean, ForeignKey, CheckConstraint\n\n\nclass<\/span> Product<\/span>(Base)<\/span>:<\/span>\n\u00a0 \u00a0 __tablename__ = 'products'<\/span>\n\u00a0 \u00a0 __table_args__ = (CheckConstraint(\n\u00a0 \u00a0 \u00a0 \u00a0 'unit_quantity>=0'<\/span>,\n\u00a0 \u00a0 \u00a0 \u00a0 'quantity should exist in the inventory'<\/span>\n\u00a0 \u00a0 \u00a0 \u00a0 ),)\n\n\u00a0 \u00a0 id = Column(Integer(), primary_key=True<\/span>)\n\u00a0 \u00a0 product_name = Column(String(40<\/span>), nullable=False<\/span>)\n\u00a0 \u00a0 unit_quantity = Column(Integer(), nullable=False<\/span>)\n\n\u00a0 \u00a0 order_details = relationship('OrderDetail'<\/span>, backref='product'<\/span>)\n\u00a0 \u00a0\nclass<\/span> Order<\/span>(Base)<\/span>:<\/span>\n\u00a0 \u00a0 __tablename__ = 'orders'<\/span>\n\n\u00a0 \u00a0 id = Column(Integer(), primary_key=True<\/span>)\n\u00a0 \u00a0 customer_id = Column(String(5<\/span>), ForeignKey('customers.customer_id'<\/span>))\n\u00a0 \u00a0 shipped = Column(Boolean(), default=False<\/span>)\n\u00a0 \u00a0 order_details = relationship('OrderDetail'<\/span>, backref='order'<\/span>)\n\nclass<\/span> OrderDetail<\/span>(Base)<\/span>:<\/span>\n\u00a0 \u00a0 __tablename__ = 'order_details'<\/span>\n\n\u00a0 \u00a0 id = Column(Integer(), primary_key=True<\/span>)\n\u00a0 \u00a0 order_id = Column(Integer(), ForeignKey('orders.id'<\/span>))\n\u00a0 \u00a0 product_id = Column(Integer(), ForeignKey('products.id'<\/span>))\n\u00a0 \u00a0 unit_price = Column(Integer(), nullable=False<\/span>)\n\u00a0 \u00a0 quantity = Column(Integer(), nullable=False<\/span>)\n\nBase.metadata.create_all(engine)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The products table is defined with the product name and quantity per unit and the order details, which back-references product instance into the order_details<\/code> table. This means the orders_details<\/code> table would have a product<\/code> column which should refer to a product field in the products table. Similarly, there is an order_details<\/code> column in the products table, which should contain the order details\/items of each product.<\/p>\n\n\n\n
The constraint defined in the __table_arg__<\/code> metadata ensures that the unit quantity equals or exceeds zero. If the unit quantity is  zero, it means the product is finished and no longer exists in the inventory. If it’s bigger than zero, it means the product has a specific quantity in the inventory.<\/p>\n\n\n\n
The orders<\/code> table is defined with a shipped boolean value to indicate whether the product is shipped or not. It has the order_details<\/code> back-referencing order to the order_details<\/code> table. The orders table has customer_id<\/code> as a foreign key to refer to the customers table.<\/p>\n\n\n\n
Finally, the order_details<\/code> table has metadata of order_id<\/code> as a foreign key to the orders table, product_id<\/code> as a foreign key to the products table, unit_price<\/code> as a price for a product unit, and quantity to show the ordered quantity of the product that the customer has ordered.<\/p>\n\n\n\n
All these objects (or tables) are created with the last command using Base.metadata.create_all(engine)<\/code>.<\/p>\n\n\n\n
Inserting data<\/strong><\/h2>\n\n\n\n
Now, you can insert data to define customers, products, orders, and order details. The examples below illustrate data insertions for our inventory app:<\/p>\n\n\n
alfki = Customer(\n    customer_id = 'ALFKI'<\/span>,\n\u00a0 \u00a0 company_name = 'Around the Horn'<\/span>,\n\u00a0 \u00a0 contact_name = 'Thomas Hardy'<\/span>,\n\u00a0 \u00a0 country='UK'<\/span>\n)\n\nproduct_chai = Product(\n\u00a0 \u00a0 product_name='Chai'<\/span>,\n\u00a0 \u00a0 unit_quantity=12<\/span>\n\u00a0 \u00a0 )\n\nproduct_syrup = Product(\n\u00a0 \u00a0 product_name='Anissed Syrup'<\/span>,\n\u00a0 \u00a0 unit_quantity=2<\/span>\n\u00a0 \u00a0 )\n\nalfki_order1 = Order(customer = alfki)\n\norder1_items = OrderDetail(\n\u00a0 \u00a0 order = alfki_order1,\n\u00a0 \u00a0 product = product_chai,\n\u00a0 \u00a0 unit_price = 18<\/span>,\n\u00a0 \u00a0 quantity = 8<\/span>\n)\n\nalfki_order2 = Order(customer = alfki)\n\norder2_items_chai = OrderDetail(\n\u00a0 \u00a0 order = alfki_order2,\n\u00a0 \u00a0 product = product_chai,\n\u00a0 \u00a0 unit_price = 18<\/span>,\n\u00a0 \u00a0 quantity = 3<\/span>\n)\n\norder2_items_syrup = OrderDetail(\n\u00a0 \u00a0 order = alfki_order2,\n\u00a0 \u00a0 product = product_syrup,\n\u00a0 \u00a0 unit_price = 10<\/span>,\n\u00a0 \u00a0 quantity = 5<\/span>\n)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
So we have 12 chai products and 2 anissed syrups. Alfki customer placed two orders. The first order is 8 chai while the second order consists of 3 chai and 5 anissed syrup.<\/p>\n\n\n\n
After defining each object with the related table, you can now add the orders and order details in the database using the .add_all()<\/code> method. Then you can commit all these changes to the database:<\/p>\n\n\n
session<\/span>.add_all<\/span>([alfki_order1, order1_items, alfki_order2, order2_items_chai, order2_items_syrup]<\/span>)\nsession<\/span>.commit<\/span>()<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Note how elegant and easy SQLAlchemy ORM is when inserting data. Every insertion is stored and operated as if it were a native Python object. Database relationships are all respected and<\/strong> a Python developer never has to write a bunch of insertion lines of SQL.<\/p>\n\n\n\n
Implement the transaction logic<\/strong><\/h2>\n\n\n\n
Now is the time to ship the order defined by the order id. The following function shows the logic for shipping the order which represents the transaction in the database:<\/p>\n\n\n
def<\/span> ship_order<\/span>(order_id)<\/span>:<\/span>\n\u00a0 \u00a0 products_to_ship = session.query(OrderDetail).filter(OrderDetail.order_id == order_id)\n\n\u00a0 \u00a0 for<\/span> product in<\/span> products_to_ship:\n\u00a0 \u00a0 \u00a0 \u00a0 print(f\"Product: {product.product_id}<\/span>. Quantity: {product.quantity}<\/span>.\"<\/span>)\n\u00a0 \u00a0 \u00a0 \u00a0 ordered_product = session.query(Product).filter(Product.id == product.product_id).first()\n\u00a0 \u00a0 \u00a0 \u00a0 ordered_product.unit_quantity -= product.quantity\n\n\u00a0 \u00a0 shipped_order = session.query(Order).filter(Order.id == order_id)\n\u00a0 \u00a0 shipped_order.shipped = True<\/span>\n\u00a0 \u00a0 session.commit()\n\u00a0 \u00a0\n\u00a0 \u00a0 print(f\"Your order is shipped. ID is: {order_id}<\/span>\"<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
As you can see, the products_to_ship<\/code> object is a Query object which selects records from the order_details<\/code> table that match the order_id<\/code> column.<\/p>\n\n\n\n
The for loop that follows is looping over each product that should be shipped. The ordered_product<\/code> object is the product record that is requested to be shipped. We then subtract the ordered quantity of the product from the actual quantity that exists in the inventory.<\/p>\n\n\n\n
The shipped_order<\/code> is the requested order record from the orders table. We mark the status of the shipped boolean value as True. Finally, we commit the changes to the database.<\/p>\n\n\n\n
Manage transactions<\/strong><\/h2>\n\n\n\n
Transactions to the database will be clear to you starting from this section. To understand what’s happening to the database, let’s track the product quantity number before and after the order is placed:<\/p>\n\n\n
print(session.query(Product.product_name, Product.unit_quantity).all())\n\nship_order(1<\/span>)\n\nprint(session.query(Product.product_name, Product.unit_quantity).all())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
The output from the query above is:<\/p>\n\n\n
[('Chai'<\/span>, 12), ('Anissed Syrup'<\/span>, 2)]<\/span>\nProduct<\/span>: 1. Quantity<\/span>: 8.\nYour<\/span> order<\/span> is<\/span> shipped<\/span>. ID<\/span> is<\/span>: 1\n[('Anissed Syrup'<\/span>, 2), ('Chai'<\/span>, 4)]<\/span><\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
As you can see, we ordered 8 products of product id of 1 (the Chai product). After the order is placed, the Chai quantity in our inventory becomes 4 (8 subtracted from 12).<\/p>\n\n\n\n
Now, hit the Reset<\/em> button on the right corner of the CoderPad sandbox and then ship the second order.<\/p>\n\n\n\n
\n
\u2139\ufe0f We’re resetting the environment to remove any change to the current session that happened in our database. You may want to remove the four tables if you’re not following along on the Pad sandbox.<\/p>\n<\/blockquote>\n\n\n\n
Add the following ship_order(2)<\/code> line:<\/p>\n\n\n
print(session.query(Product.product_name, Product.unit_quantity).all())\n\nship_order(1<\/span>)\nship_order(2<\/span>)\n\nprint(session.query(Product.product_name, Product.unit_quantity).all())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Before executing the last updated code, remember the second order. It consists of two products; 3 chai and 5 anissed syrup quantities. However, there are 12 chai and only 3 anissed syrup products in the inventory. This means after placing the second order, there is more demand for anissed syrup than the already supplied product in the inventory.<\/p>\n\n\n\n
So if you run the code, you’ll see the following error:<\/p>\n\n\n
IntegrityError: (psycopg2.errors.UniqueViolation) duplicate key value violates unique constraint \"customers_pkey\"<\/span>\nDETAIL<\/span>:  Key (customer_id)=(ALFKI) already exists.\n\n[SQL: INSERT INTO customers (customer_id, company_name, contact_name, country) VALUES (%(customer_id)s, %(company_name)s, %(contact_name)s, %(country)s)]\n[parameters: {'customer_id'<\/span>: 'ALFKI'<\/span>, 'company_name'<\/span>: 'Around the Horn'<\/span>, 'contact_name'<\/span>: 'Thomas Hardy'<\/span>, 'country'<\/span>: 'UK'<\/span>}]\n(Background on this<\/span> error at: https:\/\/sqlalche.me\/e\/14\/gkpj)<\/span><\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
The error shows an IntegrityError<\/code> exception because it violates the rule we set for the quantity attribute in the products table.<\/p>\n\n\n\n
The problem here does not only exist for this particular order. It also exists for the following orders. Say, another order is placed ordering another Chai from the same customer, Alfki:<\/p>\n\n\n
alfki_order3 = Order(customer = alfki)\n\norder3_items = OrderDetail(\n    order = alfki_order3,\n    product = product_chai,\n    unit_price = 18<\/span>,\n    quantity = 1<\/span>\n)\n\nsession.add_all([alfki_order3, order3_items])\nsession.commit()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
\n
\u2139\ufe0f Put the previous snippet to the REPL python window on the right of the Pad sandbox.<\/p>\n<\/blockquote>\n\n\n\n
When you commit any change to the database like the above, you’ll get the following error:<\/p>\n\n\n
raise sa_exc.PendingRollbackError(PendingRollbackError: This Session's transaction has been rolled back due to a previous exception during flush. To begin a new transaction with this Session, first issue Session.rollback(). Original exception was...<\/code><\/span><\/pre>\n\n\n
This PendingRollbackError<\/code> shows that the last transaction to the database was not successful. So you need to roll it back to the session first:<\/p>\n\n\n
session.rollback()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To request an order of the third order:<\/p>\n\n\n
print(session.query(Product.product_name, Product.unit_quantity).all())\n\nship_order(3<\/span>)\n\nprint(session.query(Product.product_name, Product.unit_quantity).all())<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Now the database transaction has been committed to the database:<\/p>\n\n\n
[('Anissed Syrup'<\/span>, 2), ('Chai'<\/span>, 4)]<\/span>\nProduct<\/span>: 1. Quantity<\/span>: 1.\nYour<\/span> order<\/span> is<\/span> shipped<\/span>. ID<\/span> is<\/span>: 4\n[('Anissed Syrup'<\/span>, 2), ('Chai'<\/span>, 3)]<\/span><\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
But this was an ad-hoc fix to the pending rollback error using the session.rollback()<\/code>. We want to catch this error whenever there is a violation of the database transaction. So use try\/except<\/code> and then roll back the session in the except block.<\/p>\n\n\n\n
SQLAlchemy rollback<\/strong><\/h2>\n\n\n\n
To do a rollback in the SQLAlchemy ORM, use session.rollback()<\/code>. Let’s revamp the ship_order()<\/code> function to adapt the new try\/except statement:<\/p>\n\n\n
def<\/span> ship_order<\/span>(order_id)<\/span>:<\/span>\n    # ...<\/span>\n    shipped_order.shipped = True<\/span>\n    try<\/span>:\n        session.commit()\n    except<\/span> IntegrityError as<\/span> e:\n        print(f\"QuantityViolationError: {e.orig}<\/span>\"<\/span>)\n        session.rollback()\n\n    print(f\"Your order is shipped. ID is: {order_id}<\/span>\"<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Now, let’s place the two orders with the new change. Hit Reset and then hit Run and see the output:<\/p>\n\n\n
[('Chai'<\/span>, 12<\/span>), ('Anissed Syrup'<\/span>, 2<\/span>)]\nProduct<\/span>: 1.<\/span> Quantity: 8.<\/span>\nYour order is shipped. ID is: 1<\/span>\nProduct<\/span>: 1.<\/span> Quantity: 3.<\/span>\nProduct<\/span>: 2.<\/span> Quantity: 5.<\/span>QuantityViolationError: new<\/span> row for<\/span> relation \"products\"<\/span> violates check co\nnstraint \"quantity should exist in the inventory\"<\/span>\nDETAIL<\/span>:  Failing row contains (2<\/span>, Anissed Syrup, -3<\/span>).\n\nYour order is shipped. ID is: 2<\/span>\n[('Anissed Syrup'<\/span>, 2<\/span>), ('Chai'<\/span>, 4<\/span>)]<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
As you can see, the first order is placed and ready to be shipped. However, the second order is rolled back. So the transaction has not been completed, and there is no change to the quantity of the products.<\/p>\n\n\n\n
This means if you place any other order, it will be transacted as long as it satisfies the constraints, as in the case of the unit quantity constraint.<\/p>\n\n\n\n
If you placed the third order that we wrote above and committed it to the database, and then shipped this order using the ship_order(3)<\/code>, you’d see a successful commit to the database.<\/p>\n\n\n\n
SQLAlchemy commit vs flush<\/strong><\/h2>\n\n\n\n
Session in SQLAlchemy ORM is the start of any transaction. It means you can insert, delete, or update records in the database through the session. If you want to add a new change to the database, you’ll first use session.add()<\/code>, which places this new instance<\/a> in the session object. The new instance is not persistent<\/a> in the database until it’s committed.<\/p>\n\n\n\n
When you commit that instance to the database using session.commit()<\/code>, and you’re doing two things under the hood:<\/p>\n\n\n\n
    \n
  1. Flushing the database with that new change so that you can query from the session object<\/li>\n\n\n\n
  2. Committing the new change to the database so that the database is updated with this new change<\/li>\n<\/ol>\n\n\n\n
    So the session.commit()<\/code> calls session.flush()<\/code> by default. To make it more clear, let’s first delete the third order from the database (if you committed that change already to the database):<\/p>\n\n\n
    >>> session<\/span>.delete<\/span>(alfki_order3<\/span>)\n>>> session<\/span>.delete<\/span>(order3_items<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    >>> session<\/span>.query<\/span>(Order<\/span>.id<\/span>).all<\/span>()<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    You’ll see only the first and second orders.<\/p>\n\n\n\n
    from<\/span> sqlalchemy.orm import<\/span> make_transient\n\n>>> make_transient(alfki_order3)\n>>> make_transient(order3_items)<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    The transient state is where the object is not associated yet with the session.<\/p>\n\n\n\n
    You can add them back to the session:<\/p>\n\n\n
    >>> session<\/span>.add_all<\/span>([alfki_order3, order3_items]<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    >>> session<\/span>.query<\/span>(Order<\/span>.id<\/span>).all<\/span>()<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    You’ll see the third order is included.<\/p>\n\n\n\n
    To disable autoflush<\/code>, assign the autoflush<\/code> session attribute to False:<\/p>\n\n\n
    >>> session.autoflush = False<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Let’s experiment with how you can force a flush. Delete the two objects, convert their object states to transient, and then add both back to the session:<\/p>\n\n\n
    >>> session<\/span>.delete<\/span>(alfki_order3<\/span>)\n>>> session<\/span>.delete<\/span>(order3_items<\/span>)\n>>> make_transient<\/span>(alfki_order3<\/span>)\n>>> make_transient<\/span>(order3_items<\/span>)\n>>> session<\/span>.add_all<\/span>([alfki_order3, order3_items]<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    Now when you query from the orders table, you’ll not see the third order as before unless you flush the transaction:<\/p>\n\n\n
    >>> session<\/span>.query<\/span>(Order<\/span>.id<\/span>).all<\/span>()\n[[1,), (2,)]<\/span>\n\n>>> session<\/span>.flush<\/span>()\n\n>>> session<\/span>.query<\/span>(Order<\/span>.id<\/span>).all<\/span>()\n[(1,), (2,), (3,)]<\/span><\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    Nothing is changed in the database yet unless you commit the current transaction<\/a> using session.commit()<\/code>. This commit function flushes the pending changes, which means it always<\/em> calls the session.flush()<\/code>.<\/p>\n\n\n\n\t
    Before committing the new changes to the database, you can query those changes from the session. That’s because the autoflush<\/a> is enabled by default when you declare a session. A quick check would be querying from the orders table:<\/p>\n\n\n
    The given mapped instances<\/a> alfki_order3<\/code> and order3_items<\/code> were in the detached state. That’s why you used make_transient<\/code>.<\/p>\n\n\n\n
    Before you add these aflki_order3<\/code> and order3_items<\/code> objects again to the session, you need to return their object state to transient<\/a>:<\/p>\n\n\n
    Now, alfki_order3<\/code> is just a Python object. Not attached to the session object, which means it’s in a detached<\/a> state. To check if the third order is already deleted, run the following:<\/p>\n\n\n
If you want to get deeper with defining the data models, you can consult this SQLAlchemy interaction with database article<\/a>.<\/p>\n\n\n\n
This session<\/code> instance is what you need to do Object Relational Mapping (ORM) operations to emit SQL statements<\/a> like SELECT<\/code>, INSERT<\/code>, UPDATE<\/code>, and DELETE<\/code>.<\/p>\n\n\n\n