Spark SQL（二十三）Spark SQL数据源

最新推荐文章于 2023-05-31 17:30:50 发布
最新推荐文章于 2023-05-31 17:30:50 发布
阅读量718 收藏 2
点赞数
分类专栏： spark 大数据专栏（一）Spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suubyy/article/details/82784381
版权

定义

Spark SQL可以通过DataFream接口操作各种数据源。可以通过关系转换或者临时表来操作DataFrame。这里我们将介绍通用的数据源加载方法和数据保存方法。

通用加载/保存方法

Spark默认的数据源格式为Parquet格式，数据源格式问Parquet文件的时候，Spark读取数据的时候不需要指定具体的格式，如果想要修改默认的数据格式，就需要修改spark.sql.sources.default参数

 def main(args: Array[String]): Unit = {
    val spark: SparkSession = SparkSession.builder().appName("DataFrameTest").master("local[2]").getOrCreate()
    //因为Parquet格式的文件时Spark加载数据的默认格式，所以不需要指定format格式
    val personDF: DataFrame = spark.read.load("hdfs://xxxxx:8020/testfile/person.parquet")
    personDF.show()
  }

如果我们输入的数据文件格式不是Parquet，那么我们就需要手动指定读取的数据源格式。数据源格式需要指定全名（org.apache.spark.sql.parquet）,如果手动指定的数据源格式为spark内置格式，只需要指定简称，如json、parquet、jdbc、text、orc、libsvm、csv。

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

    //从本地读取json格式的数据，因为json不是spark默认的数据源格式，所以需要手动指定数据源格式为json
    val personDF: DataFrame = spark.read.format("json").load("C:\\Users\\39402\\Desktop\\person.json")
    
    //利用Dataframe的write和save方法将本地读取到的数据以parquet的格式写到HDFS上，
    personDF.write.format("parquet").save("hdfs://xxxxx:8020/testfile/person.parquet")
  }

除此之外我们也可以把SQL执行在数据源文件上，下边就是一个例子，它将SQL运行在文件上。

def main(args: Array[String]): Unit = {
    val spark: SparkSession = SparkSession.builder().appName("DataFrameTest").master("local[2]").getOrCreate()
    
    //将SQL执行在数据源的文件上，一定要注意书写格式
 	spark.sql("select * from parquet.`hdfs://xxxxx:8020/testfile/person.parquet`").show()
  }

文件保存选项

当我们的SparkSQL处理完数据以后，需要向本地或者文件系统保存数据，我们可以利用SaveModel指定保存策略，，例如文件已经存在就抛异常、覆盖原数据等。
代码例子

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

    //从本地读取json格式的数据，因为json不是spark默认的数据源格式，所以需要手动指定数据源格式为json
    val personDF: DataFrame = spark.read.format("json").load("C:\\Users\\39402\\Desktop\\person.json")
   
    //指定SaveModel策略为如果文件已存在就抛异常
	personDF.write.mode(SaveMode.ErrorIfExists).save("hdfs://xxxx:8020/testfile/person.parquet")
  }

SaveModel保存策略表

Scala/JavaMeaning
SaveMode.ErrorIfExists (default)如果数据已经存在，将DataFrame保存到数据源时，则预计会抛出异常。
SaveMode.Append如果data / table已经存在，将DataFrame保存到数据源时，则DataFrame的内容将被添加到现有数据中。
SaveMode.Overwrite覆盖模式意味着将DataFrame保存到数据源时，如果data / table已经存在，则现有数据将被DataFrame的内容覆盖。
SaveMode.Ignore忽略模式意味着，当将DataFrame保存到数据源时，如果数据已经存在，保存操作将不会保存DataFrame的内容，也不会更改现有数据。这与CREATE TABLE IF NOT EXISTSSQL中的类似。

Parquet文件

Parquet是一种列式存储格式，可以很高效的存储具有嵌套的数据，目前是最流行的一种存储格式。SparkSQL默认的读写数据的格式就是Parquet，可想而知该格式是多么高效。在海量数据中，我们一般存储在分布式文件系统中，并且以分区的方式存储，也就是按照一定的规律拆分成小的文件。那么Parquet数据源就可以自动发现并解析分区信息。SparkSQL自动解析分区的参数为spark.sql.sources.partitionColumnTypeInference=true，默认是开启，想要关闭就设置成disabled

Hive数据库

