SQLAlchemy中常用的查询方法[示例学习]

SQLAlchemy 是一个强大的 Python ORM（对象关系映射）工具，它提供了多种方法来执行数据库查询操作。以下是 SQLAlchemy 中常用的查询方法的总结：

• session.query()：使用 session.query(Model) 来创建一个查询对象，此中 Model 是你要查询的数据库模型类。
  
• filter()：在查询对象上使用 filter() 方法可以添加过滤条件，比方 filter(Model.column == value)。
  
• all()：使用 all() 方法可以获取查询的所有效果，并以列表的形式返回。
  
• first()：使用 first() 方法可以获取查询效果的第一条记载。
  
• get()：使用 get(primary_key_value) 方法可以根据主键值直接获取相应的记载。
  
• filter_by()：使用 filter_by(column=value) 方法可以根据指定列的数值进行过滤。
  
• join()：使用 join() 方法可以进行表的内毗连查询。
  
• outerjoin()：使用 outerjoin() 方法可以进行表的外毗连查询。
  
• group_by()：使用 group_by() 方法可以按指定列分组查询。
  
• order_by()：使用 order_by() 方法可以对查询效果进行排序。
  
• count()：使用 count() 方法可以统计查询效果的数量。
  
• delete()：使用 delete() 方法可以删除满足条件的记载。
  
• update()：使用 update() 方法可以更新满足条件的记载。
  

1. from sqlalchemy.orm import declarative_base,sessionmaker
2. from sqlalchemy import create_engine, ForeignKey
4. from sqlalchemy import Column, Integer, String
6. Base = declarative_base()
8. class User(Base):
9.     __tablename__ = 'users'
10.    
11.     id = Column(Integer, primary_key=True)
12.     name = Column(String)
13.     age = Column(Integer)
15. class Address(Base):
16.     __tablename__ = 'addresses'
17.    
18.     id = Column(Integer, primary_key=True)
19.     user_id = Column(Integer, ForeignKey('users.id'))
20.     street = Column(String)
21.     city = Column(String)
23. # 创建数据库连接
24. engine = create_engine('sqlite:///users_addresses_example.db')
25. Base.metadata.create_all(engine)
27. # 创建会话
28. Session = sessionmaker(bind=engine)
29. session = Session()
31. # 清空 User 表数据
32. session.query(User).delete()
33. session.commit()
35. # 清空 Address 表数据
36. session.query(Address).delete()
37. session.commit()
39. # 插入数据到 User 表
40. user1 = User(name='Alice', age=25)
41. user2 = User(name='Bob', age=30)
42. user3 = User(name='Charlie', age=22)
43. user4 = User(name='pemp', age=34)
44. user5 = User(name='pita', age=39)
46. session.add_all([user1, user2, user3, user4, user5])
47. session.commit()
49. # 插入数据到 Address 表
50. address1 = Address(user_id=user1.id, street='123 Main St', city='New York')
51. address2 = Address(user_id=user2.id, street='456 Park Ave', city='Los Angeles')
52. address3 = Address(user_id=user3.id, street='789 Elm St', city='Chicago')
54. session.add_all([address1, address2, address3])
55. session.commit()
57. # 进行表的联合查询
58. result = session.query(User, Address).join(Address, User.id == Address.user_id).all()
60. for user, address in result:
61.     print(f"User: {user.name}, Age: {user.age}, Address: {address.street}, {address.city}")
63. print('*'*40)
65. from sqlalchemy import and_
67. # 进行表的外连接查询
68. # outerjoin外连接查询将返回左表User的所有记录，以及右表Address 表中与左表记录关联的数据，如果没有匹配的记录，则右表数据部分为 NULL。
69. # result = session.query(User.id, Address.id).outerjoin(Address, User.id == Address.user_id).all()
71. # # 找出没有关联的记录
72. # unassociated_records = [(user_id, address_id) for user_id, address_id in result if address_id is None]
74. # print("User 和 Address 表中没有关联的 ID：")
75. # for user_id, _ in unassociated_records:
76. #     print(f"独立User ID: {user_id}")
78. # 进行表的外连接查询
79. result = session.query(User, Address).outerjoin(Address, User.id == Address.user_id).all()
81. for user, address in result:
82.     if address is None:
83.         print(f"独立User: {user.name}, Age: {user.age}, Address: None")
84.     else:
85.         print(f"User(关联ID): {user.name}, Age: {user.age}, Address: {address.street}, {address.city}")
87. # 关闭会话
88. session.close()

