update sqlalchemy to 2.0.54

pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/requirements.txt

@@ -1,2 +1 @@
-greenlet==3.2.4
-sqlalchemy==1.4.19
+sqlalchemy==2.0.54

pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/run_benchmark.py

@@ -1,47 +1,49 @@
-import pyperf
+from typing import Optional
 
-from sqlalchemy import Column, ForeignKey, Integer, String
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import relationship, sessionmaker
-from sqlalchemy import create_engine
+import pyperf
+from sqlalchemy import ForeignKey, String, create_engine, delete, select
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,
+    mapped_column,
+    relationship,
+    sessionmaker,
+)
 
 
-Base = declarative_base()
+class Base(DeclarativeBase):
+    pass
 
 
 class Person(Base):
-    __tablename__ = 'person'
+    __tablename__ = "person"
     # Here we define columns for the table person
     # Notice that each column is also a normal Python instance attribute.
-    id = Column(Integer, primary_key=True)
-    name = Column(String(250), nullable=False)
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(250))
 
 
 class Address(Base):
-    __tablename__ = 'address'
+    __tablename__ = "address"
     # Here we define columns for the table address.
     # Notice that each column is also a normal Python instance attribute.
-    id = Column(Integer, primary_key=True)
-    street_name = Column(String(250))
-    street_number = Column(String(250))
-    post_code = Column(String(250), nullable=False)
-    person_id = Column(Integer, ForeignKey('person.id'))
-    person = relationship(Person)
+    id: Mapped[int] = mapped_column(primary_key=True)
+    street_name: Mapped[Optional[str]] = mapped_column(String(250))
+    street_number: Mapped[Optional[str]] = mapped_column(String(250))
+    post_code: Mapped[str] = mapped_column(String(250))
+    person_id: Mapped[Optional[int]] = mapped_column(ForeignKey("person.id"))
+    person: Mapped[Optional[Person]] = relationship()
 
 
-# Create an engine that stores data in the local directory's
-# sqlalchemy_example.db file.
-engine = create_engine('sqlite://')
+# Create an engine that stores data in an in-memory SQLite database.
+engine = create_engine("sqlite://")
 
 # Create all tables in the engine. This is equivalent to "Create Table"
 # statements in raw SQL.
 Base.metadata.create_all(engine)
 
 
-# Bind the engine to the metadata of the Base class so that the
-# declaratives can be accessed through a DBSession instance
-Base.metadata.bind = engine
-
+# Bind sessions to the engine.
 DBSession = sessionmaker(bind=engine)
 # A DBSession() instance establishes all conversations with the database
 # and represents a "staging zone" for all the objects loaded into the
@@ -55,13 +57,18 @@ class Address(Base):
 
 # add 'npeople' people to the database
 
+
 def bench_sqlalchemy(loops, npeople):
     total_dt = 0.0
 
     for loops in range(loops):
         # drop rows created by the previous benchmark
-        session.query(Person).delete(synchronize_session=False)
-        session.query(Address).delete(synchronize_session=False)
+        session.execute(
+            delete(Person), execution_options={"synchronize_session": False}
+        )
+        session.execute(
+            delete(Address), execution_options={"synchronize_session": False}
+        )
 
         # Run the benchmark once
         t0 = pyperf.perf_counter()
@@ -73,15 +80,15 @@ def bench_sqlalchemy(loops, npeople):
             session.commit()
 
             # Insert an Address in the address table
-            new_address = Address(post_code='%05i' % i, person=new_person)
+            new_address = Address(post_code="%05i" % i, person=new_person)
             session.add(new_address)
             session.commit()
 
-        # do 100 queries per insert
+        # do 'npeople' queries
         for i in range(npeople):
-            session.query(Person).all()
+            session.scalars(select(Person)).all()
 
-        total_dt += (pyperf.perf_counter() - t0)
+        total_dt += pyperf.perf_counter() - t0
 
     return total_dt
 
@@ -92,11 +99,10 @@ def add_cmdline_args(cmd, args):
 
 if __name__ == "__main__":
     runner = pyperf.Runner(add_cmdline_args=add_cmdline_args)
