gitweixin
  • 首页
  • 小程序代码
    • 资讯读书
    • 工具类
    • O2O
    • 地图定位
    • 社交
    • 行业软件
    • 电商类
    • 互联网类
    • 企业类
    • UI控件
  • 大数据开发
    • Hadoop
    • Spark
    • Hbase
    • Elasticsearch
    • Kafka
    • Flink
    • 数据仓库
    • 数据挖掘
    • flume
    • Kafka
    • Hive
    • shardingsphere
    • solr
  • 开发博客
    • Android
    • php
    • python
    • 运维
    • 技术架构
    • 数据库
  • 程序员网赚
  • bug清单
  • 量化投资
  • 在线查询工具
    • 去行号
    • 在线时间戳转换工具
    • 免费图片批量修改尺寸在线工具
    • SVG转JPG在线工具

分类归档Spark

精品微信小程序开发门户,代码全部亲测可用

  • 首页   /  大数据开发
  • 分类归档: "Spark"
Hive, Spark 11月 1,2024

Hive或Spark数据抽样技术详解

抽样的重要性

在离线数仓开发中,抽样技术扮演着至关重要的角色,其重要性主要体现在以下几个方面:

提升查询性能

抽样技术能够显著提高复杂查询的执行效率。通过从大规模数据集中提取代表性样本,可以在短时间内获得接近真实结果的估算值,大大缩短查询响应时间。这在处理海量数据时尤为重要,尤其是在需要频繁执行复杂分析查询的场景中。例如,假设有一个包含数十亿条记录的订单表,通过抽样技术,我们可以在几分钟内获得订单金额分布的概览,而不必等待全表扫描的漫长过程。

优化查询执行计划

抽样数据可以帮助查询优化器更准确地估计查询成本,从而选择更有效的执行计划。这对于处理大规模数据集的查询尤为重要,可以显著提高查询效率。例如,通过分析抽样数据,查询优化器可以更准确地估计连接操作的成本,从而选择更适合的连接算法和顺序。

数据质量验证

抽样技术在数据质量验证方面发挥着重要作用。通过对样本数据进行检查,可以快速发现潜在的数据质量问题,如异常值、缺失值或不符合预期的数据分布等。这有助于及时发现和修复数据问题,确保数据仓库中存储的数据质量和一致性。例如,可以通过抽样检查来验证数据转换规则的正确性,或者监测数据分布的变化趋势,从而及时发现潜在的数据质量问题。

方便进行初步的数据探索和分析

抽样技术允许分析师在处理完整数据集之前,快速查看和分析一小部分数据,从而更快地理解数据的整体特征和分布情况。这有助于快速形成初步的分析假设和方向,为后续的深入分析奠定基础。例如,通过抽样分析,分析师可以快速识别数据中的主要类别、异常值或有趣的数据模式,从而指导后续的分析工作重点。

减少计算资源消耗

抽样技术可以显著降低计算资源的消耗。通过处理较小的样本数据集,可以减少CPU、内存和网络带宽的使用,从而提高整体系统的处理能力。这对于处理大规模数据集尤其有益,可以使有限的计算资源得到更有效的利用。例如,在进行大规模数据聚合操作时,可以先对数据进行抽样,然后再进行聚合计算,这样不仅可以提高计算速度,还能减少内存占用。

加速数据处理和分析流程

抽样技术可以加速整个数据处理和分析流程。通过使用样本数据,可以在较短的时间内完成初步的数据探索和分析,从而更快地迭代分析过程,提高工作效率。这对于需要快速响应业务需求的场景尤为重要,可以显著缩短从数据收集到洞察产出的时间周期。例如,在进行市场趋势分析时,可以通过抽样快速获取市场概况,然后再根据需要逐步扩大分析范围,既提高了效率,又保证了分析的深度和广度。

常用抽样方法

在离线数仓开发中,抽样技术是一项关键工具,能够帮助我们在处理大规模数据集时提高效率和准确性。本节将详细介绍两种广泛应用的抽样方法:随机抽样和系统抽样,并讨论它们在不同场景下的适用性。

随机抽样

随机抽样 是最基本且最直观的抽样方法。它确保总体中的每个个体都有同等被选中的机会。随机抽样的核心优势在于其简单性和灵活性,适用于大多数情况。然而,当总体规模庞大时,实施随机抽样可能面临挑战。

系统抽样

系统抽样 则提供了一种更高效的选择。这种方法通过固定间隔从总体中选择样本,特别适合处理大规模数据集。系统抽样的步骤如下:

  1. 确定总体大小N
  2. 计算抽样间隔k = N / n(n为样本大小)
  3. 随机选择起始点
  4. 按照固定间隔k选择样本

系统抽样的优势在于其实施简单且成本较低。然而,如果总体存在某种周期性或规律性,系统抽样可能产生偏差。例如,在客户满意度调查中,如果数据按日期排序,系统抽样可能无意中选择同一时间段的样本,影响结果的代表性。

分层抽样

分层抽样 是另一种值得关注的方法。它首先将总体按特定特征分成若干层,然后从各层中随机抽取样本。这种方法特别适用于需要确保各子群体代表性的情况。分层抽样的优势在于可以提高样本的代表性,减少抽样误差,特别适合于数据分布不均匀的场景。

整群抽样

整群抽样 则是将总体划分为若干个群,然后随机选择部分群作为样本。这种方法在地理分布广泛的数据集中尤为有效,可以显著降低成本。然而,整群抽样可能引入更大的抽样误差,特别是当群内差异较大时。

在选择适当的抽样方法时,需要综合考虑以下因素:

  • 总体特征 :数据分布、结构和规模
  • 研究目的 :所需精度、代表性要求
  • 资源限制 :时间和成本约束
  • 可行性 :实施难度和技术要求

通过合理选择和应用这些抽样方法,我们可以在离线数仓开发中实现数据处理的效率提升和资源优化,同时保证分析结果的准确性和代表性。

TABLESAMPLE语句

在Hive中, TABLESAMPLE语句 是一种强大的工具,用于从大型数据集中抽取代表性样本。这个功能在处理海量数据时尤为重要,因为它允许用户快速获取数据的概览,而无需扫描整个表。

TABLESAMPLE语句的主要语法形式如下:

SELECT * FROM <table_name>
TABLESAMPLE(BUCKET x OUT OF y [ON colname])

