基于2.11.8版本的DataFrame的使用sql

最新推荐文章于 2024-11-07 18:36:43 发布

lv_yishi

最新推荐文章于 2024-11-07 18:36:43 发布

阅读量597

点赞数

分类专栏：大数据之spark一些例子

本文链接：https://blog.youkuaiyun.com/lv_yishi/article/details/83958480

版权

大数据之spark一些例子专栏收录该内容

16 篇文章

订阅专栏

（1）DataFrame使用

import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

object sparkSqlWC {
  def main(args: Array[String]): Unit = {
    //定义一个sparkSession,getOrCreate相当于单例，如果有SparkSession对象直接使用，没有就直接创建
    val sparkSession = SparkSession.builder().appName("sparkSqlwc").master("local[2]").getOrCreate()
    //得到Dataset的数据集
    val lines: Dataset[String] = sparkSession.read.textFile("D:\\数据\\person.txt")
    lines.show() //没有压平输出的是一行，使用的字段名也是value
    import sparkSession.implicits._ //这里需要一个隐式转换
    val words: Dataset[String] = lines.flatMap(_.split(","))
    //查看count()函数的源码可知道使用count()函数会自动给你定义一个字段为count，所以sort里面可以直接跟count
    val counts: Dataset[Row] = words.groupBy($"value").count().sort($"count")
     counts.show()

    //(2)
    //使用聚合函数,agg是聚合
    import org.apache.spark.sql.functions._
    val res: Dataset[Row] = words.groupBy($"value").agg(count("*") as "counts1").orderBy($"counts1" desc)
    //res.show()

    //(3)
    //使用临时表
    words.createTempView("t_wc")
    val res0: DataFrame = sparkSession.sql("select value,count(*) as counts from t_wc group by value order by counts desc")
   // res0.show()
    sparkSession.stop()
  }
}

（2）从数据库里面读取数据并写到数据库里面

import java.util.Properties
import org.apache.spark.sql.{DataFrame, SparkSession}

object ReadFromMysql {
  def main(args: Array[String]): Unit = {
    val sparkSession = SparkSession.builder().appName("ReadFromMysql").master("local[2]").getOrCreate()

    //从数据库里面读取信息
   val res: DataFrame =  sparkSession.read.format("jdbc").options(
      Map("url"->"jdbc:mysql://192.168.88.130:3306/sessioanalyze",
      "driver"->"com.mysql.jdbc.Driver",
      "dbtable"->"city_info",
      "user"->"root",
      "password"->"root")
    ).load()

    //将数据写入到数据库里面,dataFrame形式
    val props = new Properties()
    props.put("user","root")//连接的参数
    props.put("password","root")
    props.put("driver","com.mysql.jdbc.Driver")
    res.write.mode("append").jdbc("jdbc:mysql://192.168.88.130:3306/sessioanalyze?characterEncoding=utf8","city_info",props)
    //mode里面提供了追加的模式,追加到读取的那个表里面的时候如果存在主键就会报错，

    res.printSchema()//读到的是表的结构信息
    res.show()//读取的是表里面的数据信息
    //如果将RDD写到sql里面需要转为dataFrame
    sparkSession.close()
  }
}

（3）读不同格式文件，并写入

import org.apache.spark.sql.{DataFrame, SparkSession}
//读不同格式文件，并写入
object FileSource {

  def main(args: Array[String]): Unit = {
    val sparkSession = SparkSession.builder().appName("FileRead").master("local[2]").getOrCreate()

    //读取不通格式的文件
    import sparkSession.implicits._
    val df: DataFrame = sparkSession.read.json("D:\\数据\\json.txt")
    //val sparkJson1 = sparkSession.read.format("")//和上面的等价
    //val sparkJson = sparkSession.read.csv("")
    //val sparkJson = sparkSession.read.parquet("")

    //如果需要过滤的是String的字段可以使用临时表的方式
   /* df.createTempView("people")
    val nameDF: DataFrame = sparkSession.sql("select * from people where name='cc'")
    nameDF.show()
    nameDF.write.json("D:\\数据\\1.txt")//如果存到文件里面存的是数据的原始格式，并不是解析出来的格式
*/
    //可以直接使用df.where的方式过滤，但是不能过滤String类型的字符不支持df.where($"name"='cc')
   // val res = df.where($"age">=13)

    //val res = df.filter(df("age")>12).show()//也可以使用这种的格式
    //df.groupBy("age").count().show()//计算同龄的人数

    val res = df.select($"name")//这个是针对的是text类型的输出类型
     res.printSchema()//读到的是表的结构信息

    //写文件,写入的是一个文件夹，里面有具体写的文件
    //res.write.csv("")
    //res.write.json("D:\\数据\\1.txt")//写入文件的格式是源文件的格式

    res.write.text("D:\\数据\\1.txt")
    //Text data source supports only a single column, and you have 2 columns.;
    //Text data source supports only a string column, but you have bigint
    //以上的条件说了text中只支持单字段的格式和只支持String类型的字段，写入的有两个一个是乱码格式的sql语句文件，一个是结果文件

    res.show()
    sparkSession.close()
  }
}

