（詳細）データソースのSQL共通の4種類のスパーク

一般的なロード/書き込み方法

手動でオプションを指定します

スパークSQLインタフェースは、データフレームの操作をさまざまなデータソースをサポートしています。データフレームRDDSは、モードを動作させることができるも一時テーブルとして登録することができます。一時テーブルとして登録DATAFRAMEしたら、データフレームは、SQLを実行問い合わせることができます。

寄せ木形式のSpark SQLのデフォルトのデータソース。寄せ木ファイルのデータソースは、スパークするとSQLは簡単にすべての操作を行うことができます。

設定項目を変更しspark.sql.sources.default、デフォルトのデータ・ソース・フォーマットを変更することができます。

scala> val df = spark.read.load("hdfs://hadoop001:9000/namesAndAges.parquet")
df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

scala> df.select("name").write.save("names.parquet")

データ形式は、ソース形式のファイル寄木細工でない場合は、手動でデータソースの形式を指定する必要があります。（例：フルネームを指定するためのデータソース形式org.apache.spark.sql.parquet）データフォーマットは、内蔵されている場合、ソース形式、唯一呼ばJSON、寄木細工、JDBC、オーク、指定する必要が LIBSVM、CSV、テキストデータの形式を指定するために。

これは、ライトを使用して、read.load SparkSession方法によって提供される一般的な負荷データに使用され、保存されたデータを保存することができます。

scala> val peopleDF = spark.read.format("json").load("hdfs://hadoop001:9000/people.json")
peopleDF: org.apache.spark.sql.DataFrame = [age: bigint, name: string]          

scala> peopleDF.write.format("parquet").save("hdfs://hadoop001:9000/namesAndAges.parquet")
scala>

また、あなたは、SQLファイル上で直接実行することができます：

val sqlDF = spark.sql("SELECT * FROM parquet.`hdfs://hadoop001:9000/namesAndAges.parquet`")
sqlDF.show()

保存オプションファイル

SaveModeはSaveMode処理モードデータを定義し、記憶操作を用いることができる行います。これらは、いずれかのロックを使用しないモードを保存することに注意してください、それはアトミックではありません。上書きモードを使用して実行時に加えて、元のデータに新たなデータの前に出力が削除されていました。次の表に詳述さSaveMode：

スカラ/ Javaの	どんな言語でも	意味
SaveMode.ErrorIfExists（デフォルト）	「エラー」（デフォルト）	ファイルが存在する場合、エラー
SaveMode.Append	「追加」	追加
SaveMode.Overwrite	「上書き」	上書き
SaveMode.Ignore	「無視」	データは、それが無視され、存在しています

寄木細工のファイル

寄木細工の読み書き

寄木細工のフォーマットは、多くの場合、Hadoopのエコシステムで使用されている、それはまた、すべてのスパークのSQLデータ型をサポートしています。スパークSQLを直接読み取り、店舗寄せ木形式のアプローチを提供します。

// Encoders for most common types are automatically provided by importing spark.implicits._
import spark.implicits._

val peopleDF = spark.read.json("examples/src/main/resources/people.json")

// DataFrames can be saved as Parquet files, maintaining the schema information
peopleDF.write.parquet("hdfs://hadoop001:9000/people.parquet")

// Read in the parquet file created above
// Parquet files are self-describing so the schema is preserved
// The result of loading a Parquet file is also a DataFrame
val parquetFileDF = spark.read.parquet("hdfs://hadoop001:9000/people.parquet")

// Parquet files can also be used to create a temporary view and then used in SQL statements
parquetFileDF.createOrReplaceTempView("parquetFile")
val namesDF = spark.sql("SELECT name FROM parquetFile WHERE age BETWEEN 13 AND 19")
namesDF.map(attributes => "Name: " + attributes(0)).show()
// +------------+
// |       value|
// +------------+
// |Name: Justin|
// +------------+

解決パーティション情報

