【SparkSQL】使用IDEA开发Spark SQL程序

目录

创建DataFrame/DataSet

指定列名添加Schema

StructType指定Schema

反射推断Schema

查询

相互转化（RDD  DataFrame DataSet）

WordCount

---

• 创建DataFrame/DataSet

Spark会根据文件信息尝试着去推断DataFrame/DataSet的Schema，当然我们也可以手动指定，手动指定的方式有以下几种：

第1种：指定列名添加Schema

第2种：通过StructType指定Schema

第3种：编写样例类，利用反射机制推断Schema

 

• 指定列名添加Schema

//创建sparkSession
val spark = SparkSession.builder().master("local[*]").appName("test01").getOrCreate()

//通过sparkSession获取sparkContext
val sc= spark.sparkContext
sc.setLogLevel("WARN")

//读取数据，转换为RDD
val datas: RDD[String] = sc.textFile("hdfs://node01:8020/user.txt")
val dataAlls: RDD[(Int, String, Int)] = datas.map(_.split(" ")).map(x => (x(0).toInt, x(1), x(2).toInt))

//转换成DF/DS
//RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
import spark.implicits._
val dfDatas: DataFrame = dataAlls.toDF("id","name","age")

//执行sql语句
//查询所有
dfDatas.show(10)
//获取表结构
dfDatas.printSchema()

//关闭连接
spark.stop()
spark.stop()

 

• StructType指定Schema

StructType方式是不能用DSL方式查询的

//创建SparkSession
val spark = SparkSession.builder().master("local[*]").appName("test02").getOrCreate();

//通过sparkSession获取sparkContext
val sc = spark.sparkContext
sc.setLogLevel("WARN")

//获取数据
val datas: RDD[String] = sc.textFile("hdfs://node01:8020/user.txt")

//处理数据
val datasAll: RDD[Row] = datas.map(x => {
  var line = x.split(" ")
  Row(line(0).toInt, line(1), line(2).toInt)
})

//添加列
val schema: StructType = StructType(Seq(
  StructField("id", IntegerType, true),
  StructField("name", StringType, true),
  StructField("age", IntegerType, true))
)

//创建DataFrame
val personDF: DataFrame = spark.createDataFrame(datasAll, schema)

//显示数据
personDF.show(10)

//显示表结构
personDF.printSchema()

//关闭连接
sc.stop()
spark.stop()

 

• 反射推断Schema

//创建样例类
case class Person(id: Int, name: String, age: Int)

def main(args: Array[String]): Unit = {
   //获取SparkSession
   val spark: SparkSession = SparkSession.builder().master("local[*]").appName("test03").getOrCreate()

   //通过SparkSession创建sparkContext
   val sc = spark.sparkContext
  sc.setLogLevel("WARN")

  //获取数据
  val datas: RDD[String] = sc.textFile("hdfs://node01:8020/user.txt")

  //处理数据
  val dataAlls: RDD[Person] = datas.map(x => {
    val line = x.split(" ")
    Person(line(0).toInt, line(1), line(2).toInt)
  })

  //将RDD转成DF
  // 注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
  import spark.implicits._
  var personDF: DataFrame = dataAlls.toDF

  //显示数据
  personDF.show()

  //查看表结构
  personDF.printSchema()

  //关闭连接
  sc.stop()
  spark.stop()
}

 

• 查询

case class Person(id: Int, name: String, age: Int)

