SQLAlchmy模块详解

最新推荐文章于 2024-08-22 16:36:43 发布
最新推荐文章于 2024-08-22 16:36:43 发布
阅读量328 收藏 2
点赞数
文章标签： python 数据库
原文链接：http://www.cnblogs.com/phennry/p/5731299.html
版权

   之前写过一篇博客介绍过sqlalchemy的基本用法，本篇博客主要介绍除增删改查以外SQLAlchemy对数据库表的操作，主要内容有单表操作、一对多操作、多对多操作。

一、单表操作

    单表操作的增删改查在上篇博客中已经详细介绍过，这里不再详细介绍，今天主要对数据库查询在详细介绍一下，下面我们先创建表并插入数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#!/usr/bin/env python
# -*- coding: utf-8 -*-
  
from sqlalchemy import and_, or_
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
engine = create_engine( "mysql+pymysql://root:123456@127.0.0.1:3306/mydata" , max_overflow = 5 )
  
Base = declarative_base()
  
class Group(Base):
     __tablename__ = 'group'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     caption = Column(String( 32 ))
  
class User(Base):
     __tablename__ = 'user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     username = Column(String( 32 ))
     group_id = Column(Integer, ForeignKey( 'group.nid' ))
     group = relationship( "Group" ,backref = 'uuu' )  #跟Group表建立关系，方便查询,常和ForeignKey在一起使用
  
def init_table():
     """
     创建表，调用Base类的子类
     :return:
     """
     Base.metadata.create_all(engine)
  
def drop_table():
     Base.metadata.drop_all(engine)
  
init_table()
Session = sessionmaker(bind = engine)
session = Session()
  
# 单表操作：
session.add(Group(caption = 'dba' ))   #往组里添加数据
session.add(Group(caption = 'dddd' ))
session.commit()
  
session.add_all([
     User(username = 'jack1' ,group_id = 1 ),
     User(username = 'jack2' ,group_id = 1 ),
     User(username = 'jack1' ,group_id = 2 ),
     User(username = 'jack1' ,group_id = 1 ),
     User(username = 'jack2' ,group_id = 1 ),
])
session.commit()
1，条件查询
1
2
3
4
5
6
7
8
9
#查询用户jack1的nid,filter和filter_by两种书写方式
ret1 = session.query(User.nid). filter (User.username = = 'jack1' ). all ()
print (ret1)
ret2 = session.query(User.nid).filter_by(username = 'jack1' ). all ()
print (ret2)
 
#结果：
[( 1 ,), ( 3 ,), ( 4 ,)]
[( 1 ,), ( 3 ,), ( 4 ,)]
1
2
3
4
5
6
7
8
9
10
11
12
13
#查询用户nid大于1并且username等于jack2的nid
ret1 = session.query(User.nid). filter (User.nid > 1 ,User.username = = 'jack2' ). all ()
print (ret1)
 
#结果：
[( 2 ,), ( 5 ,)]
 
#查询nid在1和3之间username等于jack1的所有信息
ret2 = session.query(User.nid,User.username). filter (User.nid.between( 1 , 3 ),User.username = = 'jack1' ). all ()
print (ret2)
 
#结果：
[( 1 , 'jack1' ), ( 3 , 'jack1' )]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#查询用户nid在1,3,4这个列表里的用户信息
ret = session.query(User.nid,User.username). filter (User.nid.in_([ 1 , 3 , 4 ])). all ()
print (ret)
   
#结果：
[( 1 , 'jack1' ), ( 3 , 'jack1' ), ( 4 , 'jack1' )]
   
#取反，查询用户nid不在1,3,4这个列表里的用户信息
ret1 = session.query(User.nid,User.username). filter (~User.nid.in_([ 1 , 3 , 4 ,])). all ()
print (ret1)
   
#结果：
[( 2 , 'jack2' ), ( 5 , 'jack2' )]
  
#查询username='jack1'的所有信息
ret2 = session.query(User.nid,User.username). filter (
User.nid.in_(session.query(User.nid).filter_by(username = 'jack1' ))). all ()
print (ret2)
  
#结果：
[( 1 , 'jack1' ), ( 3 , 'jack1' ), ( 4 , 'jack1' )]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#查询nid大于3并且username='jack1'的信息
ret = session.query(User.nid,User.username). filter (and_(User.nid > 3 ,User.username = = 'jack1' )). all ()
print (ret)
 
