2024年11月

书接上回,我们继续来分享一些关于时间转换的常用扩展方法。

01
、时间转日期时间 TimeOnly

该方式是把TimeOnly类型转为DateTime类型,其中日期部分使用系统当前日期,时间部分则使用TimeOnly,具体代码如下:

//时间转日期时间,默认使用当前日期+时间转为日期时间格式
public static DateTime ToDateTime(this TimeOnly timeOnly)
{
    return DateOnly.FromDateTime(DateTime.Now).ToDateTime(timeOnly);
}

02
、日期+时间转为日期时间 TimeOnly

该方法是直接对TimeOnly时间进行扩展,取用其时间,然后补全指定DateOnly日期,最后转为DateTime,代码如下:

//日期+时间转为日期时间
public static DateTime ToDateTime(this TimeOnly timeOnly, DateOnly dateOnly)
{
    return dateOnly.ToDateTime(timeOnly);
}

03
、日期时间中日期部分+时间转日期时间 TimeOnly

该方法是对TimeOnly时间进行扩展,取其时间,然后补全指定DateTime中的日期部分,最后再转为DateTime,代码如下:

//日期时间中日期部分+时间转日期时间格式
public static DateTime ToDateTime(this TimeOnly timeOnly, DateTime dateTime)
{
    return DateOnly.FromDateTime(dateTime).ToDateTime(timeOnly);
}

04
、日期转日期时间 DateOnly

该方式是把DateOnly类型转为DateTime类型,其中日期部分使用DateOnly,时间部分则使用系统当前时间,具体代码如下:

//日期转日期时间,日期+默认使用当前时间转为日期时间格式
public static DateTime ToDateTime(this DateOnly dateOnly)
{
    return dateOnly.ToDateTime(TimeOnly.FromDateTime(DateTime.Now));
}

05
、日期+日期时间中时间部分转日期时间 DateOnly

该方法是对DateOnly日期进行扩展,取其日期,然后补全指定DateTime中的时间部分,最后再转为DateTime,代码如下:

//日期+日期时间中时间部分转日期时间
public static DateTime ToDateTime(this DateOnly dateOnly, DateTime dateTime)
{
    return dateOnly.ToDateTime(TimeOnly.FromDateTime(dateTime));
}

06
、日期时间中日期部分+时间转日期时间 DateTime

该方法是对DateTime日期时间进行扩展,取其日期部分,然后补全指定TimeOnly时间,最后再转为DateTime,代码如下:

//日期时间中日期部分+时间转日期时间
public static DateTime ToDateTime(this DateTime dateTime, TimeOnly timeOnly)
{
    return DateOnly.FromDateTime(dateTime).ToDateTime(timeOnly);
}

07
、日期+日期时间中时间部分转为日期时间 DateTime

该方法是对DateTime日期时间进行扩展,取其时间部分,然后补全指定DateOnly日期,最后再转为DateTime,代码如下:

//日期+日期时间中时间部分转为日期时间
public static DateTime ToDateTime(this DateTime dateTime, DateOnly dateOnly)
{
    return dateOnly.ToDateTime(TimeOnly.FromDateTime(dateTime));
}

08
、日期时间转日期 DateTime

该方法是对DateTime日期时间进行扩展,取其日期部分转为DateOnly,代码如下:

//日期时间转日期,保留日期时间中日期部分
public static DateOnly ToDateOnly(this DateTime dateTime)
{
    return DateOnly.FromDateTime(dateTime);
}

09
、日期时间转时间 DateTime

该方法是对DateTime日期时间进行扩展,取其时间部分转为TimeOnly,代码如下:

//日期时间转时间,保留日期时间中时间部分
public static TimeOnly ToTimeOnly(this DateTime dateTime)
{
    return TimeOnly.FromDateTime(dateTime);
}

上面的这些扩展方法虽然大多都是简单调用原生方法,但是通过扩展方法方式提供出来后的确在编码上提升了一些效率,代码也会根据简洁。

10
、代码结构设计与组织

代码结构的设计和组织是软件开发过程中重要的一环,它将直接影响代码的可读性、可维护性、扩展性、测试性和团队协作的效率。

到目前为止我们关于时间的扩展方法已经有接近30个方法了,后面还有很多,目前都是放在DateTimeExtension类下面,如下图:

到这里已经能感受到代码结构显得很混乱了,直观感觉就是可读性差,没有结构化必然会导致扩展困难。

可能会有人提出不同观点,这些不就是很多静态方法吗,只有排版整齐就行了,其实不然,我们可以借助一些小技巧把方法集合结构化的管理起来。

结构化的管理一种实现方式就行——分类。下面我们就对现有代码进行分类。

分类是一门技术活,如何选择分类标准很关键,比如我们这里可以根据入参类型分为针对long类型转换、针对DateTime类型转换、针对string类型转换;也可以根据功能分类比如时间和时间戳互相转换是一类,时间和字符串互相转换是一类,DateTime与DateOnly和TimeOnly互相转换是一类等等分类方式。

1、分大类

我的思路是这样的,首先通过部分类partial把DateTimeExtension根据入参类型分成几个大类。

代码整理后效果如下:

2、分小类

分完大类后发现long类型中方法还是很大,因此我们继续对其进行分类,我们根据功能不同分为两类:转为本地日期时间和转为UTC日期时间。我们可以使用代码折叠的预处理指令#region和#endregion来处理处理小分类。

代码整理以后效果如下:

从一开始一堆方法到现在结构层次已经非常清晰了,阅读起来也非常方便,后期维护扩展就可以很容易的快速找到相应地方处理。

11
、单元测试

作为一个开源代码,我们首要任务应该保证代码正确性,因此单元测试是必不可少的。单元测试不但可以保证我们代码的正确性,还可以促使我们代码写的跟健壮。

单元测试我们以同样的分类方式进行代码组织,代码大致如下:

因为具体的测试用例都比较简单,这里就不拿出来讲解了。

测试用例编写的越完善,我们代码就越可靠,因此我们在编写单元测试时候,要尽可能覆盖所有逻辑,要尽可能覆盖到一些特例情况,我们想的越多代码质量才能越高。

12
、文档

作为一个开源代码,还需要一个好的文档,这样别人才能轻松使用,目前文档还是缺失的,后续我将陆续添加上。

当代码结构设计与组织、单元测试、文档这三部分都做好了,我感觉这个开源代码就达到开源给别人的最低要求了。后面的开源代码我都将围绕这三部分展开,希望可以给大家分享一些高质量的开源代码。

稍晚些时候我会把库上传至Nuget上,大家可以搜索Ideal.Core.Common直接使用。


:测试方法代码以及示例源码都已经上传至代码库,有兴趣的可以看看。
https://gitee.com/hugogoos/Ideal

大家好,我是木宛哥;在 10余年的工作经历让我深刻体会到软件开发不仅仅是写代码,更是一个系统化的交付过程。
为此我总结了20条编程感悟,涵盖了代码规范、设计原则、测试方法与交付流程等多个方面;​通过遵循代码规范,让代码更加可读与可维护,同时合理的设计能够有效应对需求变化,模块化的单元测试又确保了产品的可靠性,顾全的交付流程最后提升了项目质量。
希望这些感悟更多程序员提供参考,帮助大家在编程的道路上不断进步。

1. 清晰的命名

● 原则:代码应该易于阅读和理解;例如:变量、函数和类的名称应能清楚表达其意图;

● 示例:

// 明确表示学生数量
int numberOfStudents = 30; 

/**
 * 计算圆面积
 * @param radius 半径
 * @return 面积
 */
public double calculateAreaOfCircle(double radius) {
    return Math.PI * radius * radius;
}

2. 使用注释

● 原则:在复杂或重要的代码段添加注释,帮助他人理解;

● 示例:

/**
 * 计算给定列表的平均值
 *
 * @param numbers 要计算的数字列表
 * @return 返回数字的平均值,如果列表为空则返回0
 */
public static double calculateAverage(List<Double> numbers) {
    if (numbers == null || numbers.isEmpty()) {
        return 0;
    }

    double sum = 0.0; // 用于保存数字的总和
    int count = 0; // 用于记录有效数字的数量

    // 遍历列表中的每个数字并计算总和
    //【注意】:检查列表中的每个元素是否为 null,需要过滤
    for (Double num : numbers) {
        if (num != null) {
            sum += num; 
            count++;
        }
    }

    if (count == 0) {
        return 0;
    }
    double average = sum / count;
    return average;
}

