基于Java的高性能轻量化数据库设计与实现第七篇：元数据管理实现

1. 引言

在前六篇中，我们完成了JDBC驱动、存储引擎、事务管理器和查询优化器的实现，支持了SQL执行、数据存储和查询优化。本篇将聚焦元数据管理（metadata-manager模块）的实现，设计表结构、索引和统计信息的存储与访问机制。元数据管理器将为其他模块提供关键信息，支持DDL操作和查询优化。

2. 元数据管理器的目标与功能

2.1 目标

提供表结构、索引和统计信息的集中管理。
支持SQL ANSI 92标准的DDL操作（如CREATE TABLE）。
为查询优化器提供统计数据，提升执行计划效率。
确保元数据的持久性和一致性。

2.2 功能

表定义：存储表名、列定义和约束。
索引管理：记录主键和二级索引。
统计信息：维护表行数和列选择率。
持久化：支持内存和文件存储模式。

3. 元数据管理器的核心设计

3.1 数据结构

表元数据（TableMetadata）：

包含表名、列定义和索引信息。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class TableMetadata {
    private final String tableName;
    private final List<ColumnDefinition> columns;
    private final List<String> indexedColumns;
    private double rowCount; // 统计信息

    public TableMetadata(String tableName, List<ColumnDefinition> columns, List<String> indexedColumns) {
        this.tableName = tableName;
        this.columns = columns;
        this.indexedColumns = indexedColumns;
        this.rowCount = 0;
    }
    // getter和setter
}

列定义（ColumnDefinition）：

定义列名、类型和约束。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class ColumnDefinition {
    private final String name;
    private final String type; // INT, VARCHAR, JSON等
    private final boolean isPrimaryKey;

    public ColumnDefinition(String name, String type, boolean isPrimaryKey) {
        this.name = name;
        this.type = type;
        this.isPrimaryKey = isPrimaryKey;
    }
    // getter
}

3.2 存储模式

内存模式：使用Map<String, TableMetadata>存储。
文件模式：将元数据序列化为JSON文件，配合WAL日志确保持久性。

3.3 统计信息

动态更新行数（rowCount）。
未来可扩展列选择率（selectivity）估算。

4. 元数据管理器实现

以下是MetadataManager类的核心实现：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package com.yinlongfei.lightweight.database.metadata;

import com.yinlongfei.lightweight.database.storage.Row;

import javax.json.Json;
import javax.json.JsonObject;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.stream.Collectors;

public class MetadataManager {
    private final Map<String, TableMetadata> tables = new HashMap<>();
    private final Path dataDir;
    private final boolean isMemoryMode;

    public MetadataManager(String url) {
        this.dataDir = Path.of(url.replace("jdbc:lightweight:", ""));
        this.isMemoryMode = url.contains("memory");
        if (!isMemoryMode && !Files.exists(dataDir)) {
            try {
                Files.createDirectories(dataDir);
            } catch (Exception e) {
                throw new RuntimeException("Failed to create metadata directory", e);
            }
        }
        loadMetadata(); // 初始化时加载元数据
    }

    public void addTable(String tableName, List<String> columnNames, List<String> columnTypes, List<String> indexedColumns) {
        List<ColumnDefinition> columns = new ArrayList<>();
        for (int i = 0; i < columnNames.size(); i++) {
            boolean isPrimaryKey = indexedColumns.contains(columnNames.get(i));
            columns.add(new ColumnDefinition(columnNames.get(i), columnTypes.get(i), isPrimaryKey));
        }
        tables.put(tableName, new TableMetadata(tableName, columns, indexedColumns));
        if (!isMemoryMode) persistMetadata();
    }

    public void dropTable(String tableName) {
        tables.remove(tableName);
        if (!isMemoryMode) persistMetadata();
    }

    public double getRowCount(String tableName) {
        TableMetadata table = tables.get(tableName);
        return table != null ? table.getRowCount() : 0;
    }

    public void updateRowCount(String tableName, double rowCount) {
        TableMetadata table = tables.get(tableName);
        if (table != null) {
            table.setRowCount(rowCount);
            if (!isMemoryMode) persistMetadata();
        }
    }

    public List<String> getIndexedColumns(String tableName) {
        TableMetadata table = tables.get(tableName);
        return table != null ? table.getIndexedColumns() : Collections.emptyList();
    }

    public String getTableNameForRow(Row row) {
        // 根据Row内容查找所属表（简化为遍历）
        return tables.entrySet().stream()
                .filter(entry -> entry.getValue().getColumns().stream()
                        .allMatch(col -> row.getColumns().containsKey(col.getName())))
                .map(Map.Entry::getKey)
                .findFirst()
                .orElse(null);
    }

