spark-sql

最新推荐文章于 2024-12-04 22:41:31 发布
最新推荐文章于 2024-12-04 22:41:31 发布
阅读量314 收藏
点赞数
分类专栏： scala和spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52106226/article/details/112197646
版权

在spaek-shell端演示

1.val rdd1 =sc.textFile(“hdfs://linux01:8020/1.txt”)
2.case class User(id:Long , name:String , age:Int , fv:Double)

3.rdd1.map(e => {val fields = e.split(",")
User(fields(0).toLong , fields(1) , fields(2).toInt , fields(3).toDouble)})

4.val df = res1.toDF 转成dataframe
5.df.printSchema
6.df.createTempView(“v_user”) 注册成视图(一个特殊的表)
7.spark
8.val df2 = spark.sql(“SELECT name , age , fv FROM v_user ORDER BY fv DESC, age ASC”)
9.df2.show

desc是倒叙
asc是正序
在这里插入图片描述
在这里插入图片描述

还有一种方法
df.select(“name” , “age” , “fv”).orderBy($“fv” desc).show
在这里插入图片描述

使用多种方法创建DateFrame

第一种将RDD关联Case class创建DateFrame

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SparkSession}
//将RDD关联Case class创建DateFrame
object DataFrameCreatDemo01 {
  def main(args: Array[String]): Unit = {
    //创建SparkConf,然后创建SparkContext
    //使用SparkContext创建RDD
    //调用RDD的算子(Teansformation和Action)
    //释放资源sc.stop

    //创建SparkSession(是对SparkContext的包装和增强)
    val spark = SparkSession.builder()
      .appName("DataFrame")
      .master("local[*]")
      .getOrCreate()

    val sc = spark.sparkContext
    val rdd1: RDD[String] = sc.textFile("hdfs://linux01:8020/1.txt")
    val userRDD: RDD[User] = rdd1.map(e => {
      val fields = e.split(",")
      User(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })
    //导入隐式转换
    import spark.implicits._
    //将RDD转成特殊的数据集
    val df: DataFrame = userRDD.toDF
    //使用两种风格的API

    //SOL风格
    df.createTempView("v_user")
    val df2 = spark.sql("select id,name , fv from v_user order by fv")
    //show只是默认显示20 行,如果想看更多可以向括号里写
    df2.show()

    //DSL(特定领域语法)
    //不用注册视图
    val df3 = df.select("id", "name", "fv") orderBy($"fv".desc, $"age".desc)
    df3.show()

  }
}
case class User(id:Long , name:String , age:Int , fv: Double )

将RDD关联scala class创建DataForame

import org.apache.spark.sql.SparkSession
import org.apache.spark.storage.StorageLevel

import scala.beans.BeanProperty

//将RDD关联scala class创建DataForame
object DataFrameCreatDemo02 {
  def main(args: Array[String]): Unit = {
    //创建SparkSession(是对SparkContext的包装和加强)
    val session = SparkSession.builder()
      .appName("DataFrameCreatDemo02")
      .master("local[*]")
      .getOrCreate()

    val sc = session.sparkContext
    val rdd1 = sc.textFile("hdfs://linux01:8020/1.txt")
    val PersonRDD = rdd1.map(e => {
      val fields = e.split(",")
      new Person(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })
//    PersonRDD.persist(StorageLevel.DISK_ONLY)
//    PersonRDD.count()
    //将RDD转换成特殊的数据集    参数一rdd  参数二类型
val df = session.createDataFrame(PersonRDD, classOf[Person])

      //SQL风格
    df.createTempView("v_user")
    val df2 = session.sql("select id ,name , fv from v_user order by fv desc ,age asc")
    df2.show()

  }

}
class Person(//因为没有get和set方法所以打上注解
            @BeanProperty
              val id :Long,
            @BeanProperty
              val name: String,
            @BeanProperty
              val age :Int,
            @BeanProperty
              val fv :Double
            )

最正宗的 将RDD中的数据转成row,并关联schema

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types.{DoubleType, IntegerType, LongType, StringType, StructField, StructType}
import org.apache.spark.sql.{Row, SparkSession}

//将RDD中的数据转成row,并关联schema
object DataFrameCreatDemo03 {
  def main(args: Array[String]): Unit = {
    //创建SparkSession(是对SparkContext的包装和增强)
    val session = SparkSession.builder()
      .appName("DataFrameCreatDemo03")
      .master("local[*]")
      .getOrCreate()
    val sc = session.sparkContext
    val rdd1 = sc.textFile("hdfs://linux01:8020/1.txt")

    //row的字段没有类型没有名称
    val rowRDD: RDD[Row] = rdd1.map(e => {
      val fields = e.split(",")
      Row(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })

    //关联schema(字段名称,数据类型,是否可以为空)
    val schema = StructType(
      Array(
        StructField("id",LongType),
        StructField("name",StringType),
        StructField("age",IntegerType),
        StructField("fv",DoubleType)
      )
    )
    //将RowRDD和StructType类型的Schema进行关联
    val df = session.createDataFrame(rowRDD, schema)
    //打印字段名称和字段类型
    df.printSchema()
    df.show()

  }

}

通过DJSON文件创建DataFrame

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

//通过DJSON文件创建DataFrame
object CreatDataFreamFromJSON {
  def main(args: Array[String]): Unit = {
    //创建SparkSession(是对SparkContext的包装和增强)
    val spark = SparkSession.builder()
      .appName(this.getClass.getSimpleName)
      .master("local[*]")
      .getOrCreate()

    //RDD数据从哪里读取
    //schema:字段名,类型(json文件中自带schema属性)
    val df: DataFrame = spark.read.json("D:\\ideawork\\spark\\src\\main\\scala\\cn\\_51doit\\demo05DateFrame\\user.json")


//    df.createTempView("v_user")
    //_corrupt_record脏数据
//    val df2 = spark.sql("select name , fv ,age from v_user where _corrupt_record is null")
//     df2.show()



    //DSL方法   要给$这个特殊的方法导包
    import spark.implicits._
    val df2 = df.select("name", "fv", "age").where($"_corrupt_record".isNull)
    df2.show()

  }

}

将读到的数据写成JSON文件

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types.{DoubleType, IntegerType, LongType, StringType, StructField, StructType}
import org.apache.spark.sql.{Row, SparkSession}

//将RDD中的数据转成row,并关联schema
object WriteToJSON {
  def main(args: Array[String]): Unit = {
    //创建SparkSession(是对SparkContext的包装和增强)
    val session = SparkSession.builder()
      .appName("DataFrameCreatDemo03")
      .master("local[*]")
      .getOrCreate()
    val sc = session.sparkContext
    val rdd1 = sc.textFile("hdfs://linux01:8020/1.txt")

    //row的字段没有类型没有名称
    val rowRDD: RDD[Row] = rdd1.map(e => {
      val fields = e.split(",")
      Row(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })

    //关联schema(字段名称,数据类型,是否可以为空)
    val schema = StructType(
      Array(
        StructField("id",LongType),
        StructField("name",StringType),
        StructField("age",IntegerType),
        StructField("fv",DoubleType)
      )
    )
    //将RowRDD和StructType类型的Schema进行关联
    val df = session.createDataFrame(rowRDD, schema)
    //把获得的数据转成json写本地
    df.write.json("d:/aaa/222/out")

    session.stop()
  }
}

通过csv文件创建DataFrame

import org.apache.spark.sql.SparkSession
//通过csv文件创建DataFrame
object CreatDataFreamFromCSV {
  def main(args: Array[String]): Unit = {
    //创建SparkSession(是对SparkContext的包装和加强)
    val spark = SparkSession.builder()
      .appName(this.getClass.getCanonicalName)
      .master("local[*]")
      .getOrCreate()
    //RDD数据从哪里读数据
    //schema:字段名称,类型(csv文件自带schema属性)
    val df = spark.read
      .option("header", "true") //将第一行当作表头
      .option("inferSchema", "true") //推断数据类型
      .csv("D:\\ideawork\\spark\\src\\main\\scala\\cn\\_51doit\\demo05DateFrame\\user.csv")
    //修改名称
    //val df2 = df.toDF("name", "age", "fv")
    df.show()
    df.printSchema()
    Thread.sleep(100000000)
  }

}

将读到的数据写成csv文件

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types._
import org.apache.spark.sql.{Row, SparkSession}

//将RDD中的数据转成row，并关联schema
object WriteToCsv {