3. 一致的编码风格

● 原则:遵循团队的编码标准,保持代码风格一致;

● 示例:使用统一的缩进和大括号位置。例如 IDEA 等 IDE 中配置统一的 CodeStyle:Alibaba-CodeStyle 、Google-CodeStyle 等;

4. 代码模块化

● 原则:将功能分解成小模块,增加重用性;

● 示例:

public class Calculator {
    /**
     * 加
     * @param a
     * @param b
     * @return
     */
    public int add(int a, int b) {
        return a + b;
    }

    /**
     * 减
     * @param a
     * @param b
     * @return
     */
    public int subtract(int a, int b) {
        return a - b;
    }
}

5. 避免重复代码

● 原则:遵循DRY原则(Don’t Repeat Yourself);

● 示例:

//不好的实践:重复
public class Calculator {
    public void addAndPrint(int a, int b) {
        int result = a + b;
        System.out.println("Result: " + result);
    }

    public void addAndPrintAnother(int x, int y) {
        int result = x + y;
        System.out.println("Result: " + result);
    }
}

//好的实践:我们可以提取出一个公共方法来遵循DRY原则:
public class Calculator {

    public void addAndPrint(int a, int b) {
        printResult(add(a, b));
    }

    public int add(int a, int b) {
        return a + b;
    }

    private void printResult(int result) {
        System.out.println("Result: " + result);
    }
}

6. 依赖接口而不是具体的实现

● 原则:依赖接口而不是具体的实现,增强灵活性;

● 示例:


public interface Shape {
    double area();
}

public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public class Square implements Shape {
    private double sideLength;

    public Square(double sideLength) {
        this.sideLength = sideLength;
    }

    @Override
    public double area() {
        return sideLength * sideLength;
    }
}

//依赖接口而不是具体的实现
void printf(Shape shape);

7. 避免魔法数字

● 原则:使用常量代替魔法数字;

● 示例:


final double FIXED_RATE = 3
double area = FIXED_NO * radius

8. 简化条件语句

● 原则:避免复杂的条件逻辑。用快速 return 来减少 if 嵌套层次;

● 示例:


//不推荐:嵌套太深
public void checkUser(User user) {
    if (user != null) {
        if (user.getAge() > 18) {
            if (user.isActive()) {
                // 允许访问
                System.out.println("Access granted");
            } else {
                System.out.println("User is not active");
            }
        } else {
            System.out.println("User is underage");
        }
    } else {
        System.out.println("User is null");
    }
}

//推荐:快速失败返回
public void checkUser(User user) {
    if (user == null) {
        System.out.println("User is null");
        return;
    }
    
    if (user.getAge() <= 18) {
        System.out.println("User is underage");
        return;
    }

    if (!user.isActive()) {
        System.out.println("User is not active");
        return;
    }

    // 允许访问
    System.out.println("Access granted");
}

9. 异常处理

● 原则:通过适当的异常处理提高程序的健壮性;

● 示例:


//异常
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    log.error("非法参数,不能被零除");
}

//熔断
try (Entry entry = SphU.entry("resourceName")) {  
    // 你的业务逻辑  
} catch (BlockException ex) {  
    // 处理被阻止的请求  
}

10. 标准化错误日志处理

● 原则:统一错误处理的方式和日志记录。方便日志采集和告警配置;

● 示例:


public void logError(String message) {
    log.error("ERROR|Trace:{0}|Msg:{1} " Context.getTrace(), message);
}

11. 方法参数不宜过长

● 原则:方法参数应尽量少,避免混乱,超过3个推荐封装成模型;

● 示例:


//不推荐
void createUser(String name,int age,String email);


//推荐
public class UserService {
    public void createUser(User user) {
        
    }
}

class User {
    private String name;
    private int age;
    private String email;

    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // Getters and Setters
}

12. 使用现有工具类来简化操作

● 原则:优先使用现有工具类 如
apache.commons
来简化操作

● 示例:


StringUtils.isNotEmpty("");
CollectionUtils.isNotEmpty()

13. 尽量使用不变的变量

● 原则:使用
final
关键字声明不可变的变量,提高代码的可靠性;