#结果：
[( 4 , 'jack1' )]
 
#查询nid小于2或者username等于jack1的数据
ret = session.query(User.nid,User.username). filter (
or_(User.nid < 2 , User.username = = 'jack1' )). all ()
print (ret)
 
#查询用户nid小于2或者username等于jack1并且nid大于3的信息
ret = session.query(User.nid,User.username). filter (
     or_(User.nid < 2 ,and_(User.username = = 'jack1' , User.nid > 3 ))). all ()
print (ret)
 
#结果：
[( 1 , 'jack1' ), ( 4 , 'jack1' )]
二、通配符
1
2
3
4
5
6
7
8
9
10
11
12
13
#模糊匹配用户名以字母j开头的所有数据
ret = session.query(User.nid,User.username). filter (User.username.like( 'j%' )). all ()
 
#结果：
[( 1 , 'jack1' ), ( 2 , 'jack2' ), ( 3 , 'jack1' ), ( 4 , 'jack1' ), ( 5 , 'jack2' )]
 
#取反
ret1 = session.query(User.nid,User.username). filter (~User.username.like( 'j%' )). all ()
print (ret)
print (ret1)
 
#结果：
[]
三、限制
1
2
3
4
5
ret = session.query(User.nid,User.username)[ 1 : 2 ]
print (ret)
 
#结果：
[( 2 , 'jack2' )]
四、排序
1
2
3
4
5
6
7
8
9
10
11
12
13
#倒序排序
ret = session.query(User.nid,User.username).order_by(User.nid.desc()). all ()
print (ret)  
 
#结果：
[( 5 , 'jack2' ), ( 4 , 'jack1' ), ( 3 , 'jack1' ), ( 2 , 'jack2' ), ( 1 , 'jack1' )]
 
#正序排序
ret1 = session.query(User.nid,User.username).order_by(User.nid.asc()). all ()
print (ret1)
 
#结果：
[( 1 , 'jack1' ), ( 2 , 'jack2' ), ( 3 , 'jack1' ), ( 4 , 'jack1' ), ( 5 , 'jack2' )]
 五、分组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#导入模块
from sqlalchemy.sql import func
  
ret = session.query(User.nid,User.username).group_by(User.nid). all ()
print (ret)
  
#结果：
[( 1 , 'jack1' ), ( 2 , 'jack2' ), ( 3 , 'jack1' ), ( 4 , 'jack1' ), ( 5 , 'jack2' )]
  
ret1 = session.query(
     func. max (User.nid),
     func. sum (User.nid),
     func. min (User.nid),).group_by(User.username). all ()
print (ret1)
  
#结果：
[( 4 , Decimal( '8' ), 1 ), ( 5 , Decimal( '7' ), 2 )]
  
ret2 = session.query(
     func. max (User.nid),
     func. sum (User.nid),
     func. min (User.nid), ).group_by(User.username).having(func. min (User.nid)> 1 ). all ()
print (ret2)
  
#结果：
[( 5 , Decimal( '7' ), 2 )]
 
#打印SQL语句：
from sqlalchemy.sql import func
ret2 = session.query(
     func. max (User.nid),
     func. sum (User.nid),
     func. min (User.nid), ).group_by(User.username).having(func. min (User.nid)> 1 )
print (ret2)
 
#结果：
SELECT max ( "user" .nid) AS max_1, sum ( "user" .nid) AS sum_1, min ( "user" .nid) AS min_1
FROM "user" GROUP BY "user" .username
HAVING min ( "user" .nid) > :min_2
[( 'jack1' , 'dba' ), ( 'jack2' , 'dddd' )]
SELECT "user" .nid AS user_nid, "user" .username AS user_username, "user" .group_id AS user_group_id
FROM "user" LEFT OUTER JOIN "group" ON "group" .nid = "user" .group_id
六、组合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
q1 = session.query(User.username). filter (User.nid > 2 )
q2 = session.query(Group.caption). filter (Group.nid < 2 )
ret = q1.union(q2). all ()
print (ret)
 
#结果：
[( 'jack1' ,), ( 'jack2' ,), ( 'dba' ,)]
 
