Detailed explanation of two methods of Sqlalchemy

Work needs , Yes sqlalchemy, After nearly a month of continuous learning, exploration and practice , Now tidy up , In case there is no place to look for .

sqlalchemy There are two ways , One is session-mapper The way , be called orm The way , The other is native select etc. sql sentence , be called core The way .

In the following explanation, we uniformly encapsulate the related operations of the database in a class .

Let's start with the first ：

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.dialects.mysql import INTEGER, DATETIME, REAL, TEXT, VARCHAR
from sqlalchemy import Table, Column, ForeignKey, MetaData
from sqlalchemy.orm import mapper, sessionmaker
from sqlalchemy import  func
import re
import hashlib
import os, sys
import time, datetime


class SelectData():
    def __init__(self):
        s1     = "mysql+mysqldb://"
        server = "root:[email protected]:3306/test"
        s2     = "?use_unicode=0&charset=utf8"
        connectserver = s1 + server + s2
        self.engine = create_engine(connectserver, encoding = 'utf-8', echo = False)
        self.Base = MetaData()

        self.user= Table(
            'user', self.Base,
             Column('id', INTEGER, primary_key = True),
             Column('name', TEXT)
             Column('passwd', TEXT)
             )
        self.client = Table(
            'client', self.Base,
             Column('id', INTEGER, primary_key = True),
             Column('name', TEXT),
             Column('id_user', INTEGER),
             Column('reserved_int', INTEGER),
             Column('reserved_varchar', VARCHAR(200))
             )
	self.Base.create_all(self.engine)#create_all It can automatically detect whether the table has been established , Very convenient 
        self.Session = sessionmaker() # Created a customized  Session class 
        self.Session.configure(bind = self.engine)  # Associate the created database connection to this session

The following function shows the query insertion update of a single table ：

def insert_function(self):
    session = self.Session()
    class User(object): pass
    mapper(User, self.user)
    class Client(object): pass
    mapper(Client, self.client)
    
    #select The way ：
    ret = session.query(User).filter(User.name == "admin").first()
    if ret is None:
        # Add new fields 
        user = User()
        user.name = "admin"
        user.passwd = CountMd5("123456")# here CountMd5() It's a calculation written by myself md5 The value of the function 
        session.add(user)
        session.flush()
        #session.commit()
        # Get the self incrementing primary key of the data just inserted id
        id_usr = user.id
    else:
        id_usr = ret.id
    
    ret2 = session.query(Client).filter_by(id_user = id_usr).first()
    if ret2 is None:
        client = Client()
        client.name = "Chocolate"
        client.id_user = id_usr
        client.session.add(client)
        session.flush()
        session.commit()
    else:
        # Use update:
        session.query(Client).filter_by(id_user = id_usr).update({"name": "Chocolate", "id_user":id_usr})   
        session.flush()
        session.commit()
        session.close()

The following is multi table joint query ：

# Multi table joint query 
def testfun2(self, partname, pageindex):
    session = self.Session()
    class User(object): pass
    mapper(User, self.user)
    class Client(object): pass
    mapper(Client, self.client)

    pageval = (pageindex - 1) * 10
    # One of them is like Usage of , One is to show only a 10 strip 
    ret = self.session.query(User)\
            .join(Client, Client.id_user == User.id )\
            .filter(User.name.like('%' + partname + '%'))\
            .offset().limit(10).all()
    if ret is None:
        return None
    else:
        for k in ret:
            print k.name, k.passwd
    session.close()

The following is the usage of deleting the contents of the table :

# Delete all contents of the table , Don't delete the table 
def delete_func(self):
    session = self.Session()
    class User(object): pass
    mapper(User, self.user)
    class Client(object): pass
    mapper(Client, self.client)
    session.query(Client).delete()
    session.query(User).delete()
    session.commit()
    session.close()

Above is orm The way of the , What we should pay special attention to in this way is ,session The problem of , because session It has a valid period , If we put session stay init The function is made into a global variable self.session, Then the database will update the inserted value in real time, which cannot be queried , therefore , about session The attitude of , We use and then build , Close manually after use .

Then let's talk about the second way ,core The way ：

The above table building part is the same , It's just that after the table is built session Replace that piece with ：

self.Base.create_all(self.engine)
self.conn = self.engine.connect()

Define a function to close the database connection ：

def close(self):
        self.conn.close()

Here are some simple basic usage ：

Contains the query , Insert and update .

def resetpwd(self, passwdm):
        sel = select([self.user]).where(self.user.c.name == "admin")
        ret = self.conn.execute(sel).fetchone()
        if ret is None:
            ins = self.user.insert().values(name = "admin", passwd = passwdm)
            self.conn.execute(ins)
        else:
            updpwd = self.user.update().values(name = "admin", passwd = passwdm).where(self.user.c.name == "admin")
            self.conn.execute(updpwd)

execute automatically commit, We don't have to do it manually . such core The way we should pay attention to is that there is a .c, Such as self.user.c.name, I don't know why there is this c, Look at the use cases on the official website , If you don't add it, it's not correct . So surrender to authority . The most important thing is to solve the problem .

That's all . I hope you can make progress together ！

Reprint an article , Please indicate the source .