python orm 能否实现类似于SQL语句中的like"%"表示所有的效果？

Posted 2023-05-14

环境介绍：
id和pid都是通过用户界面输入的，正常情况下如果客户两个都输入的话，sql语句中的
input_id = request.POST.get('post_id')
input_pid = request.POST.get('post_pid')
where id = "%s" and pid = “%s”%(input_id,input_pid)

但是有一种情况下，用户可能有一个变量不输入表示查询所有，我用sql实现的时候就可以用sql中的like方法实现，比如：
input_id = request.POST.get('post_id') #input id如果没有输入我可以直接用%代替，这样就实现了不去做判断，用户是否输入下xxx变量，我再去更改sql语句的麻烦
input_pid = request.POST.get('post_pid')
where client_id like "%s" and isp_id like "%s" %(input_id,input_pid)
SQL语句Like "%"表示所有

数据库查询环境：
django orm环境：
input_id = request.POST.get('post_id')
input_pid = request.POST.get('post_pid')
ret = models.ip_list.objects.filter(id=post_id,pid=post_pid)
用户有一种情况下只输入了一种变量，我需要去做判断，如果有很多种用户输入条件时，那个判断是指数级增加。

参考技术A 使用 if ... else ...表达式
input_id = request.POST.get('post_id')
input_pid = request.POST.get('post_pid')
where id like "\%%s" and pid like "\%%s”%(input_id if input_id else "",input_pid if input_pid else '')

python之ORM的使用

---恢复内容开始---

1.ORM是什么？

orm就是对象映射关系程序，简单来世就是类似于python这种面向对象的程序来说一切接对象，它可以将我们平常所使用的SQL语句，转换成可以使用对象模型进行操作的模块，而不是直接使用SQL语句。

2.sqlalchemy的安装

在python中这个模块时最有名的，使用的人较多。

 通过PIP 安装：

　　

1 pip install SQLALchemy<br><br>pip install pymysql 
2  #由于mysqldb依然不支持py3，所以这里我们用pymysql与sqlalchemy交互

3.sqlalchemy基本使用

最开始我们创建一张数据表如下：

1 CREATE TABLE user (
2     id INTEGER NOT NULL AUTO_INCREMENT, 
3     name VARCHAR(32), 
4     password VARCHAR(64), 
5     PRIMARY KEY (id)
6 )

这是最简单的SQL表如果再加上外键什么的，那就更加复杂了，所以就有了我们的sqlalchemy!

 1 import sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String
 5  
 6 engine = create_engine("mysql+pymysql://root:[email protected]/testdb",
 7                                     encoding=‘utf-8‘, echo=True)
 8  
 9  
10 Base = declarative_base() #生成orm基类
11  
12 class User(Base):
13     __tablename__ = ‘user‘ #表名
14     id = Column(Integer, primary_key=True)
15     name = Column(String(32))
16     password = Column(String(64))
17  
18 Base.metadata.create_all(engine) #创建表结构

看到这里你可能感觉不出什么，那是因为现在实现的功能比较简单，但是当功能复杂以后，你就会发现这个东西的好处。

除上面的创建之外，还有一种创建表的方式，虽不常用，但还是看看吧

 

---恢复内容结束---

1.ORM是什么？

orm就是对象映射关系程序，简单来世就是类似于python这种面向对象的程序来说一切接对象，它可以将我们平常所使用的SQL语句，转换成可以使用对象模型进行操作的模块，而不是直接使用SQL语句。

2.sqlalchemy的安装

在python中这个模块时最有名的，使用的人较多。

 通过PIP 安装：

　　

1 pip install SQLALchemy<br><br>pip install pymysql 
2  #由于mysqldb依然不支持py3，所以这里我们用pymysql与sqlalchemy交互

3.sqlalchemy基本使用

最开始我们创建一张数据表如下：

1 CREATE TABLE user (
2     id INTEGER NOT NULL AUTO_INCREMENT, 
3     name VARCHAR(32), 
4     password VARCHAR(64), 
5     PRIMARY KEY (id)
6 )

这是最简单的SQL表如果再加上外键什么的，那就更加复杂了，所以就有了我们的sqlalchemy!

 1 import sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String
 5  
 6 engine = create_engine("mysql+pymysql://root:[email protected]/testdb",
 7                                     encoding=‘utf-8‘, echo=True)
 8  
 9  
10 Base = declarative_base() #生成orm基类
11  
12 class User(Base):
13     __tablename__ = ‘user‘ #表名
14     id = Column(Integer, primary_key=True)
15     name = Column(String(32))
16     password = Column(String(64))
17  
18 Base.metadata.create_all(engine) #创建表结构

