【Flink】 Flink 源码之 SQL 执行流程

最新推荐文章于 2024-05-22 10:37:39 发布
最新推荐文章于 2024-05-22 10:37:39 发布
阅读量2.2k 收藏 4
点赞数
分类专栏： 大数据-flink 文章标签： sql flink 数据库
原文链接：https://www.jianshu.com/p/e4956652cfcb
版权
大数据-flink 专栏收录该内容
838 篇文章 841 订阅 ¥99.90 ¥99.00
订阅专栏

在这里插入图片描述

1.概述

转载：Flink 源码之 SQL 执行流程

2.前言

本篇为大家带来Flink执行SQL流程的分析。它的执行步骤概括起来包含：

  • 解析。使用Calcite的解析器，解析SQL为语法树（SqlNode）。
  • 校验。按照校验规则，检查SQL的合法性，同事重写语法树。
  • 转换。将SqlNode转换为Releational tree。再包装为Flink的Operation。
  • 执行。根据上一步生成的Operation，将其翻译为执行计划。

3.入口

TableEnvironmentImpl.sqlQuery方法为SQL执行的入口，接收字符串格式的SQL语句。返回Table类型对象，可用于进一步SQL查询或变换。

@Override
public Table sqlQuery(String query) {
    // 使用解析器，解析SQL查询语句
    List<Operation> operations = parser.parse(query);

    // 如果解析出的operation多于1个，说明填写了多个SQL，不支持这样使用
    if (operations.size() != 1) {
        throw new ValidationException(
            "Unsupported SQL query! sqlQuery() only accepts a single SQL query.");
    }

    // 获取解析过的operation
    Operation operation = operations.get(0);

    // 检查SQL类型，只支持查询语句
    if (operation instanceof QueryOperation && !(operation instanceof ModifyOperation)) {
        // 根据operation构造出Table对象
        return createTable((QueryOperation) operation);
    } else {
        throw new ValidationException(
            "Unsupported SQL query! sqlQuery() only accepts a single SQL query of type " +
                "SELECT, UNION, INTERSECT, EXCEPT, VALUES, and ORDER_BY.");
    }
}

4.解析

我们展开分析上面parser.parse(query)这一句。parser实际上是ParserImpl，封装了SQL的解析逻辑。

ParseImpl的parse方法：

@Override
public List<Operation> parse(String statement) {
    // 获取Calcite的解析器
    CalciteParser parser = calciteParserSupplier.get();
    // 使用FlinkPlannerImpl作为validator
    FlinkPlannerImpl planner = validatorSupplier.get();
    
    // 对于一些特殊的写法，例如SET key=value。CalciteParser是不支持这种写法的
    // 为了避免在Calcite引入过多的关键字，这里定义了一组extended parser，专门用于在CalciteParser之前，解析这些特殊的语句
    Optional<Operation> command = EXTENDED_PARSER.parse(statement);
    if (command.isPresent()) {
        return Collections.singletonList(command.get());
    }
    
    
    // parse the sql query
    // 解析SQL为语法树
    SqlNode parsed = parser.parse(statement);

    // 将解析过的语法树转换为operator
    Operation operation = SqlToOperationConverter.convert(planner, catalogManager, parsed)
        .orElseThrow(() -> new TableException(
            "Unsupported SQL query! parse() only accepts SQL queries of type " +
                "SELECT, UNION, INTERSECT, EXCEPT, VALUES, ORDER_BY or INSERT;" +
                "and SQL DDLs of type " +
                "CREATE TABLE"));
    return Collections.singletonList(operation);
}

5.ExtendedParser

ExtendedParser用于在不增加CalciteParser复杂性的前提下（不用修改Calcite，增加新的关键字），让Flink SQL支持更多专用的语法。

ExtendedParser包含如下解析策略：

private static final List<ExtendedParseStrategy> PARSE_STRATEGIES =
        Arrays.asList(
                ClearOperationParseStrategy.INSTANCE,
                HelpOperationParseStrategy.INSTANCE,
                QuitOperationParseStrategy.INSTANCE,
                ResetOperationParseStrategy.INSTANCE,
                SetOperationParseStrategy.INSTANCE);

