SQLAlchemy-對象關系教程ORM-create

　　ORM是建立在SQL語言構造器之上的工具集，用於將Python對象映射到數據庫的行，提供了一系列接口用於從數據庫中存取對象(行)。在ORM 工作時，在底層調用SQL語言構造器的API，這些通用的操作有些許的不同。不同的是，你不再使用行，而是使用自定義類的對象來操作。另外，數據庫的查詢 方式也不同，ORM的可以生成大多數的SQL查詢，除此之外還可以在類中定義更多操作

 

1)檢查sqlalchemy版本

>>> import sqlalchemy
>>> sqlalchemy.__version__
'1.2.0b2'

2) 建立連接connecting

>>> from sqlalchemy import create_engine
>>> engine=create_engine("mysql+pymysql://admin:admin@192.168.6.22/coursesys?charset=utf8",encoding="utf-8",echo=True)

    1）通過create_engine()建立連接，create_engine是 Engine實例，create_engine第一次調用的時候會調用Engine.execute()或者 Engine.connect()方法，
    通過dialect在數據庫和DBAPI之間建立連接關系。
    注意：返回create_engine對象並沒有連接到數據庫。只有在執行第一次要求對數據庫時才連接
    2）echo是SQLAlchemy logging 是個標准logging模型。當echo 為True看到所有生成的SQL；希望少輸出,設置它 False
    3）mysql+pymysql://admin:admin@192.168.6.22/coursesys?charset=utf8 是個dialect連接
    4）engine=create_engine('sqlite:///:memory:',echo=True)將使用一個只在內存中SQLite數據庫

3）聲明映射

我們使用ORM：映射類與數據庫表。SQLAlchemy在中首先通過declarative_base申明一個基類。這個基類維持着類與數據庫表的關系

>>> from sqlalchemy.ext.declarative import declarative_base
>>> Base=declarative_base()

　　聲明表第一種方式：在自定義類繼承declarative_base這個基類來映射數據表

　　

>>>  class User(Base):
         __tablename__="users"
         id=Column(Integer,primary_key=True)
         name=Column(String)
         fullname=Column(String)
         password=Column(String)
         def __repr__(self):
             return "User(name=%s,fullname=%s,password=%s" %(self.name,self.fullname,self.password)
        

　　__tablename__指定表名
　　Column 指定字段
　　primary_key 設置主鍵
　　__repr__ 當打印User對象時顯示的數據。
聲明表第二種方式：通過模式聲明，通過__table__可以查看定義表元數據。

　　

from sqlalchemy import Table, MetaData, Column, Integer, String, ForeignKey
from sqlalchemy.orm import mapper
 
metadata = MetaData()
 
user = Table('user', metadata,
            Column('id', Integer, primary_key=True),
            Column('name', String(50)),
            Column('fullname', String(50)),
            Column('password', String(12))
        )
 
class User(object):
    def __init__(self, name, fullname, password):
        self.name = name
        self.fullname = fullname
        self.password = password
 