q1 = session.query(User.username). filter (User.nid > 2 )
q2 = session.query(Group.caption). filter (Group.nid < 2 )
ret = q1.union_all(q2). all ()
print (ret)
 
#结果：
[( 'jack1' ,), ( 'jack1' ,), ( 'jack2' ,), ( 'dba' ,)]

二、一对多操作

    一对多的关系就需要我们外键来进行约束，下面我们来举例来说明一对多进行连表操作。

1，原始方式：通过join方法来进行连表操作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
ret = session.query(User.username,Group.caption). filter (User.nid = = Group.nid). all ()
print (ret)
   
#结果：
[( 'jack1' , 'dba' ), ( 'jack2' , 'dddd' )]
   
#通过join来进行连表操作，加isouter的区别：
sql1 = session.query(User).join(Group,isouter = True )
print (sql1)
   
#结果：
SELECT "user" .nid AS user_nid, "user" .username AS user_username, "user" .group_id AS user_group_id
FROM "user" LEFT OUTER JOIN "group" ON "group" .nid = "user" .group_id
   
sql2 = session.query(User).join(Group)
print (sql2)
   
#结果：
SELECT "user" .nid AS user_nid, "user" .username AS user_username, "user" .group_id AS user_group_id
FROM "user" JOIN "group" ON "group" .nid = "user" .group_id
 
#连表操作
ret = session.query(User.username,Group.caption).join(Group,isouter = True ). filter (Group.caption = = 'dba' ). all ()
print (ret)
 
#结果：
[( 'jack1' , 'dba' ), ( 'jack2' , 'dba' ), ( 'jack1' , 'dba' )]
2，新方式：通过建立relationship的方式
1
2
3
4
5
6
7
#首先在创建表的类中加入relationship字段
class User(Base):
     __tablename__ = 'user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     username = Column(String( 32 ))
     group_id = Column(Integer, ForeignKey( 'group.nid' ))
     group = relationship( "Group" ,backref = 'uuu' )    #跟Group表建立关系，方便查询，backref为虚拟列
正向查询：通过User表查询Group表
1
2
3
4
5
6
7
8
9
10
11
12
13
ret = session.query(User). all ()
for obj in ret:
     #obj代指user表的每一行数据
     #obj.group代指group对象
     print (obj.nid,obj.username,obj.group_id,obj.group_id,obj.group,
           obj.group.nid,obj.group.caption)
 
#结果：
1 jack1 1 1 <__main__.Group object at 0x0000015D762F4630 > 1 dba
2 jack2 1 1 <__main__.Group object at 0x0000015D762F4630 > 1 dba
3 jack1 2 2 <__main__.Group object at 0x0000015D762F47F0 > 2 dddd
4 jack1 1 1 <__main__.Group object at 0x0000015D762F4630 > 1 dba
5 jack2 2 2 <__main__.Group object at 0x0000015D762F47F0 > 2 dddd

反向查询：通过Group表查询User表

1
2
3
4
5
6
7
8
9
obj = session.query(Group). filter (Group.caption = = 'dba' ).first()
print (obj.nid)
print (obj.caption)
print (obj.uuu)
 
#结果：
1
dba
[<__main__.User object at 0x000002606096C5C0 >, <__main__.User object at 0x000002606096C630 >, <__main__.User object at 0x000002606096C6A0 >]

  我们可以看到上面的例子输出的为对象的列表，输出不太友好，为了达到自己想要的结果，我们可以进行自定义返回结果，请看下面代码，加入__repr__函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class User(Base):
     __tablename__ = 'user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     username = Column(String( 32 ))
     group_id = Column(Integer, ForeignKey( 'group.nid' ))
     group = relationship( "Group" ,backref = 'uuu' )  #跟Group表建立关系，方便查询,常和ForeignKey在一起使用
 
     def __repr__( self ):
         """
         自定义返回结果
         :return:
         """
         temp = '%s:%s:%s' % ( self .nid, self .username, self .group_id)
         return temp

三、多对多操作

1，创建表结构并插入信息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
engine = create_engine( "mysql+pymysql://root:123456@127.0.0.1:3306/mydata" , max_overflow = 5 )
 
Base = declarative_base()
 
class Host(Base):
     __tablename__ = 'host'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     hostname = Column(String( 32 ))
     port = Column(String( 32 ))
     ip = Column(String( 32 ))
 