这5条策略分别对应：

CLEAR语句，清空输出
HELP语句，打印帮助信息
EXIT或QUIT语句，退出执行环境
RESET语句，重设一个变量的值
SET语句，设置一个变量的值

下面以较为复杂的SetOperationParseStrategy为例，讲解下Flink如何把SET语句解析为operation。

SetOperationParseStrategy继承了AbstractRegexParseStrategy，它包含statement正则匹配的逻辑。

// 默认的正则匹配方式，忽略大小写，点可以匹配行结束标志
protected static final int DEFAULT_PATTERN_FLAGS = Pattern.CASE_INSENSITIVE | Pattern.DOTALL;

// 这个pattern的用于匹配语句，如果语句和pattern匹配，则使用这个strategy解析
protected Pattern pattern;

protected AbstractRegexParseStrategy(Pattern pattern) {
    this.pattern = pattern;
}

// 用于验证语句是否和pattern匹配的方法
@Override
public boolean match(String statement) {
    return pattern.matcher(statement.trim()).matches();
}

紧接着我们分析SetOperationParseStrategy。SET语句的pattern如下：

protected SetOperationParseStrategy() {
    super(
            Pattern.compile(
                    "SET(\\s+(?<key>[^'\\s]+)\\s*=\\s*('(?<quotedVal>[^']*)'|(?<val>\\S+)))?",
                    DEFAULT_PATTERN_FLAGS));
}

从正则表达式可知，SET语句的格式为：SET key='quotedVal’或者SET key=val。

转换SET语句为Operation的过程位于convert方法：

@Override
public Operation convert(String statement) {
    // 匹配statement
    Matcher matcher = pattern.matcher(statement.trim());
    // 创建保存操作符的集合
    final List<String> operands = new ArrayList<>();
    if (matcher.find()) {
        if (matcher.group("key") != null) {
            // 获取key和对应的quotedVal或者val，加入操作符集合
            operands.add(matcher.group("key"));
            operands.add(
                    matcher.group("quotedVal") != null
                            ? matcher.group("quotedVal")
                            : matcher.group("val"));
        }
    }

    // only capture SET
    // 如果只有SET个单词，operands为空，创建一个空的SetOperation
    if (operands.isEmpty()) {
        return new SetOperation();
    } else if (operands.size() == 2) {
        // 如果operands的大小为2，说明解析到了key和val或者quotedVal，创建SetOperation
        return new SetOperation(operands.get(0), operands.get(1));
    } else {
        // impossible
        // 其他情况，抛出异常
        throw new TableException(
                String.format(
                        "Failed to convert the statement to SET operation: %s.", statement));
    }
}

6.CalciteParser

对于标准的SQL语句，上一节的ExtendedParser不会去解析它。标准SQL的解析过程由CalciteParser负责。

public SqlNode parse(String sql) {
    try {
        // 创建Sql解析器
        SqlParser parser = SqlParser.create(sql, config);
        // 解析statement
        return parser.parseStmt();
    } catch (SqlParseException e) {
        throw new SqlParserException("SQL parse failed. " + e.getMessage(), e);
    }
}

parserStmt方法将SQL解析成为语法树。例如select * from demo将被解析为一个SqlSelect对象。

我们一路跟踪parser.parseStmt方法（这些方法都位于Calcite Core中）：

parseStmt
parseQuery
parseSqlStmtEof

它的底层是通过JavaCC生成的解析器去解析SQL。过程非常复杂，此处暂不分析。

7.校验和转换

SqlToOperationConverter.convert方法负责校验SQL语句，并将其转换为Operation。

