手写MySQL(九) TBM模块篇-字段解析与表管理

已于 2023-03-15 10:48:33 修改
阅读量366 收藏 1
点赞数
分类专栏： 手写MySQL数据库 文章标签： mysql mariadb sql
于 2022-06-15 16:45:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang24360/article/details/125292363
版权

代码地址：GitHub - zhangqingqing24630/MySQL-

此项目来源于何人听我楚狂声

 

 

目录

 

SQL 解析器

实现方法

语句切割

测试代码

语句解析

字段与表管理

字段管理Field

存储结构

读取字段

创建字段

表管理Table

存储结构

读取表

解析表

创建表

Update操作

insert操作

read操作

计算 Where 条件的范围

表的启动管理

TableManager的实现

测试代码

 

TBM也是最后一个模块，实现了对字段结构和表结构的管理，其与其他模块的依赖关系如下

8a45ac85c4d8484d9b41a070d91398ad.jpeg

 

SQL 解析器

实现的 SQL 语句语法如下：

<begin statement>
    begin [isolation level (read committed|repeatable read)]
        begin isolation level read committed

<commit statement>
    commit

<abort statement>
    abort

<create statement>
    create table <table name>
    <field name> <field type>
    <field name> <field type>
    ...
    <field name> <field type>
    [(index <field name list>)]
        create table students
        id int32,
        name string,
        age int32,
        (index id name)

<drop statement>
    drop table <table name>
        drop table students

<select statement>
    select (*|<field name list>) from <table name> [<where statement>]
        select * from student where id = 1
        select name from student where id > 1 and id < 4
        select name, age, id from student where id = 12

<insert statement>
    insert into <table name> values <value list>
        insert into student values 5 "Zhang Yuanjia" 22

<delete statement>
    delete from <table name> <where statement>
        delete from student where name = "Zhang Yuanjia"

<update statement>
    update <table name> set <field name>=<value> [<where statement>]
        update student set name = "ZYJ" where id = 5

<where statement>
    where <field name> (>|<|=) <value> [(and|or) <field name> (>|<|=) <value>]
        where age > 10 or age < 3

<field name> <table name>
    [a-zA-Z][a-zA-Z0-9_]*

<field type>
    int32 int64 string

实现方法

语句切割

parser 包的 Tokenizer 类，对语句进行逐字节解析，根据空白符或者上述词法规则，将语句切割成多个 token。对外提供了 peek()、pop() 方法方便取出 Token 进行解析。

其解析规则如下

1 取出完整的字符串

2 取出引号包起来的内容

3 取出符号，如> < =

其具体实现代码为

private String nextMetaState() throws Exception {
        while(true) {
            //遍历字节数组，直至遍历完，取出
            Byte b = peekByte();
            if(b == null) {
                return "";
            }
            //遇到空格或回车，忽略，继续遍历
            if(!isBlank(b)) {
                break;
            }
            popByte();//pos++;
        }
        byte b = peekByte();
        //如果b是<>=*,这些符号，取出符号
        if(isSymbol(b)) {
            popByte();
            return new String(new byte[]{b});
        //如果b是单引号或者双引号，找到单引号双引号包起来的内容
        } else if(b == '"' || b == '\'') {
            return nextQuoteState();
        //如果b是数字或字母，找到完整的数字或字符串
        } else if(isAlphaBeta(b) || isDigit(b)) {
            return nextTokenState();
        } else {
            err = Error.InvalidCommandException;
            throw err;
        }
    }

测试代码

public class test {
    public static void main(String[] args) throws Exception {
        String ss=" insert into student values 5 \"xiaohong\" 22";
        byte[]b=ss.getBytes(StandardCharsets.UTF_8);
        Tokenizer tokenizer = new Tokenizer(b);
        for(int i=0;i<b.length;i++){
            String token = tokenizer.peek();
            System.out.println(token);
            tokenizer.pop();
        }
    }
}

解析出的字段为  

insert
into
student
values
5
xiaohong
22

语句解析

解析过程是根据解析出的第一个 Token 来区分语句类型，并分别做处理