看到这里你可能感觉不出什么，那是因为现在实现的功能比较简单，但是当功能复杂以后，你就会发现这个东西的好处。

这里还有一种创建表的方式，但是不常用

 1 from sqlalchemy import Table, MetaData, Column, Integer, String, ForeignKey
 2 from sqlalchemy.orm import mapper
 3  
 4 metadata = MetaData()
 5  
 6 user = Table(‘user‘, metadata,
 7             Column(‘id‘, Integer, primary_key=True),
 8             Column(‘name‘, String(50)),
 9             Column(‘fullname‘, String(50)),
10             Column(‘password‘, String(12))
11         )
12  
13 class User(object):
14     def __init__(self, name, fullname, password):
15         self.name = name
16         self.fullname = fullname
17         self.password = password
18  
19 mapper(User, user) #the table metadata is created separately with the Table construct, then associated with the User class via the mapper() function

其实第一种就是第二种创建表方式的一种封装

现在来创建一条数据试试

Session_class = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class() #生成session实例
 
 
user_obj = User(name="alex",password="alex3714") #生成你要创建的数据对象
print(user_obj.name,user_obj.id)  #此时还没创建对象呢，不信你打印一下id发现还是None
 
Session.add(user_obj) #把要创建的数据对象添加到这个session里， 一会统一创建
print(user_obj.name,user_obj.id) #此时也依然还没创建
 
Session.commit() #现此才统一提交，创建数据

 

查询：

1 my_user = Session.query(User).filter_by(name="alex").first()
2 print(my_user)

 

他输出的是：

<__main__.User object at 0x105b4ba90>

他返回的是一个对象，所以是这个样子，你可以通过调出他里面对象的方式来显示。

1 print(my_user.id,my_user.name,my_user.password)
2  
3 输出
4 1 alex alex3714

 不过刚才上面的显示的内存对象对址你是没办法分清返回的是什么数据的，除非打印具体字段看一下，如果想让它变的可读，只需在定义表的类下面加上这样的代码

def __repr__(self):
    return "<User(name=‘%s‘,  password=‘%s‘)>" % (
        self.name, self.password)

修改

1 my_user = Session.query(User).filter_by(name="alex").first()
2  
3 my_user.name = "Alex Li"
4  
5 Session.commit()

回滚

 1 my_user = Session.query(User).filter_by(id=1).first()
 2 my_user.name = "Jack"
 3  
 4  
 5 fake_user = User(name=‘Rain‘, password=‘12345‘)
 6 Session.add(fake_user)
 7  
 8 print(Session.query(User).filter(User.name.in_([‘Jack‘,‘rain‘])).all() )  #这时看session里有你刚添加和修改的数据
 9  
10 Session.rollback() #此时你rollback一下
11  
12 print(Session.query(User).filter(User.name.in_([‘Jack‘,‘rain‘])).all() ) #再查就发现刚才添加的数据没有了。
13  
14 # Session
15 # Session.commit()

获取所有数据

print(Session.query(User.name,User.id).all() )

多条件查询

1 objs = Session.query(User).filter(User.id>0).filter(User.id<7).all()

上面2个filter的关系相当于 user.id >1 AND user.id <7 的效果

统计和分组

Session.query(User).filter(User.name.like("Ra%")).count()

分组

from sqlalchemy import func
print(Session.query(func.count(User.name),User.name).group_by(User.name).all() )

输出为：

[(1, ‘Jack‘), (2, ‘Rain‘)]

 

外键关联

创建一个address表，跟user表关联

 1 from sqlalchemy import ForeignKey
 2 from sqlalchemy.orm import relationship
 3  
 4 class Address(Base):
 5     __tablename__ = ‘addresses‘
 6     id = Column(Integer, primary_key=True)
 7     email_address = Column(String(32), nullable=False)
 8     user_id = Column(Integer, ForeignKey(‘user.id‘))
 9  
10     user = relationship("User", backref="addresses") #这个nb，允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项
11  
12     def __repr__(self):
13         return "<Address(email_address=‘%s‘)>" % self.email_address

表创建好以后可以反查试试

1 obj = Session.query(User).first()
2 for i in obj.addresses: #通过user对象反查关联的addresses记录
3     print(i)
4  
5 addr_obj = Session.query(Address).first()
6 print(addr_obj.user.name)  #在addr_obj里直接查关联的user表

 

创建关联对象

1 obj = Session.query(User).filter(User.name==‘rain‘).all()[0]
2 print(obj.addresses)
3  
4 obj.addresses = [Address(email_address="[email protected]"), #添加关联对象
5                  Address(email_address="[email protected]")]
6  
7  
8 Session.commit()