精华内容
下载资源
问答
  • SQLAlchemy创建,crud,聚合函数,过滤条件,外键约束,relationship 1.sqlalchemy的创建创建引擎create_engine,再创建基类Base: from sqlalchemy.ext.declarative import declarative_base,Column from ...

    SQLAlchemy创建,crud,聚合函数,过滤条件,外键约束,relationship


    1.sqlalchemy的创建

    先创建引擎create_engine,再创建基类Base:
    from sqlalchemy.ext.declarative import declarative_base,Column
    from sqlalchemy import create_engine
    
    DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
    engine = create_engine(DB_URI)
    Base = declarative_base(engine)
    
    class Person(Base):
            __tablename__ = 'person'
            # 2. 在这个ORM模型中创建一些属性,来跟表中的字段进行一一映射。这些属性必须是sqlalchemy给我们提供好的数据类型。
            id = Column(Integer,primary_key=True,autoincrement=True)
            name = Column(String(50))
            age = Column(Integer)
    

    使用Base.metadata.create_all()来将模型映射到数据库中。

    **注意:**一旦使用Base.metadata.create_all()将模型映射到数据库中后,即使改变了模型的字段,也不会重新映射了。

    2.crud

    用session做数据的增删改查操作:

    构建session对象:所有和数据库的ORM操作都必须通过一个叫做session的会话对象来实现,通过以下代码来获取会话对象:

    *add_data:
    ```python
    from sqlalchemy.orm import sessionmaker
    engine = create_engine(DB_URI)
    session = sessionmaker(engine)()
    添加对象:
    * 创建对象,也即创建一条数据:
    
        p = Person(name='zhiliao',age=18,country='china')
       
    * 将这个对象添加到`session`会话对象中:
        
        session.add(p)
       
    * 将session中的对象做commit操作(提交):
     
        session.commit()
       
    * 一次性添加多条数据:
        
        p1 = Person(name='zhiliao1',age=19,country='china')
        p2 = Person(name='zhiliao2',age=20,country='china')
        session.add_all([p1,p2])
        session.commit()
      
    ```
    
    *seach_data:
     	# 查找某个模型对应的那个表中所有的数据:
        all_person = session.query(Person).all()
        # 使用filter_by来做条件查询
        all_person = session.query(Person).filter_by(name='zhiliao').all()
        # 使用filter来做条件查询
        all_person = session.query(Person).filter(Person.name=='zhiliao').all()
        # 使用get方法查找数据,get方法是根据id来查找的,只会返回一条数据或者None
        person = session.query(Person).get(primary_key)
        # 使用first方法获取结果集中的第一条数据
        person = session.query(Person).first()
    
    *update_data:
    	#修改对象:首先从数据库中查找对象,然后将这条数据修改为你想要的数据,最后做commit操作就可以修改数据了
        person = session.query(Person).first()
        person.name = 'ketang'
        session.commit()
    
    *delete_data:
         #删除对象:将需要删除的数据从数据库中查找出来,然后使用`session.delete`方法将这条数据从session中删除,最后做commit操作就可以了
        person = session.query(Person).first()
        session.delete(person)
        session.commit()
    
    SQLAlchemy常用数据类型:
    1. Integer:整形,映射到数据库中是int类型。

    2. Float:浮点类型,映射到数据库中是float类型。他占据的32位。

    3. Double:双精度浮点类型,映射到数据库中是double类型,占据64位。

    4. String:可变字符类型,映射到数据库中是varchar类型.

    5. Boolean:布尔类型,映射到数据库中的是tinyint类型。

    6. DECIMAL:定点类型。是专门为了解决浮点类型精度丢失的问题的。在存储钱相关的字段的时候建议大家都使用这个数据类型。并且这个类型使用的时候需要传递两个参数,第一个参数是用来标记这个字段总能能存储多少个数字,第二个参数表示小数点后有多少位。

    7. Enum:枚举类型。指定某个字段只能是枚举中指定的几个值,不能为其他值。在ORM模型中,使用Enum来作为枚举,示例代码如下:

      ```python
      class Article(Base):
          __tablename__ = 'article'
          id = Column(Integer,primary_key=True,autoincrement=True)
          tag = Column(Enum("python",'flask','django'))
      ```
      

      ​ 在Python3中,已经内置了enum这个枚举的模块,我们也可以使用这个模块去定义相关的字段。示例代码如下:

      ```python
      class TagEnum(enum.Enum):
          python = "python"
          flask = "flask"
          django = "django"
      ```
      
      class Article(Base):
          __tablename__ = 'article'
          id = Column(Integer,primary_key=True,autoincrement=True)
          tag = Column(Enum(TagEnum))
      
      article = Article(tag=TagEnum.flask)
      
      
      1. Date:存储时间,只能存储年月日。映射到数据库中是date类型。在Python代码中,可以使用datetime.date来指定。示例代码如下:

        class Article(Base):
            __tablename__ = 'article'
            id = Column(Integer,primary_key=True,autoincrement=True)
            create_time = Column(Date)
        
        article = Article(create_time=date(2017,10,10))
        
      2. DateTime:存储时间,可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型。在Python代码中,可以使用datetime.datetime来指定。示例代码如下:

        class Article(Base):
            __tablename__ = 'article'
            id = Column(Integer,primary_key=True,autoincrement=True)
            create_time = Column(DateTime)
        
        article = Article(create_time=datetime(2011,11,11,11,11,11))
        
      3. Time:存储时间,可以存储时分秒。映射到数据库中也是time类型。在Python代码中,可以使用datetime.time来至此那个。示例代码如下:

        class Article(Base):
            __tablename__ = 'article'
            id = Column(Integer,primary_key=True,autoincrement=True)
            create_time = Column(Time)
        
        article = Article(create_time=time(hour=11,minute=11,second=11))
        
      4. Text:存储长字符串。一般可以存储6W多个字符。如果超出了这个范围,可以使用LONGTEXT类型。映射到数据库中就是text类型。

      5. LONGTEXT:长文本类型,映射到数据库中是longtext类型。

    Column常用参数:

    1. primary_key:设置某个字段为主键。

    2. autoincrement:设置这个字段为自动增长的。

    3. default:设置某个字段的默认值。在发表时间这些字段上面经常用。

    4. nullable:指定某个字段是否为空。默认值是True,就是可以为空。

    5. unique:指定某个字段的值是否唯一。默认是False。

    6. onupdate:在数据更新的时候会调用这个参数指定的值或者函数。在第一次插入这条数据的时候,不会用onupdate的值,只会使用default的值。常用的就是update_time(每次更新数据的时候都要更新的值)。

    7. name:指定ORM模型中某个属性映射到表中的字段名。如果不指定,那么会使用这个属性的名字来作为字段名。如果指定了,就会使用指定的这个值作为参数。这个参数也可以当作位置参数,在第1个参数来指定。

      title = Column(String(50),name='title',nullable=False)
      title = Column('my_title',String(50),nullable=False)
      

    3.聚合函数

    query可用参数:
    1. 模型对象。指定查找这个模型中所有的对象。
    2. 模型中的属性。可以指定只查找某个模型的其中几个属性。
    3. 聚合函数。
      • func.count:统计行的数量。
      • func.avg:求平均值。
      • func.max:求最大值。
      • func.min:求最小值。
      • func.sum:求和。
        func上,其实没有任何聚合函数。但是因为他底层做了一些魔术,只要mysql中有的聚合函数,都可以通过func调用。
    4.过滤条件
    filter过滤条件:

    过滤是数据提取的一个很重要的功能,以下对一些常用的过滤条件进行解释,并且这些过滤条件都是只能通过filter方法实现的:

    1. equals:

      article = session.query(Article).filter(Article.title == "title0").first()
      print(article)
      
    2. not equals:

      query.filter(User.name != 'ed')
      
    3. like:

      query.filter(User.name.like('%ed%'))
      
    4. in:

      query.filter(User.name.in_(['ed','wendy','jack']))
      # 同时,in也可以作用于一个Query
      query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))
      
    5. not in:

      query.filter(~User.name.in_(['ed','wendy','jack']))
      
    6. is null:

      query.filter(User.name==None)
      # 或者是
      query.filter(User.name.is_(None))
      
    7. is not null:

      query.filter(User.name != None)
      # 或者是
      query.filter(User.name.isnot(None))
      
    8. and:

      from sqlalchemy import and_
      query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
      # 或者是传递多个参数
      query.filter(User.name=='ed',User.fullname=='Ed Jones')
      # 或者是通过多次filter操作
      query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')
      
    9. or:

      from sqlalchemy import or_  query.filter(or_(User.name=='ed',User.name=='wendy'))
      

    如果想要查看orm底层转换的sql语句,可以在filter方法后面不要再执行任何方法直接打印就可以看到了。比如:

    ```python
        articles = session.query(Article).filter(or_(Article.title=='abc',Article.content=='abc'))
        print(articles)
    ```
    

    5.外键约束

    外键:

    使用SQLAlchemy创建外键非常简单。在从表中增加一个字段,指定这个字段外键的是哪个表的哪个字段就可以了。从表中外键的字段,必须和父表的主键字段类型保持一致。
    示例代码如下:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
    class Article(Base):
        __tablename__ = 'article'
        id = Column(Integer,primary_key=True,autoincrement=True)
        title = Column(String(50),nullable=False)
        content = Column(Text,nullable=False)
    
        uid = Column(Integer,ForeignKey("user.id"))
    
    外键约束有以下几项: 
    1. RESTRICT:父表数据被删除,会阻止删除。默认就是这一项。 
    2. NO ACTION:在MySQL中,同RESTRICT。 
    3. CASCADE:级联删除。 
    4. SET NULL:父表数据被删除,子表数据会设置为NULL。
    
    第一种:RESTRICT(默认就是这种。当父表数据被删除,从表会拒绝删除)
    语法:uid = Column(Integer , ForeignKey("user.id" ,ondelete="RESTRICT")) 
    
    第二种:NO ACTIION(同RESTRICT 一样)
    语法: uid = Column(Integer , ForeignKey("user.id" ,ondelete="NO ACTION")) 
    
    第三种:CASCADE (父表数据删除、从表数据也会跟着删除)
    语法:uid = Column(Integer , ForeignKey("user.id" ,ondelete="CASCADE"))
    
    第四种: SET NULL (父表数据删除,从表外键字段设为NULL)
    语法:uid = Column(Integer , ForeignKey("user.id" ,ondelete="SET NULL"))
    
    注意: 如果uid字段设置了 nullable=False , 再设置 ondelete = "SET NULL",pycharm运行程序则会报错
    

    6.relationship

    ORM关系以及一对多:

    mysql级别的外键,还不够ORM,必须拿到一个表的外键,然后通过这个外键再去另外一张表中查找,这样太麻烦了。SQLAlchemy提供了一个relationship,这个类可以定义属性,以后在访问相关联的表的时候就直接可以通过属性访问的方式就可以访问得到了。示例代码:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
        # articles = relationship("Article")
    
        def __repr__(self):
            return "<User(username:%s)>" % self.username
    
    class Article(Base):
        __tablename__ = 'article'
        id = Column(Integer,primary_key=True,autoincrement=True)
        title = Column(String(50),nullable=False)
        content = Column(Text,nullable=False)
        uid = Column(Integer,ForeignKey("user.id"))
    
        author = relationship("User",backref="articles")
    

    另外,可以通过backref来指定反向访问的属性名称。articles是有多个。他们之间的关系是一个一对多的关系

    一对一的关系:

    在sqlalchemy中,如果想要将两个模型映射成一对一的关系,那么应该在父模型中,指定引用的时候,要传递一个uselist=False这个参数进去。就是告诉父模型,以后引用这个从模型的时候,不再是一个列表了,而是一个对象了。示例代码如下:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
        extend = relationship("UserExtend",uselist=False)
    
        def __repr__(self):
            return "<User(username:%s)>" % self.username
    
    class UserExtend(Base):
        __tablename__ = 'user_extend'
        id = Column(Integer, primary_key=True, autoincrement=True)
        school = Column(String(50))
        uid = Column(Integer,ForeignKey("user.id"))
    
        user = relationship("User",backref="extend")
    

    当然,也可以借助sqlalchemy.orm.backref来简化代码:

    class User(Base):
        __tablename__ = 'user'
        id = Column(Integer,primary_key=True,autoincrement=True)
        username = Column(String(50),nullable=False)
    
        # extend = relationship("UserExtend",uselist=False)
    
        def __repr__(self):
            return "<User(username:%s)>" % self.username
    
    class UserExtend(Base):
        __tablename__ = 'user_extend'
        id = Column(Integer, primary_key=True, autoincrement=True)
        school = Column(String(50))
        uid = Column(Integer,ForeignKey("user.id"))
    
        user = relationship("User",backref=backref("extend",uselist=False))
    
    多对多的关系:
    1. 多对多的关系需要通过一张中间表来绑定他们之间的关系。
    2. 先把两个需要做多对多的模型定义出来
    3. 使用Table定义一个中间表,中间表一般就是包含两个模型的外键字段就可以了,并且让他们两个来作为一个“复合主键”。
    4. 在两个需要做多对多的模型中随便选择一个模型,定义一个relationship属性,来绑定三者之间的关系,在使用relationship的时候,需要传入一个secondary=中间表。
    展开全文
  • 3.4.2 实体间关系 76 3.4.3 识别属性和域 82 3.5 识别业务规则和业务过程 90 3.5.1 识别业务规则 90 3.5.2 识别基础业务过程 92 3.6 完成概念模型 93 3.6.1 识别明显、额外数据需求 94 3.6.2 和客户一起...
  • 3.4.2 实体间关系 76 3.4.3 识别属性和域 82 3.5 识别业务规则和业务过程 90 3.5.1 识别业务规则 90 3.5.2 识别基础业务过程 92 3.6 完成概念模型 93 3.6.1 识别明显、额外数据需求 94 3.6.2 和客户一起...
  • Hibernate_3.2.0_符合Java习惯的关系数据库持久化

    千次下载 热门讨论 2009-01-14 08:06:55
    HIBERNATE - 符合Java习惯的关系数据库持久化 Hibernate参考文档 3.2 -------------------------------------------------------------------------------- 目录 前言 1. 翻译说明 2. 版权声明 1. Hibernate...
  • pdm文件生成几种方式

    万次阅读 2015-10-23 15:30:41
    PowerDesigner 是数据库建模功能很强大工具,其可以生成pdm文件建立表结构及表间关联关系,也可以生成java 中bo,po,dao层代码。还可以生成建库脚本,方便的创建数据库结构。因此,能够快速生成PDM文件是提高...


          PowerDesigner 是数据库建模功能很强大的工具,其可以生成pdm文件建立表结构及表间关联关系,也可以生成java 中bo,po,dao层的代码。还可以生成建库脚本,方便的创建数据库结构。因此,能够快速生成PDM文件是提高数据库建模的必要条件。一般powerdesiger生成PDM模型文件有几种方式:

    1. 通过PD界面手动操作,一个一个建表,建字段说明,并建立表关系。 

    2. 通过已有的sql脚本导入pd中生成pdm模型。

    3. 通过连接数据库,对已有的数据表结构进行建模备份。

    4. 通过pd的接口调用vb脚本,读取规定模板的文本来建模。  


      下面我一一说明下这几种方式建模的步骤。

      一、 工具选择

             a. PowerDesigner 15 ,

             b. mysql 5.6 

             

     二 , PD界面手动操作建模

         步骤如下,按图片顺序:建模-建表-建字段-建约束-建表关联关系保存生成pdm文件

     

    第二步:


    第三步:


    第四步:


    第五步:


    第六步:



    第七步:



    二,通过已有sql脚本导入pd中生成pdm文件

     第一步:创建sql脚本



      第二步;File ---> Reverse Engineer--->Databases..---> 确定库及归属模型


    第三步:点确定按钮配置脚本目录及归属模型


    第四步:


    第五步:



    三、通过连接数据库,对已有的数据表结构进行建模备份。


    通过数据库脚本文件生成PDM的步骤为:选择File------->选择Reverse Engineer----->选择database,如下图:

    ----->点击确定----->选择Using script files,如下图所示:

    ----->并选择所要使用的数据库脚本 ----->最后点击确定就会自动生成PDM。

    6.2 通过ODBC生成PDM

    首先需要先设置一个数据库链接,设置方法如下:鼠标左键选择Database------>选择Confiure Connections----->如果还没有配置过数据库链接的话选择Add Data source----->设置链接的类型、设置链接的文件、选择链接的驱动文件以及配置ID、数据库等内容,如下图所示和:

    ----->配置完成点击旁边的Test Connection,测试一下是否能正常连接----->点击OK即可。

    通过ODBC生成PDM的步骤:选择File------->选择Reverse Engineer----->选择database,如下图所示:

    ------->点击确定------->选择table将不需要生成PDM的表去掉,只选择需要生成的表(小技巧:使用shift来批量选择),如下图:

    ------->点击OK就生成了指定数据库的PDM图了。


    四、 同步pd工具中提供的执行vb接口批量快速创建表(推荐)

       鼠标左键 Tools------>Execute Commands --->Edit/Run Script .. (Ctrl+Shift+X)   快速打开



    第二步: 在编辑框内编写vb脚本内容,功能是读取D:\table.txt 文档中固定模板格式的数据,包括: 表名称,表描述,表code。 字段别名,字段code,字段类型,是否主键,是否外键,是否不为空约束。

    具体内容如下:

    talbe-begin                              
    表1 table1 表说明                        
    字段1 test1 VARCHAR2(322) false true 说明
    字段2 test2 VARCHAR2(322) true true 说明 
    字段3 test3 VARCHAR2(256) false true 说明
    talbe-begin                              
    表2 table2 表说明                        
    字段1 test1 VARCHAR2(322) true true 说明 
    字段2 test2 VARCHAR2(322) true true 说明 
    字段3 test3 VARCHAR2(256) false true 说明
    

    注意:内容之间用空格分割,便于vb脚本中split函数拆分每行的字段。


    此文件是txt的文档,内容格式根据要创建的字段配置项灵活配置。具体vb脚本如下:

    Dim system, file
    Set system = CreateObject("Scripting.FileSystemObject") '创建文件对象
    
    Dim ForReading, ForWriting, ForAppending
    dim str
    dim tittle
    dim first
    ForReading   = 1 ' 设置文件只读 
    ForWriting   = 2 ' 设置文件写入
    ForAppending = 8 ' 设置文件追加
    '-----------------------------------------
    ' 主要程序
    '-----------------------------------------
    Set file = system.OpenTextFile("D:\table.txt", ForReading)'打开文本文档
    Dim noLine
    Dim Tab  '定义一个表,vbscript中变量没有那么严格的类型,但此变量将来将用来表示table
    ValidationMode = True
    Dim mdl ' 定义当前激活的模型,也就是mdl
    Dim Col
    dim dm, dmstr
    Dim SSS
    Dim isNewTable
    dim tableCreateFlag
    dim tableHeadFlag
    dim tableContentFlag
    dim exitFlag
    Set mdl = ActiveModel '获取当前激活模型
    tableCreateFlag = false
    tableHeadFlag = false
    tableContentFlag = false
    Do While file.AtEndOfStream <> True '循环读取文档的每一行
       SSS = file.ReadLine
       'msgbox  "tab.name:" &SSS
       if SSS ="talbe-begin" then
          tableCreateFlag = true
          tableHeadFlag = true
       elseif tableCreateFlag=true then
    			if tableHeadFlag=true then
    				title=split(SSS)
    				exitFlag = isExitTable(mdl,title(0))
    				 if exitflag=true then exit do
    				set tab = mdl.Tables.CreateNew '创建表,并设  置表属性
    				 tab.name=title(0) 'name
    				 'msgbox  "tab.name:" &title(0)
    				 tab.code=title(1) 'code
    				 tab.comment=title(2) 'comment
    				 tableHeadFlag = false
    				 tableContentFlag = true
    			elseif tableContentFlag=true then
    				set col=tab.Columns.CreateNew '创建一行字段
    				str = split(SSS)
    				col.name = str(0) '依次设置属性,同表的属性,字段熟悉也可以设置更多,根据实际情况
    				col.Code = str(1)
    				col.datatype=str(2)
    				col.Primary=str(3)
    				if col.Primary=false then 
    					col.Mandatory=str(4)
    					col.Comment=str(5)
    				end if
    			end if 
        end if
    Loop
    file.Close
    private function isExitTable(model,tableName)
      dim tables
      dim table
      dim flag
      set tables = model.Tables
      flag = false
      for each table in tables
          if table.name=tableName then 
             flag = true
             msgbox  "该模型中已存在此表"+tableName
             exit for
           end if
       next
       isExitTable = flag
    end function

    关于vb脚本语法简单说明以下几点:

    1. 基础语法说明

     Set 设置变量值, 
     Dim 定义变量, <pre name="code" class="vb"> function 定义函数, 
     if .. elseif ... end if  判断语句,   
     '做为注释行
    msgbox 打印内容
    + 链接变量与字符串
    <pre name="code" class="vb">& 加上变量 可以输出变量内容
    
    
    
    

    2. 此脚本中几个关键函数说明

       

    file = system.OpenTextFile("D:\table.txt", ForReading) 读取指定目录下的txt文件
    <pre name="code" class="vb">file.AtEndOfStream  读取文件流判断是否到结尾
    <pre name="code" class="vb">file.ReadLine  读取一行内容 返回字符串
    <pre name="code" class="vb">title=split(SSS)  默认按空格分割字符串,返回字符数组
    <pre name="code" class="vb">title(0) 获取数组中第一变量值
    Set mdl = ActiveModel '获取当前激活模型
    set tab = mdl.Tables.CreateNew '创建表,并设  置表属性
    tab.name=title(0) 'name属性设置值
    set col=tab.Columns.CreateNew '创建一行字段
    
    
    col.name = str(0) '依次设置属性,同表的属性,字段熟悉也可以设置更多,根据实际情况
    col.Code = str(1) '设置字段code
    col.datatype=str(2)'设置字段datatype
    col.Primary=str(3)'设置字段主键
    if col.Primary=false then ' 判断主键
    col.Mandatory=str(4) '设置强制不能为空项
    col.Comment=str(5) '设置字段描述
    
    
    file.Close 关闭文件流
    
    
    
    

    ok, 那这里目前所知的pdm创建方式流程均总结完毕,每种方式有自己的特定使用条件,可以根据需求场景自行选择。 我们这边奇葩领导要求在半天内(ˇˍˇ) 想~出一种快速创建pdm文件的方式,据说有了这个pdm文件,什么java层次的代码都有了,持久层也可以自动生成,设置前台页面增删改查都可以自动生成了,解决掉这个创建模型一环几乎就可以逆天了,god!

     



    展开全文
  • 导航表间关系:描述如何使用 DataSet 中表之间的关系来返回具有父子关系的子行或父行。 将 DataSet 与现有数据一起使用"描述如何使用 DataAdapter 将 DataSet 中的更改解析回数据源。 合并 DataSet 内容:描述如何将...
  • 每一个视图是一个管理对象,视图中可以包括原材料、半成品、零件、部件等构件及它们之间的关系,这些构件可以同时与多个视图相关联,不同视图间的区别在于构件集合的不同以及构件间关系的不同。从一个产品配置视图...
  • Oraclet中触发器

    2011-06-04 21:58:17
    但是我们可以创建INSTEAD_OF触发器来为 DELETE 操作执行所需处理,即删除EMP中所有基准行: CREATE OR REPLACE TRIGGER emp_view_delete INSTEAD OF DELETE ON emp_view FOR EACH ROW BEGIN DELETE FROM emp ...

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 319
精华内容 127
关键字:

创建表间关系的条件