Tokenizer tokenizer = new Tokenizer(statement);
        String token = tokenizer.peek();
        tokenizer.pop();
        Object stat = null;
        Exception statErr = null;
        try {
            switch(token) {
                case "begin":
                    stat = parseBegin(tokenizer);
                    break;
                case "commit":
                    stat = parseCommit(tokenizer);
                    break;
                case "abort":
                    stat = parseAbort(tokenizer);
                    break;
                case "create":
                    stat = parseCreate(tokenizer);
                    break;
                case "drop":
                    stat = parseDrop(tokenizer);
                    break;
                case "select":
                    stat = parseSelect(tokenizer);
                    break;
                case "insert":
                    stat = parseInsert(tokenizer);
                    break;
                case "delete":
                    stat = parseDelete(tokenizer);
                    break;
                case "update":
                    stat = parseUpdate(tokenizer);
                    break;
                case "show":
                    stat = parseShow(tokenizer);
                    break;
                default:
                    throw Error.InvalidCommandException;
            }
        } catch(Exception e) {
            statErr = e;
        }

以解析插入的SQL 语句为例，需要解析出要插入的表名，和要插入的字段。如果解析出的字段不满足规则，报错。

以insert为例解析出的字段必须满足

insert into 表名（自定 格式 以字母开头） values value（自定）

private static Insert parseInsert(Tokenizer tokenizer) throws Exception {
        Insert insert = new Insert();
        //比如解析insert的下一句一定得是into
        if(!"into".equals(tokenizer.peek())) {
            throw Error.InvalidCommandException;
        }
        tokenizer.pop();
        //解析出表名，不满足规则报错
        String tableName = tokenizer.peek();
        if(!isName(tableName)) {
            throw Error.InvalidCommandException;
        }
        insert.tableName = tableName;
        tokenizer.pop();
        //下一个字段必须是values
        if(!"values".equals(tokenizer.peek())) {
            throw Error.InvalidCommandException;
        }
        //要插入的值
        List<String> values = new ArrayList<>();
        while(true) {
            tokenizer.pop();
            String value = tokenizer.peek();
            if("".equals(value)) {
                break;
            } else {
                values.add(value);
            }
        }
        insert.values = values.toArray(new String[values.size()]);

        return insert;
    }

字段与表管理

字段管理Field

存储结构

由于 TBM 基于 VM的基础之上的，单个字段信息和表信息都是直接保存在 Entry 中，即保存在VM结构的【data】部分。Entry的存储结构为

[FieldName][TypeName][IndexUid]
字段名      字段类型    字段根节点uid

 这里 FieldName 和 TypeName，以及后面要介绍的TableName，存储的都是字节形式的字符串。这里规定一个字符串的存储方式，以明确其存储边界。

[StringLength][StringData]

TypeName 为字段的类型，限定为 int32、int64 和 string 类型。如果这个字段有索引，那个 IndexUID 指向了索引二叉树的根，否则该字段为 0。

即，如果该字段建立了索引，则以该字段会建立一个B+树。

为了不容易混淆，我们总结一下前面介绍过的存储结果。

DataItem的存储结构为

[ValidFlag][Size][Data]

VM的存储结构为一个Entry，存储在DataItem的【Data】中，Entry的存储结构为

[XMin][XMax][Data]

IM存储结构为一个Entry，存储在DataItem的【Data】中，Entry的存储结构为

[LeafFlag][KeyNumber][SiblingUid]
占1个字节          2         8
[Son0][Key0][Son1][Key1]...[SonN][KeyN]
8      8     8

 

重新回到TBM模块上来

读取字段

根据这个结构，通过一个 UID 从表中读取字段并解析如下：

public static Field loadField(Table tb, long uid) {
        byte[] raw = null;
        try {
            //读取一个entry.data()
            raw = ((TableManagerImpl)tb.tbm).vm.read(TransactionManagerImpl.SUPER_XID, uid);
        } catch (Exception e) {
            Panic.panic(e);
        }
        assert raw != null;
        return new Field(uid, tb).parseSelf(raw);
 }