复制代码

1. from sqlalchemy import create_engine, Column, Integer, String,select
2. from sqlalchemy.orm import sessionmaker, declarative_base
3. from sqlalchemy import func
5. # 创建数据库连接
6. engine = create_engine('sqlite:///users_example.db')
8. Base = declarative_base()
10. # 定义模型类
11. class User(Base):
12.     __tablename__ = 'users'
14.     id = Column(Integer, primary_key=True)
15.     name = Column(String)
16.     age = Column(Integer)
18. # 创建数据表
19. Base.metadata.create_all(engine)
21. # 创建 Session 类
22. Session = sessionmaker(bind=engine)
23. session = Session()
25. # 事先清空数据
26. session.query(User).delete()
27. session.commit()
29. # 插入更多数据
30. users_data = [
31.     {'name': 'Charlie', 'age': 28},
32.     {'name': 'David', 'age': 32},
33.     {'name': 'Eve', 'age': 27},
34.     {'name': 'gemm', 'age': 43},
35.     {'name': 'riyu', 'age': 43}
36. ]
38. for user_data in users_data:
39.     user = User(**user_data)
40.     session.add(user)
41. session.commit()
43. # 查询数据
44. query = session.query(User)
46. # 使用 filter() 方法添加过滤条件
47. result = query.filter(User.age > 25).all()
48. print("年龄大于25的用户：", [(user.name, user.age) for user in result])
50. # 使用 func.group_concat() 函数将同一年龄下的用户名合并成一个字符串
51. result = session.query(User.age, func.group_concat(User.name)).group_by(User.age).all()
52. print("按年龄分组查询：")
53. for age, names in result:
54.     name_list = names.split(',')
55.     print(f"年龄 {age} 的用户有：{', '.join(name_list)}")
58. # # 使用 group_by() 方法按年龄分组查询
59. # result = query.with_entities(User.age, func.group_concat(User.name)).group_by(User.age).all()
60. # print("按年龄分组查询：")
61. # for age, names in result:
62. #     name_list = names.split(',')
63. #     print(f"年龄 {age} 的用户有：{', '.join(name_list)}")
65. # 使用 order_by() 方法对结果进行排序
66. result = query.order_by(User.age).all()
67. print("按年龄排序：", [(user.name, user.age) for user in result])
69. # 统计查询结果的数量
70. count = query.count()
71. print("查询结果的数量：", count)
73. # 删除满足条件的记录
74. session.query(User).filter(User.name == 'Charlie').delete()
75. session.commit()
77. # 更新满足条件的记录
78. session.query(User).filter(User.name == 'David').update({User.age: 35})
79. session.commit()
81. # 执行 SELECT 查询
82. # 使用 select(User) 会创建一个 SELECT 查询，查询的对象是 User 这个表格（模型类）。这意味着你将检索 User 表中的所有列
83. with engine.connect() as connection:
84.     stmt = select(User).where(User.age > 25)
85.     result = connection.execute(stmt)
86.     for row in result:
87.         print(row)

复制代码

---------------
sqlalchemy 中 select 函数的参数可以是一个或多个表达式，用于指定要查询的列。它担当一个可迭代对象作为参数，该可迭代对象包含要选择的列或其他表达式。
以下是 select 函数的基本语法：
select(columns, whereclause=None, from_obj=[], **kwargs)

• columns：要选择的列或其他表达式，可以是一个或多个。select(User模型类)
  
• whereclause：可选参数，用于指定 WHERE 子句中的条件表达式。
  
• from_obj：可选参数，用于指定查询的泉源表（FROM 子句）。
  
• **kwargs：其他可选参数，比方 group_by、having、order_by 等。
  

在使用 select 函数时，你至少必要提供一个 columns 参数来指定要选择的列。其他参数都是可选的，根据实际必要来决定是否使用。
------------------------
session.scalars() 方法是 SQLAlchemy 中用于执行查询并返回标量值（Scalar）的方法。在 ORM 查询中，当你只必要获取一列数据的值而不是整个对象时，可以使用 session.scalars() 方法。 

1. from sqlalchemy import select
3. # 创建一个 SELECT 查询，选择名字为 "spongebob" 或 "sandy" 的用户的 id 列
4. stmt = select(User.id).where(User.name.in_(["spongebob", "sandy"]))
6. # 使用会话执行查询
7. with Session(engine) as session:
8.     # 执行查询并返回标量值
9.     for user_id in session.scalars(stmt):
10.         print(user_id)

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。