SQLAlchemy

SQLAlchemy安裝

1. 安裝  
2. pip install sqlalchemy -i https://pypi.douban.com/simple  
3. 連接的時候依賴pymysql  

通過SQLAlchemy連接資料庫

1. from sqlalchemy import create_engine  
2.         
3. # 資料庫的配置變數  
4. HOSTNAME = '127.0.0.1'  
5. PORT     = '3306'  
6. DATABASE = 'xt_flask'  
7. USERNAME = 'root'  
8. PASSWORD = 'root'  
9. DB_URI = 'mysql+mysqldb://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)  
10.         
11. # 創建資料庫引擎  
12. engine = create_engine(DB_URI)  
13.         
14. #創建連接  
15. with engine.connect() as con:  
16.     rs = con.execute('SELECT 1')  
17.     print rs.fetchone()  
18.         
19. 首先從sqlalchemy中匯入create_engine，用這個函式來創建引擎，然后用engine.connect()來連接資料庫，其中一個比較重要的一點是，通過create_engine函式的時候，需要傳遞一個滿足某種格式的字串，對這個字串的格式來進行解釋：  
20.         
21. dialect+driver://username:password@host:port/database  
22. dialect是資料庫的實作，比如MySQL、PostgreSQL、SQLite，并且轉換成小寫，driver是Python對應的驅動，如果不指定，會選擇默認的驅動，比如MySQL的默認驅動是MySQLdb，username是連接資料庫的用戶名，password是連接資料庫的密碼，host是連接資料庫的域名，port是資料庫監聽的埠號，database是連接哪個資料庫的名字，  
23.         
24. 如果以上輸出了1，說明SQLAlchemy能成功連接到資料庫，  

SQLAlchemy引數

1. Column常用引數：  
2.     default：默認值，  
3.     nullable：是否可空，  
4.     primary_key：是否為主鍵，  
5.     unique：是否唯一，  
6.     autoincrement：是否自動增長，  
7.     onupdate：更新的時候執行的函式，  
8.     name：該屬性在資料庫中的欄位映射，  
9.         
10. sqlalchemy常用資料型別：  
11.     Integer：整形，  
12.     Float：浮點型別，  
13.     Boolean：傳遞True/False進去，  
14.     DECIMAL：定點型別，  
15.     enum：列舉型別，  
16.     Date：傳遞datetime.date()進去，  
17.     DateTime：傳遞datetime.datetime()進去，  
18.     Time：傳遞datetime.time()進去，  
19.     String：字符型別，使用時需要指定長度，區別于Text型別，  
20.     Text：文本型別，  
21.     LONGTEXT：長文本型別，  
22.         
23. query可用引數：  
24.     模型物件，指定查找這個模型中所有的物件，  
25.     模型中的屬性，可以指定只查找某個模型的其中幾個屬性，  
26.     聚合函式，  
27.     func.count：統計行的數量，  
28.     func.avg：求平均值，  
29.     func.max：求最大值，  
30.     func.min：求最小值，  
31.     func.sum：求和，  

創建表

1. # -*- coding: utf-8 -*-  
2. from sqlalchemy.ext.declarative import declarative_base  
3. from sqlalchemy import Column # 列  
4. from sqlalchemy import Integer, String  # 屬性  
5.             
6. Base = declarative_base()  # django models  
7.             
8. # 創建表  
9. class User(Base):  
10.     __tablename__ = 'user'  
11.     id = Column(Integer, primary_key=True, autoincrement=True)  
12.     name = Column(String(32), index=True, name='名字')  
13.             
14.             
15. # 資料庫連接  
16. from sqlalchemy import create_engine  
17. engine = create_engine("mysql+pymysql://root:[email protected]:3306/my_sql?charset=utf8")  
18.             
19. # 去engine資料庫中創建所有繼承Base的表  
20. Base.metadata.create_all(engine)  

增加資料

1. # -*- coding: utf-8 -*-  
2. from .create import engine, User  
3. # 增加資料  
4. # 創建會話視窗  
5. from sqlalchemy.orm import sessionmaker  
6. Session = sessionmaker(engine)  
7. # 打開會話視窗  
8. db_session = Session()  
9.             
10. # ---單條資料  
11. user_obj = User(name='Ywb')  # 實體化  
12. db_session.add(user_obj) # 相當于 insert into  
13.             
14. # 執行會化視窗中的所有操作  
15. db_session.commit()  
16. db_session.close()  
17.             
18. # ---增加批量資料  
19. db_session.add_all([  
20.     User(name='peach'),  
21.     User(name='小紅')  
22. ])  
23.             
24. db_session.commit()  
25. db_session.close()  
26.             
27. # ---擴展  
28. user1 = User(name='11')  
29. user2 = User(name='12')  
30. user3 = User(name='13')  
31. user4 = User(name='14')  
32. db_session.add(user1)  
33. db_session.add(user2)  
34. db_session.add(user3)  
35. db_session.add(user4)  
36. db_session.commit()  # 全部添加進去  
37. db_session.close()  

         