private Field parseSelf(byte[] raw) {
        int position = 0;
        ParseStringRes res = Parser.parseString(raw);
        //解析出字段名
        fieldName = res.str;
        position += res.next;
        res = Parser.parseString(Arrays.copyOfRange(raw, position, raw.length));
        //解析出字段类型
        fieldType = res.str;
        position += res.next;
        //该字段根节点的索引
        this.index = Parser.parseLong(Arrays.copyOfRange(raw, position, position+8));
        if(index != 0) {
            try {
                bt = BPlusTree.load(index, ((TableManagerImpl)tb.tbm).dm);
            } catch(Exception e) {
                Panic.panic(e);
            }
        }
        return this;
    }

创建字段

创建一个字段的方法类似，将相关的信息通过 VM 持久化即可：

//创建字段
public static Field createField(Table tb, long xid, String fieldName, String fieldType, boolean indexed) throws Exception {
        typeCheck(fieldType);
        Field f = new Field(tb, fieldName, fieldType, 0);
        //有索引
        if(indexed) {
            //生成一个空的根节点   ，返回存放根节点的uid
            long index = BPlusTree.create(((TableManagerImpl)tb.tbm).dm);
            以该uid为bootUid的节点为根节点建立一个B+树
            BPlusTree bt = BPlusTree.load(index, ((TableManagerImpl)tb.tbm).dm);
            f.index = index;
            f.bt = bt;
        }
        f.persistSelf(xid);
        return f;
    }
//创建一个字段的方法类似，将相关的信息通过 VM 持久化即可
private void persistSelf(long xid) throws Exception {
    byte[] nameRaw = Parser.string2Byte(fieldName);
    byte[] typeRaw = Parser.string2Byte(fieldType);
    byte[] indexRaw = Parser.long2Byte(index);
    this.uid = ((TableManagerImpl)tb.tbm).vm.insert(xid, Bytes.concat(nameRaw, typeRaw, indexRaw));
}

表管理Table

存储结构

一个数据库中存在多张表，TBM 使用链表的形式将其组织起来，每一张表都保存一个指向下一张表的 UID。表的二进制结构如下：

[TableName][NextTable]
表名        下一张表的uid
[Field1Uid][Field2Uid]...[FieldNUid]

读取表

根据 UID 从 Entry 中读取表数据的过程和读取字段的过程类似。

//根据uid从已有文件中加载表
    public static Table loadTable(TableManager tbm, long uid) {
        byte[] raw = null;
        try {
            raw = ((TableManagerImpl)tbm).vm.read(TransactionManagerImpl.SUPER_XID, uid);
        } catch (Exception e) {
            Panic.panic(e);
        }
        assert raw != null;
        Table tb = new Table(tbm, uid);
        return tb.parseSelf(raw);
    }

解析表

表的解析过程如下，由于uid的字节数是固定的（8个），所以于是无需保存字段的个数。

1 解析表名

2 解析下一个表的uid

3 解析表中的所有字段，且创建字段，把所有的字段存储在一个fields中

private Table parseSelf(byte[] raw) {
        int position = 0;
        ParseStringRes res = Parser.parseString(raw);
        //表名
        name = res.str;
        position += res.next;
        //下一个表的uid
        nextUid = Parser.parseLong(Arrays.copyOfRange(raw, position, position+8));
        position += 8;
        //字段的uid
        while(position < raw.length) {
            long uid = Parser.parseLong(Arrays.copyOfRange(raw, position, position+8));
            position += 8;
            fields.add(Field.loadField(this, uid));
        }
        return this;
    }

创建表

常常用于插入新表时，用Create存储一张表的信息。
public class Create {
    public String tableName;//表名
    public String[] fieldName;//存储的字段名
    public String[] fieldType;//存储的字段类型
    public String[] index;//存储的索引
}

创建表时，需要把表中所有的字段信息存储到dm中