public static Optional<Operation> convert(
        FlinkPlannerImpl flinkPlanner, CatalogManager catalogManager, SqlNode sqlNode) {
    // validate the query
    // 校验解析后的SQL语法树
    final SqlNode validated = flinkPlanner.validate(sqlNode);
    
    // 创建SqlToOperationConverter，它负责SQL转换
    SqlToOperationConverter converter =
            new SqlToOperationConverter(flinkPlanner, catalogManager);
    
    // 判断SqlNode的类型，采用不同的转换逻辑
    if (validated instanceof SqlCreateCatalog) {
        return Optional.of(converter.convertCreateCatalog((SqlCreateCatalog) validated));
    } else if (validated instanceof SqlDropCatalog) {
        return Optional.of(converter.convertDropCatalog((SqlDropCatalog) validated));
    } else if (validated instanceof SqlLoadModule) {
        return Optional.of(converter.convertLoadModule((SqlLoadModule) validated));
    } else if (validated instanceof SqlShowCatalogs) {
        return Optional.of(converter.convertShowCatalogs((SqlShowCatalogs) validated));
    } else if (validated instanceof SqlShowCurrentCatalog) {
        return Optional.of(
                converter.convertShowCurrentCatalog((SqlShowCurrentCatalog) validated));
    } else if (validated instanceof SqlShowModules) {
        return Optional.of(converter.convertShowModules((SqlShowModules) validated));
    } else if (validated instanceof SqlUnloadModule) {
        return Optional.of(converter.convertUnloadModule((SqlUnloadModule) validated));
    } else if (validated instanceof SqlUseCatalog) {
        return Optional.of(converter.convertUseCatalog((SqlUseCatalog) validated));
    } else if (validated instanceof SqlUseModules) {
        return Optional.of(converter.convertUseModules((SqlUseModules) validated));
    } else if (validated instanceof SqlCreateDatabase) {
        return Optional.of(converter.convertCreateDatabase((SqlCreateDatabase) validated));
    } else if (validated instanceof SqlDropDatabase) {
        return Optional.of(converter.convertDropDatabase((SqlDropDatabase) validated));
    } else if (validated instanceof SqlAlterDatabase) {
        return Optional.of(converter.convertAlterDatabase((SqlAlterDatabase) validated));
    } else if (validated instanceof SqlShowDatabases) {
        return Optional.of(converter.convertShowDatabases((SqlShowDatabases) validated));
    } else if (validated instanceof SqlShowCurrentDatabase) {
        return Optional.of(
                converter.convertShowCurrentDatabase((SqlShowCurrentDatabase) validated));
    } else if (validated instanceof SqlUseDatabase) {
        return Optional.of(converter.convertUseDatabase((SqlUseDatabase) validated));
    } else if (validated instanceof SqlCreateTable) {
        return Optional.of(
                converter.createTableConverter.convertCreateTable((SqlCreateTable) validated));
    } else if (validated instanceof SqlDropTable) {
        return Optional.of(converter.convertDropTable((SqlDropTable) validated));
    } else if (validated instanceof SqlAlterTable) {
        return Optional.of(converter.convertAlterTable((SqlAlterTable) validated));
    } else if (validated instanceof SqlShowTables) {
        return Optional.of(converter.convertShowTables((SqlShowTables) validated));
    } else if (validated instanceof SqlCreateView) {
        return Optional.of(converter.convertCreateView((SqlCreateView) validated));
    } else if (validated instanceof SqlDropView) {
        return Optional.of(converter.convertDropView((SqlDropView) validated));
    } else if (validated instanceof SqlAlterView) {
        return Optional.of(converter.convertAlterView((SqlAlterView) validated));
    } else if (validated instanceof SqlShowViews) {
        return Optional.of(converter.convertShowViews((SqlShowViews) validated));
    } else if (validated instanceof SqlCreateFunction) {
        return Optional.of(converter.convertCreateFunction((SqlCreateFunction) validated));
    } else if (validated instanceof SqlDropFunction) {
        return Optional.of(converter.convertDropFunction((SqlDropFunction) validated));
    } else if (validated instanceof SqlAlterFunction) {
        return Optional.of(converter.convertAlterFunction((SqlAlterFunction) validated));
    } else if (validated instanceof SqlShowCreateTable) {
        return Optional.of(converter.convertShowCreateTable((SqlShowCreateTable) validated));
    } else if (validated instanceof SqlShowFunctions) {
        return Optional.of(converter.convertShowFunctions((SqlShowFunctions) validated));
    } else if (validated instanceof SqlShowPartitions) {
        return Optional.of(converter.convertShowPartitions((SqlShowPartitions) validated));
    } else if (validated instanceof SqlRichExplain) {
        return Optional.of(converter.convertRichExplain((SqlRichExplain) validated));
    } else if (validated instanceof SqlRichDescribeTable) {
        return Optional.of(converter.convertDescribeTable((SqlRichDescribeTable) validated));
    } else if (validated instanceof SqlAddJar) {
        return Optional.of(converter.convertAddJar((SqlAddJar) validated));
    } else if (validated instanceof SqlRemoveJar) {
        return Optional.of(converter.convertRemoveJar((SqlRemoveJar) validated));
    } else if (validated instanceof SqlShowJars) {
        return Optional.of(converter.convertShowJars((SqlShowJars) validated));
    } else if (validated instanceof RichSqlInsert) {
        return Optional.of(converter.convertSqlInsert((RichSqlInsert) validated));
    } else if (validated instanceof SqlBeginStatementSet) {
        return Optional.of(
                converter.convertBeginStatementSet((SqlBeginStatementSet) validated));
    } else if (validated instanceof SqlEndStatementSet) {
        return Optional.of(converter.convertEndStatementSet((SqlEndStatementSet) validated));
    } else if (validated instanceof SqlSet) {
        return Optional.of(converter.convertSet((SqlSet) validated));
    } else if (validated instanceof SqlReset) {
        return Optional.of(converter.convertReset((SqlReset) validated));
    } else if (validated.getKind().belongsTo(SqlKind.QUERY)) {
        // 对于查询语句
        return Optional.of(converter.convertSqlQuery(validated));
    } else {
        return Optional.empty();
    }
}