テーブルを分割することのいずれかの方法、データの最適化です。パーティションテーブルでは、データを分割することによって、列データが異なるディレクトリに格納されています。寄せ木データソースが自動的にパーティション情報を発見し、解決することができます。例えば、人口データストレージパーティションは、性別や国などのパーティションは、次のディレクトリ構造を使用します。

path
└── to
    └── table
        ├── gender=male
        │   ├── ...
        │   │
        │   ├── country=US
        │   │   └── data.parquet
        │   ├── country=CN
        │   │   └── data.parquet
        │   └── ...
        └── gender=female
            ├── ...
            │
            ├── country=US
            │   └── data.parquet
            ├── country=CN
            │   └── data.parquet
            └── ...

SQLContext.read.parqueへのパス/に/テーブルを渡すことで、

またはSQLContext.read.load、スパークSQLは自動的にパーティション情報を解析します。

次のようにスキーマのデータフレームを返しました：

root
|-- name: string (nullable = true)
|-- age: long (nullable = true)
|-- gender: string (nullable = true)
|-- country: string (nullable = true)

データ分割列のデータ型が自動的に解決されることに注意してください。現在では、数値型と文字列型がサポートされています。自動的にパーティションタイプのパラメータは解決します。

spark.sql.sources.partitionColumnTypeInference.enabledデフォルト値はtrueです。

あなたはこの機能をオフにしたい場合は、パラメータが直接無効にすることができます。この場合、パーティション列のデータ形式は、タイプはもはや解決し、デフォルトの文字列型として設定されていません。

スキーマの合併

ProtocolBuffer、アブロとスリフトなどのように、寄木張りもスキーマの進化（スキーマ進化）をサポートしています。ユーザは、単純なスキーマを定義し、次にスキーマカラムが緩やかに説明向かって増加することができます。このように、ユーザーが複数の異なるが相互に互換性のある寄せ木スキーマファイルにアクセスすることができます。寄木細工は現在、データソースが自動的にこのような状況、これらのスキーマを検出し、ファイルをマージします。
スキーマの合併が高い消費を操作しているし、必要としないため、ほとんどの場合、そのSQL 1.5.0スパーク

デフォルトではオフになって機能を開始します。この機能は、次の2つの方法でオンにすることができます。

寄木細工のファイルの場合は、データソース、データソースオプションmergeSchemaはtrueに設定します。

グローバルSQLオプションを設定します。

spark.sql.parquet.mergeSchemaそれは本当です。

// sqlContext from the previous example is used in this example.
// This is used to implicitly convert an RDD to a DataFrame.
import spark.implicits._

// Create a simple DataFrame, stored into a partition directory
val df1 = sc.makeRDD(1 to 5).map(i => (i, i * 2)).toDF("single", "double")
df1.write.parquet("hdfs://hadoop001:9000/data/test_table/key=1")

// Create another DataFrame in a new partition directory,
// adding a new column and dropping an existing column
val df2 = sc.makeRDD(6 to 10).map(i => (i, i * 3)).toDF("single", "triple")
df2.write.parquet("hdfs://hadoop001:9000/data/test_table/key=2")

// Read the partitioned table
val df3 = spark.read.option("mergeSchema", "true").parquet("hdfs://hadoop001:9000/data/test_table")
df3.printSchema()

// The final schema consists of all 3 columns in the Parquet files together
// with the partitioning column appeared in the partition directory paths.
// root
// |-- single: int (nullable = true)
// |-- double: int (nullable = true)
// |-- triple: int (nullable = true)
// |-- key : int (nullable = true)

ハイブデータソース

Apacheのハイブは、Hadoopの上のSQLエンジンで、SQLは、ハイブのサポート、コンパイル時間が含まれていてもよいスパーク、それが含まれないことがあります。スパークSQLのサポートは、ハイブハイブテーブルの訪問をサポートすることができます含まれている、UDF（ユーザー定義関数）とハイブクエリ言語（HiveQL / HQL）のように。強調される必要がありますが、スパークSQLハイブライブラリに含める場合、ハイブをインストールする必要がないということです。一般的に、それはあなたがこれらの機能を使用できるように、コンパイル時のスパークSQLでハイブのサポートを導入するのが最善です。あなたはスパークのバイナリ版をダウンロードした場合は、コンパイル時にハイブサポートが追加されている必要があります。

