StarRocks分布式元数据源码解析

1. 支持元数据表

https://github.com/StarRocks/starrocks/pull/44276/files

核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段

public static LogicalIcebergMetadataTable create(String catalogName, String originDb, String originTable) {
    return new LogicalIcebergMetadataTable(catalogName,
            ConnectorTableId.CONNECTOR_ID_GENERATOR.getNextId().asInt(),
            ICEBERG_LOGICAL_METADATA_TABLE_NAME,
            Table.TableType.METADATA,
            builder()
                    .columns(PLACEHOLDER_COLUMNS)
                    .column("content", ScalarType.createType(PrimitiveType.INT))
                    .column("file_path", ScalarType.createVarcharType())
                    .column("file_format", ScalarType.createVarcharType())
                    .column("spec_id", ScalarType.createType(PrimitiveType.INT))
                    .column("partition_data", ScalarType.createType(PrimitiveType.VARBINARY))
                    .column("record_count", ScalarType.createType(PrimitiveType.BIGINT))
                    .column("file_size_in_bytes", ScalarType.createType(PrimitiveType.BIGINT))
                    .column("split_offsets", ARRAY_BIGINT)
                    .column("sort_id", ScalarType.createType(PrimitiveType.INT))
                    .column("equality_ids", ARRAY_INT)
                    .column("file_sequence_number", ScalarType.createType(PrimitiveType.BIGINT))
                    .column("data_sequence_number", ScalarType.createType(PrimitiveType.BIGINT))
                    .column("column_stats", ScalarType.createType(PrimitiveType.VARBINARY))
                    .column("key_metadata", ScalarType.createType(PrimitiveType.VARBINARY))
                    .build(),
            originDb,
            originTable,
            MetadataTableType.LOGICAL_ICEBERG_METADATA);
}

2. Iceberg表扫描

https://github.com/StarRocks/starrocks/pull/44313

核心类：StarRocksIcebergTableScan，扫描Iceberg表的实现类，基于Iceberg的上层接口实现，类似Iceberg默认提供的DataTableScan，doPlanFiles中定义实际的元数据文件扫描逻辑

这一块应当属于数据上层扫描逻辑

protected CloseableIterable<FileScanTask> doPlanFiles() {
    List<ManifestFile> dataManifests = findMatchingDataManifests(snapshot());
    List<ManifestFile> deleteManifests = findMatchingDeleteManifests(snapshot());

    boolean mayHaveEqualityDeletes = !deleteManifests.isEmpty() && mayHaveEqualityDeletes(snapshot());
    boolean loadColumnStats = mayHaveEqualityDeletes || shouldReturnColumnStats();

    if (shouldPlanLocally(dataManifests, loadColumnStats)) {
        return planFileTasksLocally(dataManifests, deleteManifests);
    } else {
        return planFileTasksRemotely(dataManifests, deleteManifests);
    }
}

3. Iceberg元数据信息接口

[Feature] Introduce meta spec interface by stephen-shelby · Pull Request #44527 · StarRocks/starrocks · GitHub

核心类：IcebergMetaSpec，Iceberg元数据描述，核心是RemoteMetaSplit的一个List，代表了元数据文件的列表，基于这个做分布式解析

这一块应当属于元数据文件的切片逻辑

public List<RemoteMetaSplit> getSplits() {
    return splits;
}

4. Iceberg元数据扫描节点

https://github.com/StarRocks/starrocks/pull/44581

核心类：IcebergMetadataScanNode，Iceberg元数据的扫描节点，袭乘自PlanNode类，主要是把上节的RemoteMetaSplit放到StarRocks的执行结构当中

这一块属于Iceberg逻辑向StarRocks逻辑的中间转换层