  def main(args: Array[String]): Unit = {

    //创建SparkSession(是对SparkContext的包装和增强)
    val session: SparkSession = SparkSession.builder()
      .appName("DataFrameCreateDemo01")
      .master("local[*]")
      .getOrCreate()

    val sc = session.sparkContext
    val rdd1: RDD[String] = sc.textFile("hdfs://linux01:8020/1.txt")

    //row的字段没有类型，没有名称
    val rowRDD: RDD[Row] = rdd1.map(e => {
      val fields = e.split(",")
      Row(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })

    //关联schema(字段名称，数据类型，是否可以为空)
    val schema = StructType(
      Array(
        StructField("id", LongType),
        StructField("name", StringType),
        StructField("age", IntegerType),
        StructField("fv", DoubleType),
      )
    )
    //将RowRDD和StructType类型的Schema进行关联
    val df = session.createDataFrame(rowRDD, schema)
//以csv格式写出括号里写出路径
    df.write.csv("d:/aaa/222/outcsv2")

    session.stop()

  }
}

通过JDBC文件创建DataFream(从mysql中读文件)

import java.util.Properties

import org.apache.spark.sql.SparkSession

object CreatDataFreamFromJDBC {
  def main(args: Array[String]): Unit = {
    //通过JDBC文件创建DataFream
    //创建SparkSession(是对SparkContext的包装和增强)
    val spark = SparkSession.builder()
      .appName(this.getClass.getSimpleName)
      .master("local[*]")
      .getOrCreate()
    //获取连接数据库的用户名密码
    val properties = new Properties()
    properties.setProperty("user","root")
    properties.setProperty("password","123456")
//一定要有schema信息
    //在执行时调用read.jdbc方法一定要获取数据库表的信息
    //read.jdbc是在Driver端跟数据库查询,返回指定表的schema信息
    val df = spark.read.jdbc("jdbc:mysql://localhost:3306/doit_19?characterEncoding=utf-8", "tb_user", properties)

    df.show()
    Thread.sleep(100000000)
  }

}

将读到的数据写到mysql中

import java.util.Properties

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types._
import org.apache.spark.sql.{DataFrame, Row, SaveMode, SparkSession}

//将RDD中的数据转成row，并关联schema
object WriteToJDBC {