● 示例:


final int MAX_VALUE = 100;
ImmutableList.of();

14. 测试驱动开发(TDD)

● 原则:先写测试,再写代码,确保代码的可测试性;

● 示例:


@Test
public void testAdd() {
    Calculator calculator = new Calculator();
    assertEquals(5, calculator.add(2, 3));
}

15. 避免过度优化

● 原则:优先考虑代码的可读性,优化通常是在识别出性能问题后进行的;

16. 使用版本控制

● 原则:使用版本控制工具(git)管理代码变化;

17. 重视系分文档

● 原则:

○ 开发前,考虑清楚为什么要做这个需求。从背景及现状分析->为什么要做(why)->要做什么(what)->如何去做(how) 体系化思考;

○ 再从业务用例分析->系统依赖分析->领域模型分析->架构设计分析->时序图分析等落地最终的系分;

18. 重视代码评审

● 原则:定期进行代码评审,提高代码质量,提高团队研发意识;

19. 重视每一次交付

● 原则:

○ 事前锁定资源,上下游达成一致,明确里程碑计划;

○ 事中按需推进,每周项目进度同步,及时通晒风险;

○ 事后组织复盘以及关注业务数据(关注价值)

20.重视交付质量

● 原则:新功能需多考虑灰度验证

○ 后端服务:可按分组进行灰度验证(gray 分组->default 分组)

○ 客户端:小范围升级验证无问题后,逐步放量升级;

写在最后

欢迎关注我的公众号:编程启示录,第一时间获取最新消息;

微信 公众号
image image

上一篇:《人工智能——自然语言处理简介》

序言:
人工智能大语言模型(LLM)如何理解人类的自然语言?这个过程的核心在于将文本转化为计算机能处理的数值形式,经过计算,最终达到对语言的理解。起初,我们只是简单的随便用一个数字来表示一个单词或一个词根,但随着研究深入,我们发现,不同的数值表达方式能显著提高模型对语言的理解效果。因此,在构建大语言模型(LLM)时,关键的一步是将人类语言转化成合适的数值表示,以便模型能够接收、处理并生成有效的输出。好了,让我们进入正题。

与真实数据源协同工作

现在你已经了解了获取句子、用词索引进行编码以及对结果进行序列化的基本知识,你可以通过使用一些著名的公共数据集,将其通过工具转换为易于序列化的格式来进一步提升技能。我们将从TensorFlow Datasets中的IMDb数据集开始,它的大部分处理工作已经为你完成了。之后,我们将亲自动手处理一个基于JSON的数据集以及几个包含情感数据的逗号分隔值(CSV)数据集!

从TensorFlow Datasets获取文本

我们在第4章探索过TFDS,因此如果你对本节中的某些概念不熟悉,可以回顾一下。TFDS的目标是尽可能简单地以标准化方式访问数据。它提供了多个基于文本的数据集,我们将探索imdb_reviews,这是一个包含5万条电影评论的IMDb数据集,每条评论的情感被标注为正面或负面。

下面的代码将加载IMDb数据集的训练集并逐项迭代,将包含评论的文本字段添加到名为imdb_sentences的列表中。每条评论由文本和表示情感的标签组成。注意,将tfds.load调用包裹在tfds.as_numpy中,确保数据以字符串而不是张量的形式加载:

imdb_sentences = []

train_data = tfds.as_numpy(tfds.load('imdb_reviews', split="train"))

for item in train_data:

imdb_sentences.append(str(item['text']))

获得句子后,可以像之前一样创建一个分词器并对它们进行拟合,还可以创建一组序列:

tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=5000)

tokenizer.fit_on_texts(imdb_sentences)

sequences = tokenizer.texts_to_sequences(imdb_sentences)

你还可以打印出你的词索引以查看:

print(tokenizer.word_index)

词索引过大无法全部显示,但以下是前20个词。注意,分词器按数据集中词的频率排列,因此“the”、“and”和“a”等常用词被索引:

{'the': 1, 'and': 2, 'a': 3, 'of': 4, 'to': 5, 'is': 6, 'br': 7, 'in': 8, 'it': 9, 'i': 10, 'this': 11, 'that': 12, 'was': 13, 'as': 14, 'for': 15, 'with': 16, 'movie': 17, 'but': 18, 'film': 19, "'s": 20, ...}