在这个语法中:

  • BUCKET x OUT OF y :指定从y个桶中选择第x个桶的数据
  • ON colname :指定用于确定桶分配的列

值得注意的是,colname可以是一个具体的列名,也可以是 rand()函数 ,表示对整行进行抽样。例如:

SELECT * FROM source
TABLESAMPLE(BUCKET 3 OUT OF 32 ON rand())

这个查询将从source表的32个桶中选择第3个桶的数据。

TABLESAMPLE的一个关键特点是它的 灵活性 。它可以根据不同的需求选择不同数量的桶。例如:

TABLESAMPLE(BUCKET 3 OUT OF 16 ON id)

这个查询将从16个桶中选择第3个和第19个桶的数据,因为每个桶实际上由2个簇组成。

此外,Hive还支持 块抽样 功能,允许用户根据数据大小的百分比或具体字节数进行抽样:

SELECT * FROM source
TABLESAMPLE(0.1 PERCENT)

这个查询将抽取表数据大小的0.1%,但请注意,由于HDFS块级别的抽样,实际返回的数据可能会大于指定的百分比。

Hive的TABLESAMPLE语句不仅提高了查询效率,还为数据分析师提供了一个快速评估数据质量的强大工具。通过合理使用这个功能,用户可以在处理大规模数据集时节省大量时间和计算资源,同时保持结果的代表性和准确性。

分桶表抽样

在Hive中,分桶表是一种高级的数据组织方式,旨在提高大规模数据集的处理效率。这种技术通过将数据按照特定列的哈希值进行分组,实现了更精细的数据划分,从而优化了查询性能和抽样操作。

分桶表的基本原理是:

  1. 对指定列的值进行哈希运算
  2. 使用哈希值除以桶的总数进行取余
  3. 得到的结果决定了每条记录所属的具体桶

这种方法确保了相似值的数据会被分散到不同的桶中,从而减少了数据倾斜的问题。

在创建分桶表时,我们需要指定分桶列和桶的数量。例如:

CREATE TABLE bucketed_table (
    id INT,
    name STRING
) CLUSTERED BY (id) INTO 4 BUCKETS;

这段代码创建了一个名为bucketed_table的分桶表,使用id列进行分桶,并将其划分为4个桶。

分桶表的一个关键优势是在进行抽样查询时的高效性。Hive提供了专门的TABLESAMPLE语句来实现这一功能:

SELECT * FROM bucketed_table TABLESAMPLE(BUCKET 1 OUT OF 4);

这个查询将从4个桶中选择第1个桶的数据。这里的OUT OF后面的数字必须是总桶数的倍数或因子,Hive会根据这个值来决定抽样的比例。

分桶表抽样的一个重要特点是其灵活性。它可以与其他查询操作结合使用,如:

SELECT COUNT(*) FROM bucketed_table TABLESAMPLE(BUCKET 1 OUT OF 4) WHERE age > 30;

这个查询展示了如何在抽样数据的基础上进行进一步的筛选和聚合操作。

通过合理使用分桶表抽样技术,我们可以在处理大规模数据集时实现高效的查询和分析,同时保证结果的代表性和准确性。这种方法不仅提高了查询性能,还为数据分析师提供了一种快速评估数据质量的有效途径。

sample()函数

在Spark中,sample()函数是处理大规模数据集时的一项强大工具。它允许开发者从RDD或DataFrame中抽取代表性样本,从而在处理海量数据时提高效率并减少计算资源的消耗。

sample()函数的基本语法如下:

sample(withReplacement: Boolean, fraction: Double, seed: Long = 0)

其中:

参数类型描述
withReplacementBoolean是否允许重复抽样
fractionDouble抽样的比例(0-1之间)
seedLong随机数生成器的种子

下面通过几个例子来详细说明sample()函数的使用方法:

  1. 基本用法
val rdd = sc.parallelize(1 to 1000000)

// 抽取10%的样本,不放回
val sampleRdd = rdd.sample(false, 0.1)

println(sampleRdd.count())  // 输出约100000
  1. 使用随机种子
val sampleRddWithSeed = rdd.sample(false, 0.1, 123L)

// 使用相同种子将得到相同结果
println(sampleRddWithSeed.count())  // 输出约100000
  1. DataFrame中的使用
import spark.implicits._

val df = Seq(("Alice", 34), ("Bob", 28), ("Charlie", 45)).toDF("Name", "Age")

// 抽取50%的样本
val sampleDf = df.sample(0.5)

sampleDf.show()
  1. 分层抽样
val df = Seq(("Alice", "Female"), ("Bob", "Male"), ("Charlie", "Male")).toDF("Name", "Gender")

val stratifiedSample = df.stat.sampleBy("Gender", Map("Female" -> 0.5, "Male" -> 0.3))

stratifiedSample.show()

通过灵活运用sample()函数,开发者可以在处理大规模数据集时实现高效的抽样操作,从而优化查询性能、减少计算资源消耗,并在数据探索和分析过程中获得有价值的见解。这种方法特别适用于需要快速了解数据整体分布或进行初步数据分析的场景。

takeSample()方法

在Spark中,takeSample()方法是处理大规模数据集时的一种高效抽样工具。它允许开发者从RDD或DataFrame中抽取代表性样本,特别适用于需要快速获取数据概览或进行初步分析的场景。

takeSample()方法的基本语法如下:

takeSample(withReplacement: Boolean, num: Int, seed: Long = 0)

其中:

  • withReplacement :是否允许重复抽样
  • num :抽样的样本数量
  • seed :随机数生成器的种子(可选)

takeSample()方法的一个关键特点是其灵活性。它可以在保持分布式计算优势的同时,提供精确的样本控制。这意味着开发者可以根据具体需求,精确控制抽样数量和重复性,同时充分利用Spark的并行处理能力。

在实际应用中,takeSample()方法常用于以下场景:

  1. 数据预览 :快速查看大型数据集的结构和分布
  2. 性能测试 :使用小规模样本评估复杂查询的执行计划
  3. 数据质量检查 :抽样验证数据清洗和转换的正确性
  4. 模型训练 :从大规模数据集中抽取适量样本用于机器学习模型训练

例如,假设我们有一个包含百万级用户评论的大数据集,我们可以使用takeSample()方法快速获取1000条评论样本进行初步分析:

val commentsRDD = sc.textFile("hdfs://path/to/comments")
val sampleComments = commentsRDD.takeSample(false, 1000)

