RDD de Big Data-Spark

RDD tipo chispa

RDD: conjunto de datos distribuidos elásticos

Caracteristicas

• RDD está compuesto de particiones, cada partición se ejecuta en un trabajador diferente, de esta manera para lograr computación distribuida (Una lista de particiones)
• En RDD, proporcione un operador para procesar los datos en cada partición (una función para calcular cada división)
• RDD tiene dependencias: dependencias anchas y estrechas (Una lista de dependencias en otros RDD)
• Puede personalizar las reglas de partición para crear RDD (Opcionalmente, un Particionador para RDD de valor-clave (El RDD está dividido en hash))
• Seleccione preferentemente nodos cercanos a la ubicación del archivo para ejecutar (Opcionalmente, una lista de ubicaciones preferidas para calcular cada división en (Ubicaciones de bloque para el archivo hdfs))

(1) mecanismo de caché RDD

Identifique que el RDD puede almacenarse en caché (persistir, caché), ejecutar el caché y la segunda ejecución de la declaración solo refleja el efecto

Ubicación de caché

• NINGUNA
• DISK_ONLY
• DISK_ONLY_2
• MEMORY_ONLY
• MEMORY_ONLY_2
• MEMORY_ONLY_SER
• MEMORY_ONLY_SER_2
• MEMORIA_DISCO
• MEMORY_AND_DISK_2
• MEMORY_AND_DISK_SER
• MEMORY_AND_DISK_SER_2
• OFF_HEAP

(2) Mecanismo de tolerancia a fallos de RDD

Tipos de puntos de control RDD

1. Basado en el directorio local
2. Basado en el directorio HDFS

//设置检查点
sc.textFile("hdfs://192.168.138.130:9000/tmp/text_Cache.txt")
//设置检查点目录
sc.setCheckpointDir("hdfs://192.168.138.130:9000/checkpoint")
//执行检查点操作
rdd1.checkpoint

(3) Dependencia de RDD (dependencia amplia, dependencia estrecha)

Dependencia amplia: las particiones de varios RDD secundarios dependerán de la misma partición RDD principal

Dependencias estrechas: cada partición RDD principal es utilizada como máximo por una partición del RDD secundario

La dependencia estrecha es la base para dividir el escenario.

Creación de RDD

(1) Creado por el método SparkContext.parallelize

val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8,9),3)

(2) Creado por una fuente de datos externa

val rdd = sc.textFile("/root/spark_WordCount.text")

Operador RDD

一 、 Transformación

(1) map (func) es equivalente a un bucle for, devolviendo un nuevo RDD

val rdd = sc.parallelize(Array(5,6,1,2,4,3))
val rdd1 = rdd.map(_*2)
rdd1.collect

(2) filtro (func) filtrado

val rdd = sc.parallelize(Array(5,6,1,2,4,3))
val rdd1 = rdd.filter(_>2)
rdd1.collect

（3） flatmap (func) flat + map 压 平

val rdd = sc.parallelize(Array("a b c", "d e f", "g h i"))
val rdd1 = rdd.flatmap(_.split(" "))
rdd1.collect

(4) mapPartitions (func) opera en cada partición de RDD

(5) mapPartitionsWithIndex (func) opera en cada partición de RDD, puede obtener el número de partición

(6) muestra (con Reemplazo, fracción, semilla) muestreo

(7) union (otherDataset) Establecer operación

val rdd = sc.parallelize(List(1,2,3,4,5))
val rdd1 = sc.parallelize(List(1,2,3,4,5,6,7,8))
val rdd2 = rdd.union(rdd1)
rdd2.collect
rdd2.distinct.collect  //去重

val rdd = sc.parallelize(List(("Destiny",1000), ("Freedom",2000)))
val rdd1 = sc.parallelize(List(("Destiny",2000), ("Freedom",1000)))
val rdd2 = rdd.union rdd1
rdd2.collect

(8) operación de conjunto de intersección (otro conjunto de datos)

(9) operación de agregación distinta ([numTasks]) deduplicación

(10) groupByKey ([numTasks])

val rdd = sc.parallelize(List(("Destiny",1000), ("Freedom",2000)))
val rdd1 = sc.parallelize(List(("Destiny",2000), ("Freedom",1000)))
val rdd2 = rdd.union rdd1
val rdd3 = rdd2.groupByKey
rdd3.collect