  def main(args: Array[String]): Unit = {

    //创建SparkSession(是对SparkContext的包装和增强)
    val session: SparkSession = SparkSession.builder()
      .appName("WriteToJDBC")
      .master("local[*]")
      .getOrCreate()

    val sc = session.sparkContext
    val rdd1: RDD[String] = sc.textFile("hdfs://linux01:8020/1.txt")

    //row的字段没有类型，没有名称
    val rowRDD: RDD[Row] = rdd1.map(e => {
      val fields = e.split(",")
      Row(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })

    //关联schema(字段名称，数据类型，是否可以为空)
    val schema = StructType(
      Array(
        StructField("id", LongType),
        StructField("name", StringType),
        StructField("age", IntegerType),
        StructField("fv", DoubleType),
      )
    )
    //将RowRDD和StructType类型的Schema进行关联
    val df = session.createDataFrame(rowRDD, schema)

    val properties = new Properties()

    properties.setProperty("user","root")
    properties.setProperty("password","123456")

    //ErrorIfExists如果输出的目录或表已经存在就报错
    //Append 追加
    //Overwrite 将原来的目录或数据库表删除，然后在新建目录或表将数据写入
    //Ignore 没有就写入，有就什么都不做
    df.write.mode(SaveMode.Overwrite).jdbc("jdbc:mysql://localhost:3306/doit_19?characterEncoding=utf-8", "tb_doit19", properties)

    session.stop()

  }
}

将从hdfs上读到的文件改成parquet格式写如本地

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types._
import org.apache.spark.sql.{Row, SparkSession}

object WriteToParquet {