//创建表，用于插入新表时使用
    //nextUid原来第一张表的uid
    //xid插入新表的xid
    //要插入新表的所有信息
    public static Table createTable(TableManager tbm, long nextUid, long xid, Create create) throws Exception {
        Table tb = new Table(tbm, create.tableName, nextUid);
        for(int i = 0; i < create.fieldName.length; i ++) {
            String fieldName = create.fieldName[i];
            String fieldType = create.fieldType[i];
            boolean indexed = false;
            for(int j = 0; j < create.index.length; j ++) {
                if(fieldName.equals(create.index[j])) {
                    indexed = true;
                    break;
                }
            }
            //为新表的字段存储到dm中
            tb.fields.add(Field.createField(tb, xid, fieldName, fieldType, indexed));
        }
        return tb.persistSelf(xid);
    }

private Table persistSelf(long xid) throws Exception {
        byte[] nameRaw = Parser.string2Byte(name);
        byte[] nextRaw = Parser.long2Byte(nextUid);
        byte[] fieldRaw = new byte[0];
        for(Field field : fields) {
            fieldRaw = Bytes.concat(fieldRaw, Parser.long2Byte(field.uid));
        }
        uid = ((TableManagerImpl)tbm).vm.insert(xid, Bytes.concat(nameRaw, nextRaw, fieldRaw));
        return this;
    }

Update操作

其步骤为

1 确认要更新的是哪张表

2 找出命中字段中满足where条件的uid，解析出存储的一条数据（表中可能有多个字段，以键值对存储）

3 找到要更新的字段fd

4 删除原有的字段，实则是设置xmax

5 更新一条数据，往DM插入更新后的值得到uid

6 在所有indexed字段建立的B+树中插入新的的key|uid

public int update(long xid, Update update) throws Exception {
        //找出命中字段中满足where条件的uid，如a=2,a=3
        List<Long> uids = parseWhere(update.where);
        Field fd = null;
        //找到要更新的字段fd
        for (Field f : fields) {
            if(f.fieldName.equals(update.fieldName)) {
                fd = f;
                break;
            }
        }
        if(fd == null) {
            throw Error.FieldNotFoundException;
        }
        //把需要更新的值变成相应的类型
        Object value = fd.string2Value(update.value);
        int count = 0;

        for (Long uid : uids) {
            //根据条件找到的uid
            byte[] raw = ((TableManagerImpl)tbm).vm.read(xid, uid);
            if(raw == null) continue;
            //更新即先删除再插入，删除时要判断死锁和可视化,实际上是设置xmax
            ((TableManagerImpl)tbm).vm.delete(xid, uid);
            //返回未更新之前的字段entry={name=xiaohong, age=18}
            Map<String, Object> entry = parseEntry(raw);
            //替换新值
            entry.put(fd.fieldName, value);//name=ZYJ,age=18
            //把新的值concat到一起
            raw = entry2Raw(entry);
            long uuid = ((TableManagerImpl)tbm).vm.insert(xid, raw);
            count ++;
            //更新两颗B+树
            for (Field field : fields) {
                if(field.isIndexed()) {
                    //字段的值，存储字段的值的uid
                    field.insert(entry.get(field.fieldName), uuid);
                }
            }
        }
        return count;
    }

insert操作

把插入的值合并到一个raw里面作为索引进行插入，然后为所有indexed字段建立的B+树更新树

public void insert(long xid, Insert insert) throws Exception {
        Map<String, Object> entry = string2Entry(insert.values);
        System.out.println("要插入的数据是"+entry);
        //把entry里面所有的值合并在一个raw里面
        byte[] raw = entry2Raw(entry);
        long uid = ((TableManagerImpl)tbm).vm.insert(xid, raw);
        for (Field field : fields) {
            if(field.isIndexed()) {
                field.insert(entry.get(field.fieldName), uid);
            }
        }
    }

read操作

同样，IM模块找出所有符合条件的uid，再利用VM模块进行可视化判断。

public String read(long xid, Select read) throws Exception {
        List<Long> uids = parseWhere(read.where);
        StringBuilder sb = new StringBuilder();
        for (Long uid : uids) {
            byte[] raw = ((TableManagerImpl)tbm).vm.read(xid, uid);
            if(raw == null) continue;
            Map<String, Object> entry = parseEntry(raw);
            sb.append(printEntry(entry)).append("\n");
        }
        return sb.toString();
    }