这种方法不仅速度快,还能保证样本的代表性,为后续的深入分析提供基础。

值得注意的是,takeSample()方法在处理非常大规模的数据集时可能会遇到性能瓶颈。在这种情况下,可以考虑结合其他抽样技术,如分层抽样或系统抽样,以平衡效率和代表性。

查询性能优化

在离线数仓开发中,抽样数据技术不仅能提高查询速度,还可优化复杂查询的执行计划。通过分析抽样数据,查询优化器能更准确地估计查询成本,从而选择更有效的执行策略。例如,抽样数据可帮助判断是否采用索引扫描而非全表扫描,或在连接操作中选择合适的连接算法和顺序。这种方法特别适用于处理大规模数据集的复杂查询,能在保证查询结果准确性的同时,显著提升查询效率。

数据质量验证

在ETL过程中,抽样数据是验证数据质量的关键方法之一。通过分析代表性样本,可以快速识别潜在的数据质量问题,如异常值、缺失值或不符合预期的数据分布。这种方法不仅提高了数据质量检查的效率,还降低了计算资源的消耗。具体而言,可以使用以下几种抽样技术来进行数据质量验证:

  1. 随机抽样 :从数据集中随机选择一定比例的记录进行检查。
  2. 系统抽样 :按照固定的间隔从数据集中选择样本。
  3. 分层抽样 :将数据集按特定属性分层,然后从各层中抽取样本。

这些方法可以单独使用或组合应用,以适应不同的数据特征和质量要求。通过合理运用抽样技术,可以在保证数据质量的同时,显著提高ETL过程的效率和可靠性。

作者 east
Spark 7月 18,2024

解决pyspark的py4j.protocol.Py4JError: An error occurred while calling o84.getstate错误

在pyspark使用了udf,然后就报错下面错误:

 File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\serializers.py", line 587, in dumps
return cloudpickle.dumps(obj, 2)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 863, in dumps
cp.dump(obj)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 260, in dump
return Pickler.dump(self, obj)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 409, in dump
self.save(obj)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 736, in save_tuple
save(element)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 400, in save_function
self.save_function_tuple(obj)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 549, in save_function_tuple
save(state)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 821, in save_dict
self._batch_setitems(obj.items())
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 847, in _batch_setitems
save(v)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 821, in save_dict
self._batch_setitems(obj.items())
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 847, in _batch_setitems
save(v)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 521, in save
self.save_reduce(obj=obj, *rv)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 634, in save_reduce
save(state)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 821, in save_dict
self._batch_setitems(obj.items())
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 852, in _batch_setitems
save(v)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 496, in save
rv = reduce(self.proto)
File "D:\ProgramData\Anaconda3\lib\site-packages\py4j\java_gateway.py", line 1257, in call
answer, self.gateway_client, self.target_id, self.name)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\sql\utils.py", line 63, in deco
return f(*a, **kw)
File "D:\ProgramData\Anaconda3\lib\site-packages\py4j\protocol.py", line 332, in get_return_value
format(target_id, ".", name, value))
py4j.protocol.Py4JError: An error occurred while calling o84.getstate. Trace:
py4j.Py4JException: Method getstate([]) does not exist
at py4j.reflection.ReflectionEngine.getMethod(ReflectionEngine.java:318)
at py4j.reflection.ReflectionEngine.getMethod(ReflectionEngine.java:326)
at py4j.Gateway.invoke(Gateway.java:274)
at py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)
at py4j.commands.CallCommand.execute(CallCommand.java:79)
at py4j.GatewayConnection.run(GatewayConnection.java:238)
at java.lang.Thread.run(Thread.java:748)

Traceback (most recent call last):
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\serializers.py", line 587, in dumps
return cloudpickle.dumps(obj, 2)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 863, in dumps
cp.dump(obj)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 260, in dump
return Pickler.dump(self, obj)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 409, in dump
self.save(obj)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 736, in save_tuple
save(element)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 400, in save_function
self.save_function_tuple(obj)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\cloudpickle.py", line 549, in save_function_tuple
save(state)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 821, in save_dict
self._batch_setitems(obj.items())
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 847, in _batch_setitems
save(v)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 821, in save_dict
self._batch_setitems(obj.items())
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 847, in _batch_setitems
save(v)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 521, in save
self.save_reduce(obj=obj, *rv)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 634, in save_reduce
save(state)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 476, in save
f(self, obj) # Call unbound method with explicit self
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 821, in save_dict
self._batch_setitems(obj.items())
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 852, in _batch_setitems
save(v)
File "D:\ProgramData\Anaconda3\lib\pickle.py", line 496, in save
rv = reduce(self.proto)
File "D:\ProgramData\Anaconda3\lib\site-packages\py4j\java_gateway.py", line 1257, in call
answer, self.gateway_client, self.target_id, self.name)
File "D:\ProgramData\Anaconda3\lib\site-packages\pyspark\sql\utils.py", line 63, in deco
return f(*a, **kw)
File "D:\ProgramData\Anaconda3\lib\site-packages\py4j\protocol.py", line 332, in get_return_value
format(target_id, ".", name, value))
py4j.protocol.Py4JError: An error occurred while calling o84.getstate. Trace:
py4j.Py4JException: Method getstate([]) does not exist
at py4j.reflection.ReflectionEngine.getMethod(ReflectionEngine.java:318)
at py4j.reflection.ReflectionEngine.getMethod(ReflectionEngine.java:326)
at py4j.Gateway.invoke(Gateway.java:274)
at py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)
at py4j.commands.CallCommand.execute(CallCommand.java:79)
at py4j.GatewayConnection.run(GatewayConnection.java:238)
at java.lang.Thread.run(Thread.java:748)

During handling of the above exception, another exception occurred:

Traceback (most recent call last):

刚开始以为pyspark的包有问题,后来仔细研究一下,才发现是下面的问题:

这个错误通常发生在尝试在 PySpark 中注册一个用户定义的函数(UDF)时,而该函数使用了不支持序列化的对象或方法。错误信息中的 __getstate__ 方法缺失提示 Py4J 无法正确地将 Python 对象转换为 Java 对象,这通常是因为 UDF 内部引用了 Spark DataFrame 函数或某些类实例,这些在 Py4J 上下文里是不可序列化的。

原来是在UDF用了lag 函数,这是不允许的,因为 UDF 必须是可序列化的,而 DataFrame 函数是不允许。

