精华内容
下载资源
问答
  • 那产生的undo应该和t的大小差不多,但测试结果却差的很远,undo产生的量基本上是t大小的倍,不知道为什么,难道我理解错了?下面看下这奇怪的现象。1、delete了8小时2、原大小可以发现原也就16.5G,...

    概述

    Oracle中,undo是保存记录的前镜像的,我理解如果delete from t;那产生的undo应该和t表的大小差不多,但测试结果却差的很远,undo产生的量基本上是t表大小的两倍,不知道为什么,难道我理解错了?下面看下这个奇怪的现象。

    5b4861c499019a17a8d5d9959911e9f2.png

    1、delete了8个小时

    961123817c5ec3c3296dfd3efef9dba9.png

    2、原表大小

    可以发现原表也就16.5G,需要删的数据是9G。

    a4497320d45000c652a7c65bbb6f0665.png

    3、查看undo块

    这里忘记截图了,但是是有300多万个块,查看对应占用的undo空间是占了30多G,远远超过原表的大小。


    为什么undo会占用这么多空间?

    从原理上讲,UNDO表空间,有四个作用:

    1. 回滚事务;

    2. 一致性读;

    3. 事务恢复;

    4. 闪回查询

    请教杨长老得到的一些信息:

    对于回滚事务,他保存的是修改值的前镜像,注意,不是修改的数据块,或者整行记录的镜像。

    除了考虑表大小之外,还有表上索引的总大小,是否存在触发器,物化试图日志等等。另外,看看数据库级的supplemental log是否打开。

    undo是记录事物修改前镜像的,而delete的前镜像就是表中存储的数据。当然有一些可能会导致前镜像比表中的原始数据大,比如压缩,11g后存在的非空默认值。

    另外,undo的记录一定有一些额外的成本,比如rowid,scn等信息,如果表中行记录本身很小,那么这些成本就会显得非常突出。

    如果要非常精确地知道,多出来的每一个信息是多少,确实有些困难,但通过这个实验,至少能了解到,一次delete操作删除的容量,UNDO为了保存前镜像,需要占据的容量,要比他多得多,这就是为什么不推荐一次delete操作删除过多数据的原因之一。


    总之,对于delete大量数据的情况一定要分批进行,宁愿时间花多点,风险也会少很多,避免意外导致回滚而造成的数据库卡顿。

    后面会分享更多devops和DBA方面内容,感兴趣的朋友可以关注下!

    278cf3f0ecf25d710606bbeb7d9e3d1e.png
    展开全文
  • 表结构如下,其中father_id与reply_user_id默认为0,由于我是一张表,所以这两个字段用于区分是一级评论还是二级评论 实体类如下,其中@TableField(exist = false)注解的都是虚拟字段,这里就不...

    因为项目业务需要,特此写出此仿QQ空间的评论功能,项目如下图所示,records下的是一级评论
    里面的commentList是二级评论,前端根据此数据格式渲染即可
    在这里插入图片描述
    在这里插入图片描述
    表结构如下,其中father_id与reply_user_id默认为0,由于我是一张表,所以这两个字段用于区分是一级评论还是二级评论
    在这里插入图片描述
    实体类如下,其中有@TableField(exist = false)注解的都是虚拟字段,这里就不贴出用户表的实体类了。

    import com.baomidou.mybatisplus.annotation.*;
    import java.util.Date;
    import com.baomidou.mybatisplus.extension.activerecord.Model;
    import com.fasterxml.jackson.annotation.JsonFormat;
    import lombok.Data;
    import java.io.Serializable;
    import java.util.List;
    
    /**
     * <p>
     *  评论
     * </p>
     *
     * @author Mybatis-plus
     * @since 2019-07-26
     */
    @Data
    @TableName(resultMap = "BaseResultMap")
    public class Comment extends Model<Comment> implements Serializable {
    
        private static final long serialVersionUID = 1L;
    
        /**
         * 评论ID
         */
        @TableId(value = "comment_id",type = IdType.AUTO)
        private Long commentId;
        /**
         * 所属帖子ID
         */
        private Long postId;
        /**
         * 内容
         */
        private String content;
        /**
         * 时间
         */
        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
        @TableField(fill = FieldFill.INSERT)
        private Date createTime;
        /**
         * 评论人ID(当前用户)
         */
        private Long activeUserId;
        /**
         * 所属贴主ID
         */
        private Long posterId;
        /**
         * 已读,未读
         */
        private Integer readState;
        /**
         * 所属父评论ID
         */
        private Long fatherId;
    
        /**
         * 被回复人ID
         */
        private Long replyUserId;
    
        /**
         * 当前用户用户名
         */
        @TableField(exist = false)
        private String userName;
    
        /**
         * 被回复人用户名
         */
        @TableField(exist = false)
        private String replyUserName;
    
        /**
         * 当前用户头像
         */
        @TableField(exist = false)
        private String headPhoto;
    
        /**
         * 被回复人用户头像
         */
        @TableField(exist = false)
        private String replyHeadPhoto;
    
        /**
         * 子评论展示状态
         */
        @TableField(exist = false)
        private boolean commentListState;
    
        /**
         * 子评论列表
         */
        @TableField(exist = false)
        private List<Comment> commentList;
    
    
    }
    
    

    mapper.xml如下

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0//EN" "mybatis-3-mapper.dtd">
    <mapper namespace="com.jfs1010.mapper.CommentMapper">
    
        <resultMap id="BaseResultMap" type="com.jfs1010.pojo.Comment">
            <id property="commentId" column="comment_id"></id>
            <id property="postId" column="post_id"></id>
            <id property="content" column="content"></id>
            <id property="createTime" column="create_time"></id>
            <id property="activeUserId" column="active_user_id"></id>
            <id property="posterId" column="poster_id"></id>
            <id property="readState" column="read_state"></id>
            <id property="fatherId" column="father_id"></id>
            <id property="replyUserId" column="reply_user_id"></id>
        </resultMap>
    
    </mapper>
    
    
    

    serviceImpl类如下,这里一级评论和二级评论调用的接口是同一个,传的东西不同
    一级评论需要前端传 帖子ID 评论内容 父评论ID 和 被回复人ID 数据库默认是0 无需传
    二级评论需要前端传 帖子ID 评论内容 被评论人ID 评论的ID 把 评论的ID set 到 父评论ID里 即 father_id 字段

    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.jfs1010.mapper.PostMapper;
    import com.jfs1010.mapper.UserMapper;
    import com.jfs1010.pojo.Comment;
    import com.jfs1010.mapper.CommentMapper;
    import com.jfs1010.pojo.Post;
    import com.jfs1010.pojo.User;
    import com.jfs1010.service.CommentService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /**
     * <p>
     * 服务实现类
     * </p>
     *
     * @author Mybatis-plus
     * @since 2019-07-26
     */
    @Service
    public class CommentServiceImpl extends ServiceImpl<CommentMapper, Comment> implements CommentService {
    
        @Autowired(required = false)
        private CommentMapper commentMapper;
    
        @Autowired(required = false)
        private UserMapper userMapper;
    
        @Autowired(required = false)
        private PostMapper postMapper;
    
        /**
         * 发布评论(包括一级二级)
         *
         * @param comment
         * @return
         */
        @Override
        public int createComment(Comment comment) {
            //获取当前用户
            Post post = new Post();
            post.setPostId(comment.getPostId());
            //收藏数+1
            post.setCommentNum(postMapper.selectById(comment.getPostId()).getCommentNum()+1);
            postMapper.updateById(post);
            //这里获得当前用户的ID,由于我后台还没写好,故强行获取
            comment.setActiveUserId(userMapper.selectOne(new QueryWrapper<User>().eq("user_name", "小兰")).getUserId());
            return commentMapper.insert(comment);
        }
    
    
        /**
         * 查询出所有的一级评论和二级评论,并且与之对应
         * 一级与二级区分
         * 一级 post_id  father_id = 0  reply_user_id = 0
         * 二级 post_id  father_id = comment_id
         * @param postId
         * @param curr
         * @param limit
         * @return
         */
        @Override
        public IPage<Comment> findAllComment(Long postId, Integer curr, Integer limit) {
            //查出所有的一级评论
            QueryWrapper<Comment> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("post_id",postId).eq("father_id",0).eq("reply_user_id",0).orderByDesc("create_time");
            Page<Comment> page = new Page<>(curr, limit);
            IPage<Comment> listMaps = commentMapper.selectPage(page, queryWrapper);
            //根据评论人的ID获取用户名和头像
            User user;
            for (int i = 0; i < listMaps.getRecords().size(); i++) {
                Comment res = listMaps.getRecords().get(i);
                user = userMapper.selectById(res.getActiveUserId());
                res.setUserName(user.getUserName());
                res.setHeadPhoto(user.getHeadPhoto());
                //二级评论展示状态,用于前端实现逻辑分页
                res.setCommentListState(false);
                //存放二级评论
                QueryWrapper<Comment> queryWrapperTwo = new QueryWrapper<>();
                queryWrapperTwo.eq("post_id",postId).eq("father_id",res.getCommentId()).orderByDesc("create_time");
                //修改二级评论里面的用户名和头像
                List<Comment> commentList = commentMapper.selectList(queryWrapperTwo);
                for (int j = 0;j<commentList.size();j++){
                    Comment twoRes = commentList.get(j);
                    user = userMapper.selectById(twoRes.getActiveUserId());
                    //提问者用户名和头像
                    twoRes.setUserName(user.getUserName());
                    twoRes.setHeadPhoto(user.getHeadPhoto());
                    //回答者用户名和头像
                    twoRes.setReplyUserName(userMapper.selectById(twoRes.getReplyUserId()).getUserName());
                    twoRes.setReplyHeadPhoto(userMapper.selectById(twoRes.getReplyUserId()).getHeadPhoto());
                }
                //把二级评论放到一级评论里面
                res.setCommentList(commentList);
            }
            return listMaps;
        }
    }
    

    至此完成评论功能,Controller的代码我就不贴出来了。

    展开全文
  • 不同点:mysql:mysql的表空间分为两个文件一个是*.ibd文件存储数据索引...等数据信息。且只针对一张表。还有一个文件是*.frm这个文件是存储表的元数据。oralce:oralce的表空间是共享的。可以存储多个表,也可以存储...

    看到 存储引擎发现系统表空间这一章。感到很困惑。它不像oracle表空间那样是共享的。所以就来分析一下,mysql的表空间有什么不同。不同点:mysql:mysql的表空间分为两个文件一个是*.ibd文件存储数据索引...等数据信息。且只针对一张表。还有一个文件是*.frm这个文件是存储表的元数据。oralce:oralce的表空间是共享的。可以存储多个表,也可以存储多个模式下的对象。不仅存储数据信息,而且还存储元数据。以上分析只针对innodb存储引擎。其他引擎根据实际情况来定

     

    一、并发性
    并发性是Oltp数据库最重要的特性,但并发涉及到资源的获取、共享与锁定。
    Mysql:
    mysql以表级锁为主,对资源锁定的粒度很大,如果一个session对一个表加锁时间过长,会让其他session无法更新此表中的数据。
    虽然InnoDB引擎的表可以用行级锁,但这个行级锁的机制依赖于表的索引,如果表没有索引,或者sql语句没有使用索引,那么仍然使用表级锁。
    Oracle:
    Oracle使用行级锁,对资源锁定的粒度要小很多,只是锁定sql需要的资源,并且加锁是在数据库中的数据行上,不依赖与索引。所以Oracle对并发性的支持要好很多。
    二、一致性
    Oracle:
    Oracle支持serializable的隔离级别,可以实现最高级别的读一致性。每个session提交后其他session才能看到提交的更改。Oracle通过在undo表空间中构造多版本数据块来实现读一致性,
    每个session查询时,如果对应的数据块发生变化,Oracle会在undo表空间中为这个session构造它查询时的旧的数据块。
    Mysql:
    Mysql没有类似oracle的构造多版本数据块的机制,只支持read commited的隔离级别。一个session读取数据时,其他session不能更改数据,但可以在表最后插入数据。
    session更新数据时,要加上排它锁,其他session无法访问数据。

    展开全文
  • Innodb表空间

    2019-09-22 18:47:11
    Innodb有两种管理表空间的方法  独立表空间:每一张表都会生成独立的文件来进行存储,每一张表都有一个.frm表描述文件,和一个.ibd文件。其中ibd文件包括了单独一个表的数据内容和索引内容。  共享表空间:某一...

    Innodb有两种管理表空间的方法

      独立表空间:每一张表都会生成独立的文件来进行存储,每一张表都有一个.frm表描述文件,和一个.ibd文件。其中ibd文件包括了单独一个表的数据内容和索引内容。

      共享表空间:某一个数据库的所有表的数据和索引文件都放在一个文件下,默认的文件是.ibdata1文件,初始值是10M,默认是存放在数据文件的根目录下(mysql/var)。

    在性能和运维上独立表空间比共享的表空间有很多优势

     共享表空间

      优点:

        表空间可以分成多个文件存放到各个磁盘,所以表也就可以分成多个文件存放在磁盘上,表的大小不受磁盘大小的限制(很多文档描述有点问题)。

        数据和文件放在一起方便管理

       缺点:

        多个表及索引在表空间中混合存储,这样对于一个表做了大量删除操作后表空间中将会有大量的空隙,特别是对于统计分析,日值系统这类应用最不适合用共享表空间。

        共享表空间分配后不能回缩

        进行数据库的冷备很慢,mysqldump是一个好的处理方式

    独立空间

      优点:  

    1. 每个表都有自已独立的表空间。
    2. 每个表的数据和索引都会存在自已的表空间中。
    3. 可以实现单表在不同的数据库中移动。
    4. 空间可以回收

      缺点:

        单表增加过大,响应也是较慢,可以使用分区表

        单表增加过大,当单表占用空间过大时,存储空间不足,只能从操作系统层面思考解决方法

    共享表空间和独立表空间之间的转换  

    1.查看当前表空间情况:

    show variables like '%per_table';
    

    ON代表独立表空间管理,OFF代表共享表空间管理;

    2.修改数据库的表空间管理方式

      修改配置文件 ,在/etc/my.cnf文件中设置

        innodb_file_per_table=1 为使用独占表空间

        innodb_file_per_table=0 为使用共享表空间

      重启mysql

    3.共享表空间转化为独立表空间的方法

      (1)需要设置innodb_file_per_table=1

      (2)单个表 

          alter table table_name engine=innodb;

        很多表

          先把数据库导出,然后删除数据再进行导入操作,该操作可以用mysqldump进行操作

    总结:

      经过以上操作便完成数据库的存储空间的转换

      当数据量很小的时候建议使用共享表空间的管理方式。数据量很大的时候建议使用独立表空间的管理方式 

     

      

    转载于:https://www.cnblogs.com/baby123/p/6731846.html

    展开全文
  • ArcGIS的连接是基于属性的一个公共字段,将两个数据进行合并,可以是要素类与要素类的合并,也可以是表和要素类的合并。通过属性连接,将另外一个要素类或者表的信息与目标要素类进行合并,看起来就像是一张表一样。...
  • # 所有数据存放在一张表中,会什么问题? 1.浪费空间 2.扩展性差 3.结构不清晰 # 将一张表拆分成多张表(可以是张也可以是三张) # 拆分表的关系 # 一对多 1.员工表与部门表,我们应该站在张表的角度去思考...
  • 初步解决方案还是上次的步骤,但是感觉治标不治本,这不是办法,而且只有一张表有问题。 这样就有了一排查的入手点了。是因为频繁的插入删除么,还是频繁的更新新呢? GP物理空间使用的特性建议去...
  • 有一张数据备份,和业务流程日志,这两个是可以删除的,然后进行了truncate。 释放了10几个G的空间,然后启动服务,开始排查问题。 select pg_size_pretty(pg_relation_size('table_name'));查看了物理空间...
  • 字段首先符合设计范式要求,自然就合理的字段数量了,其次假设当某表的字段仍然太多时,可以根据业务情况进行拆分,比如根据常用字段和非常用字段将一张表拆分成张。 Row Size 单条记录的大小不应超过硬盘的...
  • 之间的关系

    2019-10-02 22:26:09
    通过外键使之间建立关系:关系一对多,多对多,一...确立之间的关系 一定要换位思考(必须方都考虑周全之后才能得出结论) 以员工和部门为例 先站在员工看能否员工对应一部门 翻译过来:...
  • 1.理解表与表之间建立关系的必要性比如我们建立了一张个人信息表,把所有人的信息都存在这张表中这张表中老师和他们所属的部门,并且不同的部门工作也是不同的所有数据存放在一张表中的弊端1.组织结构不清晰2.浪费...
  • 天在公司做ORACLE10G的DATAGUARD测试的... 导入一张表(TEST_ALL)280多万的数据,然后建立了建立了一同样结构的表TEST1,进行批量插入操作。 SQL&gt; insert into test1 select * from test_all;ORA...
  • Delete操作通常不会降低高水位线,当做全表扫描时oracle会扫描高水位线下的块,一个表的数据可能不多但执行时间却很长,通常需要注意高水位下会很多空闲的块存在。通常可通过对表进行shrink或move释放被占用的空间...
  • Linux 0.11进程共享同一页目录

    千次阅读 2016-09-07 18:18:42
    打断一下各位,前面关于我提问的 linux0.11中所有进程共享一页目录,而所有进程平分4G空间,每64MB,每应用程序编译时入口地址相同,而载入运行时,由于所有进程的产生的虚拟地址都一样,一张页目录无法将...
  • 顺序

    2016-07-18 21:09:48
    1、线性表--顺序 在计算机内部存储一张线性表(线性结构的数),最为方便简单的就是用一组连续地址的内存单元来存储整张线性表。 这种存储结构称为顺序存储结构,这种存储结构下...有两种定义顺序的方法:一是静
  • 所有数据存放在一张表中的弊端  1.组织结构不清晰  2.浪费存储空间  3.扩展性差 针对这问题我们可以将他们分成张表,一张专门记录个人信息,一张专门记录部门和部门工作 建立表的时候我们需要进行分析...
  • 天在公司做ORACLE10G的DATAGUARD测试的时候,发现表扩展报错后,后续的一些... 导入一张表(TEST_ALL)280多万的数据,然后建立了建立了一同样结构的表TEST1,进行批量插入操作。 SQL> insert into tes...
  • 顺序链表

    2011-10-20 23:04:32
    顺序链表 一张顺序包括以下特征: 有一唯一的表名来标识该顺序;...有两种定义顺序的方法:一是静态地定义一张顺序;二是动态地生成一张顺序 typedef int ElemType; /********************************
  • Linux 文件描述符

    2020-02-05 19:09:16
    上图为虚拟地址空间结构图; 在内核区的进程管理模块中...文件描述符表还依赖另外两个表协同工作,分别是打开文件表和i-node表,这两张表整个系统只有一份,而文件描述符表每一个进程中都有一张; 每一个文件描述符...
  • mysql 对象缓存

    千次阅读 2017-09-29 14:11:44
    mysql 对象缓存在mysql server层有两个与table相关的结构,分别为TABLE、TABLE_SHARE。在打开时会先找TABLE缓存,若无,从TABLE_SHARE的缓存空间找到对应缓存创建实例TABLE,若TABLE_SHARE也没用这从frm读取...
  • python--MySQL多查询

    2019-09-24 17:34:54
    一 介绍  我们在写项目的时候一般都会...那么就会涉及到多个表联合查询,比如说员工一张表,部门一张表,要查询各个部门哪些员工就需要将两个表联合起来查询.(上次我们也说过做项目的时候不要用外键来强行加上约束...
  • MySQL关系--外键

    2019-09-22 03:37:16
    如果我们把所有的信息都记录在一张表中会带来的问题:  1.表的结构不清晰  2.浪费磁盘空间  3.表的扩展性极差 所以我们要把这种表拆成几张不同的表,分析表与表之间的关系。 确定表与表之间的关系,一定要...
  • 数据结构 多重邻接

    2020-09-24 00:00:03
    对于无向图,我们可以根据向图的结构,加双向边进行实现,但除了空间翻倍外,在某些要对边进行标记的问题时,还要去找到反向边,可能这复杂度不是 O(1)O(1)O(1) 的,那么整体复杂度也会相应提升。于是,多重...
  • 一 介绍 ...那么就会涉及到多个表联合查询,比如说员工一张表,部门一张表,要查询各个部门哪些员工就需要将两个表联合起来查询.(上次我们也说过做项目的时候不要用外键来强行加上约束关联,因为...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 193
精华内容 77
关键字:

一张表有两个表空间