计算 Where 条件的范围

对表和字段的操作，有一个很重要的步骤，就是计算 Where 条件的范围， 比如Delete和Select都需要计算 Where，最终就需要获取到条件范围内所有的 UID，这里只支持了带有索引的两个条件的查询

//解析where语句，返回uid
private List<Long> parseWhere(Where where) throws Exception {
        long l0=0, r0=0, l1=0, r1=0;
        boolean single = false;//or字段连起来是false，其他是true
        Field fd = null;
        if(where == null) {//没有指定where范围
            for (Field field : fields) {
                if(field.isIndexed()) {
                    fd = field;
                    break;
                }
            }
            l0 = 0;
            r0 = Long.MAX_VALUE;
            single = true;
        } else {//指定了where范围
            for (Field field : fields) {
                //指定了是查找哪个字段
                if(field.fieldName.equals(where.singleExp1.field)) {
                    if(!field.isIndexed()) {
                        throw Error.FieldNotIndexedException;
                    }
                    fd = field;
                    break;
                }
            }
            if(fd == null) {
                throw Error.FieldNotFoundException;
            }
            CalWhereRes res = calWhere(fd, where);
            l0 = res.l0; r0 = res.r0;//第一个条件的低水位和高水位
            l1 = res.l1; r1 = res.r1;//第二个条件的低水位和高水位
            single = res.single;
        }
        List<Long> uids = fd.search(l0, r0);
        if(!single) {//or字段，增加后一个条件的uid
            List<Long> tmp = fd.search(l1, r1);
            uids.addAll(tmp);
        }
        return uids;
    }

在字段中搜寻满足where条件的高低水位如下，如果是and字段，取两个条件的高低水位的并集。

private CalWhereRes calWhere(Field fd, Where where) throws Exception {
        CalWhereRes res = new CalWhereRes();
        switch(where.logicOp) {
            case "":
                res.single = true;
                FieldCalRes r = fd.calExp(where.singleExp1);
                res.l0 = r.left; res.r0 = r.right;
                break;
            case "or":
                res.single = false;
                r = fd.calExp(where.singleExp1);
                res.l0 = r.left; res.r0 = r.right;
                r = fd.calExp(where.singleExp2);
                res.l1 = r.left; res.r1 = r.right;
                break;
            case "and"://两个条件的高低水位取交集
                res.single = true;
                r = fd.calExp(where.singleExp1);
                res.l0 = r.left; res.r0 = r.right;
                r = fd.calExp(where.singleExp2);
                res.l1 = r.left; res.r1 = r.right;
                if(res.l1 > res.l0) res.l0 = res.l1;//取left的最大值
                if(res.r1 < res.r0) res.r0 = res.r1;//取right的最小值
                break;
            default:
                throw Error.InvalidLogOpException;
        }
        return res;
    }

从一个where条件中解析出高低水位如下

//a>5  left=6 right=MAX_VALUE
//a<5  left=0 right=4;
//a=5  left=right=5
    public FieldCalRes calExp(SingleExpression exp) throws Exception {
        Object v = null;
        FieldCalRes res = new FieldCalRes();
        switch(exp.compareOp) {
            case "<":
                res.left = 0;
                v = string2Value(exp.value);
                res.right = value2Uid(v);
                if(res.right > 0) {
                    res.right --;
                }
                break;
            case "=":
                v = string2Value(exp.value);
                res.left = value2Uid(v);
                res.right = res.left;
                break;
            case ">":
                res.right = Long.MAX_VALUE;
                v = string2Value(exp.value);
                res.left = value2Uid(v) + 1;
                break;
        }
        return res;
    }

表的启动管理

由于 TBM 的表管理，使用的是链表串起的 Table 结构，所以就必须保存一个链表的头节点，即第一个表的 UID，这样在数据库 启动时，才能快速找到表信息。

 