Hive是Hadoop为了减缓编写MapReduce程序而存在的一种SQL引擎，它最终会被翻译成MapReduce程序。SparkSQL支持操作现有的Hive仓库。由于Hive有很多的依赖，这些依赖不会包含在Spark中，当在Spark没有在ClassPath中发现这些依赖，那么Spark就会自动加载它们，特别注意的是，这些依赖一定要在所有节点上出现，因为它们需要访问Hive的序列化和反序列库，以便于访问Hive上的数据。所谓的依赖其实就是将HIVE_HOME/hive-site.xml、HADOOP_HOME/etc/hadoop/core-site.xml、HADOOP_HOME/etc/hadoop/hdfs-site.xml文件复制到Spark目录下的conf目录中。特别注意的是在编译Spark的时候必须添加Hive依赖。如果在Spark中运行有关Hive的操作，这个时候如果你的Hive环境还没有部署好，那么Spark会在当前的工作目录中创建Hive的元数据仓库，叫做metastore_db。利用SparkSQL运行Hive存储数据的默认目录是HDFS上的/user/hive/warehouse。以上环境准备好了，那么我们怎么样才能在Spark中操作Hive呢，请看下边的代码例子。

object HiveDataSourceTest {
  //Hive数据存储在HDFS上的目录
  val hiveDataPathUrl = "/user/hive/warehouse"

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

    //初始化SparkSession，并支持Hive操作，然后hive数据在hdfs上的存储目录。
    val spark: SparkSession = SparkSession.builder()
      .appName("HiveDataSourceTest")
      .master("local[2]") //在Spark集群上运行的时候要去掉
      .config("spark.sql.warehouse.dir", hiveDataPathUrl)
      .enableHiveSupport()
      .getOrCreate()

    //利用spark sql创建Hive表
    spark.sql("CREATE TABLE IF NOT EXISTS person(name:StRING,age:INT) ROW FORMAT DELIMITED " +
      "FIELDS  TERMINATED BY ',' ")

    //利用spark sql 将数据加载到Hive表中
    spark.sql("LOAD DATA LOCAL INPATH '/opt/data/person.json' INTO TABLE person ")

    //利用spark sql 查询Hive表
    spark.sql("select * from person").show()

    //关闭SparkSession
    spark.close()
  }
}

使用spark-shell操作外部Hive

当我们使用已存在的Hive仓库，需要操作其上的数据，那我们就需要将HIVE_HOME/conf下的hive-site.xml拷贝到SPARK_HOME/conf下，然后在启动spark-shell的时候，一定要加上--jars /xx/xx/mysql-connector-java-xx.xx.jar，因为Hive元数据存在Mysql中，Driver程序需要连接Mysql。

spark-shell --jars /opt/lib/mysql-connector-java-6.0.1.jar

JSON数据库

SparkSQL能够自动推测出JSON数据集的结构，并将它加载成一个DataSet[Row]，也就是一个DataFrame。可以通过spark.read.json()的方式去读取JSON文件或者JSON字符串，然后返回一个DataFrame数据集。

 def main(args: Array[String]): Unit = {
    val spark: SparkSession = SparkSession.builder().appName("DataFrameTest").master("local[2]").getOrCreate()
    //第一种读取本地或者文件系统上的json文件
    val personDF: DataFrame = spark.read.json("C:\\Users\\39402\\Desktop\\person.json")
    
      //导入隐式转换
    import spark.implicits._
  
    //第二种读取json字符串，
    val jsonDataSet: Dataset[String] = spark.createDataset("""{"name":"Yin","address":{"city":"Columbus","state":"Ohio"}}""" :: Nil)

    //将DataSet转换成RDD，然后作为json方法的参数
    spark.read.json(jsonDataSet.rdd).show()
  }

JDBC

SparkSQL也包含了一种能够通过JDBC读取其他的数据源的数据源。这种方式比使用JdbcRDD的性能更高。这是因为这种方式的返回值是DataFrame，这样就可以利用SparkSQL进行处理，或者是跟其他数据源交互。JBDC这种方式还有的一种优点就是可以很容易利用Java或者Python操作。以下是SparkSQL利用JDBC方式操作Mysql数据库的代码。

package com.lyz.datasource

import java.util.Properties

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

object JDBCDataSourceTest {

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

    //SparkSQL利用JDBC读取Mysql数据第一种方式
    val table1: DataFrame = spark.read.format("jdbc")
      .option("url", "jdbc:mysql://localhost:3306/kettle_test?zeroDateTimeBehavior=convertToNull&characterEncoding=utf8&serverTimezone=GMT&useSSL=false")
      .option("dbtable", "local_table")
      .option("driver", "com.mysql.cj.jdbc.Driver")
      .option("user", "root")
      .option("password", "12345")
      .option("fetchsize", 5)
      .option("batchsize", 10).load()

