精华内容
下载资源
问答
  • 数据库冗余字段

    万次阅读 多人点赞 2015-01-13 11:55:37
    什么是冗余字段? 在设计数据库时,某一字段属于一个表,但它又同时出现在另一个或多个表,且完全...因为在数据库设计领域,有一个被大家奉为圭臬的数据库设计范式,这个范式理论上要求数据库设计逻辑清晰、关系明确,

    什么是冗余字段?

    在设计数据库时,某一字段属于一个表,但它又同时出现在另一个或多个表,且完全等同于它在其本来所属表的意义表示,那么这个字段就是一个冗余字段。

    ——以上是我自己给出的定义

    冗余字段的存在到底是好还是坏呢?这是一个不好说的问题。可能在有人看来,这是一个很蹩脚的数据库设计。因为在数据库设计领域,有一个被大家奉为圭臬的数据库设计范式,这个范式理论上要求数据库设计逻辑清晰、关系明确,比如,”用户昵称”字段”nickname”本来属于表”user”,那么,表示”用户昵称”的字段就唯一的只应该属于”user”表的”nickname”字段,这样,当用户要修改昵称的时候,程序就只需要修改 user.nickname这个字段就行了,瞧,很方便。不过问题也随之而来,我在其他数据表(如订单orders表)里只存储了用户的ID,我要通过这个ID值得到用户昵称该怎么办呢?一个普遍的解决方法是通过联接(join),在查询时,通过id这个唯一条件联接两个表,从而取到用户的昵称。

    这样确实是没问题,我也一直觉得这样是最好的方案,扩展方便,当要更新用户信息时,程序中要修改的地方很少,但是随着数据库里数据不断增加,百万,千万,同时,用户表的数据肯定也在不断的增加的,它可能是十万,百万。这个时候,你会发现两个表通过联接来取数据就显得相当费力了,可能你只需要取一个nickname这个用户昵称属性,你就不得不去联一下那个已经几十万的用户表进行检索,其速度可想而知了。

    这个时候,你可以尝试把nickname这个字段加到orders这个订单表中,这样做的好事是,当你要通过订单表呈现一个订单列表时,涉及用户的部分可能就不需要再进行联接查询了。当然,有利就有弊,这样做的弊端就是,当你尝试更新用户信息时,你必须记得用户信息表里当前被更新的字段中,有哪些是冗余字段,分别属于哪些表,找到他们,然后加入到你的更新程序段中来。这个是程序中的开销,开销在开发人员的时间上了。至于这样做是否值得,就得看具体情况而定了。

    所以,目前要创建一个关系型数据库设计,我们有两种选择:

    1. 尽量遵循范式理论的规约,尽可能少的冗余字段,让数据库设计看起来精致、优雅、让人心醉。
    2. 合理的加入冗余字段这个润滑剂,减少join,让数据库执行性能更高更快。

    选择哪一种呢?如果你是一个美学狂人,并且财大气粗,非要使用第一种方案,也没关系,这种方案的短板并非不可救药的。比如,你可以增加服务器,从数据库集群入手,进行读写分离,读的时候可以将压力分散到不同的数据库服务器上,这样也可以获得很好的性能,只是多付出了硬件成本和维护成本。或者,你可以在数据库前端架设Memcached之类的缓存服务,减少读写数据库的次数,也可以达到同样的效果。问题在于你确定你需要缓存之类的东西。

    当然,如果你跟我一样,只有一台每月几十元买来的vps,甚至可能是一个虚拟主机,建议还是暂时压制你的美学欲望,跟我一起选择第二种方案吧,除非你愿意你的整个数据库都一直只有零零星星的几条数据

    展开全文
  • 字段:事物的所有属性 记录:事物的本身 表:事物的集合 列:事物的某一个属性的集合 行:记录的另一种称谓 属性:字段的另一种称谓 元组:记录的另一种称谓 主键:能够唯一表示一个记录的一个字段或者多个...

    字段:事物的所有属性

    记录:事物的本身

    表:事物的集合

    列:事物的某一个属性的集合

    行:记录的另一种称谓

    属性:字段的另一种称谓

    元组:记录的另一种称谓

    主键:能够唯一表示一个记录的一个字段或者多个字段的组合

    特点:

    1.含有主键的表叫做主键表
    2.主键通常都是整数,不建议使用字符串当主键(如果主键是用于集群式服务,才可以考虑用字符串当主键)
    3.主键的值通常都不允许修改,除非本记录被删除
    4.主键不要定义成id,而要定义成表名Id或者表名_ id
    5.要用代理主键,不要用业务主键
    6.任何一张表,强烈建议不要使用有业务含义的字段充当主键
    7.我们通常都是在表中单独添加一个整型的编号充当主键字段
    8.主键是否连续增长不是十分重要

    外键:如果一个表中的若干个字段来源于另外若干个表中的主键,则这若干个字段就是外键

    特点:

    1.外键通常是来自另外表的主键而不是唯一键,因为唯一键可能为null
    2.外键不一定是来自另外的表,也可能来自本表的主键
    3.含有外键的表叫外建表,外键字段来自的那一张表叫做主键表

    展开全文
  • 数据库中的表名就是这个属性的名字,但是有前提,是你没有定义@Table这个属性") 2、@Table 是用来表示这个类(实体)对应的数据库表的信息 有三个属性:1、name 2、catalog 3、schema 这三个属性都是可选的 ...
    1、@Entity(name="对应的表的名字,比如说user。则数据库中的表名就是这个属性的名字,但是有前提,是你没有定义@Table这个属性")


    2、@Table 是用来表示这个类(实体)对应的数据库表的信息
    有三个属性:1、name 2、catalog 3、schema
    这三个属性都是可选的
    name表示数据库中的这个类对应的表的名称()
    //大家是不是疑惑了?上面的Entity的name属性也同样的表示表的名字,通过代码发现,当我们在@Table中没有定义name的属性的时候,则表名时根据@Entity的name来指定的,如果@Entity中也没有,则默认按照这个类的类名。
    所以:
    if(@Table的name!=null){
    该类对应的数据库的表名 = @Table(name=“表名");
    }elseif(@Entity的name!=null){
    该类对应的数据库的表名 = @Entity(name="表名");
    }else{
    该类对应的数据库的表名 = 该类的类名
    }           


    catalog和schema分别为catalog和schema的名称,并没有对程序的运行有太大的影响,可以自行了解。这两个属性也是可选的,一般我们也不会去写,让系统自动去默认值即可


    3、对于主键的修饰,我们有1、@Id(必须) 2、@GeneratedValue(可选) 3、@GeneratedValues(可选)
    1)、@Id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.置于getXxxx()前.


    2)、对于GeneratedValue
    @GeneratedValue(strategy=GenerationType.AUTO)  自动增长,根据底层数据库自动选择。数据库支持自动增长类型,则为自动增长。
    @GeneratedValue(GenerationType.TABLE 使用指定的表来决定主键的取值,结合@TableGeneraors使用
    @GeneratedValue(strategy=GenerationType.IDENTITY)  唯一 
    @GeneratedValue(strategy=GenerationType.SEQUENCE)  
    strategy:表示主键生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4种,分别表示让ORM框架自动选择,根据数据库的Identity字段生成,根据数据库表的Sequence字段生成,以有根据一个额外的表生成主键,默认为AUTO


    一般我们设置为默认,也就是自动增长,即GenerationType.AUTO即可,让其自动增长,所以我们也可以不写


    generator:表示主键生成器的名称,这个属性通常和ORM框架相关,例如,Hibernate可以指定uuid等主键生成方式.一般也不写,取默认值


    3)、对于@GeneratedValues我们一般也就取一次


    示例:


    @Id
    @GeneratedValues(strategy=StrategyType.SEQUENCE)
    public int getPk() {
    return pk;
    }




    4、@Basic  可以看做是基础修饰,默认每一个属性都有。默认如果不写的话为:@Basic(fetch=FetchType.EAGER,optional=true)
    fetch表示的是加载策略/读取策略,有EAGER和LAZY两种,分别表示主支抓取和延迟加载,默认为EAGER.
    但是,如果想要使用懒加载,则必须使用load方法,使用get方式是不可以的
    当使用Query的时候会不会懒加载???


    optional表示的是该属性是否允许为null,默认为true,即允许为null


    示例:
    @Basic(optional=false)
    public String getAddress() {
    return address;
    }


    5、@Column:描述了数据库表中该字段的详细定义,这对于根据JPA注解生成数据库表结构的工具非常有用
    1)、name:表示数据库中该字段的名称,默认情形属性名称与类属性名一直
    2)、nullable:表示该字段是否允许为null,默认为true  (注:同@Basic(optional=true/false) 的不同之处在于一个是类对象的属性,一个是数据库中的表的属性)
    3)、unique:表示该字段是否唯一表示,默认为false
    4)、length:表示该字段的大小,仅对String类型的字段有效
    5)、insertable:表示在ORM框架执行插入操作的时候,该字段是否应出现Insert语句中,默认为true。 
    6)、updateable:表示在ORM框架执行更新操作的时候,该字段是否应该出现在UPDATE语句中,默认为true.对于一经创建就不可以更改的字段,该属性非常有用,如对于birthday字段.即 如果设置成false的时候,该字段就是不可更新的了
    7)、columnDefinition:表示该字段在数据库中的实际类型.通常ORM框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR,如果要将String类型映射到特定数据库的BLOB或TEXT字段类型,该属性非常有用.


    示例:
    @Column(name="BIRTH",nullable="false",columnDefinition="DATE")
    public String getBithday() {
    return birthday;
    }


    6、@Transient :表示该属性并非映射到数据库中的字段,即该字段数据库中的表是没有的。


    @Transient与@Basic两者是不能同时存在的,如果没有定义@Transient,则默认为@Basic
    我们可以应用到一些我们自己的定义的方法里面,比如说一个Person类,有birthday这个类型,然后我们为了得到它已经多少岁了,我们通常都是是在Person类中直接写一个 public int getAge()  这个时候age属性就不需要在数据库中的表定义了,因为可以通过计算得到,否则就有点儿数据冗余了。这个时候我们就通过@Transient属性让它不属于表的一个字段


    示例:
    //根据birth计算出age属性
    @Transient
    public int getAge() {
    return getYear(new Date()) - getYear(birth);
    }




    8、@ManyToOne(fetch=FetchType,cascade = CascadeType)   //可选
    表示的是一个 多对一 的映射。该注解标注的属性通常是数据库表的外键
    1)、optional:是否允许该字段为null,即这个属性值是否可以为null,就是说是不是一定要有外键,比如说学生对班级,学生不可以没有班级,所以为false,即不能够为null。  
    2)、fetch,默认为FetchType.EAGER   还有FetchType.LAZY(懒加载)
    3)、cascade:这边比较经常用。表示默认的级联操作方式。有ALL(all)、PERSIST(persist)、MERGE(merge)、REFRESH(refresh)和REMVOE(remove)中的若干组合,默认为无级联操作。
    CascadeType各个值的含义:
    CascadeType.REFRESH(refresh):表示的是级联刷新,当多个用户同时操作一个实体,为了用户取到的数据是实时的,在用实体中的数据之前就可以调用一下refresh()方法!
    CsacadeType.REMOVE(remove):级联删除,当调用remove()方法删除Order实体时会先级联删除OrderItem的相关数据
    CascadeType.MERGE(merge):级联更新,当调用了Merger()方法,如果Order中的数据改变了会相应的更新到OrderItem中的数据
    CascadeType.ALL:包含以上所有级联属性。。上面的哈 
    (注:以上几种级联操作,只能实在满足数据库的约束时才能生效,比如上边的Order和OrderItem存在主外键关联,所以执行REMOVE()方法时是不能实现级联删除的)
    CascadeType.PERSIST(persist):级联保存,当调用了Persist()方法,会级联保存相应的数据。
    4)、TagertEntity:表示该属性关联的实体类型,该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity


    示例:
    //订单Order和用户User是一个ManyToOne的关系
    //在Order类中定义
    @ManyToOne()
    @JoinColumn(name="USER")
    public User getUser() {
    return user;
    }


    9、@JoinColumn(可选)
    这个量的作用就是用来定义外键在我们这个表中的属性名。只能够在有外键处才能够使用。@JoinColumn(name="USER")
    如果我们没有定义这个属性,则默认的外键的属性名,如:
    实体Order有一个user属性来关联实体User,则Order的user属性为一个外键,
    其默认的名称为实体User的名称+下划线+实体User的主键名称




    10、@OneToMany
    描述的是一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段。
    1)fetch:表示的是抓取策略,默认为FetchType.LAZY,因为关联的多个对象通常不必从数据库中预先读取到内存
    2)cascade:表示级联操作策略,对于OneToMany类型的关联非常重要,通常该实体更新或删除的时候,其关联的实体也应当被更新或删除




    例如:实体User和Order是OneToMany的关系,则实体User被删除时,其关联的实体Order也应该被全部删除
    示例:
    @OneTyMany(cascade=ALL)
    public List getOrders() {
    return orders;
    }


    11、@OneToOne(fetch=FetchType,cascade=CascadeType)
    这介描述的是一个一对一的关联
    fetch:表示的是抓取策略,默认为LAZY
    cascade:表示的是级联删除策略


    示例:
    @OneToOne(fetch=FetchType.LAZY)
    public Blog getBlog() {
    return blog;
    }


    12、@ManyToMany


    @ManyToMany描述的是一个多对多关联。多对多关联实际上是两个一对多关联,但是在ManyToMany描述中,中间表是由ORM框架自动处理


    targetEntity:表示多对多关联的另一个实体类的全名,例如:package.Book.class


     mappedBy:表示多对多关联的另一个实体类对应的属性集合名称


    示例:
    User实体表示用户,Book实体表示书籍,为了描述用户收藏的书籍,可以在User和Book之间建立ManyToMany关联
    @Entity
    public class User {
    private List books;
    @ManyToMany(targetEntity=package.Book.class)
    public List getBooks() {
    return books;
    }
    public void setBooks(List books) {
    this.books=books;
    }
    }
    @Entity
    public class Book {
    private List users;
    @ManyToMany(targetEntity=package.Users.class, mappedBy="books")
    public List getUsers() {
    return users;
    }
    public void setUsers(List users) {
    this.users=users;
    }
    }
    两个实体间相互关联的属性必须标记为@ManyToMany,并相互指定targetEntity属性,
    需要注意的是,有且只有一个实体的@ManyToMany注解需要指定mappedBy属性,指向targetEntity的集合属性名称
    利用ORM工具自动生成的表除了User和Book表外,还自动生成了一个User_Book表,用于实现多对多关联


    13、@MappedSuperclass
    可选
    @MappedSuperclass可以将超类的JPA注解传递给子类,使子类能够继承超类的JPA注解
    示例:
    @MappedSuperclass
    public class Employee() {
    ....
    }


    @Entity
    public class Engineer extends Employee {
    .....
    }
    @Entity
    public class Manager extends Employee {
    .....
    }






    14、@Embedded
    可选
    @Embedded将几个字段组合成一个类,并作为整个Entity的一个属性.
    例如User包括id,name,city,street,zip属性.
    我们希望city,street,zip属性映射为Address对象.这样,User对象将具有id,name和address这三个属性.
    Address对象必须定义为@Embededable 
    示例:
    @Embeddable //可以被嵌入的
    public class Address {city,street,zip}
    @Entity
    public class User {
    @Embedded   //将address的每一个属性嵌入到User的表中,Address类没有自己的表
    public Address getAddress() {
    ..........
    }


    }
    展开全文
  • Djangomodels字段含义、用法

    万次阅读 2019-08-23 16:01:54
    字段名称、含义2.参数含义3.元信息Meta(干预数据库建表名等操作)4.扩展二、连表结构 *****1.字段以及参数三、表的操作(正向查询按字段,反向查询按表名)1.基本操作(增、删、改、查)2.表操作进阶(牛逼的 双...

    Model

    一、model基本结构

    1.字段名称、含义

    
    AutoField(Field)
        # int自增列,必须填入参数 primary_key=True
    
    BigAutoField(AutoField)
        # bigint自增列,必须填入参数 primary_key=True
    
        注:当model中如果没有自增列,则自动会创建一个列名为id的列
        from django.db import models
    
        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)
    
        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)
    
    SmallIntegerField(IntegerField):
        # 小整数 -32768 ~ 32767
    
    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        # 正小整数 0 ~ 32767
    IntegerField(Field)
        # 整数列(有符号的) -2147483648 ~ 2147483647
    
    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        # 正整数 0 ~ 2147483647
    
    BigIntegerField(IntegerField):
        # 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807
    
    自定义无符号整数字段
    
        class UnsignedIntegerField(models.IntegerField):
            def db_type(self, connection):
                return 'integer UNSIGNED'
    
        PS: 返回值为字段在数据库中的属性,Django字段默认的值为:
            'AutoField': 'integer AUTO_INCREMENT',
            'BigAutoField': 'bigint AUTO_INCREMENT',
            'BinaryField': 'longblob',
            'BooleanField': 'bool',
            'CharField': 'varchar(%(max_length)s)',
            'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
            'DateField': 'date',
            'DateTimeField': 'datetime',
            'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
            'DurationField': 'bigint',
            'FileField': 'varchar(%(max_length)s)',
            'FilePathField': 'varchar(%(max_length)s)',
            'FloatField': 'double precision',
            'IntegerField': 'integer',
            'BigIntegerField': 'bigint',
            'IPAddressField': 'char(15)',
            'GenericIPAddressField': 'char(39)',
            'NullBooleanField': 'bool',
            'OneToOneField': 'integer',
            'PositiveIntegerField': 'integer UNSIGNED',
            'PositiveSmallIntegerField': 'smallint UNSIGNED',
            'SlugField': 'varchar(%(max_length)s)',
            'SmallIntegerField': 'smallint',
            'TextField': 'longtext',
            'TimeField': 'time',
            'UUIDField': 'char(32)',
    
    BooleanField(Field)
        # 布尔值类型
    
    NullBooleanField(Field):
        # 可以为空的布尔值
    
    CharField(Field)
        # 字符类型
        # 必须提供max_length参数, max_length表示字符长度
    
    TextField(Field)
        # 文本类型
    
    EmailField(CharField)# 字符串类型,Django Admin以及ModelForm中提供验证机制
    
    IPAddressField(Field)
        # 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制
    
    GenericIPAddressField(Field)
        # 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        # 参数:
            protocol,用于指定Ipv4或Ipv6, 'both',"ipv4","ipv6"
            unpack_ipv4, 如果指定为True,则输入::ffff:192.0.2.1时候,可解析为192.0.2.1,开启刺功能,需要protocol="both"
    
    URLField(CharField)
        # 字符串类型,Django Admin以及ModelForm中提供验证 URL
    
    SlugField(CharField)
        # 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号)
    
    CommaSeparatedIntegerField(CharField)
        # 字符串类型,格式必须为逗号分割的数字
    
    UUIDField(Field)
        # 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证
    
    FilePathField(Field)
        # 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能
        # 参数:
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹
    
    FileField(Field)
        # 字符串,路径保存在数据库,文件上传到指定目录
        # 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
    
    ImageField(FileField)
        # 字符串,路径保存在数据库,文件上传到指定目录
        # 参数:
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名(字符串)
            height_field=None   上传图片的宽度保存的数据库字段名(字符串)
    
    DateTimeField(DateField)
        # 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
    
    DateField(DateTimeCheckMixin, Field)
        # 日期格式      YYYY-MM-DD
    
    TimeField(DateTimeCheckMixin, Field)
        # 时间格式      HH:MM[:ss[.uuuuuu]]
    
    DurationField(Field)
        # 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型
    
    FloatField(Field)
        # 浮点型
    
    DecimalField(Field)
        # 10进制小数
        # 参数:
            max_digits,小数总长度
            decimal_places,小数位长度
    
    BinaryField(Field)
        # 二进制类型
    
    字段
    
    

    2.参数含义

    null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
    
    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作
                        如:gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
    
    error_messages      自定义错误信息(字典类型),从而定制想要显示的错误信息;
                        字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如:{'null': "不能为空.", 'invalid': '格式错误'}
    
    validators          自定义错误验证(列表类型),从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如:
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    'c1': '优先错信息1',
                                    'c2': '优先错信息2',
                                    'c3': '优先错信息3',
                                },
                                validators=[
                                    RegexValidator(regex='root_\d+', message='错误了', code='c1'),
                                    RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
                                    EmailValidator(message='又错误了', code='c3'), ]
                            )
    
    

    3.元信息Meta(干预数据库建表名等操作)

    class UserInfo(models.Model):
            nid = models.AutoField(primary_key=True)
            username = models.CharField(max_length=32)
            class Meta:
                # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
                db_table = "table_name"
    
                # 联合索引
                index_together = [
                    ("pub_date", "deadline"),
                ]
    
                # 联合唯一索引
                unique_together = (("driver", "restaurant"),)
    
                # 后台管理界面,admin中显示的表名称
                verbose_name
    
                # verbose_name加s   (复数显示)
                verbose_name_plural
            
        更多:https://docs.djangoproject.com/en/1.10/ref/models/options/
    

    4.扩展

    • 钩子函数,触发model验证,错误提示
    • form验证(error_messages不是一定非得定义,框架自带的信息也足够判断。)
    1.触发Model中的验证和错误提示有两种方式:
        a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示,如果都成功,才来检查Model的字段并显示指定错误信息
        b. 调用Model对象的 "clean_fields" 方法,如:
            # models.py
            class UserInfo(models.Model):
                nid = models.AutoField(primary_key=True)
                username = models.CharField(max_length=32)
    
                email = models.EmailField(error_messages={'invalid': '格式错了.'})
    
            # views.py
            def index(request):
                obj = models.UserInfo(username='11234', email='uu')
                try:
                    print(obj.clean_fields())
                except Exception as e:
                    print(e)
                return HttpResponse('ok')
    
           # Model的clean方法是一个钩子,可用于定制操作,如:上述的异常处理。
    
    2.Admin中修改错误提示
        # admin.py
        from django.contrib import admin
        from model_club import models
        from django import forms
    
    
        class UserInfoForm(forms.ModelForm):
            username = forms.CharField(error_messages={'required': '用户名不能为空.'})
            email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})
            age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})
    
            class Meta:
                model = models.UserInfo
                # fields = ('username',)
                fields = "__all__"
    
    
        class UserInfoAdmin(admin.ModelAdmin):
            form = UserInfoForm
    
    
        admin.site.register(models.UserInfo, UserInfoAdmin)
    
    

    二、连表结构 *****

    • 一对多:models.ForeignKey(其他表)
    • 多对多:models.ManyToManyField(其他表)
    • 一对一:models.OneToOneField(其他表)

    1.字段以及参数

    ForeignKey(ForeignObject) # ForeignObject(RelatedField)
            to,                         # 要进行关联的表名
            to_field=None,              # 要关联的表中的字段名称
            on_delete=None,             # 当删除关联表中的数据时,当前表与其关联的行的行为,可设置为如下值:
            # 具体的解释可见下边的解释:
                                            - models.CASCADE,删除关联数据,与之关联也删除
                                            - models.DO_NOTHING,删除关联数据,引发错误IntegrityError
                                            - models.PROTECT,删除关联数据,引发错误ProtectedError
                                            - models.SET_NULL,删除关联数据,与之关联的值设置为null(前提FK字段需要设置为可空)
                                            - models.SET_DEFAULT,删除关联数据,与之关联的值设置为默认值(前提FK字段需要设置默认值)
                                            - models.SET,删除关联数据,
                                                          a. 与之关联的值设置为指定值,设置:models.SET()
                                                          b. 与之关联的值设置为可执行对象的返回值,设置:models.SET(可执行对象)
    
                                                            def func():
                                                                return 10
    
                                                            class MyModel(models.Model):
                                                                user = models.ForeignKey(
                                                                    to="User",
                                                                    to_field="id"
                                                                    on_delete=models.SET(func),)
            related_name=None,          # 反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.表名_set.all()
            related_query_name=None,    # 反向操作时,使用的连接前缀,用于替换【表名】     如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
            limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时,提供的条件:
                                        # 如:
                                                - limit_choices_to={'nid__gt': 5}
                                                - limit_choices_to=lambda : {'nid__gt': 5}
    
                                                from django.db.models import Q
                                                - limit_choices_to=Q(nid__gt=10)
                                                - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                                - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
            db_constraint=True          # 是否在数据库中创建外键约束
            parent_link=False           # 在Admin中是否显示关联数据
    
    
        OneToOneField(ForeignKey)
            to,                         # 要进行关联的表名
            to_field=None               # 要关联的表中的字段名称
            on_delete=None,             # 当删除关联表中的数据时,当前表与其关联的行的行为
    
                                        ###### 对于一对一 ######
                                        # 1. 一对一其实就是 一对多 + 唯一索引
                                        # 2.当两个类之间有继承关系时,默认会创建一个一对一字段
                                        # 如下会在A表中额外增加一个c_ptr_id列且唯一:
                                                class C(models.Model):
                                                    nid = models.AutoField(primary_key=True)
                                                    part = models.CharField(max_length=12)
    
                                                class A(C):
                                                    id = models.AutoField(primary_key=True)
                                                    code = models.CharField(max_length=1)
    
        ManyToManyField(RelatedField)
            to,                         # 要进行关联的表名
            related_name=None,          # 反向操作时,使用的字段名,用于代替 【表名_set】 如: obj.表名_set.all()
            related_query_name=None,    # 反向操作时,使用的连接前缀,用于替换【表名】     如: models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
            limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时,提供的条件:
                                        # 如:
                                                - limit_choices_to={'nid__gt': 5}
                                                - limit_choices_to=lambda : {'nid__gt': 5}
    
                                                from django.db.models import Q
                                                - limit_choices_to=Q(nid__gt=10)
                                                - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
                                                - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
            symmetrical=None,           # 仅用于多对多自关联时,symmetrical用于指定内部是否创建反向操作的字段
                                        # 做如下操作时,不同的symmetrical会有不同的可选字段
                                            models.BB.objects.filter(...)
    
                                            # 可选字段有:code, id, m1
                                                class BB(models.Model):
    
                                                code = models.CharField(max_length=12)
                                                m1 = models.ManyToManyField('self',symmetrical=True)
    
                                            # 可选字段有: bb, code, id, m1
                                                class BB(models.Model):
    
                                                code = models.CharField(max_length=12)
                                                m1 = models.ManyToManyField('self',symmetrical=False)
    
            through=None,               # 自定义第三张表时,使用字段用于指定关系表
            through_fields=None,        # 自定义第三张表时,使用字段用于指定关系表中那些字段做多对多关系表
                                            from django.db import models
    
                                            class Person(models.Model):
                                                name = models.CharField(max_length=50)
    
                                            class Group(models.Model):
                                                name = models.CharField(max_length=128)
                                                members = models.ManyToManyField(
                                                    Person,
                                                    through='Membership',
                                                    through_fields=('group', 'person'),
                                                )
    
                                            class Membership(models.Model):
                                                group = models.ForeignKey(Group, on_delete=models.CASCADE)
                                                person = models.ForeignKey(Person, on_delete=models.CASCADE)
                                                inviter = models.ForeignKey(
                                                    Person,
                                                    on_delete=models.CASCADE,
                                                    related_name="membership_invites",
                                                )
                                                invite_reason = models.CharField(max_length=64)
            db_constraint=True,         # 是否在数据库中创建外键约束
            db_table=None,              # 默认创建第三张表时,数据库中表的名称
    
    
    

    摘自Stack overflow网友的回答:

    This is the behaviour to adopt when the referenced object is deleted. It is not specific to django, this is an SQL standard.

    There are 6 possible actions to take when such event occurs:

    CASCADE: When the referenced object is deleted, also delete the objects that have references to it (When you remove a blog post for instance, you might want to delete comments as well). SQL equivalent: CASCADE.
    PROTECT: Forbid the deletion of the referenced object. To delete it you will have to delete all objects that reference it manually. SQL equivalent: RESTRICT.

    SET_NULL: Set the reference to NULL (requires the field to be nullable). For instance, when you delete a User, you might want to keep the comments he posted on blog posts, but say it was posted by an anonymous (or deleted) user. SQL equivalent: SET NULL.

    SET_DEFAULT: Set the default value. SQL equivalent: SET DEFAULT.

    SET(...): Set a given value. This one is not part of the SQL standard and is entirely handled by Django.

    DO_NOTHING: Probably a very bad idea since this would create integrity issues in your database (referencing an object that actually doesn’t exist). SQL equivalent: NO ACTION.

    Source: Django documentation

    See also the documentation of PostGreSQL for instance.

    In most cases, CASCADE is the expected behaviour, but for every ForeignKey, you should always ask yourself what is the expected behaviour in this situation. PROTECT and SET_NULL are often useful. Setting CASCADE where it should not, can potentially delete all your database in cascade, by simply deleting a single user.


    三、表的操作(正向查询按字段,反向查询按表名)

    1.基本操作(增、删、改、查)

    # 增
    models.Tb1.objects.create(c1='xx', c2='oo') #增加一条数据,可以接受字典类型数据 **kwargs
    
    obj = models.Tb1(c1='xx', c2='oo')
    obj.save()  # 记得调用save方法,保存到数据库。
    
    # 查
    models.Tb1.objects.get(id=123)         # 获取单条数据,不存在则报错(不建议)
    models.Tb1.objects.all()               # 获取全部
    models.Tb1.objects.filter(name='seven') # 获取指定条件的数据,返回数据列表,没有返回空列表[]
    
    # 删
    models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据
    
    # 改
    models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新,均支持 **kwargs
    # obj = models.Tb1.objects.get(id=1)
    # obj.c1 = '111'
    # obj.save()                                                 # 修改单条数据
    

    2.表操作进阶(牛逼的 双下划线 __ )

    利用 双下划线_set 将表之间的操作连接起来

    # 获取个数
    models.Tb1.objects.filter(name='seven').count()
    
    # 大于,小于
    models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
    models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
    models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
    models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
    
    # in
    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
    
    # isnull
    Entry.objects.filter(pub_date__isnull=True)
    
    # contains包含
    models.Tb1.objects.filter(name__contains="ven")
    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
    models.Tb1.objects.exclude(name__icontains="ven")
    
    # range范围
    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
    
    # 其他类似
    startswith,istartswith, endswith, iendswith,
    
    # order by排序
    models.Tb1.objects.filter(name='seven').order_by('id')    # asc正序
    models.Tb1.objects.filter(name='seven').order_by('-id')   # desc倒序
    
    # group by
    from django.db.models import Count, Min, Max, Sum
    models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
    等价于SQL语句:SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
    
    # limit 、offset
    models.Tb1.objects.all()[10:20]
    
    # regex正则匹配,iregex 不区分大小写
    Entry.objects.get(title__regex=r'^(An?|The) +')
    Entry.objects.get(title__iregex=r'^(an?|the) +')
    
    # date
    Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
    Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
    
    # year
    Entry.objects.filter(pub_date__year=2005)
    Entry.objects.filter(pub_date__year__gte=2005)
    
    # month
    Entry.objects.filter(pub_date__month=12)
    Entry.objects.filter(pub_date__month__gte=6)
    
    # day
    Entry.objects.filter(pub_date__day=3)
    Entry.objects.filter(pub_date__day__gte=3)
    
    # week_day
    Entry.objects.filter(pub_date__week_day=2)
    Entry.objects.filter(pub_date__week_day__gte=2)
    
    # hour
    Event.objects.filter(timestamp__hour=23)
    Event.objects.filter(time__hour=5)
    Event.objects.filter(timestamp__hour__gte=12)
    
    # minute
    Event.objects.filter(timestamp__minute=29)
    Event.objects.filter(time__minute=46)
    Event.objects.filter(timestamp__minute__gte=29)
    
    # second
    Event.objects.filter(timestamp__second=31)
    Event.objects.filter(time__second=2)
    Event.objects.filter(timestamp__second__gte=31)
    
    # 例子
    get示例:
        # 例:查询图书id为3的图书信息。
        # 注意这里有且只有一个才行,多了或者没有都会报错
        BookInfo.objects.get(id=3)
    
    all方法示例:
        # 例:查询图书所有信息。
        BookInfo.objects.all()
    
    filter方法示例:
        """
        条件格式:(双下划线)
            模型类属性名__条件名=值
        """
        查询图书评论量为34的图书的信息:
        a)判等 条件名:exact。
            # 例:查询编号为1的图书。
            BookInfo.objects.get(id=1)
        b)模糊查询(相当于sql的 like)
            # 例:查询书名包含'传'的图书。contains
            BookInfo.objects.filter(btitle__contains='传')
            # 例:查询书名以'部'结尾的图书 endswith 开头:startswith
            BookInfo.objects.filter(btitle__endswith='部')
        c)空查询 isnull
            # 例:查询书名不为空的图书。isnull 
            select * from booktest_bookinfo where btitle is not null;
            BookInfo.objects.filter(btitle__isnull=False)
        d)范围查询 in
            # 例:查询id为1或3或5的图书。
            select * from booktest_bookinfo where id in (1,3,5);
            BookInfo.objects.filter(id__in = [1,3,5])
        e)比较查询 gt(greate than) lt(less  than) gte(equal)大于等于   lte小于等于
            # 例:查询id大于3的图书。
            Select * from booktest_bookinfo where id>3;
            BookInfo.objects.filter(id__gt=3)
        f)日期查询
            # 例:查询1980年发表的图书。
            BookInfo.objects.filter(bpub_date__year=1980)
            # 例:查询1980年1月1日后发表的图书。
            from datetime import date
            BookInfo.objects.filter(bpub_date__gt=date(1980,1,1))
    
    exclude方法示例:
        # 例:查询id不为3的图书信息。
        BookInfo.objects.exclude(id=3)
        
    order_by方法示例:
        作用:进行查询结果进行排序。默认是升序,在条件里加“-”表示降序
        # 例:查询所有图书的信息,按照id从小到大进行排序。
        BookInfo.objects.all().order_by('id')
        # 例:查询所有图书的信息,按照id从大到小进行排序。
        BookInfo.objects.all().order_by('-id')
        # 例:把id大于3的图书信息按阅读量从大到小排序显示。
        BookInfo.objects.filter(id__gt=3).order_by('-bread')
    

    3.其他

    # extra
    #
    extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
    
    # F对象
    #
    from django.db.models import F
    models.Tb1.objects.update(num=F('num')+1)
    
    
    # Q对象
    #
    # 方式一:
    Q(nid__gt=10)
    Q(nid=8) | Q(nid__gt=10)
    Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
    # 方式二:
    con = Q()
    q1 = Q()
    q1.connector = 'OR'
    q1.children.append(('id', 1))
    q1.children.append(('id', 10))
    q1.children.append(('id', 9))
    q2 = Q()
    q2.connector = 'OR'
    q2.children.append(('c1', 1))
    q2.children.append(('c1', 10))
    q2.children.append(('c1', 9))
    con.add(q1, 'AND')
    con.add(q2, 'AND')
    
    models.Tb1.objects.filter(con)
    
    
    # 执行原生SQL
    #
    from django.db import connection, connections
    cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1])
    row = cursor.fetchone()
    
    

    4.联表操作(利用 双下划线 __ )

    • Model表结构实例
    class UserProfile(models.Model):
        user_info = models.OneToOneField('UserInfo')
        username = models.CharField(max_length=64)
        password = models.CharField(max_length=64)
    
        def __unicode__(self):
            return self.username
    
    
    class UserInfo(models.Model):
        user_type_choice = (
            (0, u'普通用户'),
            (1, u'高级用户'),
        )
        user_type = models.IntegerField(choices=user_type_choice)
        name = models.CharField(max_length=32)
        email = models.CharField(max_length=32)
        address = models.CharField(max_length=128)
    
        def __unicode__(self):
            return self.name
    
    
    class UserGroup(models.Model):
    
        caption = models.CharField(max_length=64)
    
        user_info = models.ManyToManyField('UserInfo')
    
        def __unicode__(self):
            return self.caption
    
    
    class Host(models.Model):
        hostname = models.CharField(max_length=64)
        ip = models.GenericIPAddressField()
        user_group = models.ForeignKey('UserGroup')
    
        def __unicode__(self):
            return self.hostname
    
    

    1. 一对一操作

    user_info_obj = models.UserInfo.objects.filter(id=1).first()
    print(user_info_obj.user_type)
    print(user_info_obj.get_user_type_display())
    print(user_info_obj.userprofile.password)
     
    user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
    print(user_info_obj.keys())
    print(user_info_obj.values())
    

    2.一对多

    • 类似一对一
      • 1、搜索条件使用 __连接
      • 2、获取值时使用 . 连接

    3.多对多

    user_info_obj = models.UserInfo.objects.get(name=u'武沛齐')
    user_info_objs = models.UserInfo.objects.all()
    
    group_obj = models.UserGroup.objects.get(caption='CEO')
    group_objs = models.UserGroup.objects.all()
    
    -------------------------------------------------------------
    # 添加数据
    group_obj.user_info.add(user_info_obj)
    group_obj.user_info.add(*user_info_objs)  # 注意星号
    
    # 删除数据
    group_obj.user_info.remove(user_info_obj)
    group_obj.user_info.remove(*user_info_objs)
    
    # 添加数据
    user_info_obj.usergroup_set.add(group_obj)
    user_info_obj.usergroup_set.add(*group_objs)
    
    # 删除数据
    user_info_obj.usergroup_set.remove(group_obj)
    user_info_obj.usergroup_set.remove(*group_objs)
    
    # 获取数据
    print group_obj.user_info.all()
    print group_obj.user_info.all().filter(id=1)
    
    # 获取数据
    print user_info_obj.usergroup_set.all()  # __set
    print user_info_obj.usergroup_set.all().filter(caption='CEO')
    print user_info_obj.usergroup_set.all().filter(caption='DBA')
    

    5.扩展(上传文件)

    • 自定义文件上传
    def upload_file(request):
        if request.method == "POST":
            obj = request.FILES.get('fafafa')
            f = open(obj.name, 'wb')
            for chunk in obj.chunks():  # chunks函数将收到的数据分块
                f.write(chunk)
            f.close()
        return render(request, 'file.html')
    
    • Form上传文件实例
    # Form
    class FileForm(forms.Form):
        ExcelFile = forms.FileField()
        
    # Model
    from django.db import models
    
    class UploadFile(models.Model):
        userid = models.CharField(max_length = 30)
        file = models.FileField(upload_to = './upload/')
        date = models.DateTimeField(auto_now_add=True)
        
    # View
    def UploadFile(request):
        uf = AssetForm.FileForm(request.POST,request.FILES)
        if uf.is_valid():
                upload = models.UploadFile()
                upload.userid = 1
                upload.file = uf.cleaned_data['ExcelFile']
                upload.save()
                
                print upload.file
    

    6. 批量删除

    • 一般删除: models.SyncRecord.objects.filter(create_time__lte=clear_timestamp).delete() 根据过滤出来的数据直接调用删除
    • 当有page、limit在内时django是不支持进行直接的批量操作的
      • 可以利用子查询:
      models.SyncRecord.objects.filter(
              pk__in=(models.SyncRecord.objects.order_by('create_time').values_list('pk')[:5])
      ).delete()
      
      # django ORM 利用列表切片来实现sql中的page/limit操作,在利用orm生成sql时,会自动将其转换为page/limit
      
      • 但是低版本mysql(如:5.7.2)不支持这种查询,可转换为:
      id_query_set = models.SyncRecord.objects.order_by('create_time')[:clear_count].values_list('id')
      # django获取到的都是个queryset对象
      clear_id_list = [int(i[0]) for i in id_query_set]
      models.SyncRecord.objects.filter(id__in=clear_id_list).delete()
      
    展开全文
  • SQL数据库字段数据类型说明

    千次阅读 2018-03-15 23:23:47
    SQL数据库常用字段数据类型说明这里先总结数据类型。MySQL的数据类型大的方面来分,可以分为:日期和时间、数值,以及字符串。下面就分开来进行总结。日期和时间数据类型MySQL数据类型含义date3字节,日期,格式:...
  • 在项目的开发过程,经常会遇到数据库会有一些状态字段(如INIT-》processing-》Exception-》SUccess)等,对于status字段在数据表如何存储?目前有一下的解决方法: (1)将状态字段对应的值映射为数字如0,...
  • 关系数据库模型设计

    千次阅读 2020-05-19 17:13:17
    本文从现实世界-概念世界(信息世界)-机器世界(数据世界)逐级抽象,旨在以浅显易懂的语言描述关系数据库应该如何建模,最后用简单名了的描述给出关系模型的设计范式的含义
  • 关系模型名词解释 (1)关系模型:用二维表格结构表示实体集,外键表示实体间联系的数据模型称为关系模型。 (2)关系模式:关系模式实际上就是记录类型。它的定义包括:模式名,属性...在关系模型字段称为属性。...
  • 数据库字段属性和索引

    千次阅读 2019-07-05 23:30:25
    字段属性 ...SQL操作有多种方式可以给表增加主键:大体分为三种 方案1:在创建表的时候,直接在字段之后,跟primary key 关键字(主键本身不允许为空) 例如:创建表course,设置主键为Cname creat...
  • 关系数据库如何工作

    千次阅读 2021-05-15 10:54:02
    当涉及到关系数据库时,我不禁会以为有些东西丢失了。它们无处不在。有许多不同的数据库:从小型且有用的SQLite到功能强大的Teradata。但是,只有少数几篇文章解释了数据库的工作方式。您可以自己在Google上搜索...
  • 数据库中的Schema是什么?

    万次阅读 多人点赞 2018-01-10 13:14:35
    数据库中,schema(发音 “skee-muh” 或者“skee-mah”,中文叫模式)是数据库的组织和结构,schemas andschemata都可以作为复数形式。模式包含了schema对象,可以是表(table)、列(column)、数据类型(data type...
  • 数据库字段属性的详解

    千次阅读 2019-03-04 17:14:00
    好比C++,定义int类型需要多少字节,定义double类型需要多少字节一样,MySQL对表每个列的数据也会实行严格控制,这是数据驱动应用程序成功的关键。M前言 好比C++,定义int类型需要多少字节,定义double类型...
  • 关系数据库的理解

    千次阅读 2015-11-26 19:43:50
    常用的关系数据库有Oracle,SqlServer,Informix,MySql,SyBase等。(也即是我们平时看到的数据库,都是关系型数据库) 2.所谓关系型数据库,是指采用了关系模型来组织数据的数据库。关系模型是在1970年由IBM的...
  • 关系数据库 采用关系模型来组织数据结构的数据库(二维表) cle DB2 SQLServer Mysql SQLite都是关系数据库 优点:容易理解,它的逻辑类似常见的表格 使用方便,都使用sql语句,sql语句非常的成熟 数据一致性...
  • Hibernate4 注解方法所有的字段含义

    千次阅读 2015-12-30 14:48:43
    可选,表示数据库字段的名称,默认情形属性名称一致 nullable - 可选,表示该字段是否允许为 null ,默认为 true unique - 可选,表示该字段是否是唯一标识,默认为 false length -...
  • 文章目录0.思维导图1. 关系(1)域(Domain)(2)...关系数据库 0.思维导图 1. 关系 什么是关系? 单一的数据结构----关系 现实世界的实体以及实体间的各种联系均用关系来表示 逻辑结构----二维表 从用户角度,...
  • 文章目录一、关系数据库与非关系型数据库概述1、关系型数据库2、非关系型数据库二、关系数据库与非关系型数据库区别1、数据存储方式不同2、扩展方式不同3、对事务性的支持不同三、非关系型数据库产生背景四、Redis...
  • WordPress数据库表及字段详解

    千次阅读 2016-07-08 16:47:32
    今天熊哥在朋友的博客看到关于wordpress数据库的介绍,感觉很有用,相信对同样在使用wordpress的同学也很有用,所以就拿...一翻折腾,在糊里糊涂按网上的教程终于搞定,享受成就感时也第一次接触了数据库。那时感觉数
  • 关系数据库的简单概念和简单操作

    千次阅读 2021-01-16 22:40:41
    1.关系数据库:在一个给定的应用领域,所有实体及实体之间联系的集合构成一个关系数据库。它是一种以关系模式为基础存储数据以及用数字方法处理数据库组织的方法,是目前最为流行的一种数据组织形式。(接下来我所...
  • odoo字段含义和用法

    千次阅读 2018-11-07 17:18:50
    视频教程 视频教程地址:... odoo中字段的定义和含义 # _*_ coding:utf-8 _*_ # author: zhy import uuid from itertools import groupby from datetime import datetime, timedelta fro...
  • 关系数据库系列文章之到底什么是关系(一)

    千次阅读 多人点赞 2018-08-05 02:28:45
    在语言X如何实现Y,像这种具体的只是(know-how)可快速提高你的工作效率。但是一旦语言发生变化,这种知识就无法再使用。... 作为程序员,在日常的开发,我们避免不了的就要接触数据库这个概念,而关系...
  • 关系数据库标准语言——SQL

    千次阅读 2019-07-08 08:18:00
    关系数据库标准语言——SQL 1.SQL的基本概念 1.基本表 ​ 一个关系对应一个基本表。基本表是独立存在的表,不是由其他表导出的。一个,或者多个机泵表对应一个存储文件。 2.视图 ​ 视图是从一个或者几个基本表导出...
  • 数据库 一、概念 数据库是以一定方式储存在一起、能与多个用户共享、具有尽可能小的冗余度、与应用程序彼此独立的数据集合。 ...三、NoSQL与关系数据库的区别 存储方式 传统的关系型数...
  • 本篇文章主要介绍了"执行计划各个字段含义描述及获取方法",主要涉及到执行计划各个字段含义描述及获取方法方面的内容,对于执行计划各个字段含义描述及获取方法感兴趣的同学可以参考一下。 一、概述 ...
  • 数据库表与字段命名的规范总结

    千次阅读 2019-05-09 15:45:12
    开发工具与关键技术:PowerDesigner 数据库 作者:何钦波 撰写时间:2019/ 5 /8 一、 数据库表的分类 表前缀主要是为了区分不同功能的表,而非解释表的功能,表的功能由表名来解释。前面要求表名的长度要控制在30个...
  • Zabbix_zabbix数据库表各字段说明

    万次阅读 2017-05-14 21:34:33
    前言:网上有很多关于zabbix数据库的资料,但大多是复制+转载,我一直想找一篇博客是关于zabbix数据库表字段的说明,但始终找不到,为此不得不将工作需要的表字段一一记录,为了防止和我有相同需求的小伙伴和我...
  • 用户通过查询来检索数据库中的数据,而查询是一个用于限定数据库中某些区域的执行代码。关系模型可以简单理解为二维表格模型,而一个关系数据库就是由二维表及其之间的关系组成的一个数据组织。 常见的关系型...
  • 1.数据库设计14规则 1. 原始单据与实体之间的关系   可以是一对一、一对多、多对多的关系。在一般情况下,它们是一对一的关系:即一张原始单据对应且只对应一个实体。  在特殊情况下,它们可能是一对多或多对...
  • 一文带你了解关系数据库设计要领

    千次阅读 2020-04-04 02:35:13
    文章目录摘要实体-关系模型(E-R)关系表设计Boyce-Codd范式第...本文讨论关系数据库设计相关的一些内容,涉及关系模型,表结构设计等内容,以学生选修课程讲述设计过程,在尽量讲清楚设计要领的前提下,简化设计内...
  • 数据库Schema两种含义

    千次阅读 2012-08-09 09:51:04
    还有一种是物理上的 Schema,指的是数据库中的一个名字空间,它包含一组表、视图和存储过程等命名对象。物理Schema可以通过标准SQL语句来创建、更新和修改。例 如以下SQL语句创建了两个物理Schema:  create s

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,927
精华内容 24,770
关键字:

关系数据库中字段的含义