private void addSplitScanRangeLocations(RemoteMetaSplit split) {
    TScanRangeLocations scanRangeLocations = new TScanRangeLocations();

    THdfsScanRange hdfsScanRange = new THdfsScanRange();
    hdfsScanRange.setUse_iceberg_jni_metadata_reader(true);

    hdfsScanRange.setSerialized_split(split.getSerializeSplit());
    hdfsScanRange.setFile_length(split.length());
    hdfsScanRange.setLength(split.length());

    // for distributed scheduler
    hdfsScanRange.setFull_path(split.path());
    hdfsScanRange.setOffset(0);

    TScanRange scanRange = new TScanRange();
    scanRange.setHdfs_scan_range(hdfsScanRange);
    scanRangeLocations.setScan_range(scanRange);

    TScanRangeLocation scanRangeLocation = new TScanRangeLocation(new TNetworkAddress("-1", -1));
    scanRangeLocations.addToLocations(scanRangeLocation);

    result.add(scanRangeLocations);
}

5. Iceberg元数据读取

https://github.com/StarRocks/starrocks/pull/44632

核心类：IcebergMetadataScanner，这个应该是Iceberg元数据的实际读取类，实现自StarRocks的ConnectorScanner

ConnectorScanner是StarRocks的设计的介于C++-based的BE和Java-based的大数据组件之间的JNI抽象中间层，可以直接复用Java SDK，规避了对BE代码的侵入以及使用C++访问大数据存储的诸多不便

这一块属于时实际元数据文件读取的Java侧代码

image.png

public int getNext() throws IOException {
    try (ThreadContextClassLoader ignored = new ThreadContextClassLoader(classLoader)) {
        int numRows = 0;
        for (; numRows < getTableSize(); numRows++) {
            if (!reader.hasNext()) {
                break;
            }
            ContentFile<?> file = reader.next();
            for (int i = 0; i < requiredFields.length; i++) {
                Object fieldData = get(requiredFields[i], file);
                if (fieldData == null) {
                    appendData(i, null);
                } else {
                    ColumnValue fieldValue = new IcebergMetadataColumnValue(fieldData);
                    appendData(i, fieldValue);
                }
            }
        }
        return numRows;
    } catch (Exception e) {
        close();
        LOG.error("Failed to get the next off-heap table chunk of iceberg metadata.", e);
        throw new IOException("Failed to get the next off-heap table chunk of iceberg metadata.", e);
    }
}

    这一块目前没有找到Java侧的上层调用，应该在C++中调用，如下，其构造类是在C++中的

// ---------------iceberg metadata jni scanner------------------
std::unique_ptr<JniScanner> create_iceberg_metadata_jni_scanner(const JniScanner::CreateOptions& options) {
    const auto& scan_range = *(options.scan_range);
    ;

    const auto* hdfs_table = dynamic_cast<const IcebergMetadataTableDescriptor*>(options.hive_table);
    std::map<std::string, std::string> jni_scanner_params;

    jni_scanner_params["required_fields"] = hdfs_table->get_hive_column_names();
    jni_scanner_params["metadata_column_types"] = hdfs_table->get_hive_column_types();
    jni_scanner_params["serialized_predicate"] = options.scan_node->serialized_predicate;

    jni_scanner_params["serialized_table"] = options.scan_node->serialized_table;
    jni_scanner_params["split_info"] = scan_range.serialized_split;
    jni_scanner_params["load_column_stats"] = options.scan_node->load_column_stats ? "true" : "false";

    const std::string scanner_factory_class = "com/starrocks/connector/iceberg/IcebergMetadataScannerFactory";
    return std::make_unique<JniScanner>(scanner_factory_class, jni_scanner_params);
}

6. 元数据收集任务

https://github.com/StarRocks/starrocks/pull/44679/files

核心类：IcebergMetadataCollectJob，Iceberg元数据的收集类，实现自MetadataCollectJob，目前看就是通过执行SQL语句，从前文的LogicalIcebergMetadataTable表当中获取数据

这一块属于最终的元数据收集