由于需要使用lag函数,解决方法是不用UDF来实现。

作者 east
Hive, Spark 7月 7,2024

Hive、Spark SQL与Impala在大数据处理中的性能对比及应用分析

一、引言

在使用CDH6.3.2处理离线报表时,Hive、Spark SQL与Impala是三种主流的大数据处理工具。下面将对这三种工具进行详细的对比分析优缺点和适用场景。

二、Hive:Apache Hive

  1. 性能分析:Hive使用MapReduce作为其数据处理后端,适用于处理大规模数据集的批量查询和分析。然而,由于MapReduce的特性,Hive在处理实时或交互式查询时性能较差。一项由Hortonworks进行的测试显示,在处理1TB数据集时,Hive的平均查询时间约为20分钟。
  2. 优点:Hive提供了类似SQL的查询语言HiveQL,使得用户可以轻松地进行数据查询和管理。此外,Hive还支持多种数据格式,包括文本文件、序列文件、Avro等。
  3. 缺点:Hive的主要缺点是其查询速度慢,不适合实时或交互式查询。此外,Hive的资源消耗也较大,需要较大的内存和磁盘空间。
  4. 适用场景:Hive适合用于处理大规模数据集的批量查询和分析,例如日志分析、用户行为分析等。

三、Spark SQL:Apache Spark SQL

  1. 性能分析:Spark SQL使用Spark作为其数据处理后端,相较于Hive,Spark SQL的查询速度更快。一项由Databricks进行的测试显示,在处理1TB数据集时,Spark SQL的平均查询时间约为2分钟,比Hive快了近10倍。
  2. 优点:Spark SQL不仅查询速度快,而且支持实时查询和交互式查询。此外,Spark SQL还支持多种数据源,包括HDFS、Hive、Parquet、JSON、JDBC等。
  3. 缺点:Spark SQL的主要缺点是其资源消耗较大,需要较大的内存和CPU资源。此外,Spark SQL的学习曲线也比Hive陡峭。
  4. 适用场景:Spark SQL适合用于处理大规模数据集的实时查询和交互式查询,例如实时数据分析、交互式数据探索等。

四、Impala:Cloudera Impala

  1. 性能分析:Impala使用MPP(大规模并行处理)架构,相较于Hive和Spark SQL,Impala的查询速度更快。一项由Cloudera进行的测试显示,在处理1TB数据集时,Impala的平均查询时间约为1分钟,比Spark SQL快了一倍。
  2. 优点:Impala不仅查询速度快,而且支持实时查询和交互式查询。此外,Impala还支持多种数据格式,包括Parquet、ORC、Avro等。
  3. 缺点:Impala的主要缺点是其资源消耗较大,需要较大的内存和CPU资源。此外,Impala的兼容性也比Hive和Spark SQL差,不支持所有的Hive表类型和函数。用Impala做ETL时,会出现显示执行成功,但时间没有把查询结果成功写入。
  4. 适用场景:Impala适合用于处理大规模数据集的实时查询和交互式查询,例如实时数据分析、交互式数据探索等。

五、结论

总的来说,Hive、Spark SQL与Impala各有优劣。Hive适用于处理大规模数据集的批量查询和分析,其查询语言易于理解,但查询速度相对较慢。Spark SQL则在查询速度上有了显著提升,同时支持实时和交互式查询,但在资源消耗上相对较高。Impala在查询速度上更胜一筹,尤其适合实时和交互式查询,但其资源消耗和兼容性是其主要缺点。

在选择这些工具时,应根据具体的应用场景和需求来决定。例如,如果是在进行大规模数据的批量查询和分析,且对查询速度的要求不高,那么Hive是一个不错的选择。如果是在进行大规模数据的实时查询和交互式查询,且对查询速度有较高的要求,那么Spark SQL或Impala可能更适合。

此外,还应考虑到系统的资源状况。如果系统资源充足,那么可以选择Spark SQL或Impala,但如果系统资源有限,那么可能需要考虑Hive或其他资源消耗较小的工具。

总的来说,Hive、Spark SQL与Impala都是优秀的大数据处理工具,它们各有优势和劣势,没有绝对的好坏之分,只有是否适合具体的应用场景和需求。

在实际应用中,我们也可以考虑将这些工具结合使用,以发挥各自的长处。例如,可以使用Hive进行大规模数据的批量查询和分析,使用Spark SQL或Impala进行实时和交互式查询,或者使用Spark SQL进行数据预处理,然后使用Hive或Impala进行数据查询和分析。

作者 east
Spark 6月 18,2024

Deequ教程来监控Spark/Hive离线数仓的数据质量实用教程

第一部分:Deequ简介与环境搭建

1. Deequ是什么?

Deequ是AWS开源的一款基于Apache Spark的库,用于定义和验证数据质量规则。它通过声明式API允许用户定义一系列数据质量检查,并自动执行这些检查来评估数据集的质量,特别适合大数据处理场景,如Spark和Hive数据仓库。

2. 安装与配置

  • 依赖管理:在你的Spark项目中加入Deequ的依赖。如果你使用sbt,可以在build.sbt文件中添加如下依赖:Scala1libraryDependencies += "com.amazon.deequ" %% "deequ" % "latestVersion"其中latestVersion应替换为当前的稳定版本号。
  • 环境准备:确保你的开发环境已经安装并配置好了Apache Spark和相关依赖(如Hadoop客户端,如果使用Hive的话)。

第二部分:Deequ核心概念

1. 数据质量规则

Deequ支持多种数据质量检查,包括但不限于:

  • Completeness: 检查列是否完整(非空)。
  • Uniqueness: 确保列值唯一。
  • Domain Constraints: 检查数据是否符合特定域,如数值范围、正则表达式匹配等。
  • Size Constraints: 检查数据集大小是否在预期范围内。
  • Dependency Checks: 验证列间的关系,如引用完整性。

2. 声明式API

Deequ采用Scala的声明式API来定义数据质量规则,使得规则定义变得直观且易于维护。

第三部分:实战操作指南

1. 初始化Deequ

在SparkSession中初始化Deequ:

import com.amazon.deequ.analyzers._
import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder()
    .appName("Deequ Data Quality")
    .getOrCreate()

import spark.implicits._

