Structured Streaming

1. import org.apache.spark.sql.types._
2. val pathA = "hdfs:/tpc-ds/data/store_sales"
3. val pathB = "hdfs:/tpc-ds/data/store/"
4. // For Spark 2.x use -> val df = spark.read.option("header", true).csv(path)
5. val A_df = sqlContext.read.format("com.databricks.spark.csv")
6. .option("header","false")
7. .option("inferSchema","false")
8. .option("delimiter","|")
9. .load(pathA)
10. // Assign column names to the Store Sales dataframe
11. val storeSalesDF = A_df.select(
12. A_df("_c0").cast(IntegerType).as("SS_SOLD_DATE_SK"),
13. A_df("_c1").cast(IntegerType).as("SS_SOLD_TIME_SK"),
14. A_df("_c2").cast(IntegerType).as("SS_ITEM_SK"),
15. A_df("_c7").cast(IntegerType).as("SS_STORE_SK")
16. )
17. val B_df = sqlContext.read.format("com.databricks.spark.csv")
18. .option("header","false")
19. .option("inferSchema","false")
20. .option("delimiter","|")
21. .load(pathB)
22. // Assign column names to the Region dataframe
23. val storeDF = B_df.select(
24. B_df("_c0").cast(IntegerType).as("S_STORE_SK"),
25. B_df("_c1").cast(StringType).as("S_STORE_ID")
26. B_df("_c5").cast(StringType).as("S_STORE_NAME")
27. )
28. val joinedDF = storeSalesDF.join(storeDF,
29. storeSalesDF("SS_STORE_SK") === storeDF("S_STORE_SK")
30. )
31. joinedDF.take(5)

What is the full routine of Structured Streaming? 
Let’s look at the code (the example is from the Spark source code and I made some edits): 
val spark = SparkSession  .builder  . 
master("local[2]")  . 
appName("StructuredNetworkWordCount"). 
getOrCreate()

val schemaExp = StructType( 
      StructField("name", StringType, false) :: 
        StructField("city", StringType, true) 
        :: Nil 
    )

//Standard DataSource API, only the read is changed to readStream. 
   val words = spark.readStream.format("json").schema(schemaExp) 
      .load("file:///tmp/dir")

//Some APIs of DataFrame. 
    val wordCounts = words.groupBy("name").count()

//Standard DataSource writing API, only the write is changed to writeStream. 
    val query = wordCounts.writeStream 
//complete,append,update。Currently, 
//only the first two types are supported. 
      .outputMode("complete") 
//The console, parquet, memory, and foreach types 
      .format("console") 
      .trigger(ProcessingTime(5.seconds))//Here is where the timer is set. 
      .start()

query.awaitTermination()

This is the complete routine of Structured Streaming. 
Structured Streaming currently only supports File and Socket sources. It can output four types, as mentioned above. The foreach can be infinitely expanded. For example: 
val query = wordCounts.writeStream.trigger(ProcessingTime(5.seconds)) 
      .outputMode("complete") 
      .foreach(new ForeachWriter[Row] {

var fileWriter: FileWriter = _

override def process(value: Row): Unit = { 
        fileWriter.append(value.toSeq.mkString(",")) 
      }

override def close(errorOrNull: Throwable): Unit = { 
        fileWriter.close() 
      }

override def open(partitionId: Long, version: Long): Boolean = { 
        FileUtils.forceMkdir(new File(s"/tmp/example/${partitionId}")) 
        fileWriter = new FileWriter(new File(s"/tmp/example/${partitionId}/temp")) 
        true 
      } 
    }).start()