sparksql工程小记

　　最近做一个oracle项目迁移工作，跟着spark架构师学着做，进行一些方法的总结。

　　1、首先，创建SparkSession对象（老版本为sparkContext）

　　val session = SparkSession.builder().appName("app1").getOrCreate()

　　2、数据的更新时间配置表，选用mysql,就是说每次结果数据计算写入mysql后，还会将此次数据的更新时间写入数据配置表。 那么在代码里，需要创建配置表的case class,配置与构造数据库schema信息，url，用户名密码等,随后根据配置表中的不同app进行数据的过滤。

　　val appId = "1"

　　case class DBInformation(url:Stirng,schema:String,user:String,passwd:String)

　　val mysqlDB = DBInformation("jdbc:mysql://...."，schema,user,passowrd)

　　val tableName = mysqlDB.schema + "." + name

　　val props = new Properties()

　　props.setProperty("user",mysqlDB.user)

　　props.setProperty("password",mysqlDB.passwd)

　　props.setProperty(JDBCOptions.JDBC_DRIVER_CLASS，"com.mysql.jdbc.Driver")

　　val record = session.read.jdbc(mysqlDB.url,tableName,props).filter(row => row.getAs[Int]("app_id") == appId).take(1)

　　//第一次写入，木有数据

　　if（0 == record.size){

　　　　DBInfoMation(null,null,null)

　　}else{

　　　　DBInfoMation(record(0).getTimestmap(1),recode(0).getTimestamp(2),recode(0)..getTimestamp(3))　　

　　3、注册UDF，由于原来是用oracle的语法，现如今转为sparksql,需要注册一些UDF，来兼容原有oracle的函数

　　def registerUDF(session:SparkSession) : Unit = {

　　　　session.udf.register("UDF",(value : String,modifieds:Array[String) => {

　　　　　　val filter = modifieds.filter(_!=null)

　　　　　　if(!filter.isEmpty){

　　　　　　　　filter.max

　　　　　　}else{

　　　　　　　　null

　　　　　　}

　　　　　})

　　　{

　　4、很多计算是需要过往的历史数据的，在第一次初始化的时候，先对历史数据进行缓存。这里有个知识点，会将一直计算的同步数据进行checkPoint落地磁盘，如果发现历史时间在同步时间之后，则加载历史数据，否则就加载同步数据。

　　val (updateTime,initData) = if(historyTime.after(syncTime)){

　　　　（historyTime,initFromHistory(tableName)）

　　} else {

　　　　(syncTime,initFromCheckPoint(syncTime))

　　}

　　//记录schema

　　schema = initData.schema

　　//baseData为缓存在内存的数据,并根据数据量进行repartition

　　baseData = initData.repartition(numPartitions,_partitionColumns.map(new Column()):_*).rdd.persisit(storageLevel)

　　//触发action动作

　　baseData.foreach(_=>Unit)

　　5、有一种情况，下游三个表要关联生成一张大表，这三张表的数据来源于消息中间件中的三个topic,但是数据可能不是同时到来，那么就需要将历史加载的大表拆根据ID拆分为三个小表，然后逐个append到三个小表上，随后再根据ID关联起来，再组成最终表。

　　val table1 = new createUpdatingTable(session,"tableName1",topicConf,numPartitons,...)

　　val table2 = new createUpdatingTable (session,"tableName2",topicConf1,numPartitions,...)

　　val table3 = new createUpdatingTable(session,"tableName3","topicConf2,numPartitions,...)

　　val mergeBaseTable = (session,"mergeTableName",Array(table1,table2,table3),finallyColumn,finallyPartitions...)

　　mergeBaseTable.updateAndGetData(Some(genDataFilter(currentTime)))

　　//三表拆分与合并

　　val tmpPartitionKey = "pd_code"

　　if(baseData != null) {

　　　　val oldData = getOldData(baseData,keyDF.rdd,tmpPartitionKey)

　　　　oldDf = session.createDataFrame(oldData,schema)

　　　　.repartition(numPartitions,new Column(tmpPartitionKey))

　　　　.persist(storageLevel)

　　}

　　val table1 = updateShardTable(oldDf,inDfs(0)...).sparksession.createDataFrame(data,schema)

　　val table2 = ....

　　val table3 = ....

　　

　　6、三表key进行合并，通过sql进行三来源表合并

　　val keySet = keys.collect()

　　val broadcastKeys = session.sparkContext.broadCast(keySet)

　　baseData.mapPartitions({iter =>

　　　　val set = broadcastKey.value.toSet

　　　　iter.filter(row=>set.contains(row.getAs[Any](keyCol)))

　　},true)

　　val sql ="select a.column,b.column,c.column.... from table1 a left join table2 b on a.pd_code = b.pd_code......

　　val finallyTable = session.sql(sql)

　　7、从历史数据中筛选出此次需要更新的数据（通过ID进行过滤），随后将新数据进行append

　　val new Data = baseData.zipPartitions(updateData，true){case（liter,riter）=>

　　　　val rset = new mutable.HashSet[Any]

　　　　for(row <- riter){

　　　　　　rset.add(row.getAs[Any](keyCol))

　　　　}

　　　　liter.filter(row=>!rset.contains(row.getAs[Any](keyCol))))

　　　　}.zipPartitions(updateData,true){case (liter,riter)=>

　　　　　　liter++riter

　　　　}.persisit(storageLevel)