Python学习路程day11

SqlAlchemy ORM　　

SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果

Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

 1 MySQL-Python
 2     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
 3
 4 pymysql
 5     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
 6
 7 MySQL-Connector
 8     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
 9
10 cx_Oracle
11     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
12
13 更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

步骤一：

使用 Engine/ConnectionPooling/Dialect 进行数据库操作，Engine使用ConnectionPooling连接数据库，然后再通过Dialect执行SQL语句。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3
 4 from sqlalchemy import create_engine
 5
 6
 7 engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
 8
 9 engine.execute(
10     "INSERT INTO ts_test (a, b) VALUES (‘2‘, ‘v1‘)"
11 )
12
13 engine.execute(
14      "INSERT INTO ts_test (a, b) VALUES (%s, %s)",
15     ((555, "v1"),(666, "v1"),)
16 )
17 engine.execute(
18     "INSERT INTO ts_test (a, b) VALUES (%(id)s, %(name)s)",
19     id=999, name="v1"
20 )
21
22 result = engine.execute(‘select * from ts_test‘)
23 result.fetchall()

步骤二：

使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作。Engine使用Schema Type创建一个特定的结构对象，之后通过SQL Expression Language将该对象转换成SQL语句，然后通过 ConnectionPooling 连接数据库，再然后通过 Dialect 执行SQL，并获取结果。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3
 4 from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
 5
 6 metadata = MetaData()
 7
 8 user = Table(‘user‘, metadata,
 9     Column(‘id‘, Integer, primary_key=True),
10     Column(‘name‘, String(20)),
11 )
12
13 color = Table(‘color‘, metadata,
14     Column(‘id‘, Integer, primary_key=True),
15     Column(‘name‘, String(20)),
16 )
17 engine = create_engine("mysql+mysqldb://[email protected]:3306/test", max_overflow=5)
18
19 metadata.create_all(engine)

增删改查

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3
 4 from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
 5
 6 metadata = MetaData()
 7
 8 user = Table(‘user‘, metadata,
 9     Column(‘id‘, Integer, primary_key=True),
10     Column(‘name‘, String(20)),
11 )
12
13 color = Table(‘color‘, metadata,
14     Column(‘id‘, Integer, primary_key=True),
15     Column(‘name‘, String(20)),
16 )
17 engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
18
19 conn = engine.connect()
20
21 # 创建SQL语句，INSERT INTO "user" (id, name) VALUES (:id, :name)
22 conn.execute(user.insert(),{‘id‘:7,‘name‘:‘seven‘})
23 conn.close()
24
25 # sql = user.insert().values(id=123, name=‘wu‘)
26 # conn.execute(sql)
27 # conn.close()
28
29 # sql = user.delete().where(user.c.id > 1)
30
31 # sql = user.update().values(fullname=user.c.name)
32 # sql = user.update().where(user.c.name == ‘jack‘).values(name=‘ed‘)
33
34 # sql = select([user, ])
35 # sql = select([user.c.id, ])
36 # sql = select([user.c.name, color.c.name]).where(user.c.id==color.c.id)
37 # sql = select([user.c.name]).order_by(user.c.name)
38 # sql = select([user]).group_by(user.c.name)
39
40 # result = conn.execute(sql)
41 # print result.fetchall()
42 # conn.close()

Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：


1

2

3

4

5

6

7

8

9

10

11

12

13

MySQL-Python

    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

 

pymysql

    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

 

MySQL-Connector

    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

 

cx_Oracle

    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

 

更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

　　

步骤一：

使用 Engine/ConnectionPooling/Dialect 进行数据库操作，Engine使用ConnectionPooling连接数据库，然后再通过Dialect执行SQL语句。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

#!/usr/bin/env python

# -*- coding:utf-8 -*-

 

from sqlalchemy import create_engine

 

 

engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)

 

engine.execute(

    "INSERT INTO ts_test (a, b) VALUES (‘2‘, ‘v1‘)"

)

 

engine.execute(

     "INSERT INTO ts_test (a, b) VALUES (%s, %s)",

    ((555, "v1"),(666, "v1"),)

)

engine.execute(

    "INSERT INTO ts_test (a, b) VALUES (%(id)s, %(name)s)",

    id=999, name="v1"

)

 

result = engine.execute(‘select * from ts_test‘)

result.fetchall()

　　

步骤二：

使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作。Engine使用Schema Type创建一个特定的结构对象，之后通过SQL Expression Language将该对象转换成SQL语句，然后通过 ConnectionPooling 连接数据库，再然后通过 Dialect 执行SQL，并获取结果。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey

metadata = MetaData()

user = Table(‘user‘, metadata,

    Column(‘id‘, Integer, primary_key=True),

    Column(‘name‘, String(20)),

)

color = Table(‘color‘, metadata,

    Column(‘id‘, Integer, primary_key=True),

    Column(‘name‘, String(20)),

)