(11) operación de agregación reduceByKey (func, [numTasks])

val rdd = sc.parallelize(List(("Destiny",1000), ("Freedom",2000)))
val rdd1 = sc.parallelize(List(("Destiny",2000), ("Freedom",1000)))
val rdd2 = rdd.union rdd1
val rdd3 = rdd2.reduceByKey(_+_)
rdd3.collect

(12) agregateByKey (zeroValye) (seqop, combop, [numTasks]) operación de agregación

(13) sortByKey ([asceding], [numTasks]) operación de agregación

(14) sortBy (func, [asceding], [numTasks]) operación de agregación

val rdd = sc.parallelize(Array(5,6,1,2,4,3))
val rdd1 = rdd.sortBy(x => x,true)
rdd1.collect

(15) operación de agregación join (otherDataset, [numTasks]) (16) operación de agregación

cogroup (otherDataset, [numTasks])

val rdd = sc.parallelize(List(("Destiny",1000), ("Destiny",2000), ("Freedom",2000)))
val rdd1 = sc.parallelize(List(("Destiny",2000), ("Freedom",1000)))
val rdd2 = rdd.cogroup(rdd1)
rdd2.collect

(16) operación de agregación cartesiana (otro conjunto de datos)

(17) operación de agregación de tubería (comando, [envVars])

(18) operación de agregación de fusión (numPartitions)

(19) operación de agregación repartition (numPartitions) (20) operación de agregación

repartitionAnSortWithinPartitions (particionador)

Segundo, acción

（1） reducir (func)

val rdd = sc.parallelize(Array(1,2,3,4,5,6))
val rdd1 = rdd.reduce(_+_)
rdd1.collect

（2） collect ()

（3） count ()

（4） first ()

（5） take (n)

（6） takeSample (withReplacement, num, [seed])

（7） takeOrdered (n, [ordering])

（ 8） saveAsTextFile (ruta)

（9） saveAsSequenceFile (ruta)

（10） saveAsObjectFile (ruta)

（11） countByKey ()

（12） foreach (func) 与 mapa 类似 ， 没有 返回 值

Operadores avanzados de RDD

(1) mapPartitionsWithIndex

Opere en cada partición en el RDD, el índice se indica mediante el índice y se puede obtener el número de partición

val rdd = sc.parallelize(List(1,2,3,4,5,6),2)
def func(index: Int, iter: Iterator[Int]): Iterator[String] = {
	iter.toList.map(x => "Index = "+index+", Value = "+x).iterator
}
rdd.mapPartitionsWithIndex(func).collect

（2） agregado

Operación agregada. Agregue primero la parte local, luego agregue la parte global

val rdd = sc.parallelize(List(1,2,3,4,5,6),2)
rdd.aggregate(0)(max(_,_), _+_).collect
rdd.aggregate(0)(_+_, _+_).collect
rdd.aggregate(10)(_+_, _+_) .collect  //51
val rdd = sc.parallelize(List("a","b","c","d","e","f"),2)
rdd.aggregate(*)(_+_, _+_)  //**def*abc

（3） agregadoByKey

Similar al agregado, tipo de datos de valor-clave de operación

val rdd = sc.parallelize(List(("cat",2), ("cat", 5), ("mouse", 4), ("cat", 12), ("dog", 12), ("mouse", 2)),2)
def func(index: Int, iter: Iterator[(String, Int)]): Iterator[String] = {
	iter.toList.map(x => "Index = "+index+", Value = "+x).iterator
}
rdd.mapPartitionsWithIndex(func).collect
import scala.math._
rdd.aggregateByKey(0)(math.max(_,_),_+_).collect
rdd.aggregateByKey(0)(_+_,_+_).collect
<b>（4）coalesce</b><br>
<p>默认不会进行shuffle，默认为false，true为分区</p>

```scala
val rdd = sc.parallelize(List(1,2,3,4,5,6),2)
val rdd1 = rdd.coalesce(3,true)
rdd1.partitions.length

（5） repartición

Barajar por defecto

val rdd = sc.parallelize(List(1,2,3,4,5,6),2)
val rdd1 = rdd.repartition(3)
rdd1.partitions.length

(6) Otros operadores avanzados

http://homepage.cs.latrobe.edu.au/zhe/ZhenHeSparkRDDAPIExamples.html