    private void persistMetadata() {
        try {
            JsonObject json = Json.createObjectBuilder()
                    .add("tables", Json.createObjectBuilder()
                            .addAll(tables.entrySet().stream()
                                    .collect(Collectors.toMap(
                                            Map.Entry::getKey,
                                            entry -> Json.createObjectBuilder()
                                                    .add("columns", Json.createArrayBuilder(
                                                            entry.getValue().getColumns().stream()
                                                                    .map(col -> Json.createObjectBuilder()
                                                                            .add("name", col.getName())
                                                                            .add("type", col.getType())
                                                                            .add("isPrimaryKey", col.isPrimaryKey())
                                                                            .build())
                                                                    .collect(Collectors.toList())))
                                                    .add("indexedColumns", Json.createArrayBuilder(entry.getValue().getIndexedColumns()))
                                                    .add("rowCount", entry.getValue().getRowCount())
                                                    .build()))))
                    .build();
            Files.writeString(dataDir.resolve("metadata.json"), json.toString());
        } catch (Exception e) {
            throw new RuntimeException("Failed to persist metadata", e);
        }
    }

    private void loadMetadata() {
        if (isMemoryMode || !Files.exists(dataDir.resolve("metadata.json"))) return;
        try {
            String content = Files.readString(dataDir.resolve("metadata.json"));
            JsonObject json = Json.createReader(new StringReader(content)).readObject();
            JsonObject tablesJson = json.getJsonObject("tables");
            for (String tableName : tablesJson.keySet()) {
                JsonObject tableJson = tablesJson.getJsonObject(tableName);
                List<ColumnDefinition> columns = tableJson.getJsonArray("columns").stream()
                        .map(obj -> {
                            JsonObject col = (JsonObject) obj;
                            return new ColumnDefinition(col.getString("name"), col.getString("type"), col.getBoolean("isPrimaryKey"));
                        })
                        .collect(Collectors.toList());
                List<String> indexedColumns = tableJson.getJsonArray("indexedColumns").stream()
                        .map(Object::toString)
                        .collect(Collectors.toList());
                TableMetadata table = new TableMetadata(tableName, columns, indexedColumns);
                table.setRowCount(tableJson.getJsonNumber("rowCount").doubleValue());
                tables.put(tableName, table);
            }
        } catch (Exception e) {
            throw new RuntimeException("Failed to load metadata", e);
        }
    }
}

5. 与其他模块的集成

存储引擎：提供表结构和索引信息，支持索引更新和行数统计。
查询优化器：提供行数和索引信息，优化执行计划。
JDBC驱动：支持DDL语句（如CREATE TABLE）。

调整StorageEngine以更新元数据：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
public class StorageEngine {
    // ... 其他代码 ...

    public synchronized void executeInsert(InsertStatement stmt, long txId, LoggingManager logger) {
        String tableName = stmt.getTableName();
        List<Row> table = memoryTables.computeIfAbsent(tableName, k -> new ArrayList<>());
        Map<String, Object> rowData = new HashMap<>();
        for (int i = 0; i < stmt.getColumns().size(); i++) {
            rowData.put(stmt.getColumns().get(i), stmt.getValues().get(i));
        }
        Row row = new Row(rowData, 1, txId);
        table.add(row);
        updateIndexes(tableName, row);
        metadataManager.updateRowCount(tableName, table.size()); // 更新行数
        if (!isMemoryMode) logger.logWAL("INSERT INTO " + tableName + " VALUES " + rowData);
    }
}

6. 执行流程图

元数据管理的执行流程：

sequenceDiagram
    participant J as JDBC驱动
    participant M as 元数据管理
    participant S as 存储引擎

    J->>M: addTable("users", columns, indexes)
    M->>S: updateRowCount("users", 0)
    J->>S: executeInsert(stmt, txId)
    S->>M: updateRowCount("users", 1)
    J->>S: executeSelect(stmt, txId)
    S->>M: getIndexedColumns("users")
    M-->>S: indexedColumns

流程说明：
1. JDBC驱动创建表，初始化元数据。
2. 存储引擎插入数据，更新行数。
3. 查询时获取索引信息。

7. 测试示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
MetadataManager metadata = new MetadataManager("jdbc:lightweight:memory");
StorageEngine storage = new StorageEngine("jdbc:lightweight:memory", metadata, txManager);
TransactionManager txManager = new TransactionManager(storage, logger);

metadata.addTable("users", Arrays.asList("id", "name"), Arrays.asList("INT", "VARCHAR"), Collections.singletonList("id"));
InsertStatement insert = new InsertStatement("users", Arrays.asList("id", "name"), Arrays.asList(1, "Alice"));
storage.executeInsert(insert, txManager.begin(), logger);

SelectStatement select = new SelectStatement("users", null, new Condition("id", "=", 1));
List<Map<String, Object>> result = storage.executeSelect(select, txManager.getCurrentTxId());
System.out.println(result); // 输出 [{id=1, name=Alice}]
System.out.println(metadata.getRowCount("users")); // 输出 1

8. 下一步展望

下一篇文章将总结整个系统，评估性能并与H2、SQLite对比，探索扩展方向（如视图支持）。

总结

第七篇实现了元数据管理器，支持表结构、索引和统计信息的存储与访问。Mermaid图展示了与存储引擎的交互流程，为查询优化和数据操作提供了基础。后续将进行系统整合和性能测试。

基于Java的高性能轻量化数据库设计与实现 第七篇：元数据管理实现

相关文章：

基于Java的高性能轻量化数据库设计与实现第七篇：元数据管理实现