数据库使用 Booter 类和 bt 文件，来管理 数据库 的启动信息，虽然现在所需的启动信息，只有一个：头表的 UID。Booter 类对外提供了两个方法：load 和 update，并保证了其原子性。update 在修改 bt 文件内容时，没有直接对 bt 文件进行修改，而是首先将内容写入一个 bt_tmp 文件中，随后将这个文件重命名为 bt 文件。以期通过操作系统重命名文件的原子性，来保证操作的原子性。

public void update(byte[] data) {
        //创建一个bt_tmp文件
        File tmp = new File(path + BOOTER_TMP_SUFFIX);
        try {
            tmp.createNewFile();
        } catch (Exception e) {
            Panic.panic(e);
        }
        if(!tmp.canRead() || !tmp.canWrite()) {
            Panic.panic(Error.FileCannotRWException);
        }
        //将启动信息写入一个 bt_tmp 文件中
        try(FileOutputStream out = new FileOutputStream(tmp)) {
            out.write(data);
            out.flush();
        } catch(IOException e) {
            Panic.panic(e);
        }
        try {
            //随后将这个文件重命名为 bt 文件,并覆盖之前的同名文件
            Files.move(tmp.toPath(), new File(path+BOOTER_SUFFIX).toPath(), StandardCopyOption.REPLACE_EXISTING);
        } catch(IOException e) {
            Panic.panic(e);
        }
        file = new File(path+BOOTER_SUFFIX);
        if(!file.canRead() || !file.canWrite()) {
            Panic.panic(Error.FileCannotRWException);
        }
    }

当创建tbm对象时，需要把数据库中所有的表加入到缓存中。

TableManagerImpl(VersionManager vm, DataManager dm, Booter booter) {
        this.vm = vm;
        this.dm = dm;
        this.booter = booter;
        this.tableCache = new HashMap<>();
        this.xidTableCache = new HashMap<>();
        lock = new ReentrantLock();
        loadTables();
    }


private void loadTables() {
        long uid = firstTableUid();
        while(uid != 0) {
            Table tb = Table.loadTable(this, uid);
            uid = tb.nextUid;
            tableCache.put(tb.name, tb);
        }
    }

TableManager的实现

TBM 层对外提供服务的是 TableManager 接口，如下：

public interface TableManager {
    BeginRes begin(Begin begin);
    byte[] commit(long xid) throws Exception;
    byte[] abort(long xid);

    byte[] show(long xid);
    byte[] create(long xid, Create create) throws Exception;

    byte[] insert(long xid, Insert insert) throws Exception;
    byte[] read(long xid, Select select) throws Exception;
    byte[] update(long xid, Update update) throws Exception;
    byte[] delete(long xid, Delete delete) throws Exception;
}

由于 TableManager 已经是直接被最外层 Server 调用），这些方法直接返回执行的结果，例如错误信息或者结果信息的字节数组）。

各个方法的具体实现很简单，不再赘述，无非是调用 VM 的相关方法。唯一值得注意的一个小点是，在创建新表时，采用的是头插法，所以每次创建表都需要更新 Booter 文件。

测试代码

public class test {
    public static void main(String[] args) throws Exception {
        TransactionManagerImpl tm= TransactionManager.create("cun/tm");
        DataManager dm=DataManager.create("cun/dm",1 << 20,tm);
        VersionManager vm=VersionManager.newVersionManager(tm,dm);
        TableManager tbm=TableManager.create("cun/",vm,dm);
        //开启事务
        BeginRes br=tbm.begin(new Begin());
        long xid=br.xid;
        //建立一张新表
        String ss="create table students " +
                "name string,age int32 " +
                "(index name age)";
        byte b[]=ss.getBytes(StandardCharsets.UTF_8);
        Object stat = Parser.Parse(b);
        tbm.create(xid,(Create) stat);
        System.out.println("===测试插入操作===");
        ss="insert into students values xiaohong 18";
        b=ss.getBytes(StandardCharsets.UTF_8);
        stat = Parser.Parse(b);
        tbm.insert(xid,(Insert) stat);
        System.out.println("===测试更新操作===");
        ss="update students set name = \"ZYJ\" where name = xiaohong";
        b=ss.getBytes(StandardCharsets.UTF_8);
        stat = Parser.Parse(b);
        tbm.update(xid,(Update) stat);
        System.out.println("===测试查询操作===");
        ss="select name,age from students where age=18";
        b=ss.getBytes(StandardCharsets.UTF_8);
        stat = Parser.Parse(b);
        byte[] output=tbm.read(xid,(Select) stat);
        System.out.println(new String(output));
        System.out.println("===测试删除操作===");
        ss=" delete from students where age =18";
        b=ss.getBytes(StandardCharsets.UTF_8);
        stat = Parser.Parse(b);
        tbm.delete(xid,(Delete) stat);
    }
}

 

 

