精华内容
下载资源
问答
  • Django对数据库的操作分用到三个类:Manager、QuerySet、Model。 Manager的主要功能定义表级方法(表级方法就是影响一条或多条记录的方法),我们可以以models.Manager为父类,定义自己的manager,增加表级方法; ...

    Django对数据库的操作分用到三个类:Manager、QuerySet、Model。

    Manager的主要功能定义表级方法(表级方法就是影响一条或多条记录的方法),我们可以以models.Manager为父类,定义自己的manager,增加表级方法;

    QuerySet是Manager的方法返回的,是一个可遍历结构,包含一个或多个元素,每个元素都是一个Model 实例,它里面的方法也是表级方法。

    Model是一条记录的类,它的功能很强大,里面包含外键实体等,它的方法都是记录级方法(都是实例方法,无类方法),不要在里面定义类方法,比如计算记录的总数,查看所有记录,这些应该放在自定义的manager类中。

    Django给我们提供了增加表级方法的途径,那就是自定义manager类,而不是自定义QuerySet类,一般的我们没有自定义QuerySet类的必要;

    1.QuerySet

    1.1 简介

    每个Model都有一个默认的manager类,名为objects,QuerySet有两种来源:通过manager的方法得到、通过QuerySet的方法得到。QuerySet的最初来源就是通过manager的方法。mananger的方法和QuerySet的方法大部分同名,同意思,如filter(),update()等,但也有些不同,如manager有create()、get_or_create(),而QuerySet有delete()等。一个QuerySet包含一个或多个model instance。QuerySet类似于Python中的list,list的一些方法QuerySet也有,比如切片,遍历。

    from gk_user.models import UserEx

    >>> type(UserEx.objects)

    <class ‘django.db.models.manager.Manager’>

    >>> a = UserEx.objects.all()

    >>> type(a)

    <class ‘django.db.models.query.QuerySet’>

    QuerySet是延迟获取的,只有当用到这个QuerySet时(有下面几种情况),才会求值,即查询数据库。另外,查询到的QuerySet又是缓存的,当再次使用同一个QuerySet时,并不会再查询数据库,而是直接从缓存获取(不过,有一些特殊情况)。一般而言,当对一个没有求值的QuerySet进行的运算返回的不是QuerySet、ValuesQuerySet、ValuesListQuerySet、Model实例时,一般的会立即查询数据库;反之,运算返回的是QuerySet、ValuesQuerySet、ValuesListQuerySet、Model实例时,一般不会查询数据库。下面介绍几种(并非全部)对QuerySet求值的场景。

    class Blog(models.Model):

    name = models.CharField(max_length=100)

    tagline = models.TextField()

    def unicode(self):

    ​ return self.name

    class Author(models.Model):

    name = models.CharField(max_length=50)

    email = models.EmailField()

    def unicode(self):

    ​ return self.name

    class Entry(models.Model):

    blog = models.ForeignKey(Blog)

    headline = models.CharField(max_length=255)

    body_text = models.TextField()

    pub_date = models.DateField()

    mod_date = models.DateField()

    authors = models.ManyToManyField(Author)

    n_comments = models.IntegerField()

    n_pingbacks = models.IntegerField()

    rating = models.IntegerField()

    def unicode(self):

    ​ return self.headline

    我们以上面的models为例。

    一 遍历

    a = Entry.objects.all()

    for e in a:

    print (e.headline)

    当遍历时,先从数据库执行查询select * from Entry得到a,然后再遍历a。

    注意:这里只是查询Entry表,返回的a的每条记录只包含Entry表的字段值。不管Entry的model中是否有onetoone、onetomany、manytomany字段,都不会关联查询。这遵循的是数据库最少读写原则。

    我们修改一下代码,如下,遍历一开始也是先执行查询得到a,但当执行print (e.blog.name)时,还需要再次查询数据库获取blog实体。

    from django.db import connection

    l = connection.queries #l是一个列表,记录SQL语句

    a = Entry.objects.all()

    for e in a:

    print (e.blog.name)

    len(l)

    遍历时,每次都要查询数据库,l长度每次增1,Django提供了方法可以在查询时返回关联表实体,如果是onetoone或onetomany,那用select_related,不过对于onetomany,只能在主表(定义onetomany关系的那个表)的manager中使用select_related方法,即通过select_related获取的关联对象是model instance,而不能是QuerySet,

    如下,e.blog就是model instance。对于onetomany的反向和manytomany,要用prefetch_related,它返回的关联对象是QuerySet。

    a = Entry.objects.select_related(‘blog’)

    for e in a:

    print (e.blog.name)

    len(l)

    可以看到从开始到结束,l的长度只增加1。另外,通过查询connection.queries[-1]可以看到Sql语句用了join。

    二切片

    切片不会立即执行,除非显示指定了步长,如a= Entry.objects.all()[0:10:2],步长为2。

    三序列化,即Pickling

    序列化QuerySet很少用

    四repr()

    和str()功能相似,将对象转为字符串,很少用。

    五len()

    计算QuerySet元素的数量,并不推荐使用len(),除非QuerySet是求过值的(即evaluated),否则,用QuerySet.count()获取元素数量,这个效率要高。

    六 list()

    将QuerySet转为list

    七 bool(),判断是否为空

    if Entry.objects.filter(headline=“Test”):

    print(“There is at least one Entry with the headline Test”)

    同样不建议这种方法判断是否为空,而应该使用QuerySet.exists(),查询效率高

    八QuerySet的方法

    数据库的常用操作就四种:增、删、改、查,QuerySet的方法涉及删、改、查。后面还会讲model对象的方法,model方法主要是增、删、改、还有调用model实例的字段。

    (1) 删delete()

    原型:delete()

    返回:None

    相当于delete-from-where, delete-from-join-where。先filter,然后对得到的QuerySet执行delete()方法就行了,它会同时删除关联它的那些记录,比如我删除记录表1中的A记录,表2中的B记录中有A的外键,那同时也会删除B记录,那ManyToMany关系呢?不清楚。实际中,delete用的很少,对于没有用的记录,一般是update为不可用。由于有些数据库,如Sqlite不支持delete与limit连用,所以在这些数据库对QuerySet的切片执行delete()会出错。如

    >>> a = UserEx.objects.filter(is_active=False)

    >>> b = a[:3]

    >>> b.delete() #执行时会报错

    解决:UserEx.objects.filter(pk__in=b).delete()

    in后面可以是一个QuerySet,见 https://docs.djangoproject.com/en/1.6/ref/models/querysets/#in

    (2) 改 update()

    批量修改,返回修改的记录数。不过update()中的键值对的键只能是主表中的字段,不能是关联表字段,如下

    Entry.objects.update(blog__name=‘foo’) #这是错误的,无法修改关联表字段,只能修改Entry

    #表中的字段

    Entry.objects.filter(blog__name=‘foo’).update(comments_on=False) #正确,filter中的字段可以

    #是关联表

    最好的方法是先filter,查询出QuerySet,然后再执行QuerySet.update()。

    由于有些数据库,不支持update与limit连用,所以在这些数据库对QuerySet的切片执行update()会出错。

    (3)查询 filter(**kwargs)、exclude(**kwargs)、get(**kwargs)

    相当于select-from-where,select-from-join-where,很多网站读数据库操作最多。可以看到,filter()的参数是变个数的键值对,而不会出现>,<,!=等符号,这些符号分别用__gt,__lt,~Q或exclude(),不过对于!=,建议使用Q查询,更不容易出错。可以使用双下划线对OneToOne、OneToMany、ManyToMany进行关联查询和反向关联查询,而且方法都是一样的,如:

    >>> Entry.objects.filter(blog__name=‘Beatles Blog’) #限定外键表的字段下面是反向连接,不过要

    #注意,这里不是entry_set,entry_set是Blog instance的一个属性,代表某个Blog object

    #的关联的所有entry,而QuerySet的方法中反向连接是直接用model的小写,不要把两者搞#混。It works backwards, too. To refer to a “reverse” relationship, just use the lowercase name of #the model.

    >>> Blog.objects.filter(entry__headline__contains=‘Lennon’)

    >>> Blog.objects.filter(entry__authors__name=‘Lennon’) #ManyToMany关系,反向连接

    >>> myblog = Blog.objects.get(id=1)

    >>> Entry.objects.filter(blog=myblog) #正向连接。与下面一句等价,既可以用实体,也可以用

    #实体的主键,其实即使用实体,也是只用实体的主键而已。这两种方式对OneToOne、

    #OneToMany、ManyToMany的正向、反向连接都适用。

    >>> Entry.objects.filter(blog=1)

    >>> myentry = Entry.objects.get(id=1)

    >>> Blog.objects.filter(entry=myentry) #ManyToMany反向连接。与下面一句等价

    >>> Blog.objects.filter(entry=1)

    OneToOne的关系也是这样关联查询,可以看到,Django对OneToOne、OneToMany、ManyToMany关联查询及其反向关联查询提供了相同的方式,真是牛逼啊。对于OneToOne、OneToMany的主表,也可以使用下面的方式

    Entry.objects.filter(blog_id=1),因为blog_id是数据库表Entry的一个字段, 这条语句与Entry.objects.filter(blog=1)生成的SQL是完全相同的,都是只在Entry表查询,没用join,django为我们封装了对数据库的操作,所以建议只用model中的字段,而blog_id不是model定义的字段,不建议用。

    与filter类似的还有exclude(**kwargs)方法,这个方法是剔除,相当于select-from-where not,select-from-join-where not。可以使用双下划线对OneToOne、OneToMany、ManyToMany进行关联查询和反向关联查询,方法与filter()中的使用方法相同。

    >>> Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3), headline=‘Hello’)

    转为SQL为

    SELECT *

    FROM Entry

    WHERE NOT (pub_date > ‘2005-1-3’ AND headline = ‘Hello’)

    (4)SQL其它关键字在django中的实现

    在SQL中,很多关键词在删、改、查时都是可以用的,如order by、 like、in、join、union、and、or、not等等,我们以查询为例,说一下django如何映射SQL的这些关键字的(查、删、改中这些关键字的使用基本相同)。

    No1 F类(无对应SQL关键字)

    前面提到的filter/exclude中的查询参数值都是常量,如果我们想比较model的两个字段怎么办呢?Django也提供了方法,F类,F类实例化时,参数也可以用双下划线,也可以逻辑运算,如下

    >>> from django.db.models import F

    >>> Entry.objects.filter(n_comments__gt=F(‘n_pingbacks’))

    >>> from datetime import timedelta

    >>> Entry.objects.filter(mod_date__gt=F(‘pub_date’) + timedelta(days=3))

    >>> Entry.objects.filter(authors__name=F(‘blog__name’))

    No2 Q类(对应and/or/not)

    如果有or等逻辑关系呢,那就用Q类,filter中的条件可以是Q对象与非Q查询混和使用,但不建议这样做,因为混和查询时Q对象要放前面,这样就有难免忘记顺序而出错,所以最好如果使用Q对象,那就全部用Q对象。Q对象也很简单,就是把原来filter中的各个条件分别放在一个Q()即可,不过我们还可以使用或与非,分别对应符号为"|“和”&“和”~",而且这些逻辑操作返回的还是一个Q对象,另外,逗号是各组条件的基本连接符,也是与的关系,其实可以用&代替(在python manage.py shell测试过,&代替逗号,执行的SQL是一样的),不过那样的话可读性会很差,这与我们直接写SQL时,各组条件and时用换行一样,逻辑清晰。

    from django.db.models import Q

    >>> Poll.objects.get( Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),

    question__startswith=‘Who’) #正确,但不要这样混用

    >>> Poll.objects.get( Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),

    Q(question__startswith=‘Who’)) #推荐,全部是Q对象

    >>> Poll.objects.get( (Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))&

    Q(question__startswith=‘Who’)) #与上面语句同意,&代替",",可读性差

    Q类中时应该可以用F类,待测试。

    No3 annotate(无对应SQL关键字)

    函数原型annotate(*args, **kwargs)

    返回QuerySet

    往每个QuerySet的model instance中加入一个或多个字段,字段值只能是聚合函数,因为使用annotate时,会用group by,所以只能用聚合函数。聚合函数可以像filter那样关联表,即在聚合函数中,Django对OneToOne、OneToMany、ManyToMany关联查询及其反向关联提供了相同的方式,见下面例子。

    >>> from django.contrib.auth.models import User

    >>> from django.db.models import Count

    #计算每个学员的usertask数量,字段命名为ut_num,返回的QuerySet中的每个object都有

    #这个字段在UserTask中定义User为外键,在Task中定义与User是ManyToMany,中间表为

    #notification_task_users

    >>> a = User.objects.filter(is_active=True, usertask__is_active=True). annotate(n=Count(‘usertask’)) #一对多反向连接。User与UserTask是onetomany关联

    >>> b = User.objects.filter(is_active=True, task__is_active=True).annotate(n=Count(‘task__name’)) #多对多反向连接,User与Task是manytomany关联

    >>> len(a) #这里才会对a求值

    >>> len(b)

    a对应的SQL语句为(SQL中没有为表起别名,u、ut是我加的):

    select auth.user.*,Count(ut.id) as ut_num

    from auth_user as u

    left outer join ut on u.id = ut.user_id

    where u.is_active=True and ut.is_active=True

    group by u.*

    b对应的SQL语句为(SQL中没有为表起别名,u、t、r是我加的):

    select u.*,Count(t.name) as n

    from auth_user as u

    left outer join notification.task_users as r on u.id=r.user_id

    left outer join notification_task as t on r.task_id=t.id

    where t.is_active=True and u.is_active=True

    group by u.*

    No4 order_by——对应order by

    函数原型 order_by(**kwargs)

    返回QuerySet

    正向的反向关联表跟filter的方式一样。如果直接用字段名,那就是升序asc排列;如果字段名前加-,就是降序desc

    No5 distinct——对应distinct

    原型 distinct()

    一般与values()、values_list()连用,这时它返回ValuesQuerySet、ValuesListQuerySet

    这个类跟列表很相似,它的每个元素是一个字典。它没有参数(其实是有参数的,不过,参数只在PostgreSQL上起作用)。使用方法为

    >>> a=Author.objects.values_list(name).distinct()

    >>> b=Author.objects.values_list(name,email).distinct()

    对应的SQL分别为

    select distinct name

    from Author

    select distinct name,email

    from Author

    No6 values()和values_list()——对应’select 某几个字段’

    函数原型values(*field), values_list(*field)

    返回ValuesQuerySet, ValuesListQuerySet

    Author.objects.filter(**kwargs)对应的SQL只返回主表(即Author表)的所有字段值,即使在查询时关联了其它表,关联表的字段也不会返回,只有当我们通过Author instance用关联表时,Django才会再次查询数据库获取值。当我们不用Author instance的方法,且只想返回几个字段时,就要用values(),它返回的是一个ValuesQuerySet对象,它类似于一个列表,不过,它的每个元素是字典。而values_list()跟values()相似,它返回的是一个ValuesListQuerySet,也类型于一个列表,不过它的元素不是字典,而是元组。一般的,当我们不需要model instance的方法且返回多个字段时,用values(*field),而返回单个字段时用values_list(‘field’,flat=True),这里flat=True是要求每个元素不是元组,而是单个值,见下面例子。而且我们可以返回关联表的字段,用法跟filter中关联表的方式完全相同。

    >>> a = User.objects.values(‘id’,‘username’,‘userex__account_name’)

    >>> type(a)

    <class ‘django.db.models.query.ValuesQuerySet’>

    >>> a

    [{‘id’:0,‘username’:u’test0’,’ userex__account_name’: u’mlp-gikoo-test0@gk.cn’},{‘id’:1,‘username’:u’test1’,

    ‘userex__account_name’: u’mlp-gikoo-test1@gk.cn’},{‘id’:2,‘username’:u’test2’, ’ userex__account_name’: u’mlp-gikoo-test2@gk.cn’}]

    >>> b= User.objects.values_list(‘username’,flat=True)

    >>> b

    [u’gikoo’, u’test1’ ,u’test2’]

    No7 select_related()——对应返回关联表字段,嵌套,这部分要比SQL语句强大

    原型select_related(*filed)

    返回QuerySet

    它可以指定返回哪些关联表model instance,这里的field跟filter()中的键一样,可以用双下划线,但也有不同,You can refer to any ForeignKey or OneToOneField relation in the list of fields passed to select_related(),QuerySet中的元素中的OneToOne关联及外键对应的是都是关联表的一条记录,如my_entry=Entry.objects.get(id=1),my_entry.blog就是关联表的一条记录的对象。select_related()不能用于OneToMany的反向连接,和ManyToMany,这些都是model的一条记录对应关联表中的多条记录。前面提到了对于a = Author.objects.filter(**kwargs)这类语句,对应的SQL只返回主表,即Author的所有字段,并不会返回关联表字段值,只有当我们使用关联表时才会再查数据库返回,但有些时候这样做并不好。看下面两段代码,这两段代码在1.1中提到过。在代码1中,在遍历a前,先执行a对应的SQL,拿到数据后,然后再遍历a,而遍历过程中,每次都还要查询数据库获取关联表。代码2中,当遍历开始前,先拿到Entry的QuerySet,并且也拿到这个QuerySet的每个object中的blog对象,这样遍历过程中,就不用再查询数据库了,这样就减少了数据库读次数。

    代码1

    a = Entry.objects.all()

    for e in a:

    print (e.blog.name)

    代码2

    a = Entry.objects.select_related(‘blog’)

    for e in a:

    ​ print (e.blog.name)

    No8 prefetch_related(*field) ——对应返回关联表字段,嵌套,这部分要比SQL语句强大

    函数原型prefetch_related(*field)

    返回的是QuerySet

    可以用双下划线。前面提到select_related不能用于OneToMany的反向连接,及ManyToMany的情况,这部分由prefetch_related()来实现。其实,prefetch_related()也能做select_related()的事情,但由于策略不同,可能相比select_related()要低效一些,所以建议还是各管各擅长的。select_related是用select ……join来返回关联的表字段,而prefetch_related是用多条SQL语句的形式查询,一般,后一条语句用IN来调用上一句话返回的结果。

    class Restaurant(models.Model):

    pizzas = models.ManyToMany(Pizza, related_name=‘restaurants’)

    best_pizza = models.ForeignKey(Pizza, related_name=‘championed_by’)

    >>> Restaurant.objects.prefetch_related(‘pizzas__toppings’)

    >>> Restaurant.objects.select_related(‘best_pizza’).prefetch_related(‘best_pizza__toppings’)

    先用select_related查到best_pizza对象,再用prefetch_related 从best_pizza查出toppings

    至此,我们总结了查询数据库时,返回的数据形式,主要有三种:返回QuerySet,每个object只包含主表字段;返回QuerySet,每个object除了包含主表所有字段,还包含某些关联表的object,这种情况要用select_related()和prefetch_related();返回ValuesQuerySet, ValuesListQuerySet,它们的每个元素包含若干主表和关联表的字段,不包含任何实体和关联实例,这种情况要用values()和values_list()。

    No9 extra()——实现复杂的where子句

    函数原型:extra(select=None, where=None, params=None, tables=None, order_by=None, select_params=None)

    基本上,查询时用django提供的方法就够用了,不过有时where子句中包含复杂的逻辑,这种情况下django提供的方法可能不容易做到,还好,django有extra(), extra()中直接写一些SQL语句。不过,不同的数据库用的SQL有些差异,所以尽可能不要用extra()。需要时再看使用方法吧。

    No10 aggregate(*args, **kwargs)——对应聚合函数

    参数为聚合函数,最好用**kwargs的形式,每个参数起一个名字。如

    >>> from django.db.models import Count

    >>> q = Blog.objects.aggregate(Count(‘entry’)) #这是用*args的形式,最好不要这样用

    >>> q = Blog.objects.aggregate(number_of_entries=Count(‘entry’)) #这是用**kwargs的形式

    {‘number_of_entries’: 16}

    No11 exists()、count()、len()

    如果只是想知道一个QuerySet是否为空,而不想获取QuerySet中的每个元素,那就用exists(),它要比len()、count()、和直接进行if判断效率高。如果只想知道一个QuerySet有多大,而不想获取QuerySet中的每个元素,那就用count();如果已经从数据库获取到了QuerySet,那就用len()

    No12 contains/startswith/endswith——对应like

    字段名加双下划线,除了它,还有icontains,即Case-insensitive contains,这个是大小写不敏感的

    No13 in——对应in

    字段名加双下划线

    No14 gt/gte/lt/lte——对应于>,>=,<,<=

    字段名加双下划线

    No15 range——对应于between and

    字段名加双下划线,range后面值是列表

    No16 isnull——对应于is null

    Entry.objects.filter(pub_date__isnull=True)对应的SQL为SELECT … WHERE pub_date IS NULL;

    No17 QuerySet切片——对应于limit

    QuerySet的索引只能是非负整数,不支持负整数,所以QuerySet[-1]错误

    a=Entry.objects.all()[5:10]

    b=len(a) #执行Entry.objects.all()[5:8],对于不同的数据库,SQL语句不同,Sqlite 的SQL语句为select * from tablename limit 3 offset 5; MySQL的SQL语句为select * from tablename limit 3,5

    展开全文
  • 1:创建xml格式的配置文件 映射配置文件名称和位置没有固定要求 建议:在实体类所在包里面创建 格式:实体类名称.hbm.xml 2:配置文件是xml格式的,在配置文件中首先引入xml约束...3:配置映射关系 <?xml version...

    在这里插入图片描述

    Hibernate入门案例——第一步:搭建Hibernate环境
    Hibernate入门案例——第二步:第二步,创建实体类和表
    Hibernate入门案例——第三步:配置实体类和数据库一一对应关系(映射关系)
    Hibernate入门案例——第四步:创建Hibernate的核心配置文件
    Hibernate入门案例——第五步:实现添加操作

    1:创建xml格式的配置文件

    映射配置文件名称和位置没有固定要求

    建议:在实体类所在包里面创建

    格式:实体类名称.hbm.xml

    2:配置文件是xml格式的,在配置文件中首先引入xml约束

    hibernate 的DTD 文件(hibernate-mapping-3.0.dtd约束文件)下载

    把约束文件中的
    在这里插入图片描述
    放入到.hbm.xml的配置文件中

    在这里插入图片描述

    3:配置映射关系

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="Hibernate.introduction">
    <!-- 1:配置类和表对应
    
    class标签
    name属性:实体类全路径
    table属性:数据库表名称
    
     -->
    <class name="Hibernate/introduction/User.java" table="User">
    <!-- 2:配置实体类id和表id对应
    
    hibernate要求实体类有一个属性唯一值
    hibernate要求表有字段作为唯一值
    
    id标签
    name属性:实体类里面id属性名称
    column属性:生成表字段名称
    
     -->
     
    <id name="uid" column="uid">
    <!-- 设置数据库表id增长策略
    native:生成表id值就是主键自动增长
    
     -->
    <generator class="native"></generator>
    
    </id>
    
      <!-- 3:配置其他属性和表字段一一对应
    
      name属性:实体类里面属性名称
      column属性:生成表字段名称
    
      -->
      <property name="username" column="username"></property>
      <property name="address" column="address"></property>
      <property name="password" column="password"></property>
    
    </class>
    
    </hibernate-mapping>
    
    展开全文
  • 请教下大神们,有什么方法可以从数据库里面查出对应表结构关系的数据? 例如表结构:school(id,name)grade(id,name,schoolid)class(id,name,gradeid)teacher(id,name) 我用sql查出的数据只能是一行左连接的数据,...

    请教下大神们,有什么方法可以从数据库里面查出对应表结构关系的数据?
    例如表结构:school(id,name) grade(id, name, schoolid)  class(id, name, gradeid)  teacher(id, name)
    我用sql查出的数据只能是一行左连接的数据,这样数据太乱了。
    我现在希望查出来的数据是这样的(转换json后):
    {
      "data": [
        {"id": 1, "name": "xx学校", "grade": [
            { "id": 1,  "name": "一年级",  "class": [
                {"id": 1,  "name": "一班",  "headteacher": { "id": 1, "name": "小明" } },
                {"id": 1,  "name": "二班",  "headteacher": { "id": 2, "name": "小红" } }
              ]
            }]}
      ]
    }

    school和grade、grade和class都是一对多的关系,class和teacher是一对一的关系。
    这样有什么办法可以解决吗,现在项目框架不能大改,不过项目里好像有个EF,不知道应该怎么操作。

    展开全文
  • 一个数据库服务器上可以装几个数据库它们都是用sid来标志,例如orcl1,orcl2,orcl3等等,一个...来源:(http://blog.sina.com.cn/s/blog_4dc6402101009156.html) - oracle 数据库与实例的关系(转)_XW_普罗旺斯_S...

    一个数据库服务器上可以装几个数据库它们都是用sid来标志,例如orcl1,orcl2,orcl3等等,一个数据库如orcl1中可以有多个实例吗?

    Oracle数据库,实际上应该是说,我们使用的是Oracle服务server。

    来源:(http://blog.sina.com.cn/s/blog_4dc6402101009156.html) - oracle 数据库与实例的关系(转)_XW_普罗旺斯_S_新浪博客

    Oracle服务server包括有两个部分:

    一个部分是Oracle数据库database

    一个部分是数据库实例instance。

    数据库(database):物理操作系统文件或磁盘( disk)的集合。使用Oracle 10g 的自动存储管理(Automatic Storage Management,ASM)或RAW 分区时,数据库可能不作为操作系统中单独的文件,但定义仍然不变。

    实例(instance):一组Oracle 后台进程/线程以及一个共享内存区,这些内存由同一个计算机上运行的线程/进程所共享。这里可以维护易失的、非持久性内容(有些可以刷新输出到磁盘)。就算没有磁盘存储,数据库实例也能存在。也许实例不能算是世界上最有用的事物,不过你完全可以把它想成是最有用的事物,这有助于对实例和数据库划清界线。

    这两个词有时可互换使用,不过二者的概念完全不同。实例和数据库之间的关系是:数据库可以由多个实例装载和打开,而实例可以在任何时间点装载和打开一个数据库。实际上,准确地讲,实例在其整个生存期中最多能装载和打开一个数据库!

    Oracle数据库database,包括有数据文件、控制文件、重做日志文件,都是一些物理上的文件。

    数据库实例instance,包括有数据库后台进程(PMON、SMON、DBWR、LGWR、CKPT等)和内存区域SGA(包括shared pool、db buffer cache、redo log buffer等)。实例是一系列复杂的内存结构和操作系统进程

    严格的说:一个Oracle服务,只包括一个Oracle实例和一个数据库(不考虑双机并行等这样的情况)。但是一个实例只能对应一个数据库,一个数据库有可能对应多个实例。除非使用并行O r a c l e服务器选项,否则每个O r a c l e数据库都有一个实例与之相关,一个数据库被唯一的一个实例装载。

    数据库与实例之间是1对1/n的关系,在非并行的数据库系统中每个Oracle数据库与一个实例相对应;在并行的数据库系统中,一个数据库会对应多个实例,同一时间用户只与一个实例相联系,当某一个实例出现故障时,其他实例自动服务,保证数据库正常运行。在任何情况下,每个实例都只可以对应一个数据库。

    展开全文
  • 1、实例和数据库的关系是1对1,还是1对多,对应关系是怎么确立的? 2.输入用户名登陆Oracle的过程是怎样的?
  • 安装好上面的ODBC数据源驱动后选择自己对应的32位或64的选项(这里的32和64,跟操作系统位数没有关系,即操作系统是64位不一定这里ODBC也是64),我的是32位的,双击打开: 点击添加,弹出驱动类型选择列表: ...
  • 在使用mybatis时,会在maper.xml文件中写对应mapper接口类的sql语句,里面会有涉及到Java中类型与数据库mysql、oracle等的对应关系,事实上在mybatis包中有一个名为JdbcType的枚举类,下面记录一下这个枚举类的详情...
  • 主属性:候选码的都叫主属性 全码:所有属性都是候选码,称为全码关系的三种形式: 基本关系,基本表,基表;实际存在的表 查询表:查询结果对应表 视图表:由基本表或导出的表 虚表 并不独立存储关系模式: ...
  • 数据库表的关系分析

    2020-04-26 14:29:54
    通过学生号与班级号的对应关系表示学生属于班级。 多对多: 学生 ------- 课程 多对多先转换成一对多,需要一张中间表格来转换,这张表格内存放学生表里面的主键和课程表里面的主键,此时学生和中间表格是...
  • 关系数据库部分

    2019-03-06 11:23:00
    1、关系数据库:是对应于一个关系模型的...4、元组:元组是关系数据库中的基本概念,关系是一张表,表中的每行(即数据库中的每条记录)就是一个元组,在二维表,元组也称为记录。 5、相互关系:一个数据库可以...
  • 一对一关系是最好理解的一种关系,在数据库建表的时候可以将人表的主键放置与身份证表里面,也可以将身份证表的主键放置于人表里面 三、一对多关系 班级是1端,学生是多端,结合面向对象的思想,1端是父亲,多端...
  • 对应数据库中,假设有一学生关系——学生(学号,姓名,年龄),以学号为主键。那么给定一个学号,就可以找到姓名或年龄。若以学号为X,姓名、年龄为Y,则有Y = F(X),就有Y函数依赖于X。可简写为 Y -> X。 ...
  • 1 域,属性,笛卡尔积,关系,元组 【1】域 每个属性的取值范围对应一个值的集合,称为该属性的 域 例如:姓名的域是 10 位字符;性别的域为{男,女} 【2】属性 在现实世界中,要描述一个实物常常取若干特征来表示,...
  • 数据库关系整理

    千次阅读 2018-10-09 14:51:28
    例子1:T_CANDIDATE_INFO T_RECOMMEND T_COMPANY ...这两个字段不能为空,所以我们要找对应关系,我们发现这张表里面有推荐id 简历id 两个字段,我们就以这张表为主表,去查   然后我们发现在T_RECOMME...
  • 目的是为了了解模型类的定义和其对应数据库里面表的关系 实测发现: 1. 关于模型类和数据库里面的表关系,模型类里面定义的类属性是为了生成数据库里面的表结构使用的,类似mysql里面创建一个表。 1. 一个模型类...
  • 这里说明一下关于数据库数据库对应实体各种复杂情况关系映射。 最基本的实体: 比如:(这里面不涉及复杂map,list,set等) @Data @Getter @Setter @Component public class TestUser { private Integer ...
  • 一对一表示两个表中的数据必须是一一对应关系。这种场景其实并不是很常见,我们还是通过例子来直观地体会一下,例子仍然是在之前文章的基础上展开的。现在我们已经创建好了news这张表,里面主要记录了新闻的标题和...
  • oracle关系数据库模型

    千次阅读 2016-07-14 09:45:23
    1.1 关系数据库中的一些术语 好吧,其实我第一次学习数据库的时候,我特别的烦这些术语,本来很简单的很容易...关系(Relation):对应我们平时看见的一张表。 元组(Tuple):一个二维表的一行 属性(Attribute
  • dedecms的数据库关系

    2018-06-20 09:20:00
    注意:一个内容模型可以对应对个栏目,但一个栏目只能有一个对应的模型。 CMS的层级从前台分主要分为首页--栏目页--内容页三级,从后台分主要是四张表之间的关系: 模型表:dede_channeltype表,最外层也是最顶级...
  • Oracle数据库里时间的应用     1、转换函数与date操作关系最大的就是两个转换函数:to_date(),to_char()    to_date() 作用将字符类型按一定格式转化为日期类型:具体用法:to_date('2004-11-27','yyyy-...
  • 参考资料ORM框架 beego的使用根据数据库和对象关系创建实体类(默认驼峰法)beego的初始化在内存中注册一个叫做default的数据源,该数据源对应的是go这个数据库要操作的model也一起注册进去一般会申明一个全局的Ormer...
  • 创建新项目,一对多 ...之前是可以自定义实体类的属性字段,和数据库的字典不一致 增加测试方法 除了用户民 其他都是null值 @Results注解 这个注解包含了id和多个result 里面还有还...
  • 77.数据库里怎么预防死锁? 1.事务尽量简短 2.并发的事务尽可能按同一顺序访问对象 3.避免事务中的用户交互 4.使用低隔离级别(别动不动就上锁) 78.并发控制是为了保证事务的什么性质? ACID A:原子性 C:一致性 I:...
  • 关系数据库笔记1

    2020-07-12 19:47:05
    一组具有相同数据类型的值的集合,如整数、实数,对应一张表里面的一列 笛卡尔积 一组域D1 D2 D3 D4… 笛卡尔积:D1D2D3D4… 举例:D1: a b c D2: c d 笛卡尔积:D1D2={ac,ad,bc,bd,cc,cd} 元组 笛卡尔积中的每一个...
  • 数据库

    2020-03-25 22:43:36
    给表建立主键(唯一,不为空),在数据库里面设置; ​ 外键(至少2张表), 在B表里面的一个字段, 和A表的主键一定有关系(主外键关系); 2. 数据表关系 2.1 一对一 ; 一条主键纪录 对应 一条外键纪录; ​2.2 一对多 ; 一条...
  • 一个菜单表,一个角色表,一个角色对应多个菜单,一个菜单也可以在多个角色出现,多对多关系,出现了第三张表,角色权限表authfunctionrole,用于角色和用户的授权,业务是根据前端传过来的菜单查出有 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,087
精华内容 434
关键字:

数据库里对应关系