良いハイブの展開へのSQL接続をスパークたい場合は、の（$ SPARK_HOME / confに）をスパークするハイブ-site.xmlの設定ファイルのディレクトリをコピーする必要があります。でも展開ハイブせずに、スパークSQLを実行することができます。

あなたはハイブを展開していない場合なお、SQLはmetastore_dbと呼ばれる、現在の作業ディレクトリに自身のハイブのメタデータ・リポジトリを作成しますスパーク。また、あなたがクラスパスを持っている場合は、あなたのデフォルトのファイルシステム/ユーザー/ハイブ/倉庫ディレクトリ（にあるテーブルを作成するステートメント（外部表を作成しない）にCREATE TABLE HiveQLを使用しようとした場合良いHDFS-site.xmlをして、デフォルトのファイルシステムは、HDFS、そうでない場合は、ローカル・ファイル・システム）です。

import java.io.File
import org.apache.spark.sql.Row
import org.apache.spark.sql.SparkSession

case class Record(key: Int, value: String)

// warehouseLocation points to the default location for managed databases and tables
val warehouseLocation = new File("spark-warehouse").getAbsolutePath

val spark = SparkSession
.builder()
.appName("Spark Hive Example")
.config("spark.sql.warehouse.dir", warehouseLocation)
.enableHiveSupport()
.getOrCreate()

import spark.implicits._
import spark.sql

sql("CREATE TABLE IF NOT EXISTS src (key INT, value STRING)")
sql("LOAD DATA LOCAL INPATH 'examples/src/main/resources/kv1.txt' INTO TABLE src")

// Queries are expressed in HiveQL
sql("SELECT * FROM src").show()
// +---+-------+
// |key|  value|
// +---+-------+
// |238|val_238|
// | 86| val_86|
// |311|val_311|
// ...

// Aggregation queries are also supported.
sql("SELECT COUNT(*) FROM src").show()
// +--------+
// |count(1)|
// +--------+
// |    500 |
// +--------+

// The results of SQL queries are themselves DataFrames and support all normal functions.
val sqlDF = sql("SELECT key, value FROM src WHERE key < 10 ORDER BY key")

// The items in DataFrames are of type Row, which allows you to access each column by ordinal.
val stringsDS = sqlDF.map {
case Row(key: Int, value: String) => s"Key: $key, Value: $value"
}
stringsDS.show()
// +--------------------+
// |               value|
// +--------------------+
// |Key: 0, Value: val_0|
// |Key: 0, Value: val_0|
// |Key: 0, Value: val_0|
// ...

// You can also use DataFrames to create temporary views within a SparkSession.
val recordsDF = spark.createDataFrame((1 to 100).map(i => Record(i, s"val_$i")))
recordsDF.createOrReplaceTempView("records")

// Queries can then join DataFrame data with data stored in Hive.
sql("SELECT * FROM records r JOIN src s ON r.key = s.key").show()
// +---+------+---+------+
// |key| value|key| value|
// +---+------+---+------+
// |  2| val_2|  2| val_2|
// |  4| val_4|  4| val_4|
// |  5| val_5|  5| val_5|
// ...

ハイブ組み込みアプリケーション

あなたが埋め込まれたハイブを使用している場合は、直接その上で、何もしません。-conf：

spark.sql.warehouse.dir=

注：内部ハイブを使用している場合は、パスとしてHDFSを使用する必要がある場合、Spark2.0、データウェアハウスに指定さspark.sql.warehouse.dirアドレスの後、あなたはコア-site.xmlのを必要とし、 HDFS-site.xmlのは、それ以外の場合は、マスターノード上の倉庫のディレクトリが作成されます、のconfディレクトリをスパークするために追加、クエリは、HDFSを使用するには、メタストアを削除する必要があるときに表示されるファイルを見つけることができない問題が、あなたは、クラスタを再起動する必要があります。