我们这里重点关注select语句执行的这条线，它调用的是：

converter.convertSqlQuery(validated)

该方法代码：

private Operation convertSqlQuery(SqlNode node) {
    return toQueryOperation(flinkPlanner, node);
}

继续跟踪toQueryOperation方法：

private PlannerQueryOperation toQueryOperation(FlinkPlannerImpl planner, SqlNode validated) {
    // transform to a relational tree
    // 转换为relational tree
    RelRoot relational = planner.rel(validated);
    return new PlannerQueryOperation(relational.rel);
}

该方法最终生成一个PlannerQueryOperation。将Calcite转换成的reletional tree包装在其中。

接下来我们跟进其中的两个关键点：validate和转换为relation tree。

7.1 validate

validate步骤用来校验和重写SQL。

我们跟踪上一节的flinkPlanner.validate方法：

def validate(sqlNode: SqlNode): SqlNode = {
    // 创建校验器
    val validator = getOrCreateSqlValidator()
    // 校验SQL
    validate(sqlNode, validator)
}

private def validate(sqlNode: SqlNode, validator: FlinkCalciteSqlValidator): SqlNode = {
    try {
        // 校验rich SQL insert语句
        // rich SQL insert是一种带分区或overwrite的insert语句
        sqlNode.accept(new PreValidateReWriter(
            validator, typeFactory))
        // do extended validation.
        // 校验create table和create table like 语句
        sqlNode match {
            case node: ExtendedSqlNode =>
            node.validate()
            case _ =>
        }
        // no need to validate row type for DDL and insert nodes.
        // DDL和这些类型的语句无需校验
        if (sqlNode.getKind.belongsTo(SqlKind.DDL)
            || sqlNode.getKind == SqlKind.INSERT
            || sqlNode.getKind == SqlKind.CREATE_FUNCTION
            || sqlNode.getKind == SqlKind.DROP_FUNCTION
            || sqlNode.getKind == SqlKind.OTHER_DDL
            || sqlNode.isInstanceOf[SqlLoadModule]
            || sqlNode.isInstanceOf[SqlShowCatalogs]
            || sqlNode.isInstanceOf[SqlShowCurrentCatalog]
            || sqlNode.isInstanceOf[SqlShowDatabases]
            || sqlNode.isInstanceOf[SqlShowCurrentDatabase]
            || sqlNode.isInstanceOf[SqlShowTables]
            || sqlNode.isInstanceOf[SqlShowFunctions]
            || sqlNode.isInstanceOf[SqlShowJars]
            || sqlNode.isInstanceOf[SqlShowModules]
            || sqlNode.isInstanceOf[SqlShowViews]
            || sqlNode.isInstanceOf[SqlShowPartitions]
            || sqlNode.isInstanceOf[SqlRichDescribeTable]
            || sqlNode.isInstanceOf[SqlUnloadModule]
            || sqlNode.isInstanceOf[SqlUseModules]
            || sqlNode.isInstanceOf[SqlBeginStatementSet]
            || sqlNode.isInstanceOf[SqlEndStatementSet]
            || sqlNode.isInstanceOf[SqlSet]
            || sqlNode.isInstanceOf[SqlReset]) {
            return sqlNode
        }
        sqlNode match {
            // 校验SQL explain insert语句
            case richExplain: SqlRichExplain =>
            val validatedStatement = richExplain.getStatement match {
                case insert: RichSqlInsert =>
                val validatedSource = validator.validate(insert.getSource)
                insert.setOperand(2, validatedSource)
                insert
                case others =>
                validator.validate(others)
            }
            richExplain.setOperand(0, validatedStatement)
            richExplain
            // 其他情况，走通用validate逻辑
            case _ =>
            validator.validate(sqlNode)
        }
    }
    catch {
        case e: RuntimeException =>
        throw new ValidationException(s"SQL validation failed. ${e.getMessage}", e)
    }
}

