diff --git a/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/requirements.txt b/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/requirements.txt index c9434339..536a7b40 100644 --- a/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/requirements.txt +++ b/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/requirements.txt @@ -1,2 +1 @@ -greenlet==3.2.4 -sqlalchemy==1.4.19 +sqlalchemy==2.0.54 diff --git a/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/run_benchmark.py b/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/run_benchmark.py index a977775a..5e891c2a 100644 --- a/pyperformance/data-files/benchmarks/bm_sqlalchemy_declarative/run_benchmark.py +++ b/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) diff --git a/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/requirements.txt b/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/requirements.txt index c9434339..536a7b40 100644 --- a/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/requirements.txt +++ b/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/requirements.txt @@ -1,2 +1 @@ -greenlet==3.2.4 -sqlalchemy==1.4.19 +sqlalchemy==2.0.54 diff --git a/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/run_benchmark.py b/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/run_benchmark.py index b2fe89fa..2a5129aa 100644 --- a/pyperformance/data-files/benchmarks/bm_sqlalchemy_imperative/run_benchmark.py +++ b/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)