val analyzerContext = new AnalyzerContext(spark)
Scala1import com.amazon.deequ.analyzers._
2import org.apache.spark.sql.SparkSession
3
4val spark = SparkSession.builder()
5    .appName("Deequ Data Quality")
6    .getOrCreate()
7
8import spark.implicits._
9
10val analyzerContext = new AnalyzerContext(spark)

2. 定义数据质量检查

定义一套数据质量规则,例如检查某列是否非空且值唯一:

val checks = Seq(
  Completeness("column_name").isComplete, // 检查column_name列是否完整
  Uniqueness("unique_column").isUnique // 检查unique_column列是否唯一
)
Scala1val checks = Seq(
2  Completeness("column_name").isComplete, // 检查column_name列是否完整
3  Uniqueness("unique_column").isUnique // 检查unique_column列是否唯一
4)

3. 执行数据质量检查

应用定义好的规则到数据集上:

val dataset = spark.read.parquet("path/to/your/dataset")

val result = VerificationSuite()
    .onData(dataset)
    .addChecks(checks)
    .run()
Scala1val dataset = spark.read.parquet("path/to/your/dataset")
2
3val result = VerificationSuite()
4    .onData(dataset)
5    .addChecks(checks)
6    .run()

4. 分析结果与报告

检查结果包含了每个规则的通过与否及具体详情,可以通过以下方式查看:

result.checkResults.foreach { case (check, checkResult) =>
  println(s"${check.description} --> ${checkResult.status}")
}
Scala1result.checkResults.foreach { case (check, checkResult) =>
2  println(s"${check.description} --> ${checkResult.status}")
3}

Deequ还提供了生成HTML报告的功能,便于分享和存档:

result.writeReports("path/to/reports")

第四部分:高级用法与优化策略

1. 集成Hive

  • 使用Spark的Hive支持读取表数据:
  • val hiveDataset = spark.sql("SELECT * FROM your_hive_table")

2. 自定义检查与约束

Deequ允许用户自定义数据质量检查,以满足特定需求。

3. 性能优化

  • 分区处理:对于大型数据集,考虑按分区或子集处理数据。
  • 资源调整:根据Spark集群资源状况合理分配内存和CPU资源。
作者 east
mysql, Spark 6月 14,2024

PySpark清空mysql的表数据代码(亲测可用)

用PySpark来数据分析和数据仓库操作时,有时需要先清空mysql数据再写入数据。但是pyspark不能直接执行DDL(数据定义语言)操作如TRUNCATE TABLE,这时一种方法是用第三方库,利用 TRUNCATE TABLE 等方法来操作,另外还有一种变通的方法:

直接使用插入空数据的方式来“清空”表并不是传统意义上的清空(truncate或delete操作),但如果你想通过Pyspark实现类似效果,可以考虑先创建一个空的DataFrame,然后覆盖写入到目标表中。这种方式实际上是执行了一个覆盖写入操作,会删除原表数据并用新的空数据集替换。请注意,这种方法会依赖于你的MySQL配置是否允许覆盖写入操作,且在大量数据情况下效率较低。

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType, StructField, StringType

def clear_table_with_pyspark(table_name):
    try:
        # 初始化SparkSession
        spark = SparkSession.builder.getOrCreate()

        # 定义空DataFrame的架构,这里只是一个示例,根据你的表实际结构来定义
        schema = StructType([
            StructField("column1", StringType(), True),  # 更改为你表中的实际列名和类型
            StructField("column2", StringType(), True),  # 可以根据需要添加更多列
            # ...
        ])

        # 创建一个空的DataFrame
        empty_df = spark.createDataFrame(spark.sparkContext.emptyRDD(), schema)

        # JDBC连接字符串
        url = "jdbc:mysql://{host}:{port}/{database}".format(
            host=DB_HOST,
            port=str(DB_PORT),
            database=DB_NAME
        )

        # 使用覆盖写入模式(overwrite)将空DataFrame写入到表中
        empty_df.write \
            .format("jdbc") \
            .option("url", url) \
            .option("dbtable", table_name) \
            .option("user", DB_USER) \
            .option("password", DB_PASSWORD) \
            .option("driver", "com.mysql.jdbc.Driver") \
            .mode("overwrite") \
            .save()

        print(f"Table {table_name} has been emptied using Spark write operation.")
    except Exception as e:
        print(f"Error occurred while clearing table {table_name}: {e}")
        if hasattr(e, 'java_exception'):
            java_exception = e.java_exception
            print("Java exception details:", java_exception)
            print("Java exception message:", java_exception.getMessage())
            print("Java exception stack trace:", java_exception.getStackTrace())

# 调用函数
clear_table_with_pyspark("your_table_name")

请注意,这种方法的一个重要限制是它要求你明确地定义目标表的结构,这可能在表结构复杂或频繁变动时变得不够灵活。此外,对于非常大的表,尽管它能达到“清空”的目的,但效率和资源消耗可能不如直接使用TRUNCATE或DELETE语句。

作者 east
Spark 5月 30,2024

如果调试解决python的Py4JJavaError(u’An error occurred while calling o90.load.\n’, JavaObject id=o91))

在写pyspark代码,连接mysql的表进行查询,代码如下:

def execute_mysql_query(query):
    try:
        # 从数据库加载数据
        url = "jdbc:mysql://" + DB_HOST + ":" + DB_PORT + "/" + DB_NAME
        df = spark.read.format("jdbc") \
            .option("url", url) \
            .option("dbtable", "(" + query + ") as temp") \
            .option("user", DB_USER) \
            .option("password", DB_PASSWORD) \
            .option("driver", "com.mysql.jdbc.Driver") \
            .load()

        # 获取查询结果
        result = df.select(col("count(1)").alias("count")).collect()[0]["count"]
        return result
    except Exception as e:
        print("Error executing query:", e)
        return None

没查到结果并打印结果如下:’Error executing query:’, Py4JJavaError(u’An error occurred while calling o90.load.\n’, JavaObject id=o91),一脸懵逼,不知什么地方出错。

要获取更详细的错误信息,可以通过访问 Py4JJavaError.java_exception 属性来获取 Java 端抛出的异常实例,进而获取其中的错误消息和堆栈信息。下面是修改后的代码示例,以获取更详细的错误信息:

def execute_mysql_query(query):
try:
# 从数据库加载数据
url = “jdbc:mysql://” + DB_HOST + “:” + str(DB_PORT) + “/” + DB_NAME
df = spark.read.format(“jdbc”) \
.option(“url”, url) \
.option(“dbtable”, “(” + query + “) as temp”) \
.option(“user”, DB_USER) \
.option(“password”, DB_PASSWORD) \
.option(“driver”, “com.mysql.jdbc.Driver”) \
.load()

    # 获取查询结果
    result = df.select(col("count(1)").alias("count")).collect()[0]["count"]
    return result
except Exception as e:
    print("Error executing query:", e)
    if hasattr(e, 'java_exception'):
        java_exception = e.java_exception
        print("Java exception details:", java_exception)
        # 输出 Java 异常的错误消息和堆栈信息
        print("Java exception message:", java_exception.getMessage())
        print("Java exception stack trace:", java_exception.getStackTrace())
    return None

重新运行后果然报错信息很详细,查找出具体的问题了。

作者 east
Spark 5月 10,2024

如何限制spark任务占用yarn资源的最大内存和cpu

在使用 spark-submit 提交 PySpark 作业时,可以通过设置一些参数来限制任务占用的 YARN 资源,包括内存和CPU。以下是一些关键的配置选项:

  1. 内存限制:
    • --executor-memory: 为每个执行器设置内存。这是执行器可以使用的最大内存量。
    • --driver-memory: 为驱动器(即提交作业的节点)设置内存。
    • --conf "spark.yarn.executor.memoryOverhead": 为每个执行器设置额外的非堆内存(超出JVM堆内存之外的内存)。
    • --conf "spark.driver.memoryOverhead": 为驱动器设置额外的非堆内存。
  2. CPU限制:
    • --executor-cores: 为每个执行器设置可用的核心数。
    • YARN 本身不直接通过 spark-submit 提供CPU限制参数,因为YARN主要通过内存来调度任务。然而,通过限制每个执行器的核心数,可以间接限制执行器可以使用的CPU资源。
  3. 其他配置:
    • --num-executors: 设置作业的执行器数量。这可以间接控制资源使用,因为过多的执行器可能会占用更多的资源。
    • spark.dynamicAllocation.enabled: 禁用动态分配,试过没加这个,别的设置都有了还是自动动态分配资源。

为了限制作业的最大资源使用,您可以调整上述参数。例如,如果您希望限制作业使用的总内存和CPU,可以这样做:

复制spark-submit --master yarn \
  --deploy-mode cluster \
  --num-executors 10 \          # 设置执行器数量
  --executor-memory 2g \       # 为每个执行器设置2GB内存
  --driver-memory 1g \         # 为驱动器设置1GB内存
  --executor-cores 2 \         # 为每个执行器设置2个核心
  --conf "spark.yarn.executor.memoryOverhead=1024m" \ # 设置每个执行器的非堆内存
  --conf "spark.driver.memoryOverhead=1024m" \        # 设置驱动器的非堆内存
  --conf "spark.dynamicAllocation.enabled=false" \     # 禁用动态分配,避免自动增加执行器
  zinvert_cdh03/pysparkTest.py

请注意,设置资源限制时需要考虑作业的实际需求,以避免资源不足导致作业执行失败。同时,您可能需要与集群管理员协商,以确保作业的资源请求不会超过集群的容量。

另外,spark-submit 命令中的 --conf 参数允许您设置非常多的 Spark 配置选项,包括与资源相关的。您可以通过查看 Spark 的官方文档来了解更多关于这些配置的详细信息。

作者 east
Flink, Hive, Spark, 大数据开发 4月 20,2024

数仓开发LAG 和 LEAD 函数详细解析和用例

在做Iot大数据开发时,需要用到lag和lead函数来计算设备故障。下面详细解析lag和lead函数的作用和例子。

LAG 和 LEAD 函数是用于在 Spark SQL 中进行窗口函数操作时常用的两个函数,它们用于获取某一行在分组内的前一行或后一行的数值。下面详细解释它们的用法:

LAG 函数:

LAG 函数用于获取某一行在分组内的前一行的数值。其语法如下:

sqlCopy CodeLAG(column, offset, default) OVER (PARTITION BY partition_column ORDER BY order_column)
  • column: 要获取值的列。
  • offset: 指定要获取的偏移量,即前面第几行,默认为 1。
  • default: 当无法获取到前一行时的默认值,默认为 NULL。
  • PARTITION BY partition_column: 指定分组的列。
  • ORDER BY order_column: 指定排序的列。

LEAD 函数:

LEAD 函数用于获取某一行在分组内的后一行的数值。其语法如下:

sqlCopy CodeLEAD(column, offset, default) OVER (PARTITION BY partition_column ORDER BY order_column)
  • column: 要获取值的列。
  • offset: 指定要获取的偏移量,即后面第几行,默认为 1。
  • default: 当无法获取到后一行时的默认值,默认为 NULL。
  • PARTITION BY partition_column: 指定分组的列。
  • ORDER BY order_column: 指定排序的列。

示例:

假设有以下数据:

idvalue
110
220
330
440
550

我们可以使用 LAG 函数获取每一行的前一行值:

sqlCopy CodeSELECT id, value, LAG(value, 1) OVER (ORDER BY id) AS lag_value FROM table;

这将返回以下结果:

idvaluelag_value
110NULL
22010
33020
44030
55040

而使用 LEAD 函数则可以获取每一行的后一行值,以类似的方式进行操作。

作者 east
Flink, Spark 4月 11,2024

Spark的Master、Worker、Dirver和Executor,对比Flink的Jobmanager、Taskmanager、Slot异同

首先,我们来了解一下Spark和Flink的基本概念。Spark是一个快速、通用的大规模数据处理引擎,而Flink是一个流式和批处理的开源数据处理框架。它们都用于处理大量数据,但在架构和组件方面有所不同。接下来,我们将用通俗易懂的语言和比喻来解释它们的异同。

  1. Master vs Jobmanager

Spark中的Master负责管理整个集群的资源分配和任务调度。它就像一个公司的CEO,负责制定战略和协调各个部门的工作。而Flink中的Jobmanager也负责任务的调度和资源管理,但它更像是一个项目经理,负责具体项目的执行和监控。

  1. Worker vs Taskmanager

Spark中的Worker负责执行具体的任务,就像公司的员工,按照CEO的指示完成各自的工作。而Flink中的Taskmanager也负责执行任务,但它更像是一个团队,成员之间可以共享资源,协同完成任务。

  1. Driver vs Slot