ハイブ外部アプリケーション

あなたは、以下の工程を経て、外部すでに展開ハイブを接続する場合。

ハイブ-site.xmlのハイブでコピーまたはスパークのインストールディレクトリの下の下のソフトconfディレクトリに接続されています。

Bオープンスパークシェル、JDBCデータベースへのアクセスハイブの元クライアントのノートを取ります。

$ bin/spark-shell --master spark://hadoop001:7077 --jars mysql-connector-java-5.1.27-bin.jar

JSONデータセット

SQL自動的に推定JSONデータセットの構造、およびデータセット[行]にロードし、それをスパーク。SparkSession.read.json（BY）データセット[文字列] JSONまたはファイルをロードする。このファイルはJSONではないことに注意してください伝統的なJSONファイル、各行は、JSON文字列でなければなりませんでした。

{"name":"Michael"}
{"name":"Andy", "age":30}
{"name":"Justin", "age":19}
// Primitive types (Int, String, etc) and Product types (case classes) encoders are
// supported by importing this when creating a Dataset.
import spark.implicits._

// A JSON dataset is pointed to by path.
// The path can be either a single text file or a directory storing text files
val path = "examples/src/main/resources/people.json"
val peopleDF = spark.read.json(path)

// The inferred schema can be visualized using the printSchema() method
peopleDF.printSchema()
// root
//  |-- age: long (nullable = true)
//  |-- name: string (nullable = true)

// Creates a temporary view using the DataFrame
peopleDF.createOrReplaceTempView("people")

// SQL statements can be run by using the sql methods provided by spark
val teenagerNamesDF = spark.sql("SELECT name FROM people WHERE age BETWEEN 13 AND 19")
teenagerNamesDF.show()
// +------+
// |  name|
// +------+
// |Justin|
// +------+

// Alternatively, a DataFrame can be created for a JSON dataset represented by
// a Dataset[String] storing one JSON object per string
val otherPeopleDataset = spark.createDataset(
"""{"name":"Yin","address":{"city":"Columbus","state":"Ohio"}}""" :: Nil)
val otherPeople = spark.read.json(otherPeopleDataset)
otherPeople.show()
// +---------------+----+
// |        address|name|
// +---------------+----+
// |[Columbus,Ohio]| Yin|
// +---------------+----+

JDBC

スパークSQLは、リレーショナル・データベースJDBCからデータを読み取る方法でデータフレームを作成することができ、計算のデータフレームのシリーズを通じて、また戻ってリレーショナルデータベースにデータを書き込むことができます。

データベースは、クラスパスにスパークの駆動に関連する必要があることに注意してください。

$ bin/spark-shell --master spark://hadoop001:7077 --jars mysql-connector-java-5.1.27-bin.jar
// Note: JDBC loading and saving can be achieved via either the load/save or jdbc methods
// Loading data from a JDBC source
val jdbcDF = spark.read.format("jdbc").option("url", "jdbc:mysql://hadoop001:3306/rdd").option("dbtable", " rddtable").option("user", "root").option("password", "hive").load()

val connectionProperties = new Properties()
connectionProperties.put("user", "root")
connectionProperties.put("password", "hive")
val jdbcDF2 = spark.read
.jdbc("jdbc:mysql://hadoop001:3306/rdd", "rddtable", connectionProperties)

// Saving data to a JDBC source
jdbcDF.write
.format("jdbc")
.option("url", "jdbc:mysql://hadoop001:3306/rdd")
.option("dbtable", "rddtable2")
.option("user", "root")
.option("password", "hive")
.save()

jdbcDF2.write
.jdbc("jdbc:mysql://hadoop001:3306/mysql", "db", connectionProperties)

// Specifying create table column data types on write
jdbcDF.write
.option("createTableColumnTypes", "name CHAR(64), comments VARCHAR(1024)")
.jdbc("jdbc:mysql://hadoop001:3306/mysql", "db", connectionProperties)