这些是停用词,如上一节所述。由于这些词出现频率最高且缺乏独特性,它们的存在会影响训练准确性。

此外,注意“br”也在列表中,因为它在该语料库中常用作HTML标签

你可以更新代码,使用BeautifulSoup移除HTML标签,添加字符串转换以移除标点符号,并从给定列表中删除停用词,如下所示:

from bs4 import BeautifulSoup

import string

stopwords = ["a", ..., "yourselves"]

table = str.maketrans('', '', string.punctuation)

imdb_sentences = []

train_data = tfds.as_numpy(tfds.load('imdb_reviews', split="train"))

for item in train_data:

sentence = str(item['text'].decode('UTF-8').lower())

soup = BeautifulSoup(sentence)

sentence = soup.get_text()

words = sentence.split()

filtered_sentence = ""

for word in words:

word = word.translate(table)

if word not in stopwords:

filtered_sentence = filtered_sentence + word + " "

imdb_sentences.append(filtered_sentence)

tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=25000)

tokenizer.fit_on_texts(imdb_sentences)

sequences = tokenizer.texts_to_sequences(imdb_sentences)

print(tokenizer.word_index)

注意,在处理之前将句子转换为小写,因为所有的停用词都存储为小写。现在打印出的词索引如下所示

{'movie': 1, 'film': 2, 'not': 3, 'one': 4, 'like': 5, 'just': 6, 'good': 7, 'even': 8, 'no': 9, 'time': 10, 'really': 11, 'story': 12, 'see': 13, 'can': 14, 'much': 15, ...}

可以看到现在比之前干净了许多。不过,仍有改进空间,我注意到在查看完整索引时,一些不常见的词在末尾显得无意义。评论者经常将词组合在一起,比如用连字符(“annoying-conclusion”)或斜杠(“him/her”),移除标点会错误地将这些词合并为一个词。

你可以添加代码,在句子创建后立即在这些字符周围添加空格

sentence = sentence.replace(",", " , ")

sentence = sentence.replace(".", " . ")

sentence = sentence.replace("-", " - ")

sentence = sentence.replace("/", " / ")

这样,类似“him/her”这样的组合词会被转换为“him / her”,然后/被去掉,分词后会成为两个词。这样可能会带来更好的训练效果。

现在你已经有了语料库的分词器,可以对句子进行编码。例如,前面章节的简单句子会变成这样

sentences = [

'Today is a sunny day',

'Today is a rainy day',

'Is it sunny today?'

]

sequences = tokenizer.texts_to_sequences(sentences)

print(sequences)

结果为:

[[516, 5229, 147], [516, 6489, 147], [5229, 516]]

如果解码,可以看到停用词已被删除,句子被编码为“today sunny day”、“today rainy day”和“sunny today”。

如果想在代码中解码,可以创建一个新字典,将键和值反转(即词索引中的键值对互换)并进行查找。代码如下:

reverse_word_index = dict(

[(value, key) for (key, value) in tokenizer.word_index.items()])

decoded_review = ' '.join([reverse_word_index.get(i, '?') for i in sequences[0]])

print(decoded_review)

这将输出:

today sunny day

使用IMDb子词数据集

TFDS还包含几个使用子词预处理的IMDb数据集。在这里,你不需要按词分割句子,它们已经按子词进行分割。使用子词是一种在按字母(少量低语义令牌)和按词(大量高语义令牌)之间的折中方法,通常可以非常有效地训练语言分类器。这些数据集还包含用于分割和编码语料库的编码器和解码器。

要访问它们,可以调用tfds.load并传入imdb_reviews/subwords8k或imdb_reviews/subwords32k,例如

(train_data, test_data), info = tfds.load(

'imdb_reviews/subwords8k',

split=(tfds.Split.TRAIN, tfds.Split.TEST),

as_supervised=True,

with_info=True

)

可以通过info对象访问编码器,这将帮助查看词汇量大小

encoder = info.features['text'].encoder

print('Vocabulary size: {}'.format(encoder.vocab_size))

输出8185,因为在此实例中词汇量由8,185个令牌组成。若想查看子词列表,可以使用encoder.subwords属性获取:

print(encoder.subwords)

输出类似以下内容

['the_', ', ', '. ', 'a_', 'and_', 'of_', 'to_', 's_', 'is_', 'br', 'in_', 'I_', 'that_', ...]

这里可以注意到,停用词、标点和语法在语料库中都有,还有像
这样的HTML标签。空格用下划线表示,因此第一个令牌是“the”。

若想编码字符串,可以使用编码器

sample_string = 'Today is a sunny day'

encoded_string = encoder.encode(sample_string)

print('Encoded string is {}'.format(encoded_string))

输出将是令牌列表

Encoded string is [6427, 4869, 9, 4, 2365, 1361, 606]

你的五个词被编码为七个令牌。查看令牌,可以用编码器的subwords属性返回一个数组。它是从零开始的,例如“Today”中的“Tod”编码为6427,是数组中的第6426项:

print(encoder.subwords[6426])

输出:

Tod

若要解码,可以使用编码器的decode方法:

encoded_string = encoder.encode(sample_string)

original_string = encoder.decode(encoded_string)

test_string = encoder.decode([6427, 4869, 9, 4, 2365, 1361, 606])

后面的代码行将产生相同的结果,因为encoded_string尽管名字如此,其实是一个和下一行硬编码的列表相同的令牌列表。

本节总结:
本节主要介绍了如何将文本表达转化为计算机可理解的数字表达形式。 具体来说,就是通过TensorFlow Datasets对文本进行预处理,包括分词、去停用词等步骤,最终将文本转换为数字序列,为后续的自然语言处理任务做好准备;下一篇是这一篇的补充,主要讲述如何从CSV和JSON文件中提取文本用于训练模型。

序列化(Serialization)

反序列化(Deserialization)
是计算机科学中用于数据存储和传输的两种基本操作。

  1. 序列化

    • 序列化是将对象的状态信息转换为可以存储或传输的形式的过程。简单来说,就是将对象转换为字节序列(比如JSON、XML等格式)。
    • 目的:使得对象可以在网络上进行传输,或者存储到文件、数据库中。
    • 例子:将一个Java对象转换为JSON字符串,以便通过网络发送到另一个系统。
  2. 反序列化

    • 反序列化是序列化的逆过程,即从存储或传输的形式中恢复对象的状态信息,重新构建对象。
    • 目的:从文件、数据库或网络接收到的数据中恢复出原来的对象。
    • 例子:从一个JSON字符串中解析出数据,并根据这些数据创建一个新的Java对象。
      序列化和反序列化的应用场景
  • 网络传输
    :在网络通信中,对象需要在不同的服务间传输,序列化可以将对象转换为字节流,通过网络发送,接收方再通过反序列化恢复为对象。
  • 数据存储
    :将对象序列化后存储到文件或数据库中,以便后续读取和使用。
  • 分布式系统
    :在分布式系统中,对象可能需要在不同的节点间传递,序列化和反序列化是实现这一功能的关键技术。
  • 远程方法调用(RPC)
    :在RPC中,对象作为方法参数或返回值需要在不同的地址空间间传递,也需要经过序列化和反序列化。
    注意
    :序列化和反序列化时,需要确保双方使用相同的格式和规则,否则可能导致数据错误或无法解析。此外,序列化和反序列化过程中还可能涉及到安全问题,如序列化漏洞等,需要特别注意。

蓝图

image-20241108094408670

数据库自己管理磁盘数据和缓冲区,而不是通过操作系统管理(
Os is not your friend.
)。

数据存储

三层视图

数据库以页(page)为存储数据的基本单位,文件(file)是一系列页的集合,页中存储页数据(data),形成
文件-页-数据
三层架构。

文件有不同的组织形式,页包含页头和页数据,页数据可以采用不同方式组织:元组,日志,索引。

黄色部分为课程会提及的内容。

image-20241108102336292

采用Heapfile进行文件存储时的执行图:

image-20241108093210314

  • 页目录:存储管理的页的元信息(空闲页,空页)
  • 页头:存储页的元信息(页大小,校验和,数据库版本,事务可见性,压缩元数据)

面向元组的数据存储