    //SparkSQL利用JDBC读取Mysql数据第二种方式
    val connectionProperties: Properties = new Properties()
    connectionProperties.put("user", "root")
    connectionProperties.put("password", "12345")
    val table2: DataFrame = spark.read.jdbc("jdbc:mysql://localhost:3306/kettle_test?zeroDateTimeBehavior=convertToNull&characterEncoding" +
      "=utf8&serverTimezone=GMT&useSSL=false", "local_table", connectionProperties)

    //SparkSQL利用JDBC写数据到Mysql中的第一种方式
    table1.write.mode(SaveMode.Append).format("jdbc").option("url", "jdbc:mysql://localhost:3306/kettle_test?zeroDateTimeBehavior=convertToNull&characterEncoding=utf8&serverTimezone=GMT&useSSL=false")
      .option("dbtable", "remote_table")
      .option("driver", "com.mysql.cj.jdbc.Driver")
      .option("user", "root")
      .option("password", "12345")
      .option("fetchsize", 5)
      .option("batchsize", 10).save()


    //SparkSQL利用JDBC写数据到Mysql中的第二种方式

    table2.write.mode(SaveMode.Append).jdbc("jdbc:mysql://localhost:3306/kettle_test?zeroDateTimeBehavior=convertToNull&characterEncoding" +
      "=utf8&serverTimezone=GMT&useSSL=false", "remote_table", connectionProperties)
  }
}

MongDB

package com.lyz
import java.net.InetAddress
import com.mongodb.casbah.commons.MongoDBObject
import com.mongodb.casbah.{MongoClient, MongoClientURI}
import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest
import org.elasticsearch.common.settings.Settings
import org.elasticsearch.common.transport.InetSocketTransportAddress
import org.elasticsearch.transport.client.PreBuiltTransportClient

object dataloader {

  val MOVIC_PATH = "D:\\workspace-idea\\java\\recommend-system\\movie-recommend-system\\data-loader\\src\\main\\resources\\movies.csv"

  val MONGODB_MOVIE_COLLECTION = "Movie"
  
  //主函数，程序的入口
  def main(args: Array[String]): Unit = {

    val config = Map(
      "spark.cores" -> "local[*]",
      "mongodb.url" -> "mongodb://xxxx:27017/recommend",
      "mongodb.db" -> "recommend")

    //创建一个Spark配置对象
    val sparkConf = new SparkConf().setAppName("DataLoader").setMaster(config("spark.cores"))
    //创建一个SparkSession
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()


    import spark.implicits._
    //读取Moive数据并转换成DataFrame
    val movieDF: DataFrame = spark.sparkContext.textFile(MOVIC_PATH).map(line => {
      val attr: Array[String] = line.split("\\^")
      Movie(attr(0).toInt, attr(1).trim, attr(2).trim, attr(3).trim, attr(4).trim, attr(5).trim, attr(6).trim, attr(7).trim, attr(8).trim, attr(9).trim)
    }).toDF()
    
    //声明一个隐式转换，
    implicit val mongoConfig = MongoConfig(config("mongodb.url"), config("mongodb.db"))
    saveDataIntoMongodb(movieDF, ratingDF, tagDF)
    spark.stop()
  }
  
  def saveDataIntoMongodb(movie: DataFrame, rating: DataFrame, tag: DataFrame)(implicit mongoConfig: MongoConfig): Unit = {
    val mongoClient = MongoClient(MongoClientURI(mongoConfig.uri))
    //判断MongoDB中是否存在了对应的数据库，如果存在就该删除它
    mongoClient(mongoConfig.db)(MONGODB_MOVIE_COLLECTION).dropCollection()
    
    //向MongoDB写Movie数据
    movie.write
      .option("uri", mongoConfig.uri)
      .option("collection", MONGODB_MOVIE_COLLECTION)
      .mode(SaveMode.Overwrite)
      .format("com.mongodb.spark.sql")
      .save()

    //为mogondb里的表建立索引
    //为MongoDB中的Movie表创建索引，索引为mid，并且排序规则为升序
    mongoClient(mongoConfig.db)(MONGODB_MOVIE_COLLECTION).createIndex(MongoDBObject("mid" -> 1))
    //关闭mongoDB的客户端
    mongoClient.close()
  }
}
/**
  * MongoDB的连接配置
  *
  * @param uri MongoDB的连接
  * @param db  MongoDB要操作数据库
  */