通用的validate流程较为复杂，本人后续博客再展开分析。

7.2 生成Relational tree

我们跟踪FlinkPlannerImpl的rel方法。SqlNode转换为Relation tree的过程由Calcite的SqlToRelConverter完成。

def rel(validatedSqlNode: SqlNode): RelRoot = {
    rel(validatedSqlNode, getOrCreateSqlValidator())
}

private def rel(validatedSqlNode: SqlNode, sqlValidator: FlinkCalciteSqlValidator) = {
    try {
        assert(validatedSqlNode != null)
        // 创建出Rel转换器
        val sqlToRelConverter: SqlToRelConverter = createSqlToRelConverter(sqlValidator)

        // 由Calcite转换为Relation tree
        sqlToRelConverter.convertQuery(validatedSqlNode, false, true)
        // we disable automatic flattening in order to let composite types pass without modification
        // we might enable it again once Calcite has better support for structured types
        // root = root.withRel(sqlToRelConverter.flattenTypes(root.rel, true))

        // TableEnvironment.optimize will execute the following
        // root = root.withRel(RelDecorrelator.decorrelateQuery(root.rel))
        // convert time indicators
        // root = root.withRel(RelTimeIndicatorConverter.convert(root.rel, rexBuilder))
    } catch {
        case e: RelConversionException => throw new TableException(e.getMessage)
    }
}

8.执行

execute阶段为执行SQL语句并返回结果。

TableImpl的execute方法执行SQL查询，返回一个TableResult对象。

@Override
public TableResult execute() {
    return tableEnvironment.executeInternal(getQueryOperation());
}

继续追踪TableEnvironmentImpl的executeInternal方法。这个方法非常长，总体逻辑是判断operation的类型，不同的operation类型执行不同的操作。例如DDL语句透过CatalogManager操作database或table的元数据。其中有一个片段如下所示，调用executeQueryOperation来执行select语句：

@Override
public TableResult executeInternal(Operation operation) {
    // ...
     else if (operation instanceof QueryOperation) {
        return executeQueryOperation((QueryOperation) operation);
    }
    // ...
}

我们展开分析这个方法。