class HostUser(Base):
     __tablename__ = 'host_user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     username = Column(String( 32 ))
 
#使用for循环时，通过正向反向查询
class HostToHostUser(Base):
     __tablename__ = 'host_to_host_user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
 
     host_id = Column(Integer,ForeignKey( 'host.nid' ))
     host_user_id = Column(Integer,ForeignKey( 'host_user.nid' ))
 
 
     host = relationship( "Host" ,backref = 'h' )
     host_user = relationship( "HostUser" ,backref = 'u' )
 
def init_table():
     """
     创建表，调用Base类的子类
     :return:
     """
     Base.metadata.create_all(engine)
 
def drop_table():
     Base.metadata.drop_all(engine)
 
init_table()
Session = sessionmaker(bind = engine)
session = Session()
 
session.add_all([
     Host(hostname = 'c1' ,port = '22' ,ip = '1.1.1.1' ),
     Host(hostname = 'c2' ,port = '22' ,ip = '1.1.1.2' ),
     Host(hostname = 'c3' ,port = '22' ,ip = '1.1.1.3' ),
     Host(hostname = 'c4' ,port = '22' ,ip = '1.1.1.4' ),
     Host(hostname = 'c5' ,port = '22' ,ip = '1.1.1.5' ),
])
session.commit()
 
 
session.add_all([
     HostUser(username = 'root' ),
     HostUser(username = 'db' ),
     HostUser(username = 'nb' ),
     HostUser(username = 'sb' ),
])
session.commit()
 
session.add_all([
     HostToHostUser(host_id = 1 ,host_user_id = 1 ),
     HostToHostUser(host_id = 1 ,host_user_id = 2 ),
     HostToHostUser(host_id = 1 ,host_user_id = 3 ),
     HostToHostUser(host_id = 2 ,host_user_id = 2 ),
     HostToHostUser(host_id = 2 ,host_user_id = 4 ),
     HostToHostUser(host_id = 2 ,host_user_id = 3 ),
])
session.commit()

2，需求：获取主机1中所有的用户

 方法一：通过一步一步取

1
2
3
4
5
6
7
8
9
10
11
12
host_obj = session.query(Host). filter (Host.hostname = = 'c1' ).first()
# #取出host_obj.nid
host_to_host_user = session.query(HostToHostUser.host_user_id). filter (HostToHostUser.host_id = = host_obj.nid). all ()
#
# #因为取出来的结果是[(1,),(2,),(3,)],我们通过内置函数zip来转换成想要的结果
r = zip ( * host_to_host_user)
#
users = session.query(HostUser.username). filter (HostUser.nid.in_( list (r)[ 0 ])). all ()
print (users)
 
#结果：
[( 'root' ,), ( 'db' ,), ( 'nb' ,)]

方法二：通过join的方式

1
2
#通过代码整合的代码，相当复杂
session.query(HostUser.name). filter (HostUser.nid.in_(session.query(HostToHostUser.host_user_id). filter (HostToHostUser.host_id = = session.query(Host.nid). filter (Host.hostname = = 'c1' ))))

方法三：通过建立relationship的方式

 1，对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
engine = create_engine( "mysql+pymysql://root:123456@127.0.0.1:3306/mydata" , max_overflow = 5 )
 
Base = declarative_base()
 
class HostToHostUser(Base):
     __tablename__ = 'host_to_host_user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
 
     host_id = Column(Integer,ForeignKey( 'host.nid' ))
     host_user_id = Column(Integer,ForeignKey( 'host_user.nid' ))
 
class Host(Base):
     __tablename__ = 'host'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     hostname = Column(String( 32 ))
     port = Column(String( 32 ))
     ip = Column(String( 32 ))
     host_user = relationship( 'HostUser' ,secondary = HostToHostUser.__table__,backref = 'h' )
 
# host_user = relationship('HostUser', secondary=lambda: HostToHostUser.__table__, backref='h')
#这里加lambda是因为关系表在下面，可以不加lambda,但是关系表要放上面
 
 
class HostUser(Base):
     __tablename__ = 'host_user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     username = Column(String( 32 ))
 
def init_table():
     """
     创建表，调用Base类的子类
     :return:
     """
     Base.metadata.create_all(engine)
 