private static final String ICEBERG_METADATA_TEMPLATE = "SELECT content" + // INTEGER
        ", file_path" + // VARCHAR
        ", file_format" + // VARCHAR
        ", spec_id" + // INTEGER
        ", partition_data" + // BINARY
        ", record_count" + // BIGINT
        ", file_size_in_bytes" + // BIGINT
        ", split_offsets" + // ARRAY<BIGINT>
        ", sort_id" + // INTEGER
        ", equality_ids" + // ARRAY<INTEGER>
        ", file_sequence_number" + // BIGINT
        ", data_sequence_number " + // BIGINT
        ", column_stats " + // BINARY
        ", key_metadata " + // BINARY
        "FROM `$catalogName`.`$dbName`.`$tableName$logical_iceberg_metadata` " +
        "FOR VERSION AS OF $snapshotId " +
        "WHERE $predicate'";

7. 流程梳理

image.png

1. IcebergMetadataCollectJob的调用

    IcebergMetadataCollectJob -> StarRocksIcebergTableScan.planFileTasksRemotely -> StarRocksIcebergTableScan.doPlanFiles -> 由Iceberg定义的TableScan流程触发

2. StarRocksIcebergTableScan的构建

    StarRocksIcebergTableScan -> IcebergCatalog.getTableScan -> IcebergMetadata.collectTableStatisticsAndCacheIcebergSplit -> prepareMetadata()和triggerIcebergPlanFilesIfNeeded()

    prepareMetadata()线路由PrepareCollectMetaTask任务触发，其执行逻辑中调用了prepareMetadata()接口。PrepareCollectMetaTask是OptimizerTask的子类，属于StarRocks优化器的一环，在Optimizer类执行优化的时候会。这一块属于CBO优化，默认是false，没找到设置成true的地方，目前应该没有启用

    triggerIcebergPlanFilesIfNeeded()路线有几个调用的地方，主路线应该是getRemoteFileInfos()，其他两个看内容属于统计信息之类的信息收集

    IcebergMetadata.getRemoteFileInfos -> IcebergScanNode.setupScanRangeLocations -> PlanFragmentBuilder.visitPhysicalIcebergScan -> PhysicalIcebergScanOperator

    这一条调用链最终源头到PhysicalIcebergScanOperator，这个应当是IcebergScanNode经过SQL计划转换后的实际执行节点类

3. 元数据扫描

    IcebergMetaSpec -> IcebergMetadata.getSerializedMetaSpec -> MetadataMgr.getSerializedMetaSpec -> IcebergMetadataScanNode.setupScanRangeLocations -> PlanFragmentBuilder.visitPhysicalIcebergMetadataScan -> PhysicalIcebergMetadataScanOperator

    元数据扫描这一块源头最终走到PhysicalIcebergMetadataScanOperator，也就是IcebergMetadataScanNode对应的执行类

4. 元数据扫描和数据扫描的逻辑关系

    目前整体流程在最上层就差PhysicalIcebergMetadataScanOperator和PhysicalIcebergScanOperator的逻辑关系，这个逻辑在StarRocks的SQL到执行计划的转换过程当中

    往上追踪到BackendSelectorFactory，注意这里有两个扫描节点的分配策略：LocalFragmentAssignmentStrategy、RemoteFragmentAssignmentStrategy。根据类的说明，最左节点为scanNode的时候，使用LocalFragmentAssignmentStrategy，它首先将扫描范围分配给 worker，然后将分配给每个 worker 的扫描范围分派给片段实例

    在LocalFragmentAssignmentStrategy的assignFragmentToWorker当中可以看到入参包含很多scanNode，追踪上层到CoordinatorPreprocessor，scanNode的来源是StarRocks的DAG图。这之后的源头就涉及到任务解析和DAG图的顺序构建，应当是先扫描元数据再扫描数据这样构建

for (ExecutionFragment execFragment : executionDAG.getFragmentsInPostorder()) {
    fragmentAssignmentStrategyFactory.create(execFragment, workerProvider).assignFragmentToWorker(execFragment);
}

8. 代码解析