-    runner.metadata['description'] = ("SQLAlchemy Declarative benchmark "
-                                      "using SQLite")
-    runner.argparser.add_argument("--rows", type=int, default=100,
-                                  help="Number of rows (default: 100)")
+    runner.metadata["description"] = "SQLAlchemy Declarative benchmark using SQLite"
+    runner.argparser.add_argument(
+        "--rows", type=int, default=100, help="Number of rows (default: 100)"
+    )
 
     args = runner.parse_args()
-    runner.bench_time_func('sqlalchemy_declarative', bench_sqlalchemy,
-                           args.rows)
+    runner.bench_time_func("sqlalchemy_declarative", bench_sqlalchemy, args.rows)

pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/requirements.txt

@@ -1,2 +1 @@
-greenlet==3.2.4
-sqlalchemy==1.4.19
+sqlalchemy==2.0.54

pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/run_benchmark.py

@@ -1,26 +1,40 @@
 import pyperf
-
-from sqlalchemy import Column, ForeignKey, Integer, String, Table, MetaData
+from sqlalchemy import (
+    Column,
+    ForeignKey,
+    Integer,
+    MetaData,
+    String,
+    Table,
+    create_engine,
+    delete,
+    insert,
+    select,
+)
 from sqlalchemy.orm import sessionmaker
-from sqlalchemy import create_engine
-
 
 metadata = MetaData()
 
-Person = Table('person', metadata,
-               Column('id', Integer, primary_key=True),
-               Column('name', String(250), nullable=False))
-
-Address = Table('address', metadata,
-                Column('id', Integer, primary_key=True),
-                Column('street_name', String(250)),
-                Column('street_number', String(250)),
-                Column('post_code', String(250), nullable=False),
-                Column('person_id', Integer, ForeignKey('person.id')))
+Person = Table(
+    "person",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("name", String(250), nullable=False),
+)
+
+Address = Table(
+    "address",
+    metadata,
+    Column("id", Integer, primary_key=True),
+    Column("street_name", String(250)),
+    Column("street_number", String(250)),
+    Column("post_code", String(250), nullable=False),
+    Column("person_id", Integer, ForeignKey("person.id")),
+)
 
 # Create an engine that stores data in the local directory's
 # sqlalchemy_example.db file.
-engine = create_engine('sqlite://')
+engine = create_engine("sqlite://")
 
 # Create all tables in the engine. This is equivalent to "Create Table"
 # statements in raw SQL.
@@ -48,30 +62,26 @@ def bench_sqlalchemy(loops, npeople):
 
     for loops in range(loops):
         # drop rows created by the previous benchmark
-        cur = Person.delete()
-        cur.execute()
-
-        cur = Address.delete()
-        cur.execute()
+        session.execute(delete(Person))
+        session.execute(delete(Address))
 
         # Run the benchmark once
         t0 = pyperf.perf_counter()
 
         for i in range(npeople):
             # Insert a Person in the person table
-            new_person = Person.insert()
-            new_person.execute(name="name %i" % i)
+            new_person = insert(Person).values(name="name %i" % i)
+            session.execute(new_person)
 
             # Insert an Address in the address table
-            new_address = Address.insert()
-            new_address.execute(post_code='%05i' % i)
+            new_address = insert(Address).values(post_code="%05i" % i)
+            session.execute(new_address)
 
         # do 'npeople' queries per insert
         for i in range(npeople):
-            cur = Person.select()
-            cur.execute()
+            session.execute(select(Person))
 
-        total_dt += (pyperf.perf_counter() - t0)
+        total_dt += pyperf.perf_counter() - t0
 
     return total_dt
 
@@ -82,11 +92,10 @@ def add_cmdline_args(cmd, args):
 
 if __name__ == "__main__":
     runner = pyperf.Runner(add_cmdline_args=add_cmdline_args)
-    runner.metadata['description'] = ("SQLAlchemy Imperative benchmark "
-                                      "using SQLite")
-    runner.argparser.add_argument("--rows", type=int, default=100,
-                                  help="Number of rows (default: 100)")
+    runner.metadata["description"] = "SQLAlchemy Imperative benchmark using SQLite"
+    runner.argparser.add_argument(
+        "--rows", type=int, default=100, help="Number of rows (default: 100)"
+    )
 
     args = runner.parse_args()
-    runner.bench_time_func('sqlalchemy_imperative',
-                           bench_sqlalchemy, args.rows)
+    runner.bench_time_func("sqlalchemy_imperative", bench_sqlalchemy, args.rows)