def drop_table():
     Base.metadata.drop_all(engine)
 
Session = sessionmaker(bind = engine)
session = Session()
 
host_obj = session.query(Host). filter (Host.hostname = = 'c1' ).first()
print (host_obj.host_user)

2，类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
engine = create_engine( "mysql+pymysql://root:123456@127.0.0.1:3306/mydata" , max_overflow = 5 )
 
Base = declarative_base()
 
class HostToHostUser(Base):
     __tablename__ = 'host_to_host_user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
 
     host_id = Column(Integer,ForeignKey( 'host.nid' ))
     host_user_id = Column(Integer,ForeignKey( 'host_user.nid' ))
 
class Host(Base):
     __tablename__ = 'host'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     hostname = Column(String( 32 ))
     port = Column(String( 32 ))
     ip = Column(String( 32 ))
     host_user = relationship( 'HostUser' ,secondary = HostToHostUser.__table__,backref = 'h' )
 
# host_user = relationship('HostUser', secondary=lambda: HostToHostUser.__table__, backref='h')
#这里加lambda是因为关系表在下面，可以不加lambda,但是关系表要放上面
 
 
class HostUser(Base):
     __tablename__ = 'host_user'
     nid = Column(Integer, primary_key = True ,autoincrement = True )
     username = Column(String( 32 ))
 
def init_table():
     """
     创建表，调用Base类的子类
     :return:
     """
     Base.metadata.create_all(engine)
 
def drop_table():
     Base.metadata.drop_all(engine)
 
Session = sessionmaker(bind = engine)
session = Session()
 
host_obj = session.query(Host). filter (Host.hostname = = 'c1' ).first()
print (host_obj.host_user)

今天SQLALchemy就介绍到这里，更多参考信息请参考：

 

转载于:https://www.cnblogs.com/phennry/p/5731299.html