1. 元数据扫描

  • LogicalIcebergMetadataTable

    首先从PhysicalIcebergMetadataScanOperator出发，访问者模式调用接口accept，走到PlanFragmentBuilder.visitPhysicalIcebergMetadataScan

    这里首先跟LogicalIcebergMetadataTable关联了起来，这里PhysicalIcebergMetadataScanOperator里包含的表是LogicalIcebergMetadataTable表

    LogicalIcebergMetadataTable的初始创建根据调用链追踪应当由CatalogMgr.createCatalog触发

PhysicalIcebergMetadataScanOperator node = (PhysicalIcebergMetadataScanOperator) optExpression.getOp();

LogicalIcebergMetadataTable table = (LogicalIcebergMetadataTable) node.getTable();

  • IcebergMetadataScanNode

    中间经历一些列的设置，之后构建了IcebergMetadataScanNode

IcebergMetadataScanNode metadataScanNode =
        new IcebergMetadataScanNode(context.getNextNodeId(), tupleDescriptor,
                "IcebergMetadataScanNode", node.getTemporalClause());

    构建之后调用了setupScanRangeLocations，走到了IcebergMetadataScanNode的类逻辑，首先获取元数据文件的分片信息

IcebergMetaSpec serializedMetaSpec = GlobalStateMgr.getCurrentState().getMetadataMgr()
        .getSerializedMetaSpec(catalogName, originDbName, originTableName, snapshotId, icebergPredicate).cast();

  • IcebergMetadata

    这段逻辑跟IcebergMetadata关联了起来，调用其getSerializedMetaSpec接口，接口中就是获取Iceberg的元数据文件，中间经历了一定的过滤

List<ManifestFile> dataManifests = snapshot.dataManifests(nativeTable.io());

List<ManifestFile> matchingDataManifests = filterManifests(dataManifests, nativeTable, predicate);
for (ManifestFile file : matchingDataManifests) {
    remoteMetaSplits.add(IcebergMetaSplit.from(file));
}

    获取分片之后就是按StarRocks的扫描结构组装TScanRangeLocations，最终在实际执行时分布式分配解析

private void addSplitScanRangeLocations(RemoteMetaSplit split) {
    TScanRangeLocations scanRangeLocations = new TScanRangeLocations();

    THdfsScanRange hdfsScanRange = new THdfsScanRange();
    hdfsScanRange.setUse_iceberg_jni_metadata_reader(true);

    hdfsScanRange.setSerialized_split(split.getSerializeSplit());
    hdfsScanRange.setFile_length(split.length());
    hdfsScanRange.setLength(split.length());

    // for distributed scheduler
    hdfsScanRange.setFull_path(split.path());
    hdfsScanRange.setOffset(0);

    TScanRange scanRange = new TScanRange();
    scanRange.setHdfs_scan_range(hdfsScanRange);
    scanRangeLocations.setScan_range(scanRange);

    TScanRangeLocation scanRangeLocation = new TScanRangeLocation(new TNetworkAddress("-1", -1));
    scanRangeLocations.addToLocations(scanRangeLocation);

    result.add(scanRangeLocations);
}

  • PlanFragment 

    visitPhysicalIcebergMetadataScan接口最终组装的是一个PlanFragment，这大体类似于Spark的stage，是物理执行计划的计划块

PlanFragment fragment =
        new PlanFragment(context.getNextFragmentId(), metadataScanNode, DataPartition.RANDOM);
context.getFragments().add(fragment);
return fragment

  • IcebergMetadataScanner

    IcebergMetadataScanner由于其调用逻辑来自于C++的代码，暂未梳理其逻辑，但是假定其执行了，可以看其效果，主要在getNext()接口中读取数据

    可以看到其读取后的数据结构是ContentFile，是Iceberg中DataFile的上层父类

