数据库中的数据

简介: 数据库中的数据

从数据库查到的数据,是这种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"
                }
            ]
        }
    ]
}
目录
相关文章
|
2月前
|
存储 缓存 数据库
数据库数据删除策略:硬删除vs软删除的最佳实践指南
在项目开发中,“删除”操作常见但方式多样,主要分为硬删除与软删除。硬删除直接从数据库移除数据,操作简单、高效,但不可恢复;适用于临时或敏感数据。软删除通过标记字段保留数据,支持恢复和审计,但增加查询复杂度与数据量;适合需追踪历史或可恢复的场景。两者各有优劣,实际开发中常结合使用以满足不同需求。
160 4
|
15天前
|
存储 SQL Java
数据存储使用文件还是数据库,哪个更合适?
数据库和文件系统各有优劣:数据库读写性能较低、结构 rigid,但具备计算能力和数据一致性保障;文件系统灵活易管理、读写高效,但缺乏计算能力且无法保证一致性。针对仅需高效存储与灵活管理的场景,文件系统更优,但其计算短板可通过开源工具 SPL(Structured Process Language)弥补。SPL 提供独立计算语法及高性能文件格式(如集文件、组表),支持复杂计算与多源混合查询,甚至可替代数据仓库。此外,SPL 易集成、支持热切换,大幅提升开发运维效率,是后数据库时代文件存储的理想补充方案。
|
7月前
|
存储 人工智能 Cloud Native
云栖重磅|从数据到智能:Data+AI驱动的云原生数据库
在9月20日2024云栖大会上,阿里云智能集团副总裁,数据库产品事业部负责人,ACM、CCF、IEEE会士(Fellow)李飞飞发表《从数据到智能:Data+AI驱动的云原生数据库》主题演讲。他表示,数据是生成式AI的核心资产,大模型时代的数据管理系统需具备多模处理和实时分析能力。阿里云瑶池将数据+AI全面融合,构建一站式多模数据管理平台,以数据驱动决策与创新,为用户提供像“搭积木”一样易用、好用、高可用的使用体验。
云栖重磅|从数据到智能:Data+AI驱动的云原生数据库
|
5月前
|
数据采集 数据库 Python
有哪些方法可以验证用户输入数据的格式是否符合数据库的要求?
有哪些方法可以验证用户输入数据的格式是否符合数据库的要求?
277 75
|
3月前
|
数据库 Python
【YashanDB知识库】python驱动查询gbk字符集崖山数据库CLOB字段,数据被驱动截断
【YashanDB知识库】python驱动查询gbk字符集崖山数据库CLOB字段,数据被驱动截断
|
2月前
|
人工智能 关系型数据库 分布式数据库
让数据与AI贴得更近,阿里云瑶池数据库系列产品焕新升级
4月9日阿里云AI势能大会上,阿里云瑶池数据库发布重磅新品及一系列产品能力升级。「推理加速服务」Tair KVCache全新上线,实现KVCache动态分层存储,显著提高内存资源利用率,为大模型推理降本提速。
|
4月前
|
SQL 数据建模 BI
【YashanDB 知识库】用 yasldr 配置 Bulkload 模式作单线程迁移 300G 的业务数据到分布式数据库,迁移任务频繁出错
问题描述 详细版本:YashanDB Server Enterprise Edition Release 23.2.4.100 x86_64 6db1237 影响范围: 离线数据迁移场景,影响业务数据入库。 外场将部分 NewCIS 的报表业务放到分布式数据库,验证 SQL 性能水平。 操作系统环境配置: 125G 内存 32C CPU 2T 的 HDD 磁盘 问题出现的步骤/操作: 1、部署崖山分布式数据库 1mm 1cn 3dn 单线启动 yasldr 数据迁移任务,设置 32 线程的 bulk load 模式 2、观察 yasldr.log 是否出现如下错
|
4月前
|
JSON Java 关系型数据库
Hutool创建数据源工厂动态查询不同数据库不同数据表的数据
Hutool创建数据源工厂动态查询不同数据库不同数据表的数据
80 2
|
3月前
|
SQL Java 数据库连接
【YashanDB数据库】由于网络带宽不足导致的jdbc向yashandb插入数据慢
由于网络带宽不足导致的jdbc向yashandb插入数据慢