  def main(args: Array[String]): Unit = {

    //创建SparkSession(是对SparkContext的包装和增强)
    val session: SparkSession = SparkSession.builder()
      .appName("DataFrameCreateDemo01")
      .master("local[*]")
      .getOrCreate()

    val sc = session.sparkContext
    val rdd1: RDD[String] = sc.textFile("hdfs://linux01:8020/1.txt")

    //row的字段没有类型，没有名称
    val rowRDD: RDD[Row] = rdd1.map(e => {
      val fields = e.split(",")
      Row(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })

    //关联schema(字段名称，数据类型，是否可以为空)
    val schema = StructType(
      Array(
        StructField("id", LongType),
        StructField("name", StringType),
        StructField("age", IntegerType),
        StructField("fv", DoubleType),
      )
    )
    //将RowRDD和StructType类型的Schema进行关联
    val df = session.createDataFrame(rowRDD, schema)

    df.write.parquet("d://aaa//222//par")

    session.stop()

  }
}

读取本地的parquet文件

import org.apache.spark.sql.SparkSession

object CreateDataFrameFromParquet {
  def main(args: Array[String]): Unit = {
    //创建SparkSession(是对SparkContext的包装和增强)
    val spark = SparkSession.builder()
      .appName(this.getClass.getSimpleName)
      .master("local[*]")
      .getOrCreate()

    val df = spark.read.parquet("d://aaa//222//par")
    df.show()
    df.printSchema()
    Thread.sleep(1000000)

  }

}

JSON的
	优点，
	数据中自带schema，数据格式丰富，支持嵌套类型。
	缺点：传输、存储了很多冗余的数据

name,age,fv,gender
laozhao,18,9999.99,male
lauduan,18,999.99,male

CSV：
	特点:数据存储相对比较紧凑
	缺点：schema信息不完整，数据格式比较单一

Parquet是SparkSQL的最爱
	数据中自带schema（头尾信息：数据的描述信息），数据格式丰富，支持嵌套类型。数据存储紧凑、列式存储（支持压缩）、查询快（按需查询、快速定位）

从hdfs上读取文件以orc的格式写入本地

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types._
import org.apache.spark.sql.{Row, SparkSession}

object WriteToOrc {

  def main(args: Array[String]): Unit = {

    //创建SparkSession(是对SparkContext的包装和增强)
    val session: SparkSession = SparkSession.builder()
      .appName("DataFrameCreateDemo01")
      .master("local[*]")
      .getOrCreate()

    val sc = session.sparkContext
    val rdd1: RDD[String] = sc.textFile("hdfs://linux01:8020/1.txt")

    //row的字段没有类型，没有名称
    val rowRDD: RDD[Row] = rdd1.map(e => {
      val fields = e.split(",")
      Row(fields(0).toLong, fields(1), fields(2).toInt, fields(3).toDouble)
    })

    //关联schema(字段名称，数据类型，是否可以为空)
    val schema = StructType(
      Array(
        StructField("id", LongType),
        StructField("name", StringType),
        StructField("age", IntegerType),
        StructField("fv", DoubleType),
      )
    )
    //将RowRDD和StructType类型的Schema进行关联
    val df = session.createDataFrame(rowRDD, schema)

    df.write.orc("d://aaa//222//orc")

    session.stop()

  }
}

从本地读取orc格式的文件

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

//通过csv文件创建DataFrame
object CreateDataFrameFromOrc {