mapper(User, user）

>>> User.__table__
Table('users', MetaData(bind=None), Column('id', Integer(), table=<users>, prima
ry_key=True, nullable=False), Column('name', String(), table=<users>), Column('f
ullname', String(), table=<users>), schema=None)

MetaData是一個注冊表包括能夠一組執行的命令到數據庫，上面聲明了表的類，但是數據庫中並沒有創建表，
通過Base.metadata.create_all(engine)向數據庫發出建表完成類與表的映射

4）建立表

>>Base.metadata.create_all(engine) 2017-08-17 14:51:37,117 INFO sqlalchemy.engine.base.Engine SELECT CAST('test pla
in returns' AS VARCHAR(60)) AS anon_1
2017-08-17 14:51:37,117 INFO sqlalchemy.engine.base.Engine ()
2017-08-17 14:51:37,117 INFO sqlalchemy.engine.base.Engine SELECT CAST('test uni
code returns' AS VARCHAR(60)) AS anon_1
2017-08-17 14:51:37,117 INFO sqlalchemy.engine.base.Engine ()
2017-08-17 14:51:37,133 INFO sqlalchemy.engine.base.Engine PRAGMA table_info("us
ers")
2017-08-17 14:51:37,133 INFO sqlalchemy.engine.base.Engine ()
2017-08-17 14:51:37,133 INFO sqlalchemy.engine.base.Engine
CREATE TABLE users (
        id INTEGER NOT NULL,
        name VARCHAR,
        fullname VARCHAR,
        PRIMARY KEY (id)
)


2017-08-17 14:51:37,133 INFO sqlalchemy.engine.base.Engine ()
2017-08-17 14:51:37,133 INFO sqlalchemy.engine.base.Engine COMMIT

5）字段長度

　　在上面的String中我們並沒有指明長度，在SQLite和PostgreSQL是有效的，但是在mysql等中String,Integer, Numeric等會報錯需要指定長度
　　Column(String(50))

　　在oracleo等數據庫中，有可能需要用到序列，你可以通過Sequence來使用
　　from sqlalchemy import Sequence
　　Column(Integer, Sequence('user_id_seq'), primary_key=True)

    class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, Sequence('user_id_seq'), primary_key=True)
    name = Column(String(50))
    fullname = Column(String(50))
    password = Column(String(12))

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

6）建立會話

  1）通過 Session處理ORM和數據表。
        兩種方式：聲明並綁定engine

>>> from sqlalchemy.orm import sessionmaker
>>> Session = sessionmaker(bind=engine)

   2) 如果還沒有engine,先創建engine，在通過configure綁定到session

    Session = sessionmaker()
    Session.configure(bind=engine)

 上面通過sessionmaker創建是一個類，需要實例類

    session=Session()

 

7)增加修改數據

>>> ed_user=User(name="ed",fullname="ed Jone")
>>> session.add(ed_user)

　8)獲取自曾ID

　　

ed_user.id

　9)查看數據

　　

>>> our_user = session.query(User).filter_by(name='ed').first() 
>>> our_user
<User(name='ed', fullname='Ed Jones', password='edspassword'

　10)修改數據

ed_user.fullname = '11111'

　　session.dirty 修改數據后，數據變為臟數據，可以通過dirty查看
　　IdentitySet([<User(name='ed', fullname='11111'>])

11)增加一組數據

session.add_all([
...     User(name='wendy', fullname='Wendy Williams'),
...     User(name='mary', fullname='Mary Contrary'),
...     User(name='fred', fullname='Fred Flinstone'])


session.new  #表示查看新增加的數據
IdentitySet([<User(name='wendy', fullname='Wendy Williams', password='foobar')>,
<User(name='mary', fullname='Mary Contrary', password='xxg527')>,
<User(name='fred', fullname='Fred Flinstone', password='blah')>])

12) 提交數據回滾數據

上面的數據並沒有在數據庫中，需要通過commit()方法把數據提交到數據庫中，獲取通過rollback回滾數據。
commit()確認數據

Session.rollback()回滾數據。
mysql> select * from users;
Empty set (0.00 sec)

sesstion.commit()

mysql> select * from users;
+----+------+----------+----------+
| id | name | fullname | password |
+----+------+----------+----------+
|  1 | shi  | shi jun  | 123456   |
+----+------+----------+----------+
1 row in set (0.00 sec)

 

# -*- coding:utf-8 -*-
__author__ = 'shisanjun'

import sqlalchemy
from sqlalchemy import Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

#創建連接
engine=sqlalchemy.create_engine("mysql+pymysql://admin:admin@192.168.0.121/test2?charset=utf8",echo=True)

#聲明ORM映射基類
BASE=declarative_base()

class User(BASE):
    __tablename__="users" #指定表名
    id=Column(Integer,primary_key=True) #建立主鍵
    name=Column(String(32))
    fullname=Column(String(32))
    password=Column(String(32))

    def __repr__(self): #返回對象時打印顯示
        return "name:%s full name:%s password:%s" %(self.name,self.fullname,self.password)

#向數據庫發出建表，完成類與表的映射，在數據庫中生成所有繼承declarative_base表
BASE.metadata.create_all(bind=engine)
#聲明會話類
Session=sessionmaker(bind=engine)
#實例化會話類
session=Session()

#增加數據
user1=User(name="ed",fullname="ed jone",password="123456")
#增加一條數據
session.add(user1)
#查看自增ID號
print(user1.id)
#增加多條數據
session.add_all([
    User(name="shi",fullname="shi jone",password="123456"),
    User(name="san",fullname="san jone",password="123456"),
    User(name="jun",fullname="jun jone",password="123456"),
])
#查看新增數據
print(session.new)

#修改數據
user1.fullname="tianshi"

#查看臟數據
print(session.dirty)

#上面的數據並沒有提交到數據庫中，數據還在內存中

#把sesstion事務數據提交到數據庫中
session.commit()
#把數據從session事務中剔除
#session.rollback()