case class MongoConfig(uri: String, db: String)

ElasticSearch

package com.lyz
import java.net.InetAddress

import com.mongodb.casbah.commons.MongoDBObject
import com.mongodb.casbah.{MongoClient, MongoClientURI}
import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest
import org.elasticsearch.common.settings.Settings
import org.elasticsearch.common.transport.InetSocketTransportAddress
import org.elasticsearch.transport.client.PreBuiltTransportClient

object dataloader {

  val MOVIC_PATH = "D:\\workspace-idea\\java\\recommend-system\\movie-recommend-system\\data-loader\\src\\main\\resources\\movies.csv"
  val ES_MOVIE_INDEX = "Movie"

  //主函数，程序的入口
  def main(args: Array[String]): Unit = {

    val config = Map(
      "spark.cores" -> "local[*]",
      "es.transportHosts" -> "xxxx:9300",
      "es.index" -> "recommend",
      "es.cluster.name" -> "es-cluster")

    //创建一个Spark配置对象
    val sparkConf = new SparkConf().setAppName("DataLoader").setMaster(config("spark.cores"))
    //创建一个SparkSession
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()


    import spark.implicits._
    //读取Moive数据并转换成DataFrame
    val movieDF: DataFrame = spark.sparkContext.textFile(MOVIC_PATH).map(line => {
      val attr: Array[String] = line.split("\\^")
      Movie(attr(0).toInt, attr(1).trim, attr(2).trim, attr(3).trim, attr(4).trim, attr(5).trim, attr(6).trim, attr(7).trim, attr(8).trim, attr(9).trim)
    }).toDF()
    
    //声明一个ES配置的隐式参数
    implicit val eSConfig = ESConfig(
      config("es.httpHosts"),
      config("es.transportHosts"),
      config("es.index"),
      config("es.cluster.name"))
      
    saveDataIntoEs(movieDF)
    
    spark.stop()
  }

  def saveDataIntoEs(movie: DataFrame)(implicit eSConfig: ESConfig): Unit = {
    //新建一个配置
    val esSetting: Settings = Settings.builder().put("cluster.name", "es-cluster").build()
    //需要将TransportHosts添加到esClient中
    val REGEX_HOST_PORT = "(.+):(\\d+)".r
    val esClient = new PreBuiltTransportClient(esSetting)

    eSConfig.transportHosts.split(",").foreach {
      //模式匹配，忽略掉不合规的URL地址
      case REGEX_HOST_PORT(host: String, port: String) =>
        esClient.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(host), port.toInt))
    }

    //判断es中是否还存在旧的数据索引
    if (esClient.admin().indices().exists(new IndicesExistsRequest(eSConfig.index)).actionGet().isExists) {
      //删除旧的索引数据
      esClient.admin().indices().delete(new DeleteIndexRequest(eSConfig.index))
    }

    //创建索引
    esClient.admin().indices().create(new CreateIndexRequest(eSConfig.index))


    movie.write.
      option("es.nodes", eSConfig.httpHosts)
      .option("es.http.timeout", "100m")
      .option("es.mapping.id", "mid")
      .mode(SaveMode.Overwrite)
      .format("org.elasticsearch.spark.sql")
      .save(eSConfig.index + "/" + ES_MOVIE_INDEX)

    esClient.close()
  }
}



case class Movie(mid: Int, name: String, descri: String, timelong: String, issue: String,
                 shoot: String, language: String, genres: String, actors: String, directors: String)

/**
  * ElasticSearch的连接配置
  *
  * @param httpHosts      Http的主机列表，以，分割
  * @param transportHosts Transport主机列表， 以，分割
  * @param index          需要操作的索引
  * @param clustername    ES集群的名称，
  */
case class ESConfig(httpHosts: String, transportHosts: String, index: String, clustername: String)

性能数据调优

在SparkSQL作业中，我们可利用缓存数据来调优，将数据缓存在内存中，提高执行效率，我们可以利用spark.catalog.cacheTable("tableName")或者利用dataFrame.cache()方法来将数据缓存在内存中。删除缓存数据可以调用spark.catalog.uncacheTale("tableName")来删除缓存数据。我们可以根据实际情况来设置缓存大小等一下参数。spark.conf(key,value)来设置。下表是具体的参数