zhang24360
关注
专栏目录
docker compose mysql_Docker 运行 MySQL，使用 docker-compose
weixin_34722157的博客
01-19 109
目录结构.│ .env│ docker-compose.yml│└─mysql├─config│ my.cnf│└─datamysql 目录下的 data 为数据目录，mysql 的数据表、二进制日志文件就在这里。.env 文件包含了一些变量，这些变量可以在 docker-compose.yml 文件中通过 ${variable_name} 来引用。当然也可以把 mysql 的目录放...
Convert TBM - OGG_TBM-OGG_
09-30
【标题】"转换TBM格式至OGG：TBM-OGG转换工具" 【内容详解】 在数字音频处理领域，不同的文件格式有着各自的特点和适用场景。TBM（Truevision Targa Bitmap）是一种图像文件格式，通常用于保存高质量的位图图像，...
MYDB 之九 | TableManager (TBM) 字段解析与表管理
qq_64948664的博客
07-21 938
而记录本身的结构, 将由TBM来维护, TBM维护记录的方式非常简单: 直接将记录的值, 转换成二进制的字节数组, 然后将该字节数组, 当做数据, 交给VM进行存储和管理. 之后, 当需要某条数据时, 则通过其地址, 从VM将其读出, 然后反解析出其值.NYADB会对上述的文法进行解析, 解析的方法也很简单: 首先将语句给token化, 然后之后就是if-else的方法进行判断和进行语句组装了. token化的方法也很简单, 分析出文法的词素, 然后写一个小自动机, 不断的切分就行了.
手写MySQL(六) VM模块篇-记录的版本与事务隔离
zhang24360的博客
06-16 438
无
手写MySQL(十一)总结篇
zhang24360的博客
06-15 591
无
MYSQL重构时候一个表中最好不要超过多少个字段呢？处理表已经55个字段了，重构时在考虑是否需要分拆多表
java技术专家全栈成长之路
03-29 1990
目录 目的 1.重构先查询表里面多少个字段 2、去官网查一查，搜索关键词：【Column Count Limits】 目的 希望重构之后能够解决掉数据冗余的问题，目前数据库已经超过1亿+数据，每天20W-50W数据量在递增，需要重构程序进行优化，可是实际上，我看到一张表里面有55个字段，瞬间感觉有点冗余了。就去查了查，MYSQL最大的一张表支持多少个字段？ 1.重构先查询表里面多少个字段 主要得SQL如下： -- 查询MSQL 表字段以及属性 SELECT column_name A
一起写个数据库 —— 9. 字段与表管理
Ziyang的博客
12-25 1328
本文原载于我的博客：https://ziyang.moe/article/mydb9.html 本章涉及代码都在 https://github.com/CN-GuoZiyang/MYDB/tree/master/src/main/java/top/guoziyang/mydb/backend/parser 与 https://github.com/CN-GuoZiyang/MYDB/tree/master/src/main/java/top/guoziyang/mydb/backend/tbm 中。 前言
手写数据库轮子项目 MYDB 之九 | TableManager (TBM) 字段解析与表管理
weixin_45634447的博客
09-18 303
TBM，即表管理器的实现。TBM 实现了对字段结构和表结构的管理。
Verilog开源项目——百兆以太网交换机（九）表项管理模块设计
sz_woshishazi的博客
10-08 1029
Atom TBM（Table Manager）即交换机表项管理模块，负责根据Packet的源MAC地址、源端口号进行自学习，便于下次遇到相同的MAC地址查询端口号，并定时完成高效的表项老化处理。   此外，Atom创新的使用循环hash和双hash算法来减轻hash冲突的影响。
SpringBoot教程五配置Mysql使用Mybatis-plus
道阻且长,行则将至 行而不辍,未来可期
07-20 865
目前所有的业务场景都是用数据库来作为媒介来实现的。数据库在所有的业务系统里面都是不可或缺的，不论是关系型数据MySQL,Oracle还是非关系型数据Redis，MongDb都是经常使用的。只有这些熟悉之后，才能实现所有的业务操作！.........
TBM-to-OGG-Converter.zip_tbm
09-24
标题中的"TBM-to-OGG-Converter.zip_tbm"表明这是一个转换工具，主要功能是将TBM格式的音频文件转换成OGG格式。TBM全称为True Audio Bitstream，是一种较少见的音频格式，通常用于存储高质量的音乐或音频数据。而OGG...
E73-TBM-01-SCH_nrf52832开发板_NRF52832_蓝牙开发板原理图_芯片_SCH.zip
10-11
《NRF52832蓝牙开发板：E73-TBM-01-SCH的原理图解析》 本文将深入探讨NRF52832蓝牙开发板E73-TBM-01-SCH的设计原理和技术细节。NRF52832是一款由挪威Nordic Semiconductor公司生产的高性能、低功耗的蓝牙低功耗...
tbm.rar_TBM-OGG_tbm
09-24
【标签】"tbm-ogg tbm" 可能意味着TBM不仅指时间基模块，还可能与音频编码格式Ogg有关。Ogg Vorbis是一种免费、开放的音频压缩格式，常用于网络音频流。"tbm"在这里可能代表了一个与处理Ogg音频流相关的组件或库。 ...
MySQL中表的约束
pouop的博客
10-13 1030
表中一定要有各种约束，通过约束，让我们来插入数据库中的数据是符合预期的。约束本质是通过技术手段，倒逼程序员插入正确的数据；反过来，站在MySQL的角度来单，内部已经插进来的数据，都i是符合数据约束的数据。约束的最终目标：保证数据完整性和可预期性为了完成以上的所有目标，就需要除了数据类型自带的范围约束以外的更多约束。
MySQL表的操作
2302_81707171的博客
10-14 890
MySQL表的操作
【原创】java+springboot+mysql校园留言墙管理系统设计与实现
计算机软件编程，包含Java、Php、Python、前后端、数据库等实战项目
10-15 1009
使用java+springboot+mysql开发的留言墙管理系统网站，系统包含管理员、用户角色，功能如下：管理员：登录后台；用户管理（冻结解禁）；留言管理；公告管理；关于我们；个人信息、密码修改。用户：注册、登录系统；首页，查看所有留言，发布留言，可以回复其他人的留言，可以按内容搜索留言；查看公告；用户还具备个人中心功能，可以管理自己的留言，可以修改个人信息，上传头像，可以修改密码。系统界面美观大方，功能及其丰富，使用了springboot、bootstrap、jquery、ajax等技术栈。
windows mysql 8.0版本重置root密码
最新发布
mengbing1990的博客
10-16 368
windows 下mysql 8.0重置root密码
MySQL之Buffer Pool缓冲池详解
XT4625的专栏
10-15 808
Innodb 存储引擎设计了一个缓冲池（，来提高数据库的读写性能。Buffer Pool 以页为单位缓冲数据，可以通过参数调整缓冲池的大小，默认是 128 M。Innodb 通过三种链表来管理缓页：Free List （空闲页链表），管理空闲页；Flush List （脏页链表），管理脏页；LRU List，管理脏页+干净页，将最近且经常查询的数据缓存在其中，而不常查询的数据就淘汰出去。；
岩渣粒径分布对TBM刀具消耗的深度解析
该研究论文深入探讨了"基于岩渣粒径分布规律的TBM刀具消耗分析"，主要关注在TBM（隧道钻爆掘进机）施工过程中产生的岩渣特性与其对刀具消耗的影响。岩渣作为TBM掘进的直接产物，其粒径分布规律对于评估TBM的地质适应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值