（4）RDD和Datafream和DataSet的几种转换

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}

object change {
  def main(args: Array[String]): Unit = {
    //dataset dataframe转rdd
    val session = SparkSession.builder().appName("tranfrom").master("local[2]").getOrCreate()

    val rdd: RDD[String] = session.read.textFile("D:\\数据\\person.txt").rdd

    //Rdd转为dataframe
    import session.implicits._
    //可以指定列数,这里指定的列名和样例类无关
    val frame: DataFrame = rdd.map(line => (line, 1)).toDF("col1", "col3")
   // val frame: DataFrame = rdd.toDF()//也可以不指定列数，默认的value是列名
    //frame.show()

    //RDD转为dataset，这里也需要隐式转换,需要序列化
    //import session.implicits._
    val ds: Dataset[column] = rdd.map(line=>column(line,1)).toDS()//放到样例类里面序列化
    //ds.show()  //对应的列名column1|column2


    //dataSet 转 DataFrame,这里也需要隐式转换
    //import session.implicits._
    val df: DataFrame = ds.toDF()
    //df.show()  //对应的列名column1|column2

    //dataFrame 转为DataSet
    //import session.implicits._

    //df使用的是column，如果是要将DataFrame变为Dataset需要column和column1的字段名字一样
    val ds2: Dataset[column1] = df.as[column1]
    ds2.show()

  }
}
case class column(column1:String,column2:Int) extends Serializable
case class column1(column1:String,column2:Int) extends Serializable

Spark Shell获取MySQL中的数据

1、启动Spark Shell，必须指定mysql连接驱动jar包

/usr/local/spark-1.6.1-bin-hadoop2.6/bin/spark-shell\
--master spark://node01:7077\
--jars/usr/local/spark-1.6.1-bin-hadoop2.6/mysql-connector-java-5.1.35-bin.jar \
--driver-class-path/usr/local/spark-1.6.1-bin-hadoop2.6/mysql-connector-java-5.1.35-bin.jar

2、从mysql中加载数据

val jdbcDF =sqlContext.read.format("jdbc")
.options(Map("url" ->"jdbc:mysql://node03:3306/bigdata", "driver" ->"com.mysql.jdbc.Driver",
"dbtable" ->"person", "user" -> "root","password" -> "root"))
.load()

3、执行查询

jdbcDF.show()

将数据写入MySQL中并打包上传任务

object InsertData2MySQL {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("InsertData2MySQL").setMaster("local")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
// 获取数据
val linesRDD = sc.textFile("hdfs://node01:9000/test.txt").map(_.split(","))
// 指定schema信息
val schema = StructType{
Array(
StructField("name", StringType, true),
StructField("age", IntegerType, true))
}
// linesRDD映射到Row
val personRDD = linesRDD.map(p => Row(p(0), p(1).toInt))
// 转换成DataFrame
val personDF = sqlContext.createDataFrame(personRDD, schema)
// 封装请求MySQL的配置信息
val prop = new Properties()
prop.put("user", "root")
prop.put("password", "root")
prop.put("driver", "com.mysql.jdbc.Driver")
// 把数据写入MySQL
personDF.write.mode("append").jdbc("jdbc:mysql://node03:3306/bigdata", "person", prop)
sc.stop()
}
}

用maven将程序打包
将Jar包提交到spark集群

/usr/local/spark-1.6.1-bin-hadoop2.6/bin/spark-submit \
--class com.qf.spark.sql.JdbcRDD \
--master spark://node01:7077 \
--jars /usr/local/spark-1.6.1bin-hadoop2.6/mysql-connector-java-5.1.35-bin.jar \
--driver-class-path /usr/local/spark-1.6.1-bin-hadoop2.6/mysql-connector-java-5.1.35-bin.jar \
/root/spark-mvn-1.0-SNAPSHOT.jar