die8252
关注
【微服务】springboot 多模块打包使用详解
congge
07-25 8547
springboot整合mavem多模块打包详解
python常用库之数据库orm框架之SQLAlchemy
热门推荐
西京刀客
10-08 1万+
SQLAlchemy是一个基于Python实现的SQL工具包和ORM框架,提供了高层抽象来管理数据库交互。
python对象操作数据库—SQLAlchemy的基本介绍与简单使用
weixin_66339667的博客
01-25 3695
SQLAlchemy是一个用于Python的SQL工具和对象关系映射（ORM）库。它允许你通过Python代码来与关系型数据库交互，而不必直接编写SQL语句。
Sql语句执行过程AI化
最新发布
百态老人的博客
08-22 1037
例如，AI Query使用GPT-3模型将自然语言生成SQL查询，而Text2SQL.AI则可以将普通的英语文本转换为复杂的SQL查询。3. 智能助手与对话系统：一些AI工具提供了类似于聊天机器人的功能，允许用户以自然语言提出查询请求，并由AI助手自动生成相应的SQL语句。例如，Ai2sql.io 和Text2SQL.AI等工具可以帮助用户快速构建复杂的SQL查询语句，减少错误率。强化学习中，设计合适的奖励函数是关键。它能够解析用户输入的文本，理解SQL查询和修改的需求，然后自动生成标准的SQL语句。
SQLAlchemy使用笔记一
sdulsj的博客
11-08 508
安装 pip install sqlalchemy 引用 import sqlalchemy print sqlalchemy.__version__ 连接 from sqlclachemy import create_engine # PostgreSQL 默认使用psycopg2 # 默认情况(即使用psycopg2) engine = create_engine('
sqlalchemy常用查询
zhangenter的专栏
03-30 1059
from flask import Flask from flask_sqlalchemy import SQLAlchemy web = Flask(__name__) db = SQLAlchemy(web) db_user_name = 'test' db_password = '123456' db_name = 'school' SQLALCHEMY_DATABASE_URI = "mysql+pymysql://%s:%s@127.0.0.1:3306/%s?charset=utf8mb4"%
SqlAlchenmy基本使用
weixin_30912051的博客
03-16 841
#简单查询 print(session.query(User).all()) print(session.query(User.name, User.fullname).all()) print(session.query(User, User.name).all()) #带条件查询 print(session.qu...
新mplfinance模块详解.zip
04-28
python中调用mpl_finance已经出现警告：WARNING: `mpl_finance` is deprecated。新模块mplfinance从官方介绍的历史版本看是...mplfinance模块详解博客地址：https://blog.csdn.net/wuwei_201/article/details/105815728
Python命令行解析模块详解
01-20
本文研究的主要是Python命令行解析模块的相关内容，具体如下。 Python命令行常见的解析器有两种，一是getopt模块，二是argparse模块。下面就解读下这两种解析器。 getopt模块 这个模块可以帮助脚本解析命令行参数...
Python自动化运维之IP地址处理模块详解
01-20
实用的IP地址处理模块IPy 在IP地址规划中，涉及到计算大量的IP地址，包括网段、网络掩码、广播地址、子网数、IP类型等 别担心，Ipy模块拯救你。Ipy模块可以很好的辅助我们高效的完成IP的规划工作。 功能：辅助我们...
正则表达式+Python re模块详解
01-19
正则表达式（Regluar Expressions）又称规则表达式，在代码中常简写为REs，regexes或...re模块为这些操作分别提供了模块级别的函数以及相关类的封装。 正则表达式一些小规则  ①元字符  ②量词 ③贪婪和非贪婪匹配
SQLaL-开源
06-29
SQLaL 是一个 PHP SQL 抽象层，旨在简化 PHP 应用程序中 MySQL 数据库的使用。 它提供了一个非常简单易用的类来访问、查询和读取 MySQL 数据库的结果。
sqlalchemy和moke生成实体类（一）
qq_63401240的博客
03-20 689
sqlalchemy快速生成代码
SQL表的基本操作
w156236的博客
10-04 148
有时在实践中部分数据因为未填或其他原因显示为null，为了便于计算，可以通过将计算中null所在列名更改格式为 IFNULL(含null的列名,0) 将null赋值为0或其他数值。null是空指针不占内存，而0和'null'和' '是整数和字符串，不相等。如果表名列名或数据库名与关键字重复，可用``着重号将关键字着重为普通名称。null空值参与的任何运算结果都是null，不论是加减乘除还是比较大小。可将查询列的所有行前加入一列指定常数，可为字符串；(列1未去重，列2去重导致的行不对齐)
SQL All运算符/all函数
qq_39768495的博客
08-23 7281
在本教程中，您将了解SQL ALL运算符以及如何使用它来将值与一组值进行比较。 1. SQL ALL运算符简介 SQL ALL运算符是一个逻辑运算符，它将单个值与子查询返回的单列值集进行比较。 以下是SQL ALL运算符的语法： WHERE column_name comparison_operator ALL (subquery) SQL SQL ALL运算符必须以比较运算符开头，例如：>，>=，<，<=，<>，=，后跟子查询。 某些数据库系统(如Ora
SQLAlchemy
weixin_33877885的博客
02-20 1171
SQLAlchemy 1.介绍 SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。 pip3 install sqlalchemy 组成部分： Engine，框架的引擎 Connection Pooling ，数据库连接池 Dialect，选择连...
SQLAlchemy （一）
weixin_36870411的博客
06-23 862
SQLAlchemy 库用于与各种数据库交互，你可使用一种类似于 Python 类和语句的方式创建数据模型和查询，SQLAlchemy 可用于连接大多数常见的数据库，比如 Postgres、MySQL、SQLite、Oracle 等：SQLAlchemy 提供了两种主要的使用模式——SQLAlchemy Core和SQLAlchemy ORM，这为我们使用SQLAlchemy提供了很大的灵活性，两种方式可以单独使用也可以组合使用。SQLAlchemy Core 提供了连接数据库，操作数据的相关组件...
sqlalchemy ^1.4异步操作指南
chise_
02-17 6168
目录概述基本的操作方式查询基本查询级联查询预加载字表联合查询查询函数func 概述 本文章主要用于sqlalalchemy 2.0系列操作数据库风格的数据库操作指南。 本文主要分为两类，查询，删除，杂项（主要为删除等等） 另：本文主要为orm的操作方式，core的操作方式可以参考。 基本的操作方式 基本操作方式如下(这只是其中一种操作方式，)： from sqlalchemy.orm import sessionmaker from sqlalchemy.ext.asyncio import AsyncSe
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值