def main(args: Array[String]): Unit = {
  //创建SparkSession
  val spark: SparkSession = SparkSession.builder().master("local[*]").appName("test01").getOrCreate()

  //根据SparkSession获取SparkContext
  val sc: SparkContext = spark.sparkContext
  sc.setLogLevel("WARN")

  //获取数据
  val datas: RDD[String] = sc.textFile("hdfs://node01:8020/user.txt")

  //处理数据
  val dataAlls: RDD[Person] = datas.map(x => {
    var line = x.split(" ")
    Person(line(0).toInt, line(1), line(2).toInt)
  })

  //注意:RDD中原本没有toDF方法,新版本中要给它增加一个方法,可以使用隐式转换
  import spark.implicits._

  //获取df数据
  val dfDatas: DataFrame = dataAlls.toDF()

  //注册表
  dfDatas.createOrReplaceTempView("user")

  //查询所有数据
  spark.sql("select * from user").show()
  //查询age+1
  spark.sql("select age,age+1 from user").show()
  //查询age最大的两人
  spark.sql("select name,age from user order by age desc limit 2").show()
  //查询各个年龄的人数
  spark.sql("select age,count(*) from user group by age").show()
  //查询年龄大于30的
  spark.sql("select * from user where age > 30").show()


  //=======================DSL方式查询=======================
  //查询所有数据
  dfDatas.select("name","age")
  //查询age+1
  dfDatas.select($"name",$"age" + 1)
  //查询age最大的两人
  dfDatas.sort($"age".desc).show(2)
  //查询各个年龄的人数
  dfDatas.groupBy("age").count().show()
  //查询年龄大于30的
  dfDatas.filter($"age" > 30).show()


  //关闭连接
  sc.stop()
  spark.stop()
}

 

• 相互转化（RDD  DataFrame DataSet）

case class Person(id: Int, name: String, age: Int)

def main(args: Array[String]): Unit = {
  //创建SparkSession
  val spark: SparkSession = SparkSession.builder().appName("test08").master("local[*]").getOrCreate()

  //根据SparkSession创建SparkContext
  val sc: SparkContext = spark.sparkContext
  sc.setLogLevel("WARN")

  //获取数据
  val datas: RDD[String] = sc.textFile("hdfs://node01:8020/user.txt")

  //处理数据
  val dataAlls: RDD[Person] = datas.map(x => {
    val line: Array[String] = x.split(" ")
    Person(line(0).toInt, line(1), line(2).toInt)
  })

  //隐式转换
  import spark.implicits._

  //RDD-->DF
  val rddToDf: DataFrame = dataAlls.toDF

  //RDD-->DS
  val rddToDs: Dataset[Person] = dataAlls.toDS()

  //DF-->RDD
  val dfToRdd: RDD[Row] = rddToDf.rdd

  //DS-->RDD
  val dsToRdd: RDD[Person] = rddToDs.rdd

  //DF-->DS
  val dfToDs: Dataset[Person] = rddToDf.as[Person]

  //DS-->DF
  val dsToDf: DataFrame = rddToDs.toDF


  //关闭连接
  sc.stop()
  spark.stop()
}

 

• WordCount

SQL风格

//创建SparkSession
val spark: SparkSession = SparkSession.builder().master("local[*]").appName("test09").getOrCreate()

//根据SparkSession创建SparkContext
val sc: SparkContext = spark.sparkContext
sc.setLogLevel("WARN")

//读取文件
val fileDS: Dataset[String] = spark.read.textFile("hdfs://node01:8020/word.txt")

//对每一行按照空格进行切分并压平
import spark.implicits._
val wordDS: Dataset[String] = fileDS.flatMap(_.split(" "))

//对上面的数据进行WordCount
wordDS.createOrReplaceTempView("t_word")
val sql =
  """
    |select value ,count(value) as count
    |from t_word
    |group by value
    |order by count desc
  """.stripMargin
spark.sql(sql).show()

sc.stop()
spark.stop()

DSL风格

//创建SparkSession
val spark: SparkSession = SparkSession.builder().master("local[*]").appName("test10").getOrCreate()

//根据SparkSession创建SparkContext
val sc: SparkContext = spark.sparkContext
sc.setLogLevel("WARN")

//读取文件
val fileDS: Dataset[String] = spark.read.textFile("hdfs://node01:8020/word.txt")

//对每一行按照空格进行切分并压平
import spark.implicits._
val wordDS: Dataset[String] = fileDS.flatMap(_.split(" ")) //注意:正确,因为DS有泛型,知道_是String

//对上面的数据进行WordCount
wordDS.groupBy("value").count().orderBy($"count".desc).show()

sc.stop()
spark.stop()