快速熟悉 MatrixOne 内核前端

深入解析MatrixOne:云原生HTAP数据库的架构设计与工程实践 HTAP(混合事务/分析处理)数据库旨在通过一套系统同时支持在线事务处理(OLTP)和在线分析处理(OLAP),以消除传统架构中数据搬运带来的延迟与复杂性。其核心原理在于融合行式存储与列式存储,并借助统一的向量化执行引擎来高效处理混合负载。这项技术的价值在于能够为业务提供实时数据分析能力,简化技术栈,降低运维成本,适用于金融风控、实时报表、物联网数据分析等对数据时效性要求高的场景。本文以开源项目MatrixOne为例,深入探讨其如何通过存算分离、资源组隔离等工程实践,实现真正的HTAP能力,并解析其向量化引 阅读详情

Part 1 背景

首先简单科普下数据库内核的结构,一条sql语句的执行,主要涉及以下几个组件:

  • Parser :将sql语句生成抽象语法树(ast)。
  • Binder :负责验证语句的语义是否正确,并确定语句中涉及的表、列、函数等是否存在,最后将查询中逻辑名称与数据库中的实际对象绑定。
  • Planner :在绑定阶段完成后,Planner开始处理查询的逻辑结构,并生成查询的执行计划,执行计划描述了执行查询的方式。
  • Optimizer:负责对生成的执行计划进行进一步的优化,考虑执行计划中的多个执行路径,并根据成本估算和查询需求选择最佳的执行路径,包括选择最优的索引、连接方法、访问顺序等。
  • Executor :按照规划器生成的执行计划来执行查询。

依据之前的学习经验,个人认为熟悉一个从未接触过的全新代码库最快速方法是:照着一条最简单最常规的运行链路,看代码与单步跟踪结合,理清主线逻辑,然后从主线慢慢拓展到各个组件各个feature分支,直至覆盖整个项目。本文介绍的就是从最常见的sql语句 select … from … join … where … group by … order by … limit … 出发,快速熟悉MO内核前端部分(主要包括binder,planner和optimizer)的代码。

Part 2 大致执行流程

MO服务端handle客户端发来的请求,中间请求传递的过程我们就忽略不看,最终请求会进入到MysqlCmdExecutor.doComQuery()方法,这个方法的大致逻辑是:

  1. Parser解析sql成statement list,也就是ast list;
  2. 执行每一条statement。
// pkg/frontend/mysql_cmd_executor.go
doComQuery() {
    cws = GetComputationWrapper()
    for cw in cws {
        // 执行语句
        executeStmt(cw)
    }
}

GetComputationWrapper() {
   // parse SQL语句
    asts = parsers.Parse(sql)
    return [InitTxnComputationWrapper(stmt) for stmt in asts]
}

executeStmt方法主要做三件事:

  1. 生成执行计划
  2. 执行查询
  3. 返回结果

MO兼容MySQL通讯协议,按照MySQL协议,返回结果先发送column信息 ,然后发送具体数据,最后返回一个EOF packet结束这次通讯。Column信息在生成执行计划之后就可以拿到,而具体数据会在runner得到结果之后发送。

// pkg/frontend/mysql_cmd_executor.go
executeStmt(cw) {
    // 生成执行计划
    compile = cw.Compile()
    // 发送列信息
    for c in cw.columns {
        SendColumnDefinitionPacket(c)
    }
    SendEOFPacketIf()
    // 执行查询
    runner = compile.(ComputationRunner)
    runner.Run()
    // 结束通讯
    sendEOFOrOkPacket()
}

Part 3 生成执行计划

上一节中提到的Compile方法主要做两件事:生成执行计划以及执行器相关算子的编译

// pkg/frontend/computation_wrapper.go
Compile() {
    // 生成及优化执行计划
    cw.plan = buildPlan(..)
    // 编译执行代码
    cw.compile = compile.New(...)
    cw.compile.Compile()
}

我们先看buildPlan方法,由于下面的代码很多都是做了一层封装的简单调用,调用路径:buildPlan(mysql_cmd_executor.go) → BaseOptimizer.Optimize → BuildPlan(build.go) → runBuildSelectByBinder ,我们就略过中间部分了,直接看runBuildSelectByBinder 方法:

// pkg/sql/plan/build.go
runBuildSelectByBinder(stmt) {
    // 生成执行计划
    builder := NewQueryBuilder(SelectType...)
    bindCtx := NewBindContext(builder)
    rootId := builder.buildSelect(stmt, bindCtx, true)
    builder.qry.Steps = append(builder.qry.Steps, rootId)
    // 优化执行计划
    query := builder.createQuery()
    return &Plan{query}
}

上面介绍过binder的主要职责是将查询语句中的库/表/列名与数据库中对应的对象绑定,在MO中bind select语句的方法就是buildSelect ,代码大致如下:

// pkg/sql/plan/query_builder.go
buildSelect() {
    preprocess WITH
    build FROM
    unfold stars and generate headings
    bind WHERE
    bind GROUP BY
    bind HAVING
    bind PROJECTION
    bind TIME WINDOW
    bind ORDER BY
    bind LIMIT/OFFSET

    append AGGREGATION node
    append TIME WINDOW node
    append WINDOW node
    append PROJECT node
    append DISTINCT node
    append SORT node (include LIMIT/OFFSET)
    append result PROJECT node
}

可以看到buildSelect就是对select语句中各个部分(WITH、FROM、WHERE(HAVING)、GROUP BY、TIME WINDOW、ORDER BY及LIMIT/OFFSET)按顺序分别进行绑定,下面就对常用的几个部分进行介绍:

1. FROM

MO bind FROM子句的方法是buildTable。

// pkg/sql/plan/query_builder.go
buildTable(stmt) {
    switch tbl := stmt.(type) {
    case *tree.Select:
    case *tree.TableName:
        // 获取db,table名
        schema := tbl.SchemaName
        table := tbl.ObjectName  
        // check db
        schema, err = databaseIsValid(schema, builder.compCtx)
        if err != nil {
            return 0, err
        }
        // 得到tableDef
        obj, tableDef := builder.compCtx.Resolve(schema, table)
        if tableDef == nil {
            return 0, moerr.NewParseError("table %q does not exist", table)
        }
        // 生成node
        nodeID = builder.appendNode(&plan.Node{
            NodeType:    nodeType,
            Stats:       nil,
            ObjRef:      obj,
            TableDef:    tableDef,
            BindingTags: []int32{builder.genNewTag()},
        }, ctx)

    case *tree.JoinTableExpr:
        // 如果是单表,bind left table
        if tbl.Right == nil {
            return builder.buildTable(tbl.Left, ctx, preNodeId, leftCtx)
        }
        // 否则buildJoinTable
        return builder.buildJoinTable(tbl, ctx)
        
    case *tree.TableFunction:
    case *tree.ParenTableExpr:
    case *tree.AliasedTableExpr:
        // bind table
        nodeID = builder.buildTable(tbl.Expr)
        // addBinding
        builder.addBinding(nodeID, ctx)
}

根据sql语法,能跟在FROM后面表达式类型有:

  • select表达式
  • table名
  • join table表达式
  • 表函数
  • 带括号的table表达式
  • 带别名的table表达式

table表达式主要有table名(TableName),带别名的table表达式(AliasedTableExpr)和join table表达式(JoinTableExpr), 为了保持形式上的统一,MO的sql parser会把每个TableName都包装成AliasedTableExpr,如果不带alias,则As设为nil;每个AliasedTableExpr都会包装成JoinTableExpr,如果只是单表没有join,则Right设为nil。

举个例子,sql语句 SELECT * FROM t1,parse得到的t1的结构就类似这样的:

JoinTableExpr {
    Left: AliasedTableExpr {
        Expr: t1
        As: nil
    }
    Right: nil
}

bind这条sql语句的FROM子句过程大概是这样的:首先JoinTableExpr右表为nil,就只bind左表;左表是个AliasedTableExpr结构,先bind Expr(这里是TableName结构),然后将bind的信息添加到BindContext(ctx)中(addBinding方法)。

bind TableName的逻辑大致如下,首先验证db是否存在,如果存在获取table meta信息,得到table的column信息(即Resolve方法,如果table不存在返回nil),然后包装成plan.Node返回。

addBinding方法是将bind完的node中的信息,比如bindingTag,nodeID,表信息(tableName,tableID)以及列信息(colName,colType,是否隐藏)等信息包装成Binding结构添加到ctx中,这样在后续的bind过程中,就可以依据这些binding信息对表名/列名进行解析。

// pkg/sql/plan/query_builder.go
addBinding(nodeID, ctx) {
    // 获取node
    node := getNode(nodeID)
    // 生成col信息
    colLength := len(node.TableDef.Cols)
    cols := make([]string, colLength)
    colIsHidden := make([]bool, colLength)
    types := make([]*plan.Type, colLength)
    tag := node.BindingTags[0]  
    for i, col := range node.TableDef.Cols {
        if i < len(alias.Cols) {
            cols[i] = string(alias.Cols[i])
        } else {
            cols[i] = col.Name
        }
        colIsHidden[i] = col.Hidden
        types[i] = col.Typ
        name := table + "." + cols[i]
        builder.nameByColRef[[2]int32{tag, int32(i)}] = name
    }
    // 生成Binding结构
    binding = NewBinding(tag, nodeID, table, node.TableDef.TblId, cols, colIsHidden, types)
    // 将Binding添加到BindContext
    ctx.bindings = append(ctx.bindings, binding)
    ctx.bindingByTag[binding.tag] = binding
    ctx.bindingByTable[binding.table] = binding
}

2. WHERE / HAVING

WHERE子句的bind过程为:先将过滤条件以AND为分隔符进行切割,然后对每个表达式递归地进行bind,比如过滤条件A AND B AND C可以被分割为A,B和C, 然后分别bind(A),bind(B),bind(C);过滤条件bind完之后,需要将包含子查询的语句进行拍平,把子查询转换成等价的join语句,因为子查询的执行效率极低,会拖慢整个查询的速度,转换为join可以极大提升系统性能。

怎么将子查询转换为join这个问题比较复杂,有兴趣可以参考论文:https://github.com/matrixorigin/docs/blob/main/readings/subqueries-sigmod01.pdf。

HAVING子句和WHERE子句一样,都是起到过滤作用,但是语法上不支持子查询,因此bind过程和WHERE前半部分一样,就不多做介绍了。

// pkg/sql/plan/query_builder.go
// split过滤条件
whereList := splitAndBindCondition(clause.Where.Expr, NoAlias, ctx)

var newFilterList []*plan.Expr
var expr *plan.Expr
for _, cond := range whereList {
    // 优化子查询
    nodeID, expr, err = builder.flattenSubqueries(nodeID, cond, ctx)
    newFilterList = append(newFilterList, expr)
}
// 生成node并添加到ctx
nodeID = builder.appendNode(&plan.Node{
    NodeType:     plan.Node_FILTER,
    Children:     []int32{nodeID},
    FilterList:   newFilterList,
    NotCacheable: notCacheable,
}, ctx)

3. GROUP BY

GROUP BY子句的bind过程比HAVING更简单一点,都需要将表达式切割,直接对每个GROUP BY子表达式进行递归bind即可。

下面的PROEJCTION,ORDER BY,LIMIT/OFFSET的bind过程基本都和GROUP BY类似,除了需要做些额外的信息设置(比如排序的顺序是正序还是倒序等)和检查(比如limit后面跟的常数不能为负数等),就不做重复说明了。

// pkg/sql/plan/query_builder.go
groupBinder := NewGroupBinder(builder, ctx)
for _, group := range clause.GroupBy {
    // 补全列名,col1 -> t1.col1
    group = ctx.qualifyColumnNames(group, AliasAfterColumn)
    // bind子表达式
    groupBinder.BindExpr(group, 0, true)
}

4. PROJECTION

// pkg/sql/plan/query_builder.go
for i := range selectList {
    // bind子表达式
    expr := projectionBinder.BindExpr(selectList[i].Expr, 0, true)
    ctx.projects = append(ctx.projects, expr)
}

5. ORDER BY

// pkg/sql/plan/query_builder.go
orderBinder := NewOrderBinder(projectionBinder, selectList)
orderBys := make([]*plan.OrderBySpec, 0, len(astOrderBy))

for _, order := range astOrderBy {
    // bind子表达式
    expr := orderBinder.BindExpr(order.Expr)
    
    orderBy := &plan.OrderBySpec{
        Expr: expr,
        Flag: plan.OrderBySpec_INTERNAL,
    }
    // 设置Flag
    set orderBy.Flag
    orderBys = append(orderBys, orderBy)
}

6. LIMIT/OFFSET

// pkg/sql/plan/query_builder.go
limitBinder := NewLimitBinder(builder, ctx)
if astLimit.Offset != nil {
    // bind子表达式
    offsetExpr := limitBinder.BindExpr(astLimit.Offset, 0, true)
    // check非负性
    if ifNegative(offsetExpr) {
        return 0, moerr.NewSyntaxError(builder.GetContext(), "offset value must be nonnegative")
    }
}
if astLimit.Count != nil {
    // bind子表达式
    limitExpr := limitBinder.BindExpr(astLimit.Count, 0, true)
    // check非负性
    if ifNegative(limitExpr) {
        return 0, moerr.NewSyntaxError(builder.GetContext(), "offset value must be nonnegative")
    }
}

Part 4 优化执行计划

runBuildSelectByBinder方法中,除了buildSelect方法外,还有一部分工作是做查询优化,即createQuery方法:

// pkg/sql/plan/query_builder.go
createQuery() {
    for i, rootID := range builder.qry.Steps {
        // rule 1
        builder.rewriteDistinctToAGG(rootID)
        // rule 2
        builder.rewriteEffectlessAggToProject(rootID)
        // rule 3
        rootID = builder.pushdownFilters(rootID, nil, false)
        // rule 4
        err := foldTableScanFilters(builder.compCtx.GetProcess(), builder.qry, rootID)
        if err != nil {
            return nil, err
        }
        // rule 5
        builder.pushdownLimit(rootID)
        // rule 6
        builder.removeSimpleProjections(rootID, plan.Node_UNKNOWN, false, make(map[[2]int32]int))
        ... 
        // rule n
    }
}

从代码上看,createQuery方法逻辑很简单,就是将所有优化规则一条一条应用于之前生成的执行计划上,目前最常见的优化规则有:谓词下推,列裁剪,投影消除,外连接消除,聚合算子下推/上提,子查询优化(上文提到过,MO在生成plan阶段已经做了这个优化)等等。

这里就介绍一种比较常见且重要的策略:谓词下推。

谓词也就是过滤条件,谓词下推是从直觉上非常容易理解的一个优化:在越靠近数据读取的位置做过滤,后续需要处理的数据量就越少,整个查询的效率就越高。

例如这条sql: select * from t1, t2 where t1.col1 > 1 and t2.col2 > 2,假设t1, t2都有1万条数据,2张表满足过滤条件的数据量都是100条,如果先对t1,t2做笛卡尔积再做过滤,需要处理的数据是1亿条,如果先对t1,t2做过滤再做笛卡尔积,那需要处理的数据条数就只有1万条,能极大减少需要处理的数据量。

MO中谓词下推优化在pushdownFilters方法中:

// pkg/sql/plan/opt_misc.go
// filters是指下推到当前节点的过滤条件
pushdownFilters(nodeID, filters) {
    node := builder.qry.Nodes[nodeID]
    var canPushdown, cantPushdown []*plan.Expr
    // 带limit的语句不能下推
    if node.Limit != nil {
        cantPushdown = filters
        filters = nil
    }
    
    switch node.NodeType {
    case plan.Node_FILTER:
        canPushdown = filters
        // 收集当前节点的过滤条件
        for _, filter := range node.FilterList {
            canPushdown = append(canPushdown, splitPlanConjunction(filter)...)
        }
        // 下推到子节点
        childID, cantPushdownChild := pushdownFilters(node.Children[0], canPushdown)
        // 如果所有过滤条件都下推了,当前节点可以删除
        if len(cantPushdownChild) > 0 {
            node.Children[0] = childID
            node.FilterList = cantPushdownChild
        } else {
            nodeID = childID
        }
    case plan.Node_JOIN:
        var leftPushdown, rightPushdown []*plan.Expr
        for i, filter := range filters {
            joinSides[i] = getJoinSide(filter, leftTags, rightTags, markTag)
            // 是否能将left join转化为inner join
            if node.JoinType == plan.Node_LEFT && joinSides[i]&JoinSideRight != 0 && rejectsNull(filter, builder.compCtx.GetProcess()) {
                node.JoinType = plan.Node_INNER
                break
            }
        }
        
        node.OnList = splitPlanConjunctions(node.OnList)
        
        if node.JoinType == plan.Node_INNER {
            // 如果能转化为inner join,重新计算joinSide
            for _, cond := range node.OnList {
                // 收集ON子句的过滤条件
                filters = append(filters, splitPlanConjunction(cond)...)
            }
            node.OnList = nil
        
            joinSides = make([]int8, len(filters))
            for i, filter := range filters {
                joinSides[i] = getJoinSide(filter, leftTags, rightTags, markTag)
            }
        } else if node.JoinType == plan.Node_LEFT {
            // 如果不能转化为inner join, 收集能下推到右表的过滤条件
            var newOnList []*plan.Expr
            for _, cond := range node.OnList {
                conj := splitPlanConjunction(cond)
                for _, conjElem := range conj {
                    side := getJoinSide(conjElem, leftTags, rightTags, markTag)
                    if side&JoinSideLeft == 0 {
                        rightPushdown = append(rightPushdown, conjElem)
                    } else {
                        newOnList = append(newOnList, conjElem)
                    }
                }
            }
            node.OnList = newOnList
        }
        
        // 分别收集能下推到左表右表的条件
        for i, filter := range filters {
            switch joinSides[i] {
            case JoinSideLeft:
                if node.JoinType != plan.Node_OUTER {
                    leftPushdown = append(leftPushdown, filter)
                } else {
                    cantPushdown = append(cantPushdown, filter)
                }
            case JoinSideRight:
                if node.JoinType == plan.Node_INNER {
                    rightPushdown = append(rightPushdown, filter)
                } else {
                    cantPushdown = append(cantPushdown, filter)
                }
            // ... case XXXX    
            default:
                cantPushdown = append(cantPushdown, filter)
            }
        }
        
        // 下推到左子节点
        childID, cantPushdownChild := pushdownFilters(node.Children[0], leftPushdown)
        // 如果有不能下推的条件,左子节点增加一个FILTER节点
        if len(cantPushdownChild) > 0 {
            childID = builder.appendNode(&plan.Node{
                NodeType:   plan.Node_FILTER,
                Children:   []int32{node.Children[0]},
                FilterList: cantPushdownChild,
            }, nil)
        }
        node.Children[0] = childID
        // 下推到右子节点,处理同上
        childID, cantPushdownChild = pushdownFilters(node.Children[1], rightPushdown)
        if len(cantPushdownChild) > 0 {
            childID = builder.appendNode(&plan.Node{
                NodeType:   plan.Node_FILTER,
                Children:   []int32{node.Children[1]},
                FilterList: cantPushdownChild,
            }, nil)
        }
        node.Children[1] = childID
    }

    case plan.Node_PROJECT:
    case plan.Node_AGG:
    case plan.Node_WINDOW:
    case plan.Node_TABLE_SCAN, plan.Node_EXTERNAL_SCAN:
    case plan.Node_FUNCTION_SCAN:
    ...    
}

带limit的语句不能将谓词下推,因为先做limit再做filter,和先做filter再做limit的结果是不一样的。

然后根据节点类型做相应处理,这里看下常见的FILTER节点和JOIN节点:

FILTER节点

FILTER类型是最简单的情形,只需要将当前节点的过滤条件与上层传来的合并,尝试下推到子节点:如果所有条件都能下推,那当前节点是个没有过滤条件的FILTER节点,可以直接删除;如果有条件不能下推,那就在当前节点处理。

JOIN节点

首先介绍一个将left join简化为inner join的小优化,left join的结果包含左表的所有列,对于没有匹配的右表列,用NULL值填充;如果下推的过滤条件会将包含右表列中包含NULL值的行过滤掉,那这个left join就可以等价转化为inner join。

这个转化的好处是,对于inner join,ON子句的过滤条件如果只涉及左表或者右表的列,可以将该条件下推到对应的左右子节点。

谓词下推JOIN节点先尝试将left join转化为inner join,然后根据join side分别收集下推到左右表的过滤条件,递归下推到左右子节点,对于不能下推到子节点的条件,在子节点上方增加一个FILTER节点来处理这些条件。

Part 5 总结

本文从一个零基础学习者的视角,从最常见的select语句出发,简单介绍了MO内核代码的前端部分,包括binder,planner和optimizer 3个组件,介绍了常见sql子句bind以及plan生成的过程,基于rule的优化器代码框架以及谓词下推的优化策略。

本文主要目标还是梳理清楚主流程脉络为主,实际MO的源码要复杂的的多,涉及的细节及各类corner case非常多,想仔细研究MO以及有兴趣深挖细节的同学可以下载源码仔细阅读。

关于MatrixOne

MatrixOne 是一款基于云原生技术,可同时在公有云和私有云部署的多模数据库。该产品使用存算分离、读写分离、冷热分离的原创技术架构,能够在一套存储和计算系统下同时支持事务、分析、流、时序和向量等多种负载,并能够实时、按需的隔离或共享存储和计算资源。云原生数据库MatrixOne能够帮助用户大幅简化日益复杂的IT架构,提供极简、极灵活、高性价比和高性能的数据服务。

MatrixOne企业版和MatrixOne云服务自发布以来,已经在互联网、金融、能源、制造、教育、医疗等多个行业得到应用。得益于其独特的架构设计,用户可以降低多达70%的硬件和运维成本,增加3-5倍的开发效率,同时更加灵活的响应市场需求变化和更加高效的抓住创新机会。在相同硬件投入时,MatrixOne可获得数倍以上的性能提升。

MatrixOne秉持开源开放、生态共建的理念,核心代码全部开源,全面兼容MySQL协议,并与合作伙伴打造了多个端到端解决方案,大幅降低用户的迁移和使用成本,也帮助用户避免了供应商锁定风险。

关键词:超融合数据库、多模数据库、云原生数据库、国产数据库

MatrixOrigin 官网:新一代超融合异构开源数据库-矩阵起源(深圳)信息科技有限公司 MatrixOne

Github 仓库:GitHub - matrixorigin/matrixone: Hyperconverged cloud-edge native database

超融合数据库MatrixOne实战:统一HTAP、向量搜索与Git式数据管理 在数据架构领域,HTAP(混合事务/分析处理)数据库正成为解决数据孤岛、简化技术栈的关键技术。其核心原理在于通过统一的存储与计算引擎,同时高效处理在线事务与实时分析负载,从而避免数据在不同专用系统间的冗余与同步。这一架构为现代应用带来了显著的技术价值:它能够降低系统复杂性与运维成本,并保证数据的一致性与实时性。随着AI应用的普及,对向量搜索和全文搜索的原生支持已成为新一代数据库的重要能力,它们被集成到统一引擎中,服务于智能推荐、RAG等应用场景。本文以MatrixOne为例,深入探讨了如何利用其超融合架构与 阅读详情

相关推荐

量化爬虫第一步:手把手教你搞定同花顺问财的hexin-v参数(附JS逆向实战)

本文详细介绍了如何通过JS逆向技术破解同花顺问财数据接口的核心加密参数hexin-v,构建稳定可靠的量化数据采集方案。从抓包分析到Cookie Hook技术应用,再到环境补全与参数生成实现,手把手教你完成量化爬虫的第一步。文章还提供了实战注意事项与优化建议,帮助开发者规避常见问题。

weixin_42620202的博客 308

干货分享 | MatrixOne系统架构

随着数字化转型的深入,数据价值也愈发凸显,数据技术出现了融合的趋势,基于客户的真实痛点,矩阵起源推出了超融合MatrixOne HSTAP数据库。MatrixOne 使数据数据库同时具备 TP、AP和Streaming三种能力,帮助客户彻底打破数据孤岛问题,成为企业智能化核心的数据基础设施。今天的分享将解析新一代超融合异构云原生数据库 MatrixOne 刚刚发布的0.5版本和后续版本的架构设计。

MatrixOrigin的博客 898

COMSOL多物理场仿真:瓷绝缘子电热耦合建模与优化策略

本文详细介绍了使用COMSOL Multiphysics进行瓷绝缘子电热耦合仿真的完整流程与优化策略。文章阐述了电热耦合效应的工程意义,并逐步讲解了从几何建模、材料定义、物理场设置到边界条件与网格划分的关键步骤。重点分析了如何通过焦耳热耦合实现电场与温度场的双向交互,以及如何利用仿真结果进行参数化优化和瞬态故障模拟,为提升电力设备可靠性提供有效的数字化设计工具。

n8m7b6v5c4的博客 884

超融合数据库MatrixOne

MatrixOne旨在通过云原生化和存储、计算、事务分离的架构,构建一个强大的HSTAP(Hybrid Streaming Transactional and Analytical Processing)超融合数据引擎。它支持OLTP(在线事务处理)、OLAP(在线分析处理)、流计算等多种业务负载,并兼容公有云、私有云、边缘云等多种部署环境,实现异构基础设施的全面兼容。

xuweilin的博客 840

VLP16:使用pointcloud_to_laserscan将三维点云转化为二维LaserScan

velodyne16线激光雷达 VLP16:使用pointcloud_to_laserscan将三维点云转化为二维LaserScan

NEUer_ljx的博客 4623

Bash Shell 系统巡检脚本

部分安全相关检查需要root权限,建议通过sudo运行完整检查。

老韩的Linux云计算架构师进阶之路 96

部署篇 | MatrixOne与MySQL全面对比

MatrixOne Cloud 是一个全托管云原生数据平台,它提供了 HSTAP 数据库 MatrixOne 的云上服务,极大简化了 MatrixOne 的部署和运维成本。并且,MatrixOne Cloud 所提供的 Serverless 实例支持计算资源的自动弹性伸缩以及按 SQL 用量计费,让我们不需再关注数据库部署运维的复杂性,而可以仅关注业务应用或SQL本身。章节,MatrixOne中的CN节点是无状态的,在K8s中可以根据负载进行任意的弹性扩缩,保证集群持续保持较低的SQL执行耗时。

MatrixOrigin的博客 1266

基于C++和Basler SDK的相机开发详解

Basler相机是德国Basler公司生产的高性能工业相机,具有高分辨率、高帧率和低噪声的特点。Basler相机广泛应用于机器视觉、工业自动化、医疗影像和安防监控等领域。高分辨率和高帧率:能够捕捉清晰、细腻的图像。多种接口:支持USB、GigE、Camera Link等多种接口,方便不同应用场景的需求。丰富的配置选项:支持多种图像格式、分辨率和帧率的配置,适应不同的应用需求。本文详细介绍了如何基于C++和Basler SDK进行相机开发,涵盖了从环境搭建、相机连接、图像采集到图像处理的完整过程。

qq_38334677的博客 2100

MatrixOne v2.0.0 release note

MatrixOne 本次迭代对系统在生成式AI应用支持、容灾和稳定性方面做了大幅度提升,重点功能包括:支持对外部存储上的数据访问以及对非结构化数据的访问能力,提供了全文检索能力,提升了向量检索的性能、支持快照备份和基于时间点的数据恢复(PiTR)、CDC 和基于日志复制的主备集群容灾能力,并进一步提升了对 MySQL 的兼容性。当数据发生变更时,表级别发布订阅可以将特定表的数据变更实时同步到订阅者,而不暴露其他表的信息,这相较数据库级别的发布订阅,提供了更高的灵活性和控制。开发必须兼顾多租户模型的需求。

MatrixOrigin的博客 649

7.DJI-PSDK:psdk负载应用固件升级(基于RTOS)

在单片机应用程序开发阶段,我们可以借助keil5和J-LINK来直接下载应用程序进行开发和调试, 但在产品交付之后,我们对应用程序做了改动和升级,是断然不可能采用这种方式的,我们应该将新版本的程序固件打包发给客户, 能够方便用户通过DJI Assistant2选择更新负载设备的固件,导入本地固件程序包,更新负载设备。使用STM32F4 开发的负载设备从Flash 中直接读取固件文件并运行负载设备程序,因此开发者需先烧录Bootloader 再烧录应用固件,烧录Bootloader 的步骤不再赘述。

哒宰的博客 677

Oracle EBS 寄销/VMI(1)-->基础设置

名词解释:     BPA:一揽子采购协议     BPR:一揽子发放     SR:来源补充规则     ASL:合格供应商列表     VMI: 供应商管理库存     寄售(Consignment)是把货物放在客户那里,客户要用的时候才付款的库存,一般是指卖方把

陈显平的专栏-Oracle EBS 1万+

matrixone集群搭建、启停、高可用扩缩容和连接数据库

matrixone数据库安装部署、高可用扩缩容

qyq88888的专栏 3189

【ACP】2025-最新-疑难题解析- 练习二汇总

全球加速是优化公网访问的,负载均衡是分发流量的,公网 NAT 网关是处理公网 IP 的,高速通道是建私网连接但不直接提供固定私网地址功能。C 是客户端加密方式,D 是 ECS 云盘加密,都不属于 OSS 服务器端加密。某企业想使用云服务器 ECS + 负载均衡 SLB + 弹性伸缩 (Auto Scaling) 的架构搭建一个企业级门户网站,技术负责人对于负载均衡和弹性伸缩配合使用没有经验,于是将他理解的两种产品配合使用的一些技术细节列成了一个表单,并请作为架构师的您帮他做一下鉴别,以下哪些项是正确的?

jundao1997的专栏 297

从 0 到 100TB,MatrixOne 助您轻松应对

通过云原生相关的开源组件,如 KEDA,可以感知整个集群的负载。MatrixOne 是一款强大的云原生超融合数据库,具备优秀的流式数据写入和加工能力,同时拥有强大的可扩展性,能适应任意规模的负载和数据量。多租户相关能力是MatrixOne产品的一大亮点,通过数据库内部创建新租户,实现数据空间的隔离,便于 SaaS 应用处理多租户需求。对于 AP 相关的大规模查询,如果缓存或 LogTail 中没有所需数据,系统将直接从 S3 读取,由于AP的操作本身就会读较多数据,因此对S3的读取相对是比较友好的。

MatrixOrigin的博客 1100

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

MatrixOne 1.1.0 Release

我们非常高兴地宣布: MatrixOne内核1.1.0版本 正式发布啦!

MatrixOrigin的博客 1166

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

文字稿 | MatrixOne2.0.0:AI向量与高可用能力的重磅升级MatrixOne 2.0.0 新特性解读

针对这些需求,结合了强大的数据管理能力、检索能力与生成支持能力,为开发者提供了从底层架构到高层应用的一站式解决方案。内置的自动扩展和分布式架构,使其能够动态应对不同规模的负载需求,无论是个人开发者的轻量级应用到企业级的大规模部署,通过一台笔记本,完成了从环境搭建到系统开发的全过程,展现了大模型结合数据库的强大潜力。应用提供了无缝衔接的信息检索,特别是在多模态场景下,能显著提升检索的准确性与生成结果的相关性。向量检索:通过向量数据类型和向量索引,实现高效的向量距离检索,满足大规模数据集的需求。

MatrixOrigin的博客 953

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

CentOS 7 升级 5.4 内核

CentOS 7 使用的内核版本为较为陈旧的 Kernel 3.10.0,为了让小伙伴们更加稳定的使用 MatrixOne,经过测试小哥哥多轮回归测试验证,社区为大家整理了 CentOS 7 内核升级至 5.0+ 的简易方案。随着 CentOS 7 的支持周期接近尾声,社区不少小伙伴都在讨论用以替换的 Linux 操作系统,经过问卷调查,我们发现小伙伴们的操作系统大都仍为 CentOS 7,并且由于种种原因无法在短期内进行更新替换。通常情况下,我们较推荐使用长期维护版的内核。1内核 rpm 包获取。

MatrixOrigin的博客 1820

千元好礼等你来拿 MatrixOne最强体验官

为了让您体验到MatrixOne的易用性和友好性,MatrixOrigin社区发起了"最强体验官"活动,邀请大家一起深度体验MatrixOne数据库,参与数据库迁移、Python UDF 开发等多样任务,一起创造无限可能。在给定的活动周期内快速学习 MatrixOne 或 MO Cloud,并完成从选题数据库产品迁移到MO Cloud的操作(不少于5张表、数据量不少于100W),完成迁移后按照模版整理体验报告等待评审。TAP,多租户,流式计算,极致扩展性,高性价比等特性。

MatrixOrigin的博客 479

MatrixOne 完成与麒麟软件服务器操作系统的兼容互认。

产品支持行业专用的软件系统,已应用于政府、金融、教育、财税、公安、审计、交通、医疗、制造等领域。该产品使用存算分离、读写分离、冷热分离的原创技术架构,能够在一套存储和计算系统下同时支持事务、分析、流、时序和向量等多种负载,并能够实时、按需的隔离或共享存储和计算资源。该产品使用存算分离、读写分离、冷热分离的原创技术架构,能够在一套存储和计算系统下同时支持事务、分析、流、时序和向量等多种负载,并能够实时、按需的隔离或共享存储和计算资源。这也是我们为满足客户多样化需求和场景而不断努力的结果。

MatrixOrigin的博客 1340

MatrixOne完成与欧拉、麒麟信安的兼容互认

近日,超融合异构云原生数据库MatrixOne企业版软件V1.0完成了与欧拉开源操作系统(openEuler简称“欧拉”)、麒麟信安操作系统系列产品和虚拟化平台的相互兼容认证,通过了欧拉兼容性测评,获得了《openEuler技术测评证书》和麒麟信安《产品兼容性认证证书》。测试期间,整体运行稳定,在功能、性能及兼容性方面表现良好。

MatrixOrigin的博客 381

麒麟信安与MatrixOne完成兼容互认

湖南麒麟信安科技股份有限公司(简称:麒麟信安,股票代码:688152)致力于推进国产化安全应用,主要从事操作系统产品研发及技术服务,并以操作系统为根技术创新发展信息安全和云计算业务,产品已在航空航天、电力、金融、党政等重要领域得到了广泛应用,并助力“神舟”上天、“远望”出海,“北斗”组网等国家重大工程。该产品使用存算分离、读写分离、冷热分离的原创技术架构,能够在一套存储和计算系统下同时支持事务、分析、流、时序和向量等多种负载,并能够实时、按需的隔离或共享存储和计算资源。

weixin_49546901的博客 248

活动回顾 | 云边异构新型数据库在智慧城市的应用实践

矩阵起源的核心产品MatrixOne,是基于云原生技术,可同时在公有云和私有云部署的多模数据库。该产品使用存算分离、读写分离、冷热分离的原创技术架构,能够在一套存储和计算系统下同时支持事务、分析、流、时序和向量等多种负载,并能够实时、按需的隔离或共享存储和计算资源。王龙为现场观众分享了云原生时代 IT 架构的特点与趋势,他指出,随着云原生概念与技术的日益成熟,K8S与容器的统一平台已成为必然趋势,应用层已经逐步被 K8S 统一进行纳管,而数据层也正在向云原生化、Serverless化进行发展。

MatrixOrigin的博客 1301

MatrixOne超融合数据库:HSTAP引擎、Git for Data与AI-Native特性解析

在数据架构领域,HTAP(混合事务/分析处理)数据库旨在统一OLTP与OLAP负载,通过融合行式与列式存储引擎,在保证事务一致性的同时支持实时分析,从而简化技术栈并消除数据冗余。其核心价值在于为业务提供低延迟的实时决策能力,广泛应用于金融风控、实时监控和一体化数据平台等场景。随着AI应用的普及,向量检索与全文搜索成为新的技术热点。MatrixOne作为一款超融合数据库,其独特的HSTAP引擎将事务、分析、流处理与搜索能力深度融合,并创新性地引入了“Git for Data”数据版本控制理念,支持零拷贝快照与

weixin_36474966的博客 549

Awesome Project: 探索 MatrixOrigin 云原生分布式数据库

在当今数据驱动的世界中,数据库的多元性和融合性逐渐成为数据架构选型的重要要素。MatrixOne (以下简称 MO)是一个超融合云和边缘原生分布式数据库,其结构将存储、计算和事务分离,形成一个合并的 HSTAP (Hybrid Streaming & Transaction/Analytical Processin...

cnzzs的博客 595

以数生智、以智驭数,矩阵起源产品发布会圆满落幕

【2025年9月12日,中国·上海】——今日,矩阵起源在上海隆重举办以 “以数生智、以智驭数” 为主题的产品发布会,正式推出两款战略级核心产品:超融合异构云原生数据库 MatrixOne (MO) 与 AI原生多模态数据智能平台 MatrixOne Intelligence (MOI)。发布会吸引了来自制造、金融、能源、互联网等行业的企业代表和媒体,围绕 AI 行业趋势、数据智能发展及落地挑战展开深入探讨。

MatrixOrigin的博客 1041
上一篇: 活动回顾 | 矩阵起源 CEO 王龙:与大数据结合,是大模型成熟的必经之路
下一篇: 部署篇 | MatrixOne与MySQL全面对比
MatrixOrigin
博客等级 码龄5年 708粉丝 230原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值