engine = create_engine("mysql+mysqldb://[email protected]:3306/test", max_overflow=5)

metadata.create_all(engine)

增删改查

+

一个简单的完整例子


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

from sqlalchemy import create_engine

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String

from  sqlalchemy.orm import sessionmaker

Base = declarative_base() #生成一个SqlORM 基类

engine = create_engine("mysql+mysqldb://[email protected]:3306/test",echo=False)

class Host(Base):

    __tablename__ = ‘hosts‘

    id = Column(Integer,primary_key=True,autoincrement=True)

    hostname = Column(String(64),unique=True,nullable=False)

    ip_addr = Column(String(128),unique=True,nullable=False)

    port = Column(Integer,default=22)

Base.metadata.create_all(engine) #创建所有表结构

if __name__ == ‘__main__‘:

    SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例

    session = SessionCls()

    #h1 = Host(hostname=‘localhost‘,ip_addr=‘127.0.0.1‘)

    #h2 = Host(hostname=‘ubuntu‘,ip_addr=‘192.168.2.243‘,port=20000)

    #h3 = Host(hostname=‘ubuntu2‘,ip_addr=‘192.168.2.244‘,port=20000)

    #session.add(h3)

    #session.add_all( [h1,h2])

    #h2.hostname = ‘ubuntu_test‘ #只要没提交,此时修改也没问题

    #session.rollback()

    #session.commit() #提交

    res = session.query(Host).filter(Host.hostname.in_([‘ubuntu2‘,‘localhost‘])).all()

    print(res)

　　

更多内容详见：

http://www.jianshu.com/p/e6bba189fcbd

http://docs.sqlalchemy.org/en/latest/core/expression_api.html

注：SQLAlchemy无法修改表结构，如果需要可以使用SQLAlchemy开发者开源的另外一个软件Alembic来完成。

步骤三：

使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有组件对数据进行操作。根据类创建对象，对象转换成SQL，执行SQL。


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

#!/usr/bin/env python

# -*- coding:utf-8 -*-

 

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy import Column, Integer, String

from sqlalchemy.orm import sessionmaker

from sqlalchemy import create_engine

 

engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)

 

Base = declarative_base()

 

 

class User(Base):

    __tablename__ = ‘users‘

    id = Column(Integer, primary_key=True)

    name = Column(String(50))

 

# 寻找Base的所有子类，按照子类的结构在数据库中生成对应的数据表信息

# Base.metadata.create_all(engine)

 

Session = sessionmaker(bind=engine)

session = Session()

 

 

# ########## 增 ##########

# u = User(id=2, name=‘sb‘)

# session.add(u)

# session.add_all([

#     User(id=3, name=‘sb‘),

#     User(id=4, name=‘sb‘)

# ])

# session.commit()

 

# ########## 删除 ##########

# session.query(User).filter(User.id > 2).delete()

# session.commit()

 

# ########## 修改 ##########

# session.query(User).filter(User.id > 2).update({‘cluster_id‘ : 0})

# session.commit()

# ########## 查 ##########

# ret = session.query(User).filter_by(name=‘sb‘).first()

 

# ret = session.query(User).filter_by(name=‘sb‘).all()

# print ret

 

# ret = session.query(User).filter(User.name.in_([‘sb‘,‘bb‘])).all()

# print ret

 

# ret = session.query(User.name.label(‘name_label‘)).all()

# print ret,type(ret)

 

# ret = session.query(User).order_by(User.id).all()

# print ret

 

# ret = session.query(User).order_by(User.id)[1:3]

# print ret

# session.commit()

外键关联

A one to many relationship places a foreign key on the child table referencing the parent.relationship() is then specified on the parent, as referencing a collection of items represented by the child

from sqlalchemy import Table, Column, Integer, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

1

2

3

4

5

6

7

8

9

<br>class Parent(Base):

    __tablename__ = ‘parent‘

    id = Column(Integer, primary_key=True)

    children = relationship("Child")

class Child(Base):

    __tablename__ = ‘child‘

    id = Column(Integer, primary_key=True)

    parent_id = Column(Integer, ForeignKey(‘parent.id‘))

To establish a bidirectional relationship in one-to-many, where the “reverse” side is a many to one, specify an additional relationship() and connect the two using therelationship.back_populates parameter:


1

2

3

4

5

6

7

8

9

10

class Parent(Base):

    __tablename__ = ‘parent‘

    id = Column(Integer, primary_key=True)

    children = relationship("Child", back_populates="parent")

class Child(Base):

    __tablename__ = ‘child‘

    id = Column(Integer, primary_key=True)

    parent_id = Column(Integer, ForeignKey(‘parent.id‘))

    parent = relationship("Parent", back_populates="children")

Child will get a parent attribute with many-to-one semantics.