  def main(args: Array[String]): Unit = {

    //创建SparkSession(是对SparkContext的包装和增强)
    val spark: SparkSession = SparkSession.builder()
      .appName(this.getClass.getSimpleName)
      .master("local[*]")
      .getOrCreate()


    val df: DataFrame = spark.read.orc("d://aaa//222//orc")

    df.show(2)

    df.printSchema()

    Thread.sleep(10000000)


  }
}
hive（spark-sql） -e -f -d以及传参数, sh并行
.
09-05 9050
1. 使用“spark-sql -e” 与“Hive”一样，Spark SQL CLI也支持“-e”参数 spark-sql-e "insert intotable ***" Spark-SQL导出查询结果到 results.txt spark-sql --num-executors 100 -e "select * from table" > results.txt ...
spark on yarn模式 使用spark-shell spark-sql
yy的博客
09-01 509
spark-shell spark-sql
Spark（三）— Spark SQL
ks_1998的博客
05-01 2357
Spark（三）— Spark SQL
spark-sql配置教程
m0_74216612的博客
12-04 1845
spark-assembly` 是 Spark 1.x 版本的一个重要文件，在 Spark 2.x 及以后版本中，Spark 被重新架构，`spark-assembly` 文件已被拆分为多个 JAR 文件，因此不再需要在 Hive 启动脚本中通过 `sparkAssemblyPath` 来加载它。- 启动 Spark 时可以通过 `spark-submit` 或 `spark-sql` 来运行 Spark SQL 查询，并确保 Hive Metastore 已经启动。
Spark----Spark SQL概述
XiaodunLP的博客
02-18 479
Spark SQL概述 什么是Spark SQL Spark SQL是Spark用来处理结构化数据的一个模块，它提供了一个编程抽象叫做DataFrame并且作为分布式SQL查询引擎的作用。 我们已经学习了Hive，它是将Hive SQL转换成MapReduce然后提交到集群上执行，大大简化了编写MapReduce的程序的复杂性，由于MapReduce这种计算模型执行效率比较慢。所有Spa...
SparkSQL简介
m0_61607827的博客
03-27 127
写更少的代码 读更少的数据 提供更好的性能（字节码生成技术、SQL优化） SparkSQL数据抽象 DataSet会逐步取代 RDD 和 DataFrame 成为唯一的API接口 DataFrame 前身是SchemaRDD。Spark1.3更名为DataFrame。不继承RDD，自己实现了RDD的大部分功能 与RDD类似，DataFrame也是一个分布式数据集： DataFrame可以看做分布式 Row 对象的集合，提供了由列组成的详细模式信息，使其可以得到优化。 DataFrame..
spark-hive-2.11和spark-sql-以及spark-hadoop包另付下载地址
05-22
在标题"spark-hive-2.11和spark-sql-以及spark-hadoop包另付下载地址"中，我们关注的是Spark与Hive的特定版本（2.11）的集成，以及Spark SQL和Spark对Hadoop的支持。这里的2.11可能指的是Scala的版本，因为Spark是用...
spark-sql_2.11-2.4.0-cdh6.1.1.jar
05-14
spark-sql_2.11-2.4.0-cdh6.1.1.jar
spark-sql_2.11-2.1.3-SNAPSHOT_bak.jar
04-01
spark-sql_2.11-2.1.3-SNAPSHOT_bak.jar
Python大数据分析&人工智能教程 - Spark-SQL编程实例（含源码和学习思维导图）
最新发布
12-13
Spark-SQL概述、特点、组成、Spark-SQL语句模块解析、Spark-SQL架构、Dataframe API编程等内容 本资源包为您提供了一个全面的Python大数据分析与人工智能教程，特别关注Apache Spark中的Spark-SQL模块。Spark-SQL是...
Spark SQL 2.3.0：深入浅出
08-20
Spark SQL 2.3.0：深入浅出，看了下，还行，希望对大家有帮助
大数据进阶之路——Spark SQL基本配置_spark(1)
2401_84140707的博客
04-26 690
不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~给大家准备的学习资料包括但不限于：Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。
Spark SQL详细知识点
qq_45831157的博客
07-27 1147
Spark SQL是Spark框架中用于结构化数据(structured data)处理的Spark模块。SparkSQL知识点超详细文档！！！可以让基础小白快速入门。有丰富的小案例，边学边练！！
spark-sql实践
独醉的博客
12-30 1625
spark-sql实践一、安装anaconda二、配置jupyter notebook三、案例分析四、遇到的问题1.找不到spark2.找不到python 一、安装anaconda 安装包链接 链接：https://pan.baidu.com/s/1dvNVT4VW34SW4EVoZRqNgA 提取码：batk 二、配置jupyter notebook jupyter notebook --generate-config python -c "import IPython; print(IP
Spark-SQL小结
qq_53025556的博客
12-10 1868
“RDD、DataFrame、DataSet的概念、区别联系、相互转换操作” “Spark-SQL连接JDBC的方式及代码写法” “Spark-SQL连接Hive 的五种方法”
常用的spark数据读取和保存
haohao914的博客
10-26 907
个人收录自己常用的集中数据保存和读取方式 1、从外部读取数据之textFile 读取 var departmentData = getLoadDepartment(sqlCon,"hdfs://cnsz17pl1443:8020/spark/ddt/ASRUA_TM_DEPARTMENT")   def getLoadDepartment(spark: SparkSession,
spark同时读取多个指定文件
我的博客
07-18 7137
val result = spark.read.text("hdfs://192.168.40.51:9000/user/test/cxb/aa/aa.txt","hdfs://192.168.40.51:9000/user/test/cxb/bb/bb.txt") .toDF("str").as[A].rdd.collect().foreach(println)
Spark读取文本或CSV文件中文乱码的解决方案
大模型大数据攻城狮的专栏
05-07 1万+
使用Spark的默认方法，spark.read.option("header","true").csv(path)读取CSV文件或spark.read.textFile(path)读取文本文件，由于这2个方法默认是UTF-8编码，如果源数据带有GBK或GB2312的编码，就会出现Spark读取文本的中文乱码。 如果读取CSV文件的，可以用下面的，下面是用GBK为示例，可以根据实际替换 ...
Spark读取与写入文件
热门推荐
林 的博客
07-03 1万+
入口 在 2.3.0 的Spark版本中, SparkSession是统一的入口了 //创建 SparkSession val spark = SparkSession .builder .appName('MySparkApp') .enableHiveSupport() //开启访问Hive数据, 要将hive-site.xml等文件放入Spark的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值