image-20241108102828520

  • 通过<FileId, PageId, Slot>定位到一个指向tuple的指针(磁盘地址),然后找到tuple。

  • slot指针的灵活性:内部元组位置变化时,外部无感知;指针可以指向其他页,可以存储大数据(文件,大文本);支持变长记录。

  • 数据库会为每个元组分配一个数据记录的唯一标识(record identifier),来表示元组的
    物理位置
    。SQLite和Oracle中为ROWID,Pg中是CTID,<PageId, Slot>。但是他们对于应用程序是无用的。

image-20241108103947481

  • Header包含:可见性信息;NULL Bit Map。

  • Data包含:行数据。

Tuple只是一个字符串(char[]),本身不存储类型信息,类型信息存在数据库的
System Catalogs
中。(为了保证数据紧凑;非自解释的)

存数据时会遇到的问题:

  • 数据对齐:填充,重排序

image-20241108123458670

  • 精确值问题:BIGDECIMAL(转为字符串存储)

image-20241108123607713

  • 空值:Bit Map;特殊值

  • 大值和文件:Overflow Page和External File。

    大值采用溢出页;大文件可以采用溢出页,也可以用外部文件系统存储,然后存储一个指向文件路径的指针,而不是直接存储文件内容(Oracle:BFILE, Microsoft: FILESTREAM)。

image-20241108123852928

image-20241108123909572

日志结构存储

基本概念:

  • 利写不利读,非原地更新:只有PUT和DELETE操作,顺序IO。查询时由最新到最老时查询日志。
  • 加速查询:索引。

image-20241108132439250

  • 加速查询:日志压缩,且压缩时会排序日志。
  • 压缩方式:层级压缩,统一压缩

image-20241108133449643

特点 Level Compaction Universal Compaction
层级结构 有多层级,L0、L1、L2 等 无层级结构,所有文件在同一级别
文件组织方式 每个层级内文件不重叠,跨层逐渐下推 基于文件大小和数量合并,文件可能有重叠
合并策略 层级压缩,按顺序下推合并 文件数量和大小超过阈值时触发合并
写放大 较高,因为需要不断下推文件至更低层级 较低,因为减少频繁合并
读放大 较低,因为相同键在每层只存在一次 较高,因为没有严格层级,需检查多个文件
适用场景 读多写少的场景 写多读少、实时数据的高写入场景

索引组织存储

直接用索引组织数据,数据挂在叶子结点上,Page内部的tuple有序。

SQLite和MySQL默认用这种方式组织数据,Oracle和SQL Server可选。

image-20241108133519165

和基于元组的存储对比:

特性 Index-Organized Storage Tuple-Oriented Storage
数据与索引存储 数据存储在主键索引结构中 数据和索引独立存储
数据排序 数据按照主键顺序排序 数据无序存储
主键查询性能 高效,因数据已按主键排序 依赖主键索引,但数据本身无序
插入和更新性能 插入和更新时可能需要索引重排,较慢 插入和更新较快,无需主键排序
适用场景 主键查询频繁,数据顺序性强的场景 多种查询模式,插入和更新频繁的场景

数据模型

image-20241108160451120

  1. N-ary Storage Model (NSM)
  2. Decomposition Storage Model (DSM)
  3. Hybrid Storage Model (PAX)

NSM

优点:操作一条完整记录时快速。

缺点:操作一批记录的某一个特定列的时候,非顺序读取,会有无效IO,且数据不好做压缩。

image-20241108160903173

DSM

优点:可以取到一批特定列;可以做数据压缩。

缺点:在操作完整记录的时候,需要分解查询,得到结果后还需要再进行合并。

image-20241108161201607

PAX

结合了NSM和DSM,既能一次处理一个完整记录,也能在读取一系列特定的属性时顺序读取并避免过多的无用IO。

image-20241108161918379

数据压缩方式

目标:

  1. 压缩结果为定长值(存储定长数据)。

  2. 仅在需要时解压缩,否则都采用压缩形式处理数据。

  3. 必须是无损的。

常用的压缩方式:字典压缩。

维护字典映射,数据表中存储映射值。结果定长,且可以支持范围查询。

image-20241108162715705

image-20241108162731540

字典映射的实现方式:数组。【哈希表不支持范围查询,B+树内存消耗大】

image-20241108163114414