Alternatively, the backref option may be used on a single relationship() instead of usingback_populates:


1

2

3

4

class Parent(Base):

    __tablename__ = ‘parent‘

    id = Column(Integer, primary_key=True)

    children = relationship("Child", backref="parent")

　　

　　

附，原生sql join查询

几个Join的区别 http://stackoverflow.com/questions/38549/difference-between-inner-and-outer-joins

  • INNER JOIN: Returns all rows when there is at least one match in BOTH tables
  • LEFT JOIN: Return all rows from the left table, and the matched rows from the right table
  • RIGHT JOIN: Return all rows from the right table, and the matched rows from the left table

1

select host.id,hostname,ip_addr,port,host_group.name from host right join host_group on host.id = host_group.host_id

in SQLAchemy


1

session.query(Host).join(Host.host_groups).filter(HostGroup.name==‘t1‘).group_by("Host").all()

　　

group by 查询


1

select name,count(host.id) as NumberOfHosts from host right join host_group on host.id= host_group.host_id group by name;

in SQLAchemy


1

2

3

4

5

6

from sqlalchemy import func

session.query(HostGroup, func.count(HostGroup.name )).group_by(HostGroup.name).all()

#another example

session.query(func.count(User.name), User.name).group_by(User.name).all() SELECT count(users.name) AS count_1, users.name AS users_name

FROM users GROUP BY users.name

　　

　　

　　

　　

更多ORM内容猛点这里

　　

分类: Python之路

好文要顶 关注我 收藏该文  

金角大王
关注 - 0
粉丝 - 104

+加关注

0

0

(请您对文章做出评价)

«上一篇：Python Select 解析

posted @ 2016-03-06 19:14 金角大王 阅读(937) 评论(0)  编辑 收藏

刷新评论刷新页面返回顶部

时间： 2024-12-15 07:00:43

Python学习路程day11的相关文章

Python学习路程day16

Python之路,Day14 - It's time for Django 本节内容 Django流程介绍 Django url Django view Django models Django template Django form Django admin Django流程介绍 Django URL Example Here’s a sample URLconf: from django.conf.urls import url from . import views urlpattern

Python学习笔记day11

SqlAlchemy ORM SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果 Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如: 1 2 3 4 5 6 7 8 9 10 11 12 13 MySQL-Python     mysql+mysqldb://<user>:<pass

python学习笔记-Day11 (线程、进程、queue队列、生产消费模型、携程)

线程使用 ###方式一 import threading def f1(arg): print(arg) t = threading.Thread(target=f1, args=(123,)) t.start() # start会调用run方法执行 # t是threading.Thread类的一个对象 # t.start()就会以线程的方式执行函数,可以使用pycharm ctrl选择start方法 # 找到Thread类的start方法,在start方法的注释中就已经写明,会去调用run()

Python学习路程day10

Twsited异步网络框架 Twisted是一个事件驱动的网络框架,其中包含了诸多功能,例如:网络协议.线程.数据库管理.网络操作.电子邮件等. 事件驱动 简而言之,事件驱动分为二个部分:第一,注册事件:第二,触发事件. 自定义事件驱动框架,命名为:“弑君者”: 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 # event_drive.py 5 6 event_list = [] 7 8 9 def run(): 10 for even

Python学习路程day15

Python之路[第十五篇]:Web框架 Web框架本质 众所周知,对于所有的Web应用,本质上其实就是一个socket服务端,用户的浏览器其实就是一个socket客户端. #!/usr/bin/env python #coding:utf-8 import socket def handle_request(client): buf = client.recv(1024) client.send("HTTP/1.1 200 OK\r\n\r\n") client.send("

python学习之day11

目录 SqlAlchemy SqlAlechemy SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如: MySQL-Python mysql+mysqldb://<user>:<password>@<host>[

Python学习路程day19

Python之路,Day19 - Django 进阶 本节内容 自定义template tags 中间件 CRSF 权限管理 分页 Django分页 https://docs.djangoproject.com/en/1.9/topics/pagination/ 自定义template tags https://docs.djangoproject.com/es/1.9/howto/custom-template-tags/ 权限管理 django 自带有基本的权限管理 ,但粒度和限制权限的维度

python学习路程

常用的转义字符还有: \n 表示换行 \t 表示一个制表符 \\ 表示 \ 字符本身 任务 请将下面两行内容用Python的字符串表示并打印出来: Python was started in 1989 by "Guido". Python is free and easy to learn. 脚本实现: s = 'Python was started in 1989 by \"Guido\".\n Python is free and easy to learn .

Python学习路程day7

多态 1 class Animal: 2 def __init__(self, name): # Constructor of the class 3 self.name = name 4 def talk(self): # Abstract method, defined by convention only 5 raise NotImplementedError("Subclass must implement abstract method") 6 7 class Cat(Ani