{"id":20290,"date":"2022-10-03T04:54:13","date_gmt":"2022-10-03T11:54:13","guid":{"rendered":"https:\/\/coderpad.io\/?p=20290"},"modified":"2023-06-05T14:03:29","modified_gmt":"2023-06-05T21:03:29","slug":"sqlalchemy-with-postgresql","status":"publish","type":"post","link":"https:\/\/coderpad.io\/blog\/development\/sqlalchemy-with-postgresql\/","title":{"rendered":"How to Interact with Databases using SQLAlchemy with PostgreSQL"},"content":{"rendered":"\n

Databases can be accessed in Python through a database connector where you can write SQL queries as you do in a SQL client. Writing these queries can be complex and error-prone\u2013especially when you are using a language like Python where all data you deal with are objects or relations between objects<\/a>.<\/p>\n\n\n\n

Writing queries just like you write objects makes connecting to databases really easy. You can do that by using an ORM<\/a> (Object Relational Mapping) tool like SQLAlchemy ORM. SQLAlchemy<\/a> is a Python toolkit and ORM that helps you write SQL in a flexible way. One way to do so is to write SQL in an object-oriented paradigm.<\/p>\n\n\n\n

Another useful feature of using an ORM, in general, is that it adds guardrails to a database. That\u2019s because schema relationships<\/a> are enforced because relationships, as mentioned above, are treated as objects. For example, if you have a relationship between two tables and you define a foreign key in a table to refer to the other, this predefined schema won\u2019t allow anyone to break away from it.<\/p>\n\n\n\n

SQLAlchemy has two components:<\/p>\n\n\n\n

    \n
  1. SQLAlchemy Core – which is similar to traditional SQL. It views your data in a schema-centric<\/a> view.<\/li>\n\n\n\n
  2. SQLAlchemy ORM – which provides a high-level abstraction to write SQL queries in Python objects<\/a>, and this is our focus in this tutorial.<\/li>\n<\/ol>\n\n\n\n

    Using SQLAlchemy ORM will make you more productive because it abstracts many details of the low-level SQL queries. This tutorial’s goal is to give you insights into how to interact with databases and, namely, access a PostgreSQL database engine in Python using the SQLAlchemy ORM.<\/p>\n\n\n\n

    \n

    \u2705 You can use the CoderPad sandbox at the bottom of this page<\/a> or as a new browser window<\/a> to run the code in this tutorial \u2014 we’ve already installed the SQLAlchemy package and imported the required dependencies for you!<\/p>\n<\/blockquote>\n\n\n\n

    Install SQLAlchemy and psycopg2<\/strong><\/h2>\n\n\n\n

    If you’re using your own IDE for this tutorial, you’ll need to install sqlalchemy<\/code> library to use the ORM, and psycopg2<\/code> driver to access the PostgreSQL database using the following pip command:<\/p>\n\n\n

    pip install sqlalchemy psycopg2<\/code><\/span><\/pre>\n\n\n
    However, you don’t need to install these libraries if you’re using CoderPad sandbox as they both are already installed.<\/p>\n\n\n\n
    Connect to the database<\/strong><\/h2>\n\n\n\n
    Now, you’re ready to create the database engine using the following:<\/p>\n\n\n
    from<\/span> sqlalchemy import<\/span> create_engine\nfrom<\/span> sqlalchemy.engine import<\/span> URL\n\n\nurl = URL.create(\n    drivername=\"postgresql\"<\/span>,\n    username=\"coderpad\"<\/span>,\n    host=\"\/tmp\/postgresql\/socket\"<\/span>,\n    database=\"coderpad\"<\/span>\n)\n\nengine = create_engine(url)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Note that the engine instance here is just the starting point to the SQLAlchemy application. There is no connection to the PostgreSQL database yet.<\/p>\n\n\n\n
    If you want to experiment with that, make sure to replace the params values with your own. You may also need to add password<\/code> and port<\/code> parameters if you don’t want the default values assigned to them.<\/p>\n\n\n\n
    As you can see in the url<\/code> object above, the username is coderpad<\/code> the hostname is \/tmp\/postgresql\/socket<\/code> (which looks like a localhost<\/code> on a CoderPad instance), and coderpad<\/code> is the database that we will connect to.<\/p>\n\n\n\n
    To actually connect to the coderpad<\/code> database, you need to use the connect<\/code> method, like this:<\/p>\n\n\n
    ...\nconnection = engine.connect()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Define the schema<\/strong><\/h2>\n\n\n\n
    Defining a schema in SQLAlchemy ORM follows the same pattern as defining a native Python object. You create a class that inherits from a base class called declarative_base<\/code>. <\/p>\n\n\n\n
    When you instantiate a base class, a metaclass is given to it that creates a Table object. Hence, a table mapper to the database is created based on the information provided<\/a> declaratively in the class and any subclass of the class. Didn\u2019t follow that? Don\u2019t worry \u2013 you\u2019ll see what I mean in the example below. <\/p>\n\n\n\n
    Now, define a table with the following:<\/p>\n\n\n
    from<\/span> sqlalchemy import<\/span> Column, Integer, String, DateTime, Text\nfrom<\/span> sqlalchemy.orm import<\/span> declarative_base\nfrom<\/span> datetime import<\/span> datetime\n\nBase = declarative_base()\n\nclass<\/span> Article<\/span>(Base)<\/span>:<\/span>\n\u00a0 \u00a0 __tablename__ = 'articles'<\/span>\n\n\u00a0 \u00a0 id = Column(Integer(), primary_key=True<\/span>)\n\u00a0 \u00a0 slug = Column(String(100<\/span>), nullable=False<\/span>, unique=True<\/span>)\n\u00a0 \u00a0 title = Column(String(100<\/span>), nullable=False<\/span>)\n\u00a0 \u00a0 created_on = Column(DateTime(), default=datetime.now)\n\u00a0 \u00a0 updated_on = Column(DateTime(), default=datetime.now, onupdate=datetime.now)\n\u00a0 \u00a0 content = Column(Text)\n\u00a0 \u00a0 author_id = Column(Integer(), ForeignKey('authors.id'<\/span>))<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    The Base<\/code> object is an instance of the declarative_base()<\/code> function as we discussed and the Article<\/code> class inherits from it. The Article<\/code> class is what you can use to access the articles<\/code> table. This table has six columns, each defined as attributes to the class with the associated parameters.<\/p>\n\n\n\n
    Notes:<\/p>\n\n\n\n
    The url<\/code> passed to the sqlalchemy.create_engine()<\/code> function<\/a> is created using the sqlalchemy.engine.URL.create()<\/code> function<\/a> which has the drivername<\/code>, username<\/code>, host<\/code>, and database<\/code> parameters.<\/p>\n\n\n\n