過濾

1. 過濾是資料提取的一個很重要的功能，以下對一些常用的過濾條件進行解釋，并且這些過濾條件都是只能通過filter方法實作的：  
2.         
3. equals：  
4. query.filter(User.name == 'ed')  
5.         
6. not equals:  
7. query.filter(User.name != 'ed')  
8.         
9. like：  
10. query.filter(User.name.like('%ed%'))  
11.         
12. in：  
13. query.filter(User.name.in_(['ed','wendy','jack']))  
14. # 同時，in也可以作用于一個Query  
15. query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))  
16.         
17. not in：  
18. query.filter(~User.name.in_(['ed','wendy','jack']))  
19.         
20. is null：  
21. query.filter(User.name==None)  
22. # 或者是  
23. query.filter(User.name.is_(None))  
24.         
25. is not null:  
26. query.filter(User.name != None)  
27. # 或者是  
28. query.filter(User.name.isnot(None))  
29.         
30. and：  
31. from sqlalchemy import and_  
32. query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))  
33. # 或者是傳遞多個引數  
34. query.filter(User.name=='ed',User.fullname=='Ed Jones')  
35. # 或者是通過多次filter操作  
36. query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')  
37.         
38. or：  
39. from sqlalchemy import or_    
40. query.filter(or_(User.name=='ed',User.name=='wendy')) 

單表查詢

1. # -*- coding: utf-8 -*-  
2. # 單表查詢  
3. from sqlalchemy.orm import sessionmaker  
4. from SQLAlchemy.create import engine, User  
5. Session = sessionmaker(engine)  
6. db_session = Session()  
7.             
8. # ---基本查詢  
9. # select * from name  
10. user_list = db_session.query(User)  
11. print(user_list)  # SELECT user.`名字` AS `user_名字`, user.id AS user_id FROM user  
12.             
13. # ---------------- 所有資料 ------------------  
14. user_list = db_session.query(User).all() # [obj, obj]  
15. for usr in user_list:  
16.     print(usr.name)  
17.             
18. # ---------------- 一條資料 ------------------  
19. user = db_session.query(User).first() # obj  
20. print(user.name)  
21.             
22.             
23. # ---------------- 帶條件查詢 ------------------  
24. # --- filter  
25. user_list = db_session.query(User).filter(User.id==2).all()  # [obj, obj]  
26. print(user_list)  
27.             
28. user_list = db_session.query(User).filter(User.id >= 1).all() # [obj, obj]  
29. for user in user_list:  
30.     print(user.id) # 按照id排序，因為添加是id  
31.             
32. # --- filter_by  
33. user = db_session.query(User).filter_by(id=2).first()  # obj  
34. print(user)  
35.             
36. # --- 擴展-查看sql陳述句  
37. sql = db_session.query(User).filter(User.id >= 1)  
38. print(sql)  
39. """  
40. SELECT user.`名字` AS `user_名字`, user.id AS user_id   
41. FROM user   
42. WHERE user.id >= %(id_1)s  
43. """  

修改

1. # -*- coding: utf-8 -*-  
2. # 更新修改資料  
3. from sqlalchemy.orm import sessionmaker  
4. from SQLAlchemy.create import engine,User  
5. Session = sessionmaker(engine)  
6. db_session = Session()  
7.           
8. # 單條修改  
9. # update `uesr` set `name` = 'haha' where id =1  
10. res = db_session.query(User).filter(User.id==1).update({  
11.     "name": 'haha'  
12. })  
13.           
14. print(res)  # 回傳影響的行數  
15. db_session.commit()  
16. db_session.close()  
17.           
18. # 批量修改  
19. res = db_session.query(User).filter(User.id > 1).update({  
20.     "name": "1234"  
21. })  
22.           
23. print(res)  
24. db_session.commit()  
25. db_session.close()  

洗掉

1. # -*- coding: utf-8 -*-  
2. # 洗掉資料  
3. from sqlalchemy.orm import sessionmaker  
4. from SQLAlchemy.create import engine,User  
5. Session = sessionmaker(engine)  
6. db_session = Session()  
7.           
8. # 洗掉單條  
9. # delete from user where id = 1  
10. res = db_session.query(User).filter(User.id==1).delete()  
11. print(res)  # 回傳影響的行數  
12. db_session.commit()  
13. db_session.close()  
14.           
15.           
16. # 洗掉多條  
17. res = db_session.query(User).filter(User.name=="12345").delete()  
18. print(res)  
19. db_session.commit()  
20. db_session.close()  

標籤：SQL Server

上一篇：SqlServer操作大容量資料

下一篇：sql server