private TableResult executeQueryOperation(QueryOperation operation) {
    // 创建一个标识符
    final UnresolvedIdentifier unresolvedIdentifier =
            UnresolvedIdentifier.of(
                    "Unregistered_Collect_Sink_" + CollectModifyOperation.getUniqueId());
    final ObjectIdentifier objectIdentifier =
            catalogManager.qualifyIdentifier(unresolvedIdentifier);

    // 创建一个本地收集ModifyOperation结果的Operation
    CollectModifyOperation sinkOperation =
            new CollectModifyOperation(objectIdentifier, operation);
    
    // 将上一步的sinkOperation翻译为Flink的Transformation，后面分析
    List<Transformation<?>> transformations =
            translate(Collections.singletonList(sinkOperation));
    // 设置作业名称
    String jobName = getJobName("collect");
    // 根据transformation，生成StreamGraph
    Pipeline pipeline = execEnv.createPipeline(transformations, tableConfig, jobName);
    try {
        // 代表作业执行过程
        JobClient jobClient = execEnv.executeAsync(pipeline);
        // 用于帮助jobClient获取执行结果
        CollectResultProvider resultProvider = sinkOperation.getSelectResultProvider();
        resultProvider.setJobClient(jobClient);
        // 构建TableResultImpl对象
        return TableResultImpl.builder()
                .jobClient(jobClient)
                .resultKind(ResultKind.SUCCESS_WITH_CONTENT)
                .schema(operation.getResolvedSchema())
                .data(resultProvider.getResultIterator())
                .setPrintStyle(
                        TableResultImpl.PrintStyle.tableau(
                                PrintUtils.MAX_COLUMN_WIDTH,
                                PrintUtils.NULL_COLUMN,
                                true,
                                isStreamingMode))
                .setSessionTimeZone(getConfig().getLocalTimeZone())
                .build();
    } catch (Exception e) {
        throw new TableException("Failed to execute sql", e);
    }
}

最后我们以打印出select结果（调用print方法）为例，分析SQL执行结果的展示。

TableResultImpl的print方法：

@Override
public void print() {
    // 获取行迭代器
    Iterator<Row> it = collect();
    // 判断打印table的格式
    // 如果是Tableau风格
    if (printStyle instanceof TableauStyle) {
        // 按照tableau的风格配置打印，最大列宽，null列格式等
        int maxColumnWidth = ((TableauStyle) printStyle).getMaxColumnWidth();
        String nullColumn = ((TableauStyle) printStyle).getNullColumn();
        boolean deriveColumnWidthByType =
                ((TableauStyle) printStyle).isDeriveColumnWidthByType();
        boolean printRowKind = ((TableauStyle) printStyle).isPrintRowKind();
        PrintUtils.printAsTableauForm(
                getResolvedSchema(),
                it,
                new PrintWriter(System.out),
                maxColumnWidth,
                nullColumn,
                deriveColumnWidthByType,
                printRowKind,
                sessionTimeZone);
    } else if (printStyle instanceof RawContentStyle) {
        // 如果是原生样式
        while (it.hasNext()) {
            System.out.println(
                    String.join(
                            ",",
                            PrintUtils.rowToString(
                                    it.next(), getResolvedSchema(), sessionTimeZone)));
        }
    } else {
        throw new TableException("Unsupported print style: " + printStyle);
    }
}

9 translate

translate方法包含将Operation转换为Transformation的逻辑。

private List<Transformation<?>> translate(List<ModifyOperation> modifyOperations) {
    return planner.translate(modifyOperations);
}

这一行调用了PlannerBase的translate方法：

override def translate(
    modifyOperations: util.List[ModifyOperation]): util.List[Transformation[_]] = {
    // 检查planner和运行模式是否和configuration匹配
    validateAndOverrideConfiguration()
    // 如果modifyOperations为空，返回一个空的Transformation集合
    if (modifyOperations.isEmpty) {
        return List.empty[Transformation[_]]
    }

    // 转换Operation为Calcite的relation expression（关系表达式）
    val relNodes = modifyOperations.map(translateToRel)
    // 优化关系表达式
    val optimizedRelNodes = optimize(relNodes)
    // 生成执行节点图
    val execGraph = translateToExecNodeGraph(optimizedRelNodes)
    // 将执行节点图转换为transformation
    val transformations = translateToPlan(execGraph)
    // translation步骤完毕后，清理内部的配置
    cleanupInternalConfigurations()
    transformations
}