Spark中的Driver负责协调任务的执行,收集结果并返回给客户端。它就像一个出租车司机,负责接送乘客(任务)到达目的地。而Flink中的Slot是Taskmanager的资源单元,可以理解为一台计算机的一个CPU核心。它就像一个工厂的机床,用于加工生产产品(任务)。

相同之处:

  1. 两者的Master/Jobmanager都负责任务的调度和资源管理。
  2. 两者的Worker/Taskmanager都负责执行具体的任务。
  3. Driver和Taskmanager:在执行用户程序时,都需要接收用户的代码并将其转换为可执行的任务。

不同之处:

  1. Spark的Driver是一个独立的进程,负责协调任务的执行;而Flink没有Driver的概念,任务直接在Taskmanager中执行。
  2. Flink的Slot是资源分配的单位,可以共享资源;而Spark中没有Slot的概念,资源分配是通过Master来实现的。
  3. Spark的Executor一旦启动就会占用固定的资源直到应用程序结束,而Flink的Taskmanager可以通过Slot动态地分配和释放资源,这使得Flink在资源利用上更加灵活。
  4. Flink中的Slot是一个独特的概念,它允许更细粒度的资源管理和任务并发。而Spark的Executor则是单一的执行单元,没有类似Slot的细分。
    Spark的Driver是运行在客户端机器上的一个进程,负责将用户程序转换为RDD(弹性分布式数据集)的操作序列,而Flink的Jobmanager则是负责整个作业的生命周期管理。
作者 east
Flink, Spark 3月 17,2024

Flink跟Spark Streaming的区别

  1. 架构模型:
    • Spark Streaming:基于 Spark 框架,其运行时主要角色包括 Master、Worker、Driver 和 Executor。Driver 负责创建和管理作业,Executor 则执行任务。
    • Flink:独立的实时处理引擎,主要包含 Jobmanager、Taskmanager 和 Slot。Jobmanager 负责作业的管理和调度,Taskmanager 执行具体的任务。
  2. 任务调度:
    • Spark Streaming:通过连续不断地生成微小的数据批次来处理数据。它构建有向无环图DAG,并依次创建 DStreamGraph、JobGenerator 和 JobScheduler。
    • Flink:根据用户提交的代码生成 StreamGraph,经过优化生成 JobGraph,然后提交给 JobManager 进行处理。JobManager 根据 JobGraph 生成 ExecutionGraph,用于任务调度。
  3. 时间机制:
    • Spark Streaming:仅支持处理时间,即处理数据的时间。
    • Flink:支持处理时间、事件时间和注入时间的定义,并引入 watermark 机制来处理滞后数据。
  4. 容错机制:
    • Spark Streaming:可以设置 checkpoint 来恢复任务,但可能会导致重复处理,无法保证恰好一次处理语义。
    • Flink:使用两阶段提交协议来确保精确的一次处理语义,更好地处理容错。
  5. 数据模型:
    • Spark Streaming:基于 DStream(Discretized Stream)模型,将流数据看作是一系列微小批次的静态数据。
    • Flink:采用更灵活的 DataStream 模型,支持各种数据结构和操作。
  6. 应用场景:
    • Spark Streaming:适用于需要与现有 Spark 生态系统集成的场景,如批处理和交互式查询。
    • Flink:更专注于实时处理,提供更丰富的实时处理特性和更好的低延迟性能。
  7. 性能和扩展性:
    • Flink:在处理大流量和高并发场景时通常具有更好的性能和扩展性。
    • Spark Streaming:在某些情况下可能受到 Spark 核心框架的限制。

通过以上对比,我们可以看出Flink和Spark Streaming在架构模型、任务调度、时间机制和容错机制等方面存在显著差异。Flink作为一个基于事件驱动的实时处理引擎,具有更好的时间机制和容错机制,适用于对准确性要求较高的场景。而Spark Streaming作为一个基于微批的流处理引擎,具有较低的延迟和较高的吞吐量,适用于对性能要求较高的场景。在选择流处理框架时,应根据具体需求和场景选择合适的框架。

作者 east
Spark 3月 16,2024

Spark 用AnyFunSuite单元测试Scala详细教程

在用java开发时,通过用Junit框架来测试,在用spark开发scala时,除了可以用Junit,还可以用AnyFunSuite,无需依赖AnyFunSuite。

步骤一:设置项目依赖
确保您的项目中包含了以下必要的依赖:

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-sql_2.11</artifactId>
  <version>2.4.0</version>
</dependency>

org.apache.spark spark-core_2.11 2.4.0 test

<!-- ScalaTest 依赖 -->
<dependency>
  <groupId>org.scalatest</groupId>
  <artifactId>scalatest_2.11</artifactId>
  <version>3.2.9</version>
  <scope>test</scope>
</dependency>

步骤二、编写单元测试
例如下面wordcount的代码

import org.apache.spark.sql.SparkSession

object WordCount {
def wordCount(input: String): Long = {
val spark = SparkSession.builder().appName(“WordCount”).master(“local[*]”).getOrCreate()
val words = spark.sparkContext.parallelize(input.split(” “))
val count = words.count()
spark.stop()
count
}
}
编写单元测试的代码:

import org.scalatest.funsuite.AnyFunSuite

class WordCountTest extends AnyFunSuite {

test(“wordCount should return correct word count”) {
val input = “Hello world, hello Scala”
val expectedResult = 5
val result = WordCount.wordCount(input)
assert(result == expectedResult)
}

}
步骤三:运行单元测试
在 IDEA 中右键点击测试类名或测试方法名,选择 “Run WordCountTest” 或 “Run ‘wordCount should return correct word count'” 来运行单元测试。您也可以点击绿色的三角形按钮执行所有测试用例。

                      

关注公众号“大模型全栈程序员”回复“大数据面试”获取800页左右大数据面试宝典 ,回复“大数据”获取多本大数据电子书

作者 east
Spark 11月 16,2023

spark sql和mysql在用date_format 比较同日、同月上的差异

在Spark SQL和MySQL中,使用date_format函数比较同日、同周、同月上的差异有一些区别。下面我将分别说明它们的用法和差异。

Spark SQL

在Spark SQL中,你可以使用date_format函数来格式化日期,并结合其他函数来比较同日、同周、同月上的差异。

  1. 比较同日的差异:
sqlCopy CodeSELECT *
FROM table_name
WHERE date_format(date_column, "yyyy-MM-dd") = "2023-11-15";
  1. 比较同月的差异:
sqlCopy CodeSELECT *
FROM table_name
WHERE date_format(date_column, "yyyy-MM") = "2023-11";

MySQL

在MySQL中,date_format函数同样可以用于格式化日期,并且可以与其他函数结合来比较同日、同周、同月上的差异。

  1. 比较同日的差异:
sqlCopy CodeSELECT *
FROM table_name
WHERE date_format(date_column, "%Y-%m-%d") = "2023-11-15";
  1. 比较同月的差异:
sqlCopy CodeSELECT *
FROM table_name
WHERE date_format(date_column, "%Y-%m") = "2023-11";

总体来说,虽然在Spark SQL和MySQL中都可以使用date_format函数来格式化日期并进行比较,但在特定情况下需要留意它们在处理周的起始日上的差异。

关注公众号“大模型全栈程序员”回复“大数据面试”获取800页左右大数据面试宝典 ,回复“大数据”获取多本大数据电子书

作者 east

1 2 … 9 下一个

关注公众号“大模型全栈程序员”回复“小程序”获取1000个小程序打包源码。回复”chatgpt”获取免注册可用chatgpt。回复“大数据”获取多本大数据电子书

标签

AIGC AI创作 bert chatgpt github GPT-3 gpt3 GTP-3 hive mysql O2O tensorflow UI控件 不含后台 交流 共享经济 出行 图像 地图定位 外卖 多媒体 娱乐 小程序 布局 带后台完整项目 开源项目 搜索 支付 效率 教育 日历 机器学习 深度学习 物流 用户系统 电商 画图 画布(canvas) 社交 签到 联网 读书 资讯 阅读 预订

官方QQ群

小程序开发群:74052405

大数据开发群: 952493060

近期文章

  • 详解Python当中的pip常用命令
  • AUTOSAR如何在多个供应商交付的配置中避免ARXML不兼容?
  • C++thread pool(线程池)设计应关注哪些扩展性问题?
  • 各类MCAL(Microcontroller Abstraction Layer)如何与AUTOSAR工具链解耦?
  • 如何设计AUTOSAR中的“域控制器”以支持未来扩展?
  • C++ 中避免悬挂引用的企业策略有哪些?
  • 嵌入式电机:如何在低速和高负载状态下保持FOC(Field-Oriented Control)算法的电流控制稳定?
  • C++如何在插件式架构中使用反射实现模块隔离?
  • C++如何追踪内存泄漏(valgrind/ASan等)并定位到业务代码?
  • C++大型系统中如何组织头文件和依赖树?

文章归档

  • 2025年6月
  • 2025年5月
  • 2025年4月
  • 2025年3月
  • 2025年2月
  • 2025年1月
  • 2024年12月
  • 2024年11月
  • 2024年10月
  • 2024年9月
  • 2024年8月
  • 2024年7月
  • 2024年6月
  • 2024年5月
  • 2024年4月
  • 2024年3月
  • 2023年11月
  • 2023年10月
  • 2023年9月
  • 2023年8月
  • 2023年7月
  • 2023年6月
  • 2023年5月
  • 2023年4月
  • 2023年3月
  • 2023年1月
  • 2022年11月
  • 2022年10月
  • 2022年9月
  • 2022年8月
  • 2022年7月
  • 2022年6月
  • 2022年5月
  • 2022年4月
  • 2022年3月
  • 2022年2月
  • 2022年1月
  • 2021年12月
  • 2021年11月
  • 2021年9月
  • 2021年8月
  • 2021年7月
  • 2021年6月
  • 2021年5月
  • 2021年4月
  • 2021年3月
  • 2021年2月
  • 2021年1月
  • 2020年12月
  • 2020年11月
  • 2020年10月
  • 2020年9月
  • 2020年8月
  • 2020年7月
  • 2020年6月
  • 2020年5月
  • 2020年4月
  • 2020年3月
  • 2020年2月
  • 2020年1月
  • 2019年7月
  • 2019年6月
  • 2019年5月
  • 2019年4月
  • 2019年3月
  • 2019年2月
  • 2019年1月
  • 2018年12月
  • 2018年7月
  • 2018年6月

分类目录

  • Android (73)
  • bug清单 (79)
  • C++ (34)
  • Fuchsia (15)
  • php (4)
  • python (43)
  • sklearn (1)
  • 云计算 (20)
  • 人工智能 (61)
    • chatgpt (21)
      • 提示词 (6)
    • Keras (1)
    • Tensorflow (3)
    • 大模型 (1)
    • 智能体 (4)
    • 深度学习 (14)
  • 储能 (44)
  • 前端 (4)
  • 大数据开发 (488)
    • CDH (6)
    • datax (4)
    • doris (30)
    • Elasticsearch (15)
    • Flink (78)
    • flume (7)
    • Hadoop (19)
    • Hbase (23)
    • Hive (40)
    • Impala (2)
    • Java (71)
    • Kafka (10)
    • neo4j (5)
    • shardingsphere (6)
    • solr (5)
    • Spark (99)
    • spring (11)
    • 数据仓库 (9)
    • 数据挖掘 (7)
    • 海豚调度器 (10)
    • 运维 (34)
      • Docker (3)
  • 小游戏代码 (1)
  • 小程序代码 (139)
    • O2O (16)
    • UI控件 (5)
    • 互联网类 (23)
    • 企业类 (6)
    • 地图定位 (9)
    • 多媒体 (6)
    • 工具类 (25)
    • 电商类 (22)
    • 社交 (7)
    • 行业软件 (7)
    • 资讯读书 (11)
  • 嵌入式 (70)
    • autosar (63)
    • RTOS (1)
    • 总线 (1)
  • 开发博客 (16)
    • Harmony (9)
  • 技术架构 (6)
  • 数据库 (32)
    • mongodb (1)
    • mysql (13)
    • pgsql (2)
    • redis (1)
    • tdengine (4)
  • 未分类 (6)
  • 程序员网赚 (20)
    • 广告联盟 (3)
    • 私域流量 (5)
    • 自媒体 (5)
  • 量化投资 (4)
  • 面试 (14)

功能

  • 登录
  • 文章RSS
  • 评论RSS
  • WordPress.org

All Rights Reserved by Gitweixin.本站收集网友上传代码, 如有侵犯版权,请发邮件联系yiyuyos@gmail.com删除.