github_28583061
github_28583061

SparkSql

#Spark Sql ##设计目的：

  1. 支持spark Rdd 和外部数据的关系处理
  2. 高性能的关系数据操作
  3. 易于扩展数据源，如半结构化数据，外部数据
  4. 可以被其他高级算法使用如graph,machine learning

##基本流程 SparkSql_第1张图片

###以json文件为例子：对json文件内容进行查询过滤操作

  • 1 . Client 端 读取json文件转换为Dataframe :
    spark.read.json("../../spark/main/resources/people.json")

    • 1.1 构建DataSource对象，数据源 :
      DataSource.apply(sparkSession,paths = paths,..)
    • 1.2 生成统一的数据处理对象baseRelation: BaseRelation，spark sql处理的数据源可以是文件系统中的json文件，纯文本文件等，也可以是关系数据库中的数据jdbc，所以需要抽象成统一的数据处理方式，知道数据结构，以及数据如何读取 ：
      DataSource#resolveRelation(): BaseRelation
    • 1.3 将baseRelation封装成LogicalRelation，主要将schema转换成 AttributeReference 数组
    • 1.4 将LogicalRelation封装成Dataframe,类型为Row的Dataset，先初始化一下QueryExecution检查一下是否可以执行，然后再封装Dataset:
      Dataset.ofRows(self, LogicalRelation(baseRelation))
      • 1.4.1 预先检查一下，初始化QueryExecution， 执行关系查询的工作流，初始化各个阶段的状态analyzed，withCachedData，optimizedPlan，sparkPlan，executedPlan:
        val qe = sparkSession.sessionState.executePlan(logicalPlan) //Dataset
        def executePlan(plan: LogicalPlan): QueryExecution = new QueryExecution(sparkSession, plan) //SessionState
        • 1.4.1.1 分析阶段 analyzed: LogicalPlan
          通过 Analyzer#execute，遍历plan的所有节点应用配置的一系列规则，一系列规则rule，检查查询语句中使用的对象是否准确，如表和列是否存在，是否包含*需要展开，使用的方法是否存在
        • 1.4.1.2 使用缓存 withCachedData: LogicalPlan
          CacheManager#useCachedData ，遍历所有节点查看是否缓存有相同结果的计划
          cachedData.find(cd => plan.sameResult(cd.plan))
        • 1.4.1.3 优化阶段 optimizedPlan: LogicalPlan
          SparkOptimizer#execute,应用一些列优化规则，优化查询逻辑
        • 1.4.1.4 逻辑计划转物理计划 sparkPlan: SparkPlan
          SparkPlanner#plan(plan: LogicalPlan): Iterator[SparkPlan]，对应各种操作的物理计划，包含java代码自动生成
        • 1.4.1.5 准备执行的计划 executedPlan: SparkPlan
          preparations.foldLeft(plan) 在计划执行前应用一些规则 + CollapseCodegenStages，如果支持代码生成，在顶层插入WholeStageCodegenExec物理计划，支持全局代码生成
      • 1.4.2 实例化Dataset[Row]对象也就是Dataframe
        new Dataset[Row](sparkSession, logicalPlan, RowEncoder(qe.analyzed.schema))
        • 1.4.2.1 根据已经分析好的plan的schema初始化RowEncoder,外部的行 和 spark sql内部的二进制表现形式类型的相互转换
          • BooleanType -> java.lang.Boolean
          • StringType -> String
        • 1.4.2.2 初始化QueryExecution ※ 新的对象，没有使用1中初始化的QueryExecution对象
        • 1.4.2.3 实例化Dataset[Row]对象,分析环境准备好
          • this(sparkSession, sparkSession.sessionState.executePlan(logicalPlan), encoder)
          • logicalPlan: LogicalPlan，已经分析好的逻辑计划
          • exprEnc: ExpressionEncoder[T] = encoderFor(encoder)，表达式编码器准备

  • 2 . Client端dataframe的Transformation操作（相当于装饰器模式，一层层添加功能） :
    qf = df.filter("age > 15").select($"age" + 1).limit(100)

    • 2.1 过滤操作filter("age > 15")，解析表达式生成新的Dataset，将原来的逻辑计划添加了GreaterThan过滤的功能，Dataset#filter(conditionExpr: String): Dataset[T]
      • 2.1.1 解析条件语句成表达式，SparkSqlParser#parseExpression(sqlText: String): Expression , "age > 15" ==> GreaterThan 表达式
      • 2.1.2. 将表达式GreaterThan封装成Column对象
      • 2.1.3. 将Column对象封装成Filter逻辑计划, Filter(condition.expr, logicalPlan)
      • 2.1.4. 生成新的Dataset(sparkSession, logicalPlan)返回
    • 2.2. 投影操作select($"age" + 1)，select(cols: Column*): DataFrame
      • 2.2.1. 根据列名称包装成Project逻辑计划
      • 2.2.2. 生成新的Dataset(sparkSession, logicalPlan)返回
    • 2.3. 上限操作limit(100)
      • 2.3.1. 封装成Limit逻辑计划， Limit(Literal(n), logicalPlan)
      • 2.3.2. 生成新的Dataset(sparkSession, logicalPlan)返回
    • 2.4. 总结
      • 2.4.1. 每次Transformation操作都会封装成新的logicPlan
      • 2.4.2. 生成新的QueryExecution： 分析logiclPlan->优化->转化成对应的物理计划->在顶层元素插入全局代码生成物理计划（WholeStateCodegenExec）
      • 2.4.3. 封装成新的Dataset
    • 2.5. 最终QueryExecution结构
      • 逻辑计划结构optimizedPlan: LogicalPlan：
        • GlobalLimit
          • LocalLimit
            + Project
            • Filter
              • LogicalRelation
                • HadoopFsRelation
      • 可执行的物理计划executedPlan: SparkPlan：
        • CollectLimitExec
          • WholeStateCodegenExec
            • ProjectExec
              • FilterExec
                • RowDataSourceScanExec
                  • rdd = FileScanRdd
                  • relation = HadoopFsRelation
                  • schema = StructType

  • 3 . Client端dataframe的Action操作,qf.collect(),执行queryExecution的executedPlan的方法计算
    queryExecution.executedPlan.executeCollect().map(boundEnc.fromRow)

    • 3.1. 执行收集操作，调用顶层对象CollectLimitExec的executeCollect
      executeCollect(): Array[InternalRow] = child.executeTake(limit)
    • 3.2. 获取前n行数据，child 对象为WholeStateCodegenExec是一个SparkPlan,SparkPlan#executeTake
      • 3.2.1. 获取byte数组的RDD,为了快速序列化
        childRDD = getByteArrayRdd(n: Int = -1): RDD[Array[Byte]]
        • 3.2.1.1. 执行物理计划，获取RDD[InternalRow]，每个partion的Iterator应用了查询逻辑生成的代码：
          WholeStageCodegenExec#doExecute: RDD[InternalRow] // sparkPlan的接口方法
          • 3.2.1.1.1. 动态生成代码类 ，(ctx, cleanedSource) = WholeStageCodegenExec#doCodeGen,成员结构:
            实例化方法：
            public Object generate(Object[] references) {
            return new GeneratedIterator(references);}
            }
            逻辑处理迭代类GeneratedIterator：
            final class GeneratedIteratorextends org.apache.spark.sql.execution.BufferedRowIterator
            public void init()//初始化方法
            ${ctx.declareAddedFunctions()}//声明函数
            protected void processNext() //迭代处理函数，最主要的处理方法
            • 3.2.1.1.1.1 processNext(): 每一行数据处理逻辑代码生成 ,内容代码，遍历孩子节点的produce方法，直到最终数据源的produce,
              code = child.asInstanceOf[CodegenSupport].produce(ctx, this)
              • 3.2.1.1.1.1.1 调用WholeStageCodegenExec的child的CodegenSupport接口的produce方法生成代码,既ProjectExec#produce
              • 3.2.1.1.1.1.2 ProjectExec#doProduce调用了child的produce ,既FilterExec#produce
              • 3.2.1.1.1.1.3 FilterExec#doProduce 调用了RowDataSourceScanExec的produce方法
              • 3.2.1.1.1.1.4 RowDataSourceScanExec#doProduce，数据源物理计划,produce负责生产数据，参数准备

              //代码模板，生成代码的结构
              s"""
              |while ($input.hasNext()) { //加载数据，遍历每一行
              | InternalRow $row = (InternalRow) $input.next();
              | $numOutputRows.add(1);
              | ${consume(ctx, columnsRowInput, inputRow).trim}
              | if (shouldStop()) return;
              |}
              """
              - 3.2.1.1.1.1.5 使用当前sparkplan的produce生成的列或者行，会调用parent的doConsumer(),RowDataSourceScanExec#consume - 3.2.1.1.1.1.6 FilterExec#doConsume，实现age>15的过滤代码，调用consume方法，会调用parent的doConsumer() - 3.2.1.1.1.1.7 ProjectExec#doConsumer,字段选择代码，调用consume方法，会调用parent的doConsumer() - 3.2.1.1.1.1.8 WholeStageCodegenExec#doConsumer，结果复制代码生成，consume调用链结束，返回RowDataSourceScanExec#doProduce方法 - 3.2.1.1.1.1.9 最终生成的代码内容：
              `// 每一行处理逻辑生成代码 `
              `while (scan_input6.hasNext()) {`
              ` //获取输入行`
              ` InternalRow scan_row6 = (InternalRow) scan_input6.next();`
              ` scan_numOutputRows6.add(1);`
              ` //判断值是否是null`
              ` boolean scan_isNull13 = scan_row6.isNullAt(0);`
              ` //获取值`
              ` long scan_value13 = scan_isNull13 ? -1L : (scan_row6.getLong(0));`
              ` //null值跳过`
              ` if (!(!(scan_isNull13))) continue;`
              ` boolean wholestagecodegen_isNull2 = false;`
              ` boolean wholestagecodegen_value2 = false;`
              ` // age > 15 的代码 FilterExec的doConsume生成`
              ` wholestagecodegen_value2 = scan_value13 > 15L;`
              ` if (!wholestagecodegen_value2) continue;`
              ` wholestagecodegen_numOutputRows.add(1);`
              ` boolean project_isNull32 = false;`
              ` long project_value32 = -1L;`
              ` // $"age" + 1 的代码 ProjectExec的doConsume生成`
              ` project_value32 = scan_value13 + 1L;`
              ` project_rowWriter8.write(0, project_value32);`
              ` append(project_result8);`
              ` if (shouldStop()) return;`
              `}` - 3.2.1.1.1.1.10 代码生成过程总结： + 起点：从顶层对象WholeStageCodegenExec开始，级联调用child的produce方法 + CodegenSupport代码模型：理解成java中io的装饰器模式，CollectLimitExec，WholeStateCodegenExec，ProjectExec，FilterExec都是增强处理节点（过滤流），RowDataSourceScanExec是最底层数据处理节点（节点流），增强处理节点的produce基本上直接调用child的produce,直到最底层数据处理节点，数据处理节点构造整个代码生成 + produce方法： 构建processNext的处理代码，既每一条记录如何处理的逻辑代码 * 准备好输入对象input，以及下一行对象inputRow等 * 准备while代码，遍历每一行，级联调用parent的consume方法，生成处理这一行代码， + consume方法：逻辑功能处理代码的实现，如：FilterExec -> 过滤功能代码：
              `boolean wholestagecodegen_value2 = false;`
              `wholestagecodegen_value2 = scan_value13 > 15L;`
              `if (!wholestagecodegen_value2) continue;`
          • 3.2.1.1.2. 编译生成的代码,检查编译错误：
            CodeGenerator.compile(cleanedSource)
          • 3.2.1.1.3. 获取数据输入RDD,最终是RowDataSourceScanExec的Rdd，类型FileScanRdd, val rdds = child.asInstanceOf[CodegenSupport].inputRDDs()
            • 解析时DataSourceStrategy，匹配生成：
              toCatalystRDD(l, baseRelation.buildScan())//也就是HadoopFsRelation#buildScan方法生成RDD
          • 3.2.1.1.4. 执行转换操作，将生成的代码逻辑应用到输入Rdd，为每个rdd的partion生成新的Iterator对象，使得Iterator的next方法调用生成代码的processNext方法，也就是应用生成的对每一行数据处理的逻辑
            • 3.2.1.1.4.1 获取第一个Rdd（默认只有一个）,遍历每个partion，每个partion就是一组数据
              • rdds.head.mapPartitionsWithIndex { (index, iter) =>
            • 3.2.1.1.4.2 编译代码获取类clazz：
              • val clazz = CodeGenerator.compile(cleanedSource)
            • 3.2.1.1.4.3 根据编译的类clazz反射实例化对象buffer：
              • val buffer = clazz.generate(references).asInstanceOf[BufferedRowIterator]
            • 3.2.1.1.4.4 初始化buffer,把数据集合传递进去
              • buffer.init(index, Array(iter))
            • 3.2.1.1.4.5 生成新的Iterator，next方法重写为buffer.next()
              • buffer.next()也就是生成代码类GeneratedIterator的processNext方法，包含了生成的处理逻辑代码
        • 3.2.1.2. 执行Rdd转换操作，按格式将RDD[InternalRow]转换为RDD[Array[Byte]],既java object对象转为字节，因为rdd处理时使用的是Byte数组，序列化和传输速度快：
          [size] [bytes of UnsafeRow] [size] [bytes of UnsafeRow] ... [-1]
          • buffer =4k：
            val buffer = new Array[Byte](4 << 10) // 4K
          • 压缩：
            val codec = CompressionCodec.createCodec(SparkEnv.get.conf)
      • 3.2.2. 运行job,遍历每个partion的Iterator,遍历每个元素调用next方法，执行生成代码的逻辑，获取返回数组,主要是RDD执行逻辑FileScanRDD:
        • val res = sc.runJob(childRDD, (it: Iterator[Array[Byte]]) => if (it.hasNext) it.next() else Array.empty, p)
      • 3.2.3. 将返回数组的每个元素从byte数组解码成java对象InternalRow
        • res.foreach { r => decodeUnsafeRows(r.asInstanceOf[Array[Byte]]).foreach(buf.+=) }
      • 3.2.4. limit功能是在最后获取全部结果集后获取前n条记录,最终返回结果：
        • if (buf.size > n) { buf.take(n).toArray } else { buf.toArray }
    • 3.3 InternalRow 转出Java类型，返回数组，collect执行完成
      • map(boundEnc.fromRow)

##基本组件 ##org.apache.spark.sql ##### Datasets

  1. 强类型的分布式数据集合
  2. 可以并行函数转换处理
  3. DataSet的操作分为transformations 和 actions , Transformations 产生新的 DataSet , actions 执行计算返回结果、Dataset用一个逻辑计划描述数据如何处理计算,action调用时,优化逻辑计划,生成物理计划并行高效执行
  4. 通过Encoder
    • 运行时生成的自定义bytecode序列化反序列化,加速,减少网络传输
    • 一些操作无需反序列化就可以操作

#####Encoder

  • 将jvm类型为T的jvm对象转换为spark sql 内部的结构表现
  • 通常由sparksession隐式转换而来
import spark.implicits._
val ds = Seq(1, 2, 3).toDS() // implicitly provided (spark.implicits.newIntEncoder)
  • fields
    • schema : StructType <==
    • clsTag: ClassTag[T] <== 保存类型信息，构造array的时候生成该类型的元素

##org.apache.spark.sql.sources #####BaseRelation

  • 代表一组已知schema的元组tuples，spark sql处理数据的统一方式
  • 统一的数据处理对象，包含了数据结构，以及如何读取数据

##org.apache.spark.sql.catalyst #####InternalRow

  • 在spark sql中内部使用的抽象类，代表一行
  • 只包含列名，和内部对应的类型

##org.apache.spark.sql.catalyst.plans #####QueryPlan

  • 专门指一棵执行计划树
  • QueryPlan的泛型参数仅要求为QueryPlan的子类

##org.apache.spark.sql.catalyst.plans.logical #####LogicalPlan extends QueryPlan[LogicalPlan]

  • LogicalPlan比起QueryPlan扩展了resolve相关的操作，还加上了一个statistics变量。 该变量实际上就是一个BigInt，代表计划的执行代价
  • Statistics－－执行计划的代价估计。默认叶子节点的代价为1，非叶子节点的代价为各子结点代价的乘积。不同类型的执行计划通过重载其statistics函数来改变代价计算方式
  • 方法
    • resolveOperators(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan <== 遍历所有元素应用rule
    • resolve(schema: StructType, resolver: Resolver): Seq[Attribute] <== 将StructType 解析成 Attribute

#####LeafNode extends LogicalPlan

  • 没有子节点的逻辑计划

#####UnaryNode extends LogicalPlan

  • 只有一个子节点

#####BinaryNode extends LogicalPlan

  • 2个子节点

##org.apache.spark.sql.catalyst.expressions #####UnsafeRow extends MutableRow

  • 原始内存数据，二进制数据8-byte word per field，方便快速序列化和传输
  • Each tuple has three parts: [null bit set] [values] [variable length portion]

#####Expression extends TreeNode[Expression]

  • spark sql 语法 或者 api 解析成对应的 experssion，执行时生成相应的java 代码
  • 方法
    • eval(input: InternalRow = null): Any <== 根据输入的internalRow计算结果
    • doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode <== 生成代码

#####LeafExpression extends Expression

  • 没有输入表达式

#####UnaryExpression extends Expression

  • 一个输入，一个输出

#####BinaryExpression extends Expression

  • 两个输入，一个输出

#####UnsafeRow extends MutableRow

  • 由原始内存支持的类型取代java对象，spark内部类型，方便序列化反序列化，内存管理
  • 每个元组有三部分组成
    • ［null bit set］用来跟踪字段是否是null，分配了8个字节标记，每隔字段使用一位表示
    • ［values］每个字段存储一个8字节，保存固定长度字段的类型，对于非固定长度的字段保存offset
Substring(str: Expression, pos: Expression, len: Expression) extends TernaryExpression with ImplicitCastInputTypes
  • string截取操作表达式，生成对应的string截取代码

#####Attribute extends LeafExpression with NamedExpression with NullIntolerant

#####AttributeReference extends Attribute with Unevaluable

  • 在树中由其他操作生成的某个属性的引用
  • 属性名称，属性类型（DataType），是否可空，id

##org.apache.spark.sql.catalyst.expressions.codegen #####ExprCode(var code: String, var isNull: String, var value: String)

  • 给定InternalRow的表达式执行生成的java代码

##org.apache.spark.sql.catalyst.trees #####TreeNode[BaseType <: TreeNode[BaseType]] extends Product

  • 语法树的构建都是由一个个TreeNode组成
  • TreeNode指的是用于构建一般的树的结点

##org.apache.spark.sql.catalyst.analysis #####Analyzer(catalog: Catalog,registry: FunctionRegistry,conf: CatalystConf,maxIterations: Int = 100) extends RuleExecutor[LogicalPlan]

  • sql parser出来的logicalPlan只是针对sql的解析，表是否存在，字段是否存在，字段类型都是未知的
  • 通过rules 和　Catalogj解析属性
  • 解析步骤
    • Looking up relations by name from the catalog.
    • Mapping named attributes, such as col , to the input provided　given operator’s children.
    • Determining which attributes refer to the same value to give them a unique ID
  • batches ， 一系列规则rule，检查关系和操作是否准确
    • ResolveRelations
      • 从catalog中检查UnresolvedRelation的表名和别名是否存在
    • ResolveReferences
      • 检查project投影是否包含*，有的话展开
      • 检查聚合操作是否包含*，如count（*）
      • 检查表连接是否包含有名称冲突的列名
    • ResolveFunctions
      • 检查使用的函数是否存在
  • execute
    • 执行定义的所有ｒｕｌｅ＝＝＞batches

#####UnresolvedRelation

  • sql 中解析的表名或者别名，实际不一定存在

##org.apache.spark.sql.catalyst.encoders #####ExpressionEncoder

  • 通用jvm对象encoder,java对象和spark sql内部数据结构 internalRow的相互转换
  • 字段
    • schema: StructType <== java类型T对应的结构类型，名称列表+类型列表
    • serializer: Seq[Expression] <== 一组表达式 ，表示一个类型T的对象 到 internal row 的转换
    • deserializer: Expression <== 从internalRow转换为对象的表达式
  • 方法
    • toRow(t: T): InternalRow <== 将java对象转换为InternalRow
    • fromRow(row: InternalRow): T <== 将InternalRow转换为java对象

#####RowEncoder

  • 工厂对象，生成 将外部Row转换成spark sql 内部数据对象DataType的子类

##org.apache.spark.sql.types #####DataType -- 数据类型

  • spark sql 使用的基本数据类型的基类
  • 子类
    • BooleanType，IntegerType 等

#####StructType -- 结构类型

  • 结构类型，由StructField（名称，类型，可否空 三个字段） 数组组成

##org.apache.spark.sql.execution #####SparkOptimizer extends Optimizer

  • 查询规则优化
  • batches
    • CombineUnions ，Union操作的优化
    • OptimizeSubqueries，子查询优化
    • ReplaceIntersectWithSemiJoin，交集操作被替换为左连接
    • ReplaceDistinctWithAggregate，distinct操作替换为聚合操作
    • 等等

#####SparkPlan extends QueryPlan[SparkPlan]

  • 物理操作的基类
  • 操作命名规则是名称+Exec结尾
  • 子类：
    • LeafExecNode extends SparkPlan 无字节点
    • UnaryExecNode extends SparkPlan 一个子节点
    • BinaryExecNode extends SparkPlan 两个子节点

#####SparkPlanner (val sqlContext: SQLContext) extends SparkStrategies

  • 将Optimized Logical Plan变为Physical Plan的规则
  • strategies , 一些列转换策略
    • FileSourceStrategy，计划如何扫描一组文件
    • DataSourceStrategy，计划如何扫描数据源，使用数据源的api,如jdbc
    • BasicOperators,基本操作
      • Project ，execution.ProjectExec(projectList, planLater(child)) :: Nil
      • Filter, execution.FilterExec(condition, planLater(child)) :: Nil

#####ProjectExec(projectList: Seq[NamedExpression], child: SparkPlan) extends UnaryExecNode with CodegenSupport

  • 投影逻辑计划的物理操作
  • 投影功能的java代码生成

#####FilterExec(condition: Expression, child: SparkPlan) extends UnaryExecNode with CodegenSupport

  • 过滤计划的物理操作
  • 过滤功能的java代码生成

#####SparkStrategies extends QueryPlanner[SparkPlan]

  • self: SparkPlanner => 必须是sparkPlanner的子类
  • 成员
    • EquiJoinSelection extends Strategy
      • 使用ExtractEquiJoinKeys匹配join操作，根据ｊｏｉｎ的ｋｅｙ和ｓｉｚｅ选择合适的物理计划
      • 通过ExtractEquiJoinKeys匹配选择：
        • Broadcast　：　广播方式ｊｏｉｎ-－小的一边被广播出去
          • 需要ｊｏｉｎ的中有一个物理大小小于指定的值（SQLConf.AUTO_-BROADCASTJOIN_THRESHOLD =10m)
          • 指定需要broadcast方式
        • Shuffle hash join
          • 如果一个分区的平均大小足够小，可以生成一个哈希表
        • Sort merge 　 - 如果匹配的ｋｅｙ可以排序

#####QueryExecution(val sqlContext: SQLContext, val logical: LogicalPlan)

  • 执行关系查询的工作流,可以方便的查询执行过程中的中间阶段的状态，按顺序来是：
    1. analyzed + 解析－－调用Analyzer的execute方法，执行各种规则，返回解析后logicPlan
    2. withCachedData + 使用缓存
    3. optimizedPlan + 执行各种逻辑优化
    4. sparkPlan
      • 根据ｌｏｇｉｃＰｌａｎ的类型生成物理计划
      • LogicalRelation
        • DataSourceStrategy
          • DataSourceScanExec
    5. executedPlan + 在物理计划上扩展 + preparations
      • CollapseCodegenStages
if (conf.wholeStageEnabled) {
                WholeStageCodegenExec
                ...

#####DataSourceScanExec extends LeafExecNode

#####RowDataSourceScanExec extends DataSourceScanExec with CodegenSupport

  • 从一个relation扫描数据的物理计划节点

#####CodegenSupport extends SparkPlan

  • 支持代码生成
  • 方法
    • produce(ctx: CodegenContext, parent: CodegenSupport): String ， 添加注释代码，并调用doProduce生成代码
    • doProduce(ctx: CodegenContext): String ，生成代码，由子类实现具体方法
    • consume(ctx: CodegenContext, outputVars: Seq[ExprCode], row: String = null): String ，
    • doConsume(ctx: CodegenContext, input: Seq[ExprCode], row: ExprCode): String

######InputAdapter(child: SparkPlan) extends UnaryExecNode with CodegenSupport

#####WholeStageCodegenExec(child: SparkPlan) extends UnaryExecNode with CodegenSupport

  • 把计划的所有子树转操作表达式换成java代码封装到一个java方法里
* Here is the call graph of to generate Java source (plan A support codegen, but plan B does not):
 *
 *   WholeStageCodegen       Plan A               FakeInput        Plan B
 * =========================================================================
 *
 * -> execute()
 *     |
 *  doExecute() --------->   inputRDDs() -------> inputRDDs() ------> execute()
 *     |
 *     +----------------->   produce()
 *                             |
 *                          doProduce()  -------> produce()
 *                                                   |
 *                                                doProduce()
 *                                                   |
 *                         doConsume() <--------- consume()
 *                             |
 *  doConsume()  <--------  consume()
 *
 * SparkPlan A should override doProduce() and doConsume().
  • 方法
    • doCodeGen(): (CodegenContext, CodeAndComment) ，调用child的produce方法生成代码
    • doExecute(): RDD[InternalRow] ，调用doCodeGen生成代码，编译并执行代码

##org.apache.spark.sql.execution.joins #####HashJoin

  • self: SparkPlan => 子类必须是sparkPlan的子类
  • spark sql表连接相关的join操作

#####class BroadcastHashJoin() extends BinaryNode with HashJoin

  • 执行两个sparkplan的inner hash join
  • 异步spark job用来计算需要broadcast的关系

##org.apache.spark.sql.execution.datasources #####DataSource

  • 代表spark sql中插件式数据源的主要类 ， 数据源
  • 每种类型的数据源对应各自的数据源提供者对象
    • json ==> JsonFileFormat
    • jdbc ==> JdbcRelationProvider
  • 方法
    • resolveRelation(checkPathExist: Boolean = true): BaseRelation ，创建BaseRelation对象，用来读取和写入数据到该数据源，以json文件为例：
      1. 匹配对应provider类型
      2. 获取dataSchema（推断数据结构），JsonFileFormat#inferSchema ※ 会提交一个job处理
      3. 生成HadoopFsRelation对象（BaseRelation对象）
    • lookupDataSource(provider0: String): Class[_] ， 根据format查找对应的数据源provider
  • 成员
    • providingClass: Class[_] , 数据源提供者
    • backwardCompatibilityMap ， 支持的格式对应的数据源map

##org.apache.spark.sql.execution.datasources.json #####JsonFileFormat extends TextBasedFileFormat with DataSourceRegister

  • json格式的数据源对象
  • 方法
    • inferSchema ， 推断json格式类型，有哪些字段，类型是什么
    • buildReader(): PartitionedFile => Iterator[InternalRow] , 返回一个函数，读取文件并解析json文件
    (file: PartitionedFile) => {
      val linesReader = new HadoopFileLinesReader(file, broadcastedHadoopConf.value.value)
      Option(TaskContext.get()).foreach(_.addTaskCompletionListener(_ => linesReader.close()))
      val lines = linesReader.map(_.toString)
      JacksonParser.parseJson(
        lines,
        requiredSchema,
        columnNameOfCorruptRecord,
        parsedOptions)
    }

#####JdbcRelationProvider extends RelationProvider with DataSourceRegister

  • jdbc数据源 ， 读取jdbc数据以及对应的类型schema
  • 方法
    • createRelation（）: BaseRelation，转换成 BaseRelation

#####LogicalRelation extends LeafNode with MultiInstanceRelation

  • 是一个没有孩子节点的逻辑计划LogicPlan
  • 把schema 转成attribute的集合

##过去的迭代模型 =》Volcano Iterator Model 中文翻译

#主要类层次结构

TreeNode
    QueryPlan
        SparkPlan
            BinaryNode
            LeafNode
            UnaryNode
            CodegenSupport
                FilterExec
                BroadcastHashJoinExec
                RowDataSourceScanExec
                WholeStageCodegenExec
        LocalNode
            BinaryLocalNode
            UnaryLocalNode
            LeafLocalNode
        LogicalPlan
            LeafNode
                UnresolvedRelation
            UnaryNode
            BinaryNode
    Expression
        BinaryExpression
        LeafExpression
            Attribute
                AttributeReference
        UnaryExpression

你可能感兴趣的:(SparkSql)

  • 使用SparkSql进行表的分析与统计 xingyuan8 大数据java
    背景我们的数据挖掘平台对数据统计有比较迫切的需求，而Spark本身对数据统计已经做了一些工作，希望梳理一下Spark已经支持的数据统计功能，后期再进行扩展。准备数据在参考文献6中下载鸢尾花数据，此处格式为iris.data格式，先将data后缀改为csv后缀（不影响使用，只是为了保证后续操作不需要修改）。数据格式如下：SepalLengthSepalWidthPetalLengthPetalWid
  • Spark SQL 结构化数据处理流程及原理是什么？ 我想去吃ya sparksqlhive数据库大数据
    SparkSQL结构化数据处理流程及原理是什么？SparkSQL可以使用现有的Hive元存储、SerDes和UDF。它可以使用JDBC/ODBC连接到现有的BI工具。有了SparkSQL，用户可以编写SQL风格的查询。SparkSQL是Spark生态系统中处理结构化格式数据的模块。它在内部使用SparkCoreAPI进行处理，但对用户的使用进行了抽象。这篇文章深入浅出地告诉你SparkSQL3.x
  • SparkSql 李思缘的大数据之路 sparksparksql
    SparkSQL基本介绍什么是SparkSQL?用于处理结构化数据的Spark模块。可以通过DataFrame和DataSet处理数据。SparkSQL特点1、易整合可以使用java、scala、python、R等语言的API操作。2、统一的数据访问连接到任何数据源的方式相同。3、兼容Hive4、标准的数据连接（JDBC/ODBC）SQL优缺点优点：表达非常清晰，难度低、易学习。缺点：复杂的业务需
  • SparkSQL优化查询性能的方法 大数据海中游泳的鱼 Spark大数据优化spark大数据
    一、PySpark如何提高程序的运行效率和性能PySpark的运行效率和性能受到多个因素的影响，包括数据大小、算法复杂度、硬件资源等。以下是一些提高PySpark程序运行效率和性能的方法：1.使用DataFrame而不是RDDDataFrame比RDD更高效，因为它们使用了更为优化的二进制编码格式和查询引擎。如果可能，尽量使用DataFrame而不是RDD。2.使用广播变量（BroadcastVa
  • Spark-第六周 fightingD&W Sparkspark大数据分布式
    1.sparksql运行流程【Spark精讲】一文讲透SparkSQL执行过程_sparksql执行过程-CSDN博客摸鱼大数据——SparkSQL——SparkSQL的运行机制-CSDN博客2.熟练使用thriftserver服务thriftserver和beeline的使用，代码连接server（连接hive）_thrift连接hive-CSDN博客【八】thriftserver和beelin
  • PySpark，一个超级强大的 Python 库 炒青椒不放辣 Python库之旅pythonPython库之旅PySpark
    大家好！我是炒青椒不放辣，关注我，收看每期的编程干货。一个简单的库，也许能够开启我们的智慧之门，一个普通的方法，也许能在危急时刻挽救我们于水深火热，一个新颖的思维方式，也许能激发我们无尽的创造力，一个独特的技巧，也许能成为我们的隐形盾牌……神奇的Python库之旅，第14章目录一、初识PySpark二、基本操作三、DataFrame和SparkSQL四、机器学习与流处理五、实战案例六、结语七、作者
  • Spark从入门到精通29:Spark SQL：工作原理剖析以及性能优化 勇于自信
    SparkSQL工作原理剖析1.编写SQL语句只要是在数据库类型的技术里面，例如MySQL、Oracle等，包括现在大数据领域的数据仓库，例如Hive。它的基本的SQL执行的模型，都是类似的，首先都是要生成一条SQL语句执行计划。执行计划即从哪里查询，在哪个文件，从文件中查询哪些数据，此外，复杂的SQL还包括查询时是否对表中的数据进行过滤和筛选等等。2.UnresolvedLogicalPlan未
  • Spark SQL编程指南 <>= spark
    SparkSQL编程指南SparkSQL是用于结构化数据处理的一个模块。同SparkRDD不同地方在于SparkSQL的API可以给Spark计算引擎提供更多地信息，例如:数据结构、计算算子等。在内部Spark可以通过这些信息有针对对任务做优化和调整。这里有几种方式和SparkSQL进行交互，例如DatasetAPI和SQL等，这两种API可以混合使用。SparkSQL的一个用途是执行SQL查询。
  • spark CTAS nuion all （union all的个数很多）导致超过spark.driver.maxResultSize配置（2G） 鸿乃江边鸟
    背景该sql运行在spark版本3.1.2下的thriftserver下现象在运行包含多个union的sparksql的时候报错（该sql包含了50多个uinon，且每个union字查询中会包含join操作），其中union中子查询sql类似如下：SELECTa1.order_no,a1.need_column,a1.join_idFROMtemp.actul_aa1jointemp.actul_
  • Quick introduction to Apache Spark Liam_ml
    什么是SparkApacheSpark是一种快速通用的集群计算系统。它提供Java，Scala，Python和R中的高级API，以及支持通用执行图的优化引擎。它还支持一组丰富的更高级别的工具，包括SparkSQL用户SQL和结构化数据处理，MLlib机器学习，GraphX用户图形处理下载从项目网站的下载页面获取Spark。本文档适用于Spark版本2.3.2。Spark使用Hadoop的客户端库来
  • Structured Streaming Francek Chen Spark编程基础sparkzookeeperkafkaStructuredStreaming
    目录一、概述（一）基本概念（二）两种处理模型（三）StructuredStreaming和SparkSQL、SparkStreaming关系二、编写StructuredStreaming程序的基本步骤（一）实现步骤（二）运行测试三、输入源（一）File源（二）Kafka源（三）Socket源（四）Rate源四、输出操作（一）启动流计算（二）输出模式（三）输出接收器一、概述提供端到端的完全一致性是设
  • 入门篇 - Spark简介 君子何为
    Spark核心模块image.pngSparkCore:提供了Spark最基础与最核心的功能，Spark其他的功能如:SparkSQL，SparkStreaming，GraphX,MLlib都是在SparkCore的基础上进行扩展的SparkSQL：Spark用来操作结构化数据的组件。通过SparkSQL，用户可以使用SQL或者ApacheHive版本的SQL来查询数据。SparkStreamin
  • Spark 使用之操作Hudi表 AlienPaul
    HudiSpark使用本篇为大家带来通过Sparkshell和SparkSQL操作Hudi表的方式。Hudi表还可以通过SparkThriftServer操作，参见通过Sparkthriftserver操作Hudi表。Hudi编译我们使用如下软件环境：Scala2.12Flink1.15Spark3.3Hudi0.13.1Hudi编译的时候会遇到依赖下载缓慢的情况。需要换用国内源。修改settin
  • SQL、Hive中的SQL和Spark中的SQL三者联系与区别 大数据ＳＱＬｂｏｙ 数据库SparkHive数据库
    SQL、Hive中的SQL和Spark中的SQL（即SparkSQL）都是用于处理和分析数据的查询语言，但它们在实现、性能、应用场景等方面存在一些明显的区别和联系。联系：分布式计算：三者都是分布式计算的引擎，都可以在大数据集上进行高效的计算和处理。SQL支持：三者都支持SQL语法，用户可以通过SQL语句进行数据查询、分析和处理。处理大规模数据：三者都适用于处理大规模的数据集，可以有效地处理TB甚至
  • spark从入门到放弃二十八:Spark Sql (1)Data Set 意浅离殇
    文章地址：http://www.haha174.top/article/details/257834项目源码：https://github.com/haha174/spark.git1.简介SparkSql是Spark中的一个模块，主要是用于进行结构化数据处理。它提供的最核心的编程抽象，就是DataFrame。同时SparkSql还可以作为分布式sql查询引擎。SaprkSql最重要的功能之一，就
  • 史上最全OLAP对比 只会写demo的程序猿 数仓sparkhadoop数据仓库
    目录1.什么是OLAP2.OLAP引擎的常见操作3.OLAP分类MOLAP的优点和缺点ROLAP的优点和缺点4.并发能力与查询延迟对比5.执行模型对比5.OLAP引擎的主要特点5.2SparkSQL、FlinkSQL5.3Clickhouse5.4Elasticsearch5.5Presto5.6Impala5.7Doris5.8Druid5.9Kylin综上所述:1.什么是OLAPOLAP（On
  • spark sql 数据类型转换_spark sql时间类型转换以及其他 weixin_39535527 sparksql数据类型转换
    1.sparksql的日期转换一般使用两种形式第一种使用to_timestamp(REACHTIME1,"yyyy-MM-ddHH24:mi:ss")//它将字符串时间转换为日期类型例如2018-10-1012:34:43第二种使用时间戳的形式to_timestamp(a.REACHTIME,"yyyy-MM-ddHH24:mi:ss")//转后是1970年至今的时间戳一大长串数据2.如果spar
  • spark sql上线前的调试工作实现 lixia0417mul2 sparksparksql大数据
    背景每个公司应该都有大数据的平台的吧，平台的作用就是可以在上面执行各种sparksql以及定时任务，不过一般来说，由于这些sparksql的上线不经过测试，所以可能会影响到生产的数据，这种情况下大数据平台提供一个上线前的调试功能也就非常好了sparksql上线前的调试工作我们写sparksql主要是用来查询其他hive表的数据，经过数据清洗等操作后写入自己的hive目标表，但是我们hive的目标表
  • Spark Chapter 8 Spark SQL 深海suke
    【参考以慕课网日志分析为例进入大数据Sparksql】0导读SQL：MySQL，Oracle，DB2，SQLServer在大数据平台上实现大数据计算：Hive/SparkSQL/SparkCore直接使用SQL语句进行大数据分析hive的问题：底层MR，2.x之后可以用spark应用场景SQLonHadoop:Hive,Shark(不维护了)，Impala（Cloudera，内存使用较多），Pre
  • Spark简介 麦克阿瑟99
    Spark作为第二代大数据处理工具，跟hadoop对比，它是基于内存的，所以在迭代计算方便速度有了很大提升。我用到的主要是SparkCore,SparkSQL,SparkStreaming。Spark以Rdd作为基础，Rdd是一个分布式的容器，类似于java中的String数组，但是它是分布式的。Rdd中有各种算子，总的来说分为转化算子和行动算子，转换算子不触到真正的计算，当执行到行动算子时才会触
  • Spark视频第5期：Spark SQL架构和案例深入实战 Rocky_wangjialin Spark培训Spark企业内训Spark公开课Spark视频王家林
    SparkSQL架构和案例深入实战视频下载：http://pan.baidu.com/share/link?shareid=3629554384&uk=4013289088&fid=977951266414309王家林老师(邮箱：[email protected]:1740415547)Spark亚太研究院院长和首席专家，中国目前唯一的移动互联网和云计算大数据集大成者。在Spark、Had
  • SparkSQL on K8s 在网易传媒的落地实践 wangyishufan kubernetes大数据数据分析
    【作者：鲁成祥易顺】随着云原生技术的发展和成熟，大数据基础设施积极拥抱云原生是业内发展的一大趋势。网易传媒在2021年成功将SparkSQL部署到了K8s集群，并实现与部分在线业务的混合部署，到目前已经稳定运行了一年多。期间传媒联合杭研Spark内核团队和云计算团队对出现的问题进行了持续的改进，本文将对这些落地优化实践进行初步的梳理总结，希望能给大家带来一些有用的参考。目前，传媒大数据中心的大部分
  • PySpark（四）PySpark SQL、Catalyst优化器、Spark SQL的执行流程 独憩 PySparksql数据库pythonspark
    目录PySparkSQL基础SparkSession对象DataFrame入门DataFrame构建DataFrame代码风格DSLSQLSparkSQLShuffle分区数目DataFrame数据写出SparkUDFCatalyst优化器SparkSQL的执行流程PySparkSQL基础PySparkSQL与Hive的异同Hive和Spark均是:“分布式SQL计算引擎”均是构建大规模结构化数据
  • SparkSql---用户自定义函数UDF&&UDAF 肥大毛 scala大数据sparkspark大数据分布式
    文章目录1.UDF2.UDAF2.1UDF函数实现原理2.2需求:计算用户平均年龄2.2.1使用RDD实现2.2.2使用UDAF弱类型实现2.2.3使用UDAF强类型实现1.UDF用户可以通过spark.udf功能添加自定义函数，实现自定义功能。如：实现需求在用户name前加上"Name:"字符串，并打印在控制台defmain(args:Array[String]):Unit={//创建上下文环境
  • SparkSql---RDD DataFrame DataSet 肥大毛 大数据jsonsqlhivehadoopspark
    文章目录1.DataFrame2.DataSet3.RDD、DataFrame、DataSet三者的关系4.使用SQL操作DataFrame类型的数据4.1DSL语法4.2RDD转换为DataFrame4.3DataFrame转换为RDD5.使用SQL操作DataSet的数据5.1使用样例类序列创建DataSet5.2DataSet转换为RDD5.3DataSet和DataFrame相互转换1.D
  • SparkSql读取外部Hql文件的公共类开发 岁月的眸 #Hive总结#Spark总结大数据hive大数据spark
    SparkSql读取外部Hql文件的公共类开发SparkSQL与Hive的区别简介一、什么是SparkSQL？（官方定义）SparkSQLASparkmoduleforstructureddataprocessing(knownsetoffieldsforeachrecord-schema);SparkSQL是Spark中专门用来处理结构化数据（每一行数据都遵循Schema信息——建表时表的字段及
  • Python调用pyspark报错整理 赫加青空 Pythonspark大数据python开发语言
    前言Pycharm配置了SSH服务器和Anaconda的python解释器，如果没有配置可参考大数据单机学习环境搭建(8)Linux单节点Anaconda安装和Pycharm连接Pycharm执行的脚本执行如下pyspark_model.py的python脚本，构建SparkSession来执行sparksql"""脚本名称：Pycharm使用pyspark测试功能：Pycharm远程执行spar
  • Fink CDC数据同步（三）Flink集成Hive 苡~ flinkhive大数据
    1目的持久化元数据Flink利用Hive的MetaStore作为持久化的Catalog，我们可通过HiveCatalog将不同会话中的Flink元数据存储到HiveMetastore中。利用Flink来读写Hive的表Flink打通了与Hive的集成，如同使用SparkSQL或者Impala操作Hive中的数据一样，我们可以使用Flink直接读写Hive中的表。2环境及依赖环境：vim/etc/p
  • 2019-03-16 Spark基本架构及运行原理 做一只乐观的小猴子
    SparkCore:包含Spark的基本功能，包含任务调度，内存管理，容错机制等，内部定义了RDDs(弹性分布式数据集)，提供了很多APIs来创建和操作这些RDDs。为其他组件提供底层的服务。SparkSQL:Spark处理结构化数据的库，就像HiveSQL,Mysql一样，企业中用来做报表统计。SparkStreaming:实时数据流处理组件，类似Storm。SparkStreaming提供了A
  • [Scala学习笔记] Spark开发小笔记 Rinnki Scala笔记学习笔记ScalaSpark图
    Spark开发小笔记：从0开始的Spark建图生活持续更新中……0.开发平台Zeppelin支持多种语言，默认是scala(背后是sparkshell)，SparkSQL,Markdown和Shell。是一个基于web的笔记本，支持交互式数据分析。你可以用SQL、Scala等做出数据驱动的、交互、协作的文档。1.RDDSpark里的计算都是操作RDD进行，那么学习RDD的第一个问题就是如何构建RD
  • 异常的核心类Throwable 无量 java源码异常处理exception
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy package com.natsu;
  • mongoDB 游标（cursor） 实现分页 迭代 开窍的石头 mongodb
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询      如何声明一个游标        var mycursor = db.user.find({_id:{$lte:5}});       迭代显示游标数
  • MySQL数据库INNODB 表损坏修复处理过程 0624chenhong tomcatmysql
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
  • 剖析如何与设计人员沟通 不懂事的小屁孩 工作
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 那应该如何与设计人员沟通呢？ 我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
  • qq空间刷评论工具 换个号韩国红果果 JavaScript
    var a=document.getElementsByClassName('textinput'); var b=[]; for(var m=0;m<a.length;m++){ if(a[m].getAttribute('placeholder')!=null) b.push(a[m]) } var l
  • S2SH整合之session 灵静志远 springAOPstrutssession
    错误信息： Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
  • xmp标签 a-john 标签
    今天在处理数据的显示上遇到一个问题： var html = '<li><div class="pl-nr"><span class="user-name">' + user + '</span>' + text + '</div></li>'; ulComme
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单 aijuans Ajax
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
  • 天-安-门，好高 atongyeye 情感
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。     晚上躺在床上一个人想了很久，很久。        我生在农
  • android 动画 百合不是茶 android透明度平移缩放旋转
    android的动画有两种  tween动画和Frame动画   tween动画;,透明度,缩放,旋转,平移效果   Animation   动画 AlphaAnimation 渐变透明度 RotateAnimation 画面旋转 ScaleAnimation 渐变尺寸缩放 TranslateAnimation 位置移动 Animation
  • 查看本机网络信息的cmd脚本 bijian1013 cmd
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt" @echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt" @echo ___________________>>"%userprofile%\
  • plsql 清除登录过的用户 征客丶 plsql
    tools---preferences----logon history---history  把你想要删除的删除 -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一起进步。 email ： binary_spac
  • 【Pig一】Pig入门 bit1129 pig
    Pig安装 1.下载pig   wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz   2. 解压配置环境变量      如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量   expor
  • Java 线程同步几种方式 BlueSkator volatilesynchronizedThredLocalReenTranLockConcurrent
    为何要使用同步？      java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），      将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，      从而保证了该变量的唯一性和准确性。 1.同步方法&
  • StringUtils判断字符串是否为空的方法（转帖） BreakingBad nullStringUtils“”
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html   public static boolean isEmpty(String str)   　　判断某字符串是否为空，为空的标准是 str== null  或 str.length()== 0  
  • 编程之美-分层遍历二叉树 bylijinnan java数据结构算法编程之美
    import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class LevelTraverseBinaryTree { /** * 编程之美 分层遍历二叉树 * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
  • jquery取值和ajax提交复习记录 chengxuyuancsdn jquery取值ajax提交
    // 取值 // alert($("input[name='username']").val()); // alert($("input[name='password']").val()); // alert($("input[name='sex']:checked").val()); // alert($("
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression comsci java应用服务器工作Excel嵌入式
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 ----------转帖--------------------------------------------------- IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer daizj spring
    1、PropertyPlaceholderConfigurer Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 基本的使用方法是：(1) <bean id="propertyConfigurerForWZ&q
  • 二叉树:二叉搜索树 dieslrae 二叉树
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. tree代码:
  • C语言字符串函数大全 dcj3sjt126com cfunction
    C语言字符串函数大全     函数名: stpcpy 功 能: 拷贝一个字符串到另一个 用 法: char *stpcpy(char *destin, char *source); 程序例:   #include <stdio.h> #include <string.h>   int main
  • 友盟统计页面技巧 dcj3sjt126com 技巧
    在基类调用就可以了, 基类ViewController示例代码 -(void)viewWillAppear:(BOOL)animated { [super viewWillAppear:animated]; [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 flyvszhb javajdk
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 安装jdk1.6前，执行java -version得到 C:\Users\liuxiang2>java -version java version "1.7.0_21&quo
  • Java在创建子类对象的同时会不会创建父类对象 happyqing java创建子类对象父类对象
      1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象，   2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
  • 跟我学spring3 目录贴及电子书下载 jinnianshilongnian spring
        一、《跟我学spring3》电子书下载地址： 《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf     跟我学spring3系列 word原版 下载     二、 源代码下载 最新依
  • 第12章 Ajax（上） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • BI and EIM 4.0 at a glance blueoxygen BO
    http://www.sap.com/corporate-en/press.epx?PressID=14787   有机会研究下EIM家族的两个新产品~~~~   New features of the 4.0 releases of BI and EIM solutions include: Real-time in-memory computing –
  • Java线程中yield与join方法的区别 tomcat_oracle java
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 &nb
  • android Manifest.xml选项 阿尔萨斯 Manifest
    结构 继承关系 public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 内部类 class Manifest.permission权限 class Manifest.permission_group权限组 构造函数 public Manifest () 详细 androi
  • Oracle实现类split函数的方 zhaoshijie oracle
    关键字：Oracle实现类split函数的方 项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); cr
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他