translate步骤包含了从Operation获取关系表达式，优化，生成执行节点图和转换为Flink Transformation的步骤。这些步骤详细分析博主单独开篇分析。

作者：AlienPaul
链接：https://www.jianshu.com/p/e4956652cfcb

九师兄
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
Flink SQL 执行流程简单介绍
SmartSi
06-15 815
这篇文章从 org.apache.flink.table.examples.java.StreamSQLExample 这个简单的例子分析 Flink SQL 的一个简单的执行流程，也算 Flink SQL 执行流程初步的入门，我们先从整体的执行框架了解一个整体流程，方便之后我们有机会对 Flink SQL 进行修改先有一个简单认识
Flink 学习十 FlinkSQL
weixin_44244088的博客
06-20 9714
flinksql 从入门到入门...
Flink SQL性能优化实践
最新发布
zevjay的博客
05-22 698
优化自定义Source和Sink：减少不必要的序列化和反序列化。上面介绍了Apache Flink SQL的性能优化实践，涵盖了数据源读取、状态管理、窗口操作、并行度控制、资源调度、并发控制、源码优化、异常处理、数据预处理、数据压缩、任务并行化、网络传输、系统配置、数据倾斜处理、任务调度策略、代码组织、用户交互以及社区支持等多个方面。通过实例代码和调优建议，阐述了如何解决常见性能问题，提升系统效率，同时强调了持续监控、反馈和社区学习的重要性。
FlinkSQL源码解析（三）执行流程
Yuan_CSDF的博客
03-13 3305
1、前言 前面2部分主要是介绍以下2点： flink sql整体的执行流程大致为：sqlNode --> Operation --> RelNode --> 优化 --> execNode --> Transformation。 以及flink sql源码解析需要使用到的java spi。 现在具体来看看flink sql 在其内部转换的实现步骤，就是如何去调用连接器，主要是在sqlNode --> RelNode这一步。 ...
FlinkSQL-- sql-client及源码解析 -- flink-1.13.6
chbxw
11-05 1803
flink sql client及源码解析
Flink-FinkSQL进阶操作（系统函数，UDF，表聚合函数等，输入kafka，elasticsearch等外部系统）
m0_46507516的博客
03-25 1081
系统函数，UDF，表聚合函数等，输入kafka，elasticsearch等外部系统
flink 1.14.4 源码下载
04-03
5. **SQL解析和执行**：查看Flink如何将SQL语句转化为执行计划，并执行该计划。 6. **连接器实现**：分析Flink如何与外部数据源和接收器交互，了解其连接器的实现逻辑。 通过阅读和理解Flink 1.14.4的源码，开发者...
基于Java的实时流计算Flink SQL Web平台设计源码
04-07
实时流计算Flink SQL Web平台：基于Java开发，包含808个文件，包括215个Java类文件、192个JavaScript文件、148个Vue组件文件、58个CSS样式文件、46个SVG图像文件、29个Markdown文档、24个XML配置文件、18个PNG图像...
Flink基础系列32-Table API和Flink SQL之时间窗口
04-26
本文将详细探讨Flink的Table API和SQL中如何利用时间窗口进行数据处理。 时间窗口是一种将连续的数据流分割成离散时间段的方法，这对于统计特定时间范围内的数据特性至关重要。在Flink的Table API和SQL中，时间窗口...
Flink SQL大数据项目实战（基于Flink1.14.3版本）
09-15
Flink SQL大数据项目实战课程以FlinkSQL流批一体技术为主线，全面讲解Flink Table编程、SQL编程、Time与WaterMark、Window操作、函数使用、元数据管理，最后以一个完整的实战项目为例，详细讲解FlinkSQL的流式项目...
SQL问题记录
forever_u_wzx的博客
08-11 742
平时sql报错记录
Flink SQL的打印输出的几种方式
热门推荐
qq_31866793的博客
07-23 1万+
打广告！！！！！！！！！！！！！！！！！！！！！！！！！： 先跟鸡哥打个广告 ，博客地址:https://me.csdn.net/weixin_47482194 写的博客很有水平的，上了几次官网推荐了。 1，正常的print（） 2，在遇到FlinkSQL代码里面有聚合算子的时候，会发现报错了。比如下面的代码： Exception in thread "main" org.apache.flink.table.api.TableException: AppendStreamTa...
flink-sql大量使用案例
第一片心意的博客
08-02 6924
本文是 flink sql 的一些使用案例，同时也包括了一些特殊用法展示。
一文搞懂Flink SQL执行过程
shengjk1的博客
03-15 1276
背景 学习了 apache calcite，基本上把 apache calcite 的官网看了一遍，也写了几个小例子，现在该分析一下 Flink SQL 的执行过程了，其中关于 apache calcite 的部分不深究，因为 apache calcite 有些复杂，真的要了解清楚需要大量时间，本次还是聚焦 Flink. 正文 以 SQL Query 为例 select a.* from a join b on a.id=b.id sql query 入口方法 // sql query 入口方法 ove
Flink sql
CarloPan的博客
10-03 516
1 SQL 客户端 Flink 的 Table & SQL API 可以处理 SQL 语言编写的查询语句，但是这些查询需要嵌入用 Java 或 Scala 编写的表程序中。此外，这些程序在提交到集群前需要用构建工具打包。这或多或少限制了 Java/Scala 程序员对 Flink 的使用。 SQL 客户端的目的是提供一种简单的方式来编写、调试和提交表程序到 Flink 集群上，而无需写一行 Java 或 Scala 代码。SQL 客户端命令行界面（CLI）能够在命令行中检索和可视化分布式应用..
FlinkSql书写流程
qq_42456324的博客
10-19 982
3. ⭐ 当 14:00:00 - 14:59:59 数据输⼊之后，1 ⼩时的窗⼝，连续查询（Continuous Query）计算的结果如右图所示，将 [Mary, 1]，[Bob, 2]，[Liz, 1] 插⼊（insert）结果表。1. ⭐ 当 12:00:00 - 12:59:59 数据输⼊之后，1 ⼩时的窗⼝，连续查询（Continuous Query）计算的结果如右图所示，将 [Mary, 3]，[Bob, 1] 插⼊（insert）结果表。将数据输⼊流转换为 SQL 中的动态输⼊表。
Flink 1.15实现 Sql 脚本从savepointh恢复数据
weixin_40344051的博客
07-22 1847
flink 1.15通过sql客户端恢复job
Flink SQL(基础实践)
weixin_66034213的博客
04-29 5519
第一章 核心概念 1.1、动态表和连续查询 动态表（Dynamic Tables）是Flink的支持流数据的Table API 和SQL的核心概念。 动态表是随时间变化的，可以像查询静态批处理表一样查询它们。查询动态表将生成一个连续查询（Continuous Query）.一个连续查询永远不会终止，结果会生成一个动态表，查询不断更新其（动态）结果表，以反映其（动态）输入表上的更改。 需要注意的是，连续查询的结果在语义上总是等价于以批处理模式在输入表快照上执行的相同查询的结果。 1、将流转换为动态表
Flink SQL实现流批一体
大数据研习社
04-22 7716
1 Flink流批统一思想 1.1 有界流和无界流 在Flink中，批处理时流处理的一个特例。 1.2 Flink老架构与问题 1.从Flink用户角度（企业开发人员） （1）开发的时候，Flink SQL支持的不好，就需要在两个底层API中进行选择，甚至维护两套代码。 （2）不同的语义、不同的connector支持、不同的错误恢复策略等。 （3）Table API也会受不同的底层API、不同的connector等问题的影响。 2.从Flink开发者角度（Flink社区人员）
flinksql配置
09-07
Flink SQL 的配置可以通过对 Flink Table API & SQL 的包 `flink-table` 的源码进行一些修改来实现细粒度的 TTL 配置。这些修改可以在本系列文的第二篇《Flink SQL 细粒度TTL配置的实现(二)》中找到，具体的实现方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值