参数名称默认值具体的意思
spark.sql.inMemoryColumnarStorage.compressedtrue是否为每列选择压缩编解码器
spark.sql.inMemoryColumnarStorage.batchSize10000控制缓存批次大小
666呀
关注
专栏目录
理解Spark中SparkSQL模块DataSource使用
杨鑫newlife的专栏
04-30 1030
Spark SQL支持通过DataFrame接口对各种数据源进行操作。 DataFrame可以使用关系转换进行操作，也可以用于创建临时视图。 将DataFrame注册为临时视图允许您对其数据运行SQL查询。 本节介绍使用Spark数据源加载和保存数据的一般方法，然后介绍可用于内置数据源的特定选项。 1.Generic Load/Save Functions 在最简单的形式中，默认数据源（par...
Spark基础学习笔记27：Spark SQL数据源 - Hive表
howard2005的专栏
05-12 1060
利用Spark SQL读取和写入Hive表
SparkSQL数据源解析
shufangreal的博客
05-09 498
SparkSQL数据源解析 SparkSQL是Spark用来处理结构化数据的模块，常用的数据源有： 常用的结构化文件如：Json、Parquet、Orc、Avro、Text Jdbc相关的数据库 Hive 表 下面介绍不同的数据源简单的代码实现。 SparkSQL的常用读取形式： spark.sql() spark.read.format().load() 常用的输出形式： spark.write.format("parquet").mode.option().save() Parquet File 在
【Spark分布式内存计算框架——Spark SQL】10. External DataSource（上）数据源与格式
CSDNGuoYuying的博客
02-18 543
所以使用SpakrSQL分析数据时，从数据读取，到数据分析及数据保存，链式操作，更多就是ETL操作。SparkSQL提供一套通用外部数据源接口，方便用户从数据源加载和保存数据，例如从MySQL表中既可以加载读取数据：load/read，又可以保存写入数据：save/write。SparkSQL模块中可以从某个外部数据源读取数据，就能向某个外部数据源保存数据，提供相应接口，通过DataFrameWrite类将数据进行保存。第二种：Overwrite 覆写模式，当数据存在时，覆写以前数据，存储当前最新数据；
Spark SQL之数据源
FBB360JAVA的博客
02-07 1003
前言 本篇文章来源于官方文档。 Spark SQL 通过 DataFrame 接口支持操作各种数据源。一个 DataFrame 能够通过使用关系转换和创建临时视图来操作数据。当你使用临时视图注册一个 DataFrame 时，你可以在这数据上运行 SQL 查询。 注意，本文中的完整代码和所需的资源文件如下 【官方案例】SQLDataSourceExample.scala 资源文件 通用的读取、保存函...
Spark SQL 之 Data Sources
zdy0_2004的专栏
11-29 1754
http://www.cnblogs.com/BYRans/p/5005342.html 转载请注明出处：http://www.cnblogs.com/BYRans/ 数据源（Data Source） Spark SQL的DataFrame接口支持多种数据源的操作。一个DataFrame可以进行RDDs方式的操作，也可以被注册为临时表。把DataFrame注册为临时表之后，就可以
Spark SQL常见4种数据源详解
01-19
Spark SQL的DataFrame接口支持多种数据源的操作。一个DataFrame可以进行RDDs方式的操作，也可以被注册为临时表。把DataFrame注册为临时表之后，就可以对该DataFrame执行SQL查询。 Spark SQL的默认数据源为Parquet...
Spark Sql中时间字段少8个小时问题解决
最新发布
02-28
此问题的主要原因是Spark SQL默认使用的是UTC时区进行日期和时间的处理，而源表中的时间戳可能是基于其他时区（如北京时间UTC+8）记录的。当从一个`timestamp`字段转换为`string`字段时，如果没有明确指定时区，...
Spark SQL数据源-基本操作
new_renren的博客
05-31 953
默认情况下，load()方法和save()方法只支持Parquet格式的文件，Parquet文件是以二进制方式存储数据的，因此不可以直接读取，文件中包括该文件的实际数据和Schema信息，也可以在配置文件中通过参数spark.sql.sources.default对默认文件格式进行更改。除了使用select()方法查询外，也可以使用SparkSession对象的sql()方法执行SQL语句进行查询，该方法的返回结果仍然是一个DataFrame。
SparkSql之数据的读取和保存
石榴姐yyds
08-19 5640
目录 0 引言 1 加载数据 2 保存数据 3 Parquet 4 JSON 4 CSV 5 MySQL 6 Hive 0 引言 SparkSQL提供了通用的保存数据和数据加载的方式。这里的通用指的是使用相同的API，根据不同的参数读取和保存不同格式的数据，SparkSQL默认读取和保存的文件格式为parquet。 1 加载数据 spark.read.load 是加载数据的通用方法 scala> spark.read. csv format jdbc json
SparkSQL HDFS JAVA调用完整实例
06-28
SparkSQL HDFS JAVA调用完整实例，使用Maven管理，项目很小，里面实例很多。敬请下载。
SparkSQL-数据源
上海一九四三
08-21 1011
Spark SQL的DataFrame接口支持多种数据源的操作。一个DataFrame可以进行RDDs方式的操作，也可以被注册为临时表。把DataFrame注册为临时表之后，就可以对该DataFrame执行SQL查询。Data Sources这部分首先描述了对Spark的数据源执行加载和保存的常用方法，然后对内置数据源进行深入介绍。 一、一般Load/Save方法 Spark SQL的默认数据...
SparkSQL学习笔记(二)DataSource
热门推荐
王义凯 的博客
11-24 1万+
简介： SparkSQL通过DataFrame接口支持处理各种数据源，df可以抽象为RDD或注册内存(临时)表处理，临时表可以通过SQL操作并返回一个结果df。 Load/Save 方法： 最简单的格式，默认为parquet(列式存储格式，自身包含表结构和表数据)，可以在spark.sql.sources.default里配置。 例：scala val df = sqlCon
SparkSQL之数据源
weixin_30641999的博客
10-07 85
准备json文件： cat /root/1.json {"name":"Michael"} {"name":"Andy", "age":30} {"name":"Justin", "age":19} 可以尝试传统方法： val people = sqlContext.read.json("file:///root/1.json"); people.printSch...
使用scala将数据写入linux上的MongoDB数据库
Jacquelin_1的博客
06-10 1199
** 这篇主要记录一下数据量较大时使用scala处理数据，运用spark组件连接linux上的MongoDB并创建数据库进行数据写入** import com.mongodb.casbah.commons.MongoDBObject import com.mongodb.casbah.{MongoClient, MongoClientURI} import org.apache.spar...
spark编程mysql数据源_JDBC数据源
weixin_29762151的博客
02-11 159
Spark SQL支持使用JDBC从关系型数据库(比如MySQL)中读取数据。读取的数据，依然由DataFrame表示，可以很方便地使用Spark Core提供的各种算子进行处理。这里有一个经验之谈，实际上用Spark SQL处理JDBC中的数据是非常有用的。比如说，你的MySQL业务数据库中，有大量的数据，比如1000万，然后，你现在需要编写一个程序，对线上的脏数据某种复杂业务逻辑的处理，甚至复...
SparkSQL之DataSource
liweihope的博客
07-05 726
文章目录Parquet 文件加载Parquet文件Partition Discovery 分区探测Schema 合并ORC文件Hive表JDBC 到其它数据库TroubleshootingPerformance Tuning 你用MapReduce、Spark、Hive去处理源数据，处理之后输出出来。输入和输出的数据文件的格式可能有很多种，比如文本、json、ORC、Parquet格式的文件等。另...
spark 表关联 java_java操作spark ，将两个表进行jion操作JavaPairRDD
weixin_39879651的博客
02-27 322
private static final longserialVersionUID= 1L;@OverridepublicTuple2 call(Row row) throwsException {return newTuple2(row.getAs("job_name"),row.getAs("job_log_id"));}}).join(scoreinforDataSourceDs.javaR...
Hudi Spark SQL源码学习总结-select（查询）
主要分享大数据相关的知识，如Spark、Hudi
08-17 624
上一篇文章Hudi Spark源码学习总结-spark.read.format(“hudi”).load分析了load方法直接查询Hudi表路径的源码逻辑，那么Spark SQL select 表名的方式和load最终走的逻辑是一样的吗？本文带着这个疑问来分析一下select查询Hudi表的源码逻辑通过上面的分析，我们发现Spark查询Hudi表不管是通过load的方式还是通过sqlselect的方法最终走的逻辑都是一样的。都是先查找source=hudi的DataSource，Spark2对应的为。...
Spark SQL四大数据源详解：操作与实战示例
本文将详细介绍Spark SQL常见的四种数据源，这些数据源对于数据加载、处理和存储至关重要。 1. Parquet数据源 - Spark SQL默认的数据源是Parquet格式，这是一种列式存储格式，优化了读写性能，特别适合大数据处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值