ContentFile<?> file = reader.next();
for (int i = 0; i < requiredFields.length; i++) {
    Object fieldData = get(requiredFields[i], file);
    if (fieldData == null) {
        appendData(i, null);
    } else {
        ColumnValue fieldValue = new IcebergMetadataColumnValue(fieldData);
        appendData(i, fieldValue);
    }
}

    主要在appendData接口当中，向表添加数据，可以看到这里设置了一个offHeapTable

    offHeapTable是 StarRocks 中的一个特殊表类型，简单来说就是在堆外内存中建立一个表结构，将数据对应存储到堆外内存，之后可以以表形式去访问

protected void appendData(int index, ColumnValue value) {
    offHeapTable.appendData(index, value);
}

2. 数据扫描中的元数据解析

    首先同样到PlanFragmentBuilder.visitPhysicalIcebergScan，流程与visitPhysicalIcebergMetadataScan类似

    首先是这里的表是数据表

Table referenceTable = node.getTable();
context.getDescTbl().addReferencedTable(referenceTable);
TupleDescriptor tupleDescriptor = context.getDescTbl().createTupleDescriptor();
tupleDescriptor.setTable(referenceTable);

// set slot
prepareContextSlots(node, context, tupleDescriptor);

    之后是IcebergScanNode

IcebergScanNode icebergScanNode =
        new IcebergScanNode(context.getNextNodeId(), tupleDescriptor, "IcebergScanNode",
                equalityDeleteTupleDesc);

    IcebergScanNode这里核心是调用setupScanRangeLocations

icebergScanNode.setupScanRangeLocations(context.getDescTbl());

    最终同样封装成PlanFragment

PlanFragment fragment =
        new PlanFragment(context.getNextFragmentId(), icebergScanNode, DataPartition.RANDOM);
context.getFragments().add(fragment);
return fragment;

  • IcebergScanNode

    在setupScanRangeLocations当中，有一个操作是getRemoteFileInfos，这个就是获取数据文件信息，因此内部包含了元数据解析的部分

List<RemoteFileInfo> splits = GlobalStateMgr.getCurrentState().getMetadataMgr().getRemoteFileInfos(
        catalogName, icebergTable, null, snapshotId, predicate, null, -1);

  • IcebergMetadata

    getRemoteFileInfos是在IcebergMetadata当中，会调用triggerIcebergPlanFilesIfNeeded，看接口名字可以明确这是用来触发Iceberg的元数据解析的，最终走到了collectTableStatisticsAndCacheIcebergSplit

private void triggerIcebergPlanFilesIfNeeded(IcebergFilter key, IcebergTable table, ScalarOperator predicate,
                                             long limit, Tracers tracers, ConnectContext connectContext) {
    if (!scannedTables.contains(key)) {
        tracers = tracers == null ? Tracers.get() : tracers;
        try (Timer ignored = Tracers.watchScope(tracers, EXTERNAL, "ICEBERG.processSplit." + key)) {
            collectTableStatisticsAndCacheIcebergSplit(table, predicate, limit, tracers, connectContext);
        }
    }
}

    collectTableStatisticsAndCacheIcebergSplit当中获取了TableScan，这里的Scan就是StarRocksIcebergTableScan

TableScan scan = icebergCatalog.getTableScan(nativeTbl, new StarRocksIcebergTableScanContext(
        catalogName, dbName, tableName, planMode(connectContext), connectContext))
        .useSnapshot(snapshotId)
        .metricsReporter(metricsReporter)
        .planWith(jobPlanningExecutor);

  • StarRocksIcebergTableScan

    之后走scan.planFiles()，这个中间会基于Iceberg的逻辑进行调用

CloseableIterable<FileScanTask> fileScanTaskIterable = TableScanUtil.splitFiles(
        scan.planFiles(), scan.targetSplitSize());

    Icberg的逻辑中planFiles最终会调用TableScan的doPlanFiles，这里调用的就是StarRocksIcebergTableScan的实现接口，根据场景有本地和远程的调用方式

if (shouldPlanLocally(dataManifests, loadColumnStats)) {
    return planFileTasksLocally(dataManifests, deleteManifests);
} else {
    return planFileTasksRemotely(dataManifests, deleteManifests);
}

    Iceberg应当是使用的planFileTasksRemotely，内部会构建IcebergMetadataCollectJob

MetadataCollectJob metadataCollectJob = new IcebergMetadataCollectJob(
        catalogName, dbName, tableName, TResultSinkType.METADATA_ICEBERG, snapshotId(), icebergSerializedPredicate);

metadataCollectJob.init(connectContext.getSessionVariable());

long currentTimestamp = System.currentTimeMillis();
String threadNamePrefix = String.format("%s-%s-%s-%d", catalogName, dbName, tableName, currentTimestamp);
executeInNewThread(threadNamePrefix + "-fetch_result", metadataCollectJob::asyncCollectMetadata);

  • MetadataExecutor执行

    IcebergMetadataCollectJob的执行在MetadataExecutor当中，就是基本的SQL执行，这里是异步的

public void asyncExecuteSQL(MetadataCollectJob job) {
    ConnectContext context = job.getContext();
    context.setThreadLocalInfo();
    String sql = job.getSql();
    ExecPlan execPlan;
    StatementBase parsedStmt;
    try {
        parsedStmt = SqlParser.parseOneWithStarRocksDialect(sql, context.getSessionVariable());
        execPlan = StatementPlanner.plan(parsedStmt, context, job.getSinkType());
    } catch (Exception e) {
        context.getState().setError(e.getMessage());
        return;
    }

    this.executor = new StmtExecutor(context, parsedStmt);
    context.setExecutor(executor);
    context.setQueryId(UUIDUtil.genUUID());
    context.getSessionVariable().setEnableMaterializedViewRewrite(false);

    LOG.info("Start to execute metadata collect job on {}.{}.{}", job.getCatalogName(), job.getDbName(), job.getTableName());
    executor.executeStmtWithResultQueue(context, execPlan, job.getResultQueue());
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/796343.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ts踩坑！在类型“xx”上找不到具有类型“string”的参数的索引签名；或者：元素隐式具有“any”类型，因为类型为“string”的表达式不能用于索引类型

ts踩坑！在类型“xx”上找不到具有类型“string”的参数的索引签名；或者：元素隐式具有“any”类型，因为类型为“string”的表达式不能用于索引类型

报错信息如下1&#xff1a; 在类型 “{ themeName: string; remark: string; platformName: string; platformLogo: string; footerText: string; recordNo: string; recordUrl: string; helpEnter: string; themeColor: string; topBar: string; … 9 more …; themeId: ID; …
阅读更多...
PCL从理解到应用【04】Octree 原理分析 | 案例分析 | 代码实现

PCL从理解到应用【04】Octree 原理分析 | 案例分析 | 代码实现

前言 Octree 作为一种高效的空间分割数据结构&#xff0c;具有重要的应用价值。 本文将深入分析 Octree 的原理&#xff0c;通过多个实际案例帮助读者全面理解其功能和应用&#xff0c;包括最近邻搜索、半径搜索、盒子搜索以及点云压缩&#xff08;体素化&#xff09;。 特性…
阅读更多...
车载视频监控管理方案：无人驾驶出租车安全出行的保障

车载视频监控管理方案：无人驾驶出租车安全出行的保障

近日&#xff0c;无人驾驶出租车“萝卜快跑”在武汉开放载人测试成为热门话题。随着科技的飞速发展&#xff0c;无人驾驶技术已逐渐从概念走向现实&#xff0c;特别是在出租车行业中&#xff0c;无人驾驶出租车的推出将为公众提供更为安全、便捷、高效的出行服务。 视频监控技…
阅读更多...
Vue3 markRaw的使用

Vue3 markRaw的使用

markRaw 作用:将一个对象标记为不可以被转化为代理对象。返回该对象本身。 应用场景: 1.有些值不应被设置成响应式时,例如复杂的第三方类库等 2.当渲染具有不可变数据源的大列表时,跳过响应式转换可以提高性能 3.在动态渲染组件的时候我们就可以使用 markRaw 包裹。markRaw 的…
阅读更多...
软件系统培训方案（word原件）

软件系统培训方案（word原件）

1. 培训概述 2. 培训目的 3. 培训对象及要求 3.1. 培训对象 3.2. 培训人员基本要求 4. 培训方式 5. 培训内容 6. 培训讲师 7. 培训教材 8. 培训质量保证 8.1. 用户培训确认报告 8.2. 培训疑问解 软件资料清单列表部分文档&#xff1a; 工作安排任务书&#xff0c;…
阅读更多...
JS登录页源码 —— 可一键复制抱走

JS登录页源码 —— 可一键复制抱走

前期回顾 https://blog.csdn.net/m0_57904695/article/details/139838176?spm1001.2014.3001.5501https://blog.csdn.net/m0_57904695/article/details/139838176?spm1001.2014.3001.5501 登录页预览效果 <!DOCTYPE html> <html lang"en"><head…
阅读更多...
构建实时银行应用程序：英国金融机构 Nationwide 为何选择 MongoDB Atlas

构建实时银行应用程序：英国金融机构 Nationwide 为何选择 MongoDB Atlas

Nationwide Building Society 超过135年的互助合作 Nationwide Building Society&#xff08;以下简称“Nationwide”&#xff09; 是一家英国金融服务提供商&#xff0c;拥有超过 1500 万名会员&#xff0c;是全球最大的建房互助会。 Nationwide 的故事可以追溯到 1884 年&am…
阅读更多...
Python3 第十五课 -- 条件控制

Python3 第十五课 -- 条件控制

目录 一. 前言 二. if 语句 三. if 嵌套 四. match...case 一. 前言 Python 条件语句是通过一条或多条语句的执行结果&#xff08;True 或者 False&#xff09;来决定执行的代码块。 可以通过下图来简单了解条件语句的执行过程&#xff1a; 代码执行过程&#xff1a; 二.…
阅读更多...
【Python】下载与安装

【Python】下载与安装

目录 一、 下载安装Python 1. 配置环境变量 2. 检查是否配置成功 一、 下载安装Python 在我上传的资源可以免费下载&#xff01;&#xff01;&#xff01; https://download.csdn.net/download/m0_67830223/89536665?spm1001.2014.3001.5501https://download.csdn.net/dow…
阅读更多...
如何入门单片机嵌入式？

如何入门单片机嵌入式？

入门单片机嵌入式系统开发可以按照以下步骤进行。我收集归类了一份嵌入式学习包&#xff0c;对于新手而言简直不要太棒&#xff0c;里面包括了新手各个时期的学习方向编程教学、问题视频讲解、毕设800套和语言类教学&#xff0c;敲个22就可以免费获得。 选择单片机开发板&…
阅读更多...
Epson打印机日常问题和解决办法

Epson打印机日常问题和解决办法

1、打印过程中缺纸&#xff0c;重新放入纸张之后&#xff0c;打印机出错。 打开“控制面板”&#xff0c;进入“设备与打印机”&#xff1a; 选择你正在使用的打印机&#xff0c;最下面可以看到打印机状态&#xff08;我这边用完脱机了&#xff0c;所以显示脱机&#xff09;&a…
阅读更多...
Min P Sampling: Balancing Creativity and Coherence at High Temperature阅读笔记

Min P Sampling: Balancing Creativity and Coherence at High Temperature阅读笔记

上一篇文章是关于大语言模型的调参数&#xff0c;写了temperature这个参数近期的一个工作。那接下来&#xff0c;就不得不再来讲讲top-p这个参数啦。首先还是上文章&#xff0c;同样是非常新的一个工作&#xff0c;2024年7月1日submit的呢。 文章链接&#xff1a;https://arxi…
阅读更多...
SpringBoot新手快速入门系列教程十一：基于Docker Compose部署一个最简单分布式服务项目

SpringBoot新手快速入门系列教程十一：基于Docker Compose部署一个最简单分布式服务项目

我的教程都是亲自测试可行才发布的&#xff0c;如果有任何问题欢迎留言或者来群里我每天都会解答。 如果您还对于Docker或者Docker Compose不甚了解&#xff0c;可以劳烦移步到我之前的教程&#xff1a; SpringBoot新手快速入门系列教程九&#xff1a;基于docker容器&#xff…
阅读更多...
论文翻译：Large Language Models for Education: A Survey

论文翻译：Large Language Models for Education: A Survey

目录 大型语言模型在教育领域的应用&#xff1a;一项综述摘要1 引言2. 教育中的LLM特征2.1. LLMs的特征2.2 教育的特征2.2.1 教育发展过程 低进入门槛。2.2.2. 对教师的影响2.2.3 教育挑战 2.3 LLMEdu的特征2.3.1 "LLMs 教育"的具体体现2.3.2 "LLMs 教育"…
阅读更多...
【系统架构设计】计算机组成与体系结构（三）

【系统架构设计】计算机组成与体系结构（三）

计算机组成与体系结构&#xff08;三&#xff09; 计算机系统组成存储器系统主存储器辅助存储器Cache存储器Cache 基本原理映射机制直接映射全相联映射组相联映射 替换算法写操作 流水线&#xff08;计算&#xff09;流水线周期流水线执行时间流水线的吞吐率流水线的加速比 计算…
阅读更多...
Python函数 之 匿名函数

Python函数 之 匿名函数

1.概念 匿名函数: 使用 lambda 关键字 定义的表达式&#xff0c;称为匿名函数. 2.语法 lambda 参数, 参数: 一行代码 # 只能实现简单的功能&#xff0c;只能写一行代码 # 匿名函数 一般不直接调用&#xff0c;作为函数的参数使用的 3.代码 4.练习 # 1, 定义匿名函数, 参数…
阅读更多...
JDK 和 JRE：它们之间的区别是什么？

JDK 和 JRE：它们之间的区别是什么？

JDK 和 JRE&#xff1a;它们之间的区别是什么&#xff1f; 1、JRE&#xff08;Java Runtime Environment&#xff09;1.1 JRE的主要组成部分1.2 JRE的用途 2、JDK&#xff08;Java Development Kit&#xff09;2.1 JDK的主要组成部分2.2 JDK的用途 3、总结 &#x1f496;The Be…
阅读更多...
pbootCMS 数据库sqlite转mysql数据库

pbootCMS 数据库sqlite转mysql数据库

前言 pbootCMS默认使用 sqlite数据库 &#xff0c;那么什么是sqlite数据库呢&#xff1f; SQLite&#xff0c;是一款轻型的数据库&#xff0c;是遵守ACID的关系型数据库管理系统&#xff0c;它包含在一个相对小的C库中。它是D.RichardHipp建立的公有领域项目。它的设计目标是嵌…
阅读更多...
Java | Leetcode Java题解之第232题用栈实现队列

Java | Leetcode Java题解之第232题用栈实现队列

题目&#xff1a; 题解&#xff1a; class MyQueue {Deque<Integer> inStack;Deque<Integer> outStack;public MyQueue() {inStack new ArrayDeque<Integer>();outStack new ArrayDeque<Integer>();}public void push(int x) {inStack.push(x);}pub…
阅读更多...
Spark底层原理：案例解析（第34天）

Spark底层原理：案例解析（第34天）

系列文章目录 一、Spark架构设计概述 二、Spark核心组件 三、Spark架构设计举例分析 四、Job调度流程详解 五、Spark交互流程详解 文章目录 系列文章目录前言一、Spark架构设计概述1. 集群资源管理器&#xff08;Cluster Manager&#xff09;2. 工作节点&#xff08;Worker No…
阅读更多...
最新文章

Copyright @ 2022~2023