数据库中的数据

简介: 数据库中的数据

从数据库查到的数据,是这种JSON格式,建和值都是双引号包裹

[
  [
    {
      id: 21,
      name: 'why',
      password: 'e10adc3949ba59abbe56e057f20f883e',
      createAt: 2024-03-11T06:55:35.000Z,
      updateAt: 2024-03-11T06:55:35.000Z
    }
  ],
  [
    `id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
    `name` VARCHAR(30) NOT NULL UNIQUE_KEY,
    `password` VARCHAR(50) NOT NULL,
    `createAt` TIMESTAMP(19) NOT NULL,
    `updateAt` TIMESTAMP(19) NOT NULL ON UPDATE CURRENT_TIMESTAMP
  ]
]

要解构[ ]返回这个,[values]

获取第一个是我们需要的,第二个不需要,是表数据的相关信息

例如

[
  {
    id: 21,
    name: 'why',
    password: 'e10adc3949ba59abbe56e057f20f883e',
    createAt: 2024-03-11T06:55:35.000Z,
    updateAt: 2024-03-11T06:55:35.000Z
  }
]

第二个是这样的[values,xxx ]

[
  {
    id: 21,
    name: 'why',
    password: 'e10adc3949ba59abbe56e057f20f883e',
    createAt: 2024-03-11T06:55:35.000Z,
    updateAt: 2024-03-11T06:55:35.000Z
  }
]
 
 
 
 [
  `id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
  `name` VARCHAR(30) NOT NULL UNIQUE_KEY,
  `password` VARCHAR(50) NOT NULL,
  `createAt` TIMESTAMP(19) NOT NULL,
  `updateAt` TIMESTAMP(19) NOT NULL ON UPDATE CURRENT_TIMESTAMP
]

若要拿到数据的对象形式,前端需要的话把JSON对象转为字符串

还要解构[ ]

  {
    id: 21,
    name: 'why',
    password: 'e10adc3949ba59abbe56e057f20f883e',
    createAt: 2024-03-11T06:55:35.000Z,
    updateAt: 2024-03-11T06:55:35.000Z
  }

实操

1. ---- 创建用户表
CREATE TABLE IF NOT EXISTS`user`(
id int PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(30) UNIQUE NOT NULL,
password VARCHAR(50) NOT NULL,
createAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updateAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);
-- 发表动态表
CREATE TABLE IF NOT EXISTS`moment`(
id int PRIMARY KEY AUTO_INCREMENT,
content VARCHAR(1000) NOT NULL,
user_id INT NOT NULL COMMENT '评论者外键,来寻找评论者',
createAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updateAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
FOREIGN KEY(user_id) REFERENCES user(id)
);
2.

SELECT m.id id,m.content content, m.createAt createTime, m.updateAt updateTime,
JSON_OBJECT('id',u.id,'name',u.name,'createTime',u.createAt,'updateTime',u.updateAt) user
 FROM moment m LEFT JOIN user u ON m.user_id=u.id LIMIT 10 OFFSET 0;

据外键组织数据

数据关系

一对一、一对多、多对多都是关系型数据库中常见的数据关系类型。以下是对每种关系的举例:


一对一关系

例子:一个公民有一个唯一的身份证。


解释:在这个例子中,每个公民都与一个唯一的身份证相关联,同时每个身份证也只与一个公民相关联。这是一种典型的一对一关系。

一对多关系

例子:一个班级有多个学生。


解释:在这个例子中,每个班级可以有多个学生,但每个学生只能属于一个班级。班级与学生之间形成了一对多的关系。

多对多关系

例子:一个学生可以选修多门课程,同时一门课程也可以被多个学生选修。


解释:在这个例子中,学生和课程之间形成了多对多的关系。一个学生可以选择多门课程,而每门课程也可以被多个学生选择。这种关系通常需要通过中间表(例如选课表)来实现。

注意事项

在设计数据库时,要根据实际需求确定实体之间的关系类型。

对于多对多关系,通常需要使用一个额外的关联表来存储关系数据。

在实际应用中,可能还需要考虑其他因素,如数据的完整性、查询效率等。

通过理解这些基本的数据关系类型,可以更好地设计和优化数据库结构,以满足实际应用的需求。

数据拼接

{
    "code": 0,
    "message": "查询成功",
    "data": [
        {
            "id": 3,
            "content": "春天,是一个充满希望和梦想信息的季节。它让大地焕发出新的生机,让万物复苏。在这个季节里,我们可以x感受到生命的力量",
            "createTime": "2024-03-11T15:41:33.000Z",
            "updateTime": "2024-03-12T13:24:14.000Z",
            "user": {
                "id": 21,
                "name": "why",
                "createTime": "2024-03-11 14:55:35.000000",
                "updateTime": "2024-03-11 14:55:35.000000"
            },
            "comments": [
                {
                    "id": 1,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 6,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 7,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 8,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": 1,
                    "content": "如果可能的话,将 SQL 语句分解为更小的部分,并逐一测试它们,以找到具体的错误位置。",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 18,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                }
            ]
        }
    ]
}
-- 在此基础继续增加字段
-- 也可以分别查询,然后在代码中做拼接,合在一起
-- 6.1这样查询会出现问题,因为动态下评论有5条,左连接再左连接labels会重复5次
-- SELECT m.id id,m.content content, m.createAt createTime, m.updateAt updateTime,
-- JSON_OBJECT('id', u.id, 'name', u.name, 'createTime', u.createAt, 'updateTime', u.updateAt) user,
-- (
-- JSON_ARRAYAgg(JSON_OBJECT(
-- 'id',c.id,'content',c.content,'comment',c.comment_id,'createTime', u.createAt, 'updateTime', u.updateAt,
-- 'user',JSON_OBJECT('id',cu.id,'name',cu.name)
-- ))
-- ) comments,
-- (
-- JSON_ARRAYAGG(JSON_OBJECT(
-- 'id', l.id,'name',l.name,'createTime',l.createAt,'updateTime', l.updateAt
-- ))
-- ) labels
-- FROM moment m LEFT 
-- JOIN user u ON m.user_id=u.id 
-- LEFT JOIN comment c ON c.moment_id=m.id  
-- LEFT JOIN user cu  ON cu.id=c.user_id
-- LEFT JOIN moment_label ml ON ml.moment_id=m.id
-- LEFT JOIN label l ON l.id=ml.label_id
-- WHERE m.id=3
-- GROUP BY m.id;
-- 
-- 解决方案
-- 1.不要一次性查询,写两条SQL;2.
-- 2.写一条SQL,查询数据重复后去重操作;
-- 3.SQL完善

单独查询没问题

多个左连接会出现重复问题,会在后续字段基础上再拼接

产生重复问题

[
    {
        "id": 1,
        "name": "篮球",
        "createTime": "2024-03-12 22:21:15.000000",
        "updateTime": "2024-03-12 22:21:15.000000"
    },
    {
        "id": 8,
        "name": "电影",
        "createTime": "2024-03-12 22:26:12.000000",
        "updateTime": "2024-03-12 22:26:12.000000"
    },
    {
        "id": 9,
        "name": "Rap",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 10,
        "name": "动漫",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 1,
        "name": "篮球",
        "createTime": "2024-03-12 22:21:15.000000",
        "updateTime": "2024-03-12 22:21:15.000000"
    },
    {
        "id": 8,
        "name": "电影",
        "createTime": "2024-03-12 22:26:12.000000",
        "updateTime": "2024-03-12 22:26:12.000000"
    },
    {
        "id": 9,
        "name": "Rap",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 10,
        "name": "动漫",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 1,
        "name": "篮球",
        "createTime": "2024-03-12 22:21:15.000000",
        "updateTime": "2024-03-12 22:21:15.000000"
    },
    {
        "id": 8,
        "name": "电影",
        "createTime": "2024-03-12 22:26:12.000000",
        "updateTime": "2024-03-12 22:26:12.000000"
    },
    {
        "id": 9,
        "name": "Rap",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 10,
        "name": "动漫",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 1,
        "name": "篮球",
        "createTime": "2024-03-12 22:21:15.000000",
        "updateTime": "2024-03-12 22:21:15.000000"
    },
    {
        "id": 8,
        "name": "电影",
        "createTime": "2024-03-12 22:26:12.000000",
        "updateTime": "2024-03-12 22:26:12.000000"
    },
    {
        "id": 9,
        "name": "Rap",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 10,
        "name": "动漫",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 1,
        "name": "篮球",
        "createTime": "2024-03-12 22:21:15.000000",
        "updateTime": "2024-03-12 22:21:15.000000"
    },
    {
        "id": 8,
        "name": "电影",
        "createTime": "2024-03-12 22:26:12.000000",
        "updateTime": "2024-03-12 22:26:12.000000"
    },
    {
        "id": 9,
        "name": "Rap",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    },
    {
        "id": 10,
        "name": "动漫",
        "createTime": "2024-03-13 10:48:45.000000",
        "updateTime": "2024-03-13 10:48:45.000000"
    }
]

正确的


SELECT m.id id,m.content content, m.createAt createTime, m.updateAt updateTime,
JSON_OBJECT('id', u.id, 'name', u.name, 'createTime', u.createAt, 'updateTime', u.updateAt) user,
(
SELECT JSON_ARRAYAgg(JSON_OBJECT(
'id',c.id,'content',c.content,'comment',c.comment_id,'createTime', u.createAt, 'updateTime', u.updateAt,
'user',JSON_OBJECT('id',cu.id,'name',cu.name)
))
 FROM comment c 
LEFT JOIN user cu ON c.user_id=cu.id
WHERE c.moment_id=m.id
) comments,
(
JSON_ARRAYAGG(JSON_OBJECT(
'id', l.id,'name',l.name,'createTime',l.createAt,'updateTime', l.updateAt
))
) labels
FROM moment m LEFT 
JOIN user u ON m.user_id=u.id 
 
LEFT JOIN moment_label ml ON ml.moment_id=m.id
LEFT JOIN label l ON l.id=ml.label_id
WHERE m.id=3
GROUP BY m.id;

结果

1. {
{
    "code": 0,
    "message": "查询成功",
    "data": [
        {
            "id": 3,
            "content": "春天,是一个充满希望和梦想信息的季节。它让大地焕发出新的生机,让万物复苏。在这个季节里,我们可以x感受到生命的力量",
            "createTime": "2024-03-11T15:41:33.000Z",
            "updateTime": "2024-03-12T13:24:14.000Z",
            "user": {
                "id": 21,
                "name": "why",
                "createTime": "2024-03-11 14:55:35.000000",
                "updateTime": "2024-03-11 14:55:35.000000"
            },
            "comments": [
                {
                    "id": 1,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": 1,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 6,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 7,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 8,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": 1,
                    "content": "如果可能的话,将 SQL 语句分解为更小的部分,并逐一测试它们,以找到具体的错误位置。",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                },
                {
                    "id": 18,
                    "user": {
                        "id": 21,
                        "name": "why"
                    },
                    "comment": null,
                    "content": "使用 SQL 编辑器或 IDE 的语法高亮和错误检查功能来帮助识别潜在的错误",
                    "createTime": "2024-03-11 14:55:35.000000",
                    "updateTime": "2024-03-11 14:55:35.000000"
                }
            ],
            "labels": [
                {
                    "id": 1,
                    "name": "篮球",
                    "createTime": "2024-03-12 22:21:15.000000",
                    "updateTime": "2024-03-12 22:21:15.000000"
                },
                {
                    "id": 8,
                    "name": "电影",
                    "createTime": "2024-03-12 22:26:12.000000",
                    "updateTime": "2024-03-12 22:26:12.000000"
                },
                {
                    "id": 9,
                    "name": "Rap",
                    "createTime": "2024-03-13 10:48:45.000000",
                    "updateTime": "2024-03-13 10:48:45.000000"
                },
                {
                    "id": 10,
                    "name": "动漫",
                    "createTime": "2024-03-13 10:48:45.000000",
                    "updateTime": "2024-03-13 10:48:45.000000"
                }
            ]
        }
    ]
}
目录
相关文章
|
16天前
|
缓存 NoSQL 中间件
应对数据库不断膨胀的数据:缓存和队列中间件
【6月更文挑战第5天】该文探讨了优化数据库使用以提升应用系统性能的策略。文中建议利用Redis缓存和MQ消息队列作为辅助工具,以进一步优化性能和减少资源消耗。
18 2
应对数据库不断膨胀的数据:缓存和队列中间件
|
1天前
|
Java 数据库连接 数据库
实现Spring Boot与MyBatis结合进行数据库历史数据的定时迁移
实现Spring Boot与MyBatis结合进行数据库历史数据的定时迁移
12 2
|
5天前
|
存储 NoSQL 算法
图数据库:连接数据的新模式
【6月更文挑战第16天】图数据库是处理复杂关系数据的新兴技术,使用节点、边和属性表示数据间关系。它提供强大的关系表达能力、灵活性、实时性和扩展性。新模式包括关系网络可视化、基于路径的查询、内置图算法支持,适用于推荐系统和社交网络分析,助力企业挖掘数据价值并应对大数据时代挑战。随着技术发展,图数据库将在数据连接和分析中扮演关键角色。
|
4天前
|
SQL 弹性计算 API
云服务器 ECS产品使用问题之如何通过API调用阿里云服务器上SQL Server数据库中的数据
云服务器ECS(Elastic Compute Service)是各大云服务商阿里云提供的一种基础云计算服务,它允许用户租用云端计算资源来部署和运行各种应用程序。以下是一个关于如何使用ECS产品的综合指南。
|
5天前
|
存储 监控 物联网
时间序列数据库:处理时间数据的利器
【6月更文挑战第16天】时间序列数据库(TSDB)是处理按时间顺序排列数据的专用工具,优化了数据压缩、查询性能和可扩展性,适合高并发写入与实时查询。TSDB在存储成本、查询效率和实时分析上具优势,广泛应用在物联网、金融、能源和制造业等领域,随着技术发展,其重要性日益凸显。
|
5天前
|
Oracle 关系型数据库 数据库
实时计算 Flink版产品使用问题之连接到Oracle数据库但无法读取到数据,是什么导致的
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。
|
5天前
|
SQL 关系型数据库 数据库
实时计算 Flink版产品使用问题之如何同步一个数据库的数据转换到另一个库
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。
|
7天前
|
SQL 关系型数据库 MySQL
MySQL数据库子查询练习——单个数据的子查询
MySQL数据库子查询练习——单个数据的子查询
9 1
|
10天前
|
SQL 存储 数据管理
数据管理DMS产品使用合集之如何把整个数据库的表和数据全部导出来
阿里云数据管理DMS提供了全面的数据管理、数据库运维、数据安全、数据迁移与同步等功能,助力企业高效、安全地进行数据库管理和运维工作。以下是DMS产品使用合集的详细介绍。
|
11天前
|
存储 SQL 关系型数据库
使用关系型数据库三级模式存储数据的优缺点
【6月更文挑战第10天】数据模型是DBMS的核心,提供数据透明性和设计指导。包括概念、逻辑和物理三层:概念模型(如ER模型)用于理解和收集需求,逻辑模型(如关系模型)关注设计,物理模型涉及实际存储实现。
21 0
使用关系型数据库三级模式存储数据的优缺点

热门文章

最新文章