Spark(1.6.1) Sql 编程指南+实战案例分析

首先看看从官网学习后总结的一个思维导图

 

 

 

概述(Overview)


Spark SQL是Spark的一个模块，用于结构化数据处理。它提供了一个编程的抽象被称为DataFrames，也可以作为分布式SQL查询引擎。

开始Spark SQL

Spark SQL中所有功能的入口点是SQLContext类，或者它子类中的一个。为了创建一个基本的SQLContext，你所需要的是一个SparkContext。

除了基本的SQLContext，你还可以创建一个HiveContext，它提供了基本的SQLContext的所提供的功能的超集。这些功能中包括附加的特性，可以编写查询，使用更完全的HiveQL解析器，访问Hive UDFs，能够从Hive表中读取数据。现在暂不研究，以后学习

 

[java] view plain copy
 
 print?
  1. <span style="white-space:pre">        </span>SparkConf conf = new SparkConf();  
  2.         conf.set("spark.testing.memory", "2147480000"); // 因为jvm无法获得足够的资源  
  3.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App", conf);  
  4.         System.out.println(sc);  
  5.         // sc is an existing JavaSparkContext.  
  6.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  



DataFrames


DataFrame是一种以命名列方式组织的分布式数据集。它概念上相当于关系型数据库中的表，或者R/Python中的数据帧，但是具有更丰富的优化。有很多方式可以构造出一个DataFrame，例如：结构化数据文件，Hive中的tables，外部数据库或者存在的RDDs.
DataFrame的API适用于Scala、Java和Python.
该页上所有的例子使用Spark分布式中的样本数据，可以运行在spark-shell或者pyspark shell中。

创建DataFrames(Creating DataFrames)


使用SQLContext，应用可以从一个已经存在的RDD、Hive表或者数据源中创建DataFrames。

例如，以下根据一个JSON文件创建出一个DataFrame：

 

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2.   
  3. import org.apache.spark.SparkConf;  
  4. import org.apache.spark.api.java.JavaSparkContext;  
  5. import org.apache.spark.sql.DataFrame;  
  6. import org.apache.spark.sql.SQLContext;  
  7. /** 
  8.  * 根据一个JSON文件创建出一个DataFrame： 
  9.  * @author 汤高 
  10.  * 
  11.  */  
  12. public class DataFrameOps {  
  13.     public static void main(String[] args) {  
  14.         SparkConf conf=new SparkConf();  
  15.         conf.set("spark.testing.memory", "2147480000");     //因为jvm无法获得足够的资源  
  16.         //JavaSparkContext sc = new JavaSparkContext("spark://192.168.52.140:7077", "First Spark App",conf);  
  17.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App",conf);  
  18.   
  19.         SQLContext sqlContext = new SQLContext(sc);  
  20.           
  21.         DataFrame df = sqlContext.read().json("hdfs://master:9000/testFile/people.json");  
  22.   
  23.         // Displays the content of the DataFrame to stdout  
  24.         df.show();  
  25.           
  26.         // age  name  
  27.         // null Michael  
  28.         // 30   Andy  
  29.         // 19   Justin  
  30.   
  31.         // Print the schema in a tree format  
  32.         df.printSchema();  
  33.         // root  
  34.         // |-- age: long (nullable = true)  
  35.         // |-- name: string (nullable = true)  
  36.   
  37.         // Select only the "name" column  
  38.         df.select("name").show();  
  39.         // name  
  40.         // Michael  
  41.         // Andy  
  42.         // Justin  
  43.   
  44.         // Select everybody, but increment the age by 1  
  45.         df.select(df.col("name"), df.col("age").plus(1)).show();  
  46.         // name    (age + 1)  
  47.         // Michael null  
  48.         // Andy    31  
  49.         // Justin  20  
  50.   
  51.         // Select people older than 21  
  52.         df.filter(df.col("age").gt(21)).show();  
  53.         // age name  
  54.         // 30  Andy  
  55.   
  56.         // Count people by age  
  57.         df.groupBy("age").count().show();  
  58.         // age  count  
  59.         // null 1  
  60.         // 19   1  
  61.         // 30   1  
  62.           
  63.     }  
  64.   
  65. }  



 

SQLContext中的sql函数使应用可以以编程方式运行SQL查询，并且将结果以DataFrame形式返回。具体案例见后面

Spark SQL支持两种不同的方法，用于将存在的RDDs转换成DataFrames。第一种方法使用反射来推断包含特定类型的对象的RDD的模式。在写Spark应用时，当你已知schema的情况下，这种基于反射的方式使得代码更加简介，并且效果更好。

创建DataFrames的第二种方法是通过编程接口，它允许你构建一个模式，然后将其应用到现有的RDD上。这种方式更加的繁琐，它允许你构建一个DataFrame当列以及类型未知，直到运行时才能知道时。

使用反射推断模式(Inferring the Schema Using Reflection)

 知道RDD格式的前提下


JavaBeans类定义了表的模式，JavaBeans类的参数的名称使用反射来读取，然后称为列的名称。
JavaBeans类还可以嵌套或者包含复杂的类型，例如Sequences或者Arrays。
这个RDD可以隐式地转换为DataFrame，然后注册成表，
表可以在后续SQL语句中使用Spark SQL中的Scala接口支持自动地将包含JavaBeans类的RDD转换成DataFrame。



步骤：

1、使用JavaBeans类定义schema
2、创建一个SQLContext
3、通过调用createDataFrame方法模式应用到所有现有的RDD,并为JavaBean提供class对象  达到将RDD转换成DataFrame
4、创建一个DataFrame，并将它注册成表。
5、使用sqlContext提供的sql方法，就可以使用SQL语句来查询了。查询后返回的结果是DataFrame，它支持所有的RDD操作

 

首先写一个JavaBean类，实现序列化接口，并提供get和set方法

 

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2.   
  3. import scala.Serializable;  
  4.   
  5. public class Person implements Serializable {  
  6.       /** 
  7.      *  
  8.      */  
  9.     private static final long serialVersionUID = 727694963564948838L;  
  10.     private String name;  
  11.     private int age;  
  12.   
  13.       public String getName() {  
  14.         return name;  
  15.       }  
  16.   
  17.       public void setName(String name) {  
  18.         this.name = name;  
  19.       }  
  20.   
  21.       public int getAge() {  
  22.         return age;  
  23.       }  
  24.   
  25.       public void setAge(int age) {  
  26.         this.age = age;  
  27.       }  
  28.     }  



 

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2. import org.apache.spark.api.java.JavaRDD;  
  3. import org.apache.spark.api.java.JavaSparkContext;  
  4. import org.apache.spark.api.java.function.Function;  
  5. import org.apache.spark.sql.DataFrame;  
  6. import org.apache.spark.sql.Row;  
  7. import org.apache.spark.sql.SQLContext;  
  8. import org.apache.spark.storage.StorageLevel;  
  9.   
  10. import java.util.List;  
  11.   
  12. import org.apache.spark.SparkConf;  
  13. public class CreateDataFrame1 {  
  14.       
  15.     public static void main(String[] args) {  
  16.         SparkConf conf=new SparkConf();  
  17.         conf.set("spark.testing.memory", "2147480000");     //因为jvm无法获得足够的资源  
  18.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App",conf);  
  19.         System.out.println(sc);  
  20.         // sc is an existing JavaSparkContext.  
  21.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  
  22.   
  23.         // Load a text file and convert each line to a JavaBean.  
  24.         JavaRDD<Person> people = sc.textFile("hdfs://master:9000/testFile/people.txt").map(  
  25.           new Function<String, Person>() {  
  26.             public Person call(String line) throws Exception {  
  27.               String[] parts = line.split(",");  
  28.   
  29.               Person person = new Person();  
  30.               person.setName(parts[0]);  
  31.               person.setAge(Integer.parseInt(parts[1].trim()));  
  32.   
  33.               return person;  
  34.             }  
  35.           });  
  36.   
  37.         //A schema can be applied to an existing RDD by calling createDataFrame and providing the Class object for the JavaBean.  
  38.           
  39.           
  40.         // Apply a schema to an RDD of JavaBeans and register it as a table.  
  41.         DataFrame schemaPeople = sqlContext.createDataFrame(people, Person.class);  
  42.         schemaPeople.registerTempTable("people");  
  43.   
  44.         // SQL can be run over RDDs that have been registered as tables.  
  45.         DataFrame teenagers = sqlContext.sql("SELECT name FROM people WHERE age >= 13 AND age <= 19");  
  46.   
  47.         // The results of SQL queries are DataFrames and support all the normal RDD operations.  
  48.         // The columns of a row in the result can be accessed by ordinal.  
  49.         List<String> teenagerNames = teenagers.javaRDD().map(new Function<Row, String>() {  
  50.           public String call(Row row) {  
  51.             return "Name: " + row.getString(0);  
  52.           }  
  53.         }).collect();  
  54.           
  55.         teenagers.persist(StorageLevel.MEMORY_ONLY());  
  56.         System.out.println(teenagerNames);  
  57.     }  
  58.   
  59. }  

 

上面的这段代码

 

[java] view plain copy
 
 print?
  1. DataFrame teenagers = sqlContext.sql("SELECT name FROM people WHERE age >= 13 AND age <= 19");  

SQLContext中的sql函数使应用可以以编程方式运行SQL查询，并且将结果以DataFrame形式返回

以编程方式指定模式(Programmatically Specifying the Schema)

不知道RDD的列和它的类型时

步骤：

1.从原有的RDD中创建包含行的RDD。
2.创建一个由StructType表示的模式，StructType符合由步骤1创建的RDD的行的结构。
3.通过SQLContext提供的createDataFrame方法，将模式应用于包含行的RDD。

 

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2.   
  3. import org.apache.spark.api.java.JavaRDD;  
  4. import org.apache.spark.api.java.JavaSparkContext;  
  5. import org.apache.spark.api.java.function.Function;  
  6. import org.apache.spark.sql.DataFrame;  
  7. import org.apache.spark.sql.Row;  
  8. import org.apache.spark.sql.RowFactory;  
  9. import org.apache.spark.sql.SQLContext;  
  10. import org.apache.spark.sql.types.DataTypes;  
  11. import org.apache.spark.sql.types.StructField;  
  12. import org.apache.spark.sql.types.StructType;  
  13. import org.apache.spark.storage.StorageLevel;  
  14.   
  15. import java.util.ArrayList;  
  16. import java.util.List;  
  17.   
  18. import org.apache.spark.SparkConf;  
  19.   
  20. public class CreateDataFrame2 {  
  21.   
  22.     public static void main(String[] args) {  
  23.         SparkConf conf = new SparkConf();  
  24.         conf.set("spark.testing.memory", "2147480000"); // 因为jvm无法获得足够的资源  
  25.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App", conf);  
  26.         System.out.println(sc);  
  27.         // sc is an existing JavaSparkContext.  
  28.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  
  29.         // Load a text file and convert each line to a JavaBean.  
  30.         JavaRDD<String> people = sc.textFile("hdfs://master:9000/testFile/people.txt");  
  31.   
  32.         // Convert records of the RDD (people) to Rows.  
  33.         JavaRDD<Row> rowRDD = people.map(new Function<String, Row>() {  
  34.             public Row call(String record) throws Exception {  
  35.                 String[] fields = record.split(",");  
  36.                 return RowFactory.create(fields[0], fields[1].trim());  
  37.             }  
  38.         });  
  39.   
  40.         // The schema is encoded in a string  
  41.         String schemaString = "name age";  
  42.   
  43.         // Generate the schema based on the string of schema  
  44.         List<StructField> fields = new ArrayList<StructField>();  
  45.         for (String fieldName : schemaString.split(" ")) {  
  46.             // true表示可以为空  
  47.             fields.add(DataTypes.createStructField(fieldName, DataTypes.StringType, true));  
  48.         }  
  49.         StructType schema = DataTypes.createStructType(fields);  
  50.   
  51.         // Apply the schema to the RDD.  
  52.         DataFrame peopleDataFrame = sqlContext.createDataFrame(rowRDD, schema);  
  53.   
  54.         // Register the DataFrame as a table.  
  55.         peopleDataFrame.registerTempTable("people");  
  56.   
  57.         // SQL can be run over RDDs that have been registered as tables.  
  58.         DataFrame results = sqlContext.sql("SELECT name FROM people");  
  59.   
  60.         // The results of SQL queries are DataFrames and support all the normal  
  61.         // RDD operations.  
  62.         // The columns of a row in the result can be accessed by ordinal.  
  63.         List<String> names = results.javaRDD().map(new Function<Row, String>() {  
  64.             public String call(Row row) {  
  65.                 return "Name: " + row.getString(0);  
  66.             }  
  67.         }).collect();  
  68.         results.persist(StorageLevel.MEMORY_ONLY());  
  69.         System.out.println(names);  
  70.     }  
  71.   
  72. }  

 

 

 

数据源(Data Sources)

Spark SQL支持通过DataFrame接口在多种数据源上进行操作。一个DataFrame可以如同一个标准的RDDs那样进行操作，还可以注册成临时的表。将一个DataFrame注册成临时表允许你在它的数据上运行SQL查询。本节介绍使用Spark数据源装载和保存数据的常用方法，使用Spark数据源保存数据。然后进入可用于内置数据源的特定选项。

通用的加载/保存功能(Generic Load/Save Functions)

在最简单的形式中，默认的数据源(parquet除非通过spark.sql.sources.default另外进行配置)将被用于所有的操作。

 

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.apache.spark.SparkConf;  
  6. import org.apache.spark.api.java.JavaSparkContext;  
  7. import org.apache.spark.api.java.function.Function;  
  8. import org.apache.spark.sql.DataFrame;  
  9. import org.apache.spark.sql.Row;  
  10. import org.apache.spark.sql.SQLContext;  
  11. import org.apache.spark.sql.SaveMode;  
  12. import org.apache.spark.storage.StorageLevel;  
  13. /** 
  14.  * 加载默认的数据源格式并保存 
  15.  * //第一种读取方式xxxFile(path) 
  16.  * @author Administrator 
  17.  * 
  18.  */  
  19. public class DataSource {  
  20.   
  21.     public static void main(String[] args) {  
  22.         SparkConf conf = new SparkConf();  
  23.         conf.set("spark.testing.memory", "2147480000"); // 因为jvm无法获得足够的资源  
  24.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App", conf);  
  25.         System.out.println(sc);  
  26.         // sc is an existing JavaSparkContext.  
  27.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  
  28.           
  29.         DataFrame df = sqlContext.read().load("hdfs://master:9000/testFile/users.parquet");  
  30.           
  31.         df.select("name", "favorite_color").write().save("namesAndFavColors.parquet");  
  32.         //指定保存模式  
  33.         //df.select("name", "favorite_color").write().mode(SaveMode.Overwrite).save("namesAndFavColors.parquet");  
  34.         //第一种读取方式  
  35.         DataFrame parquetFile = sqlContext.parquetFile("namesAndFavColors.parquet");  
  36.           
  37.         parquetFile.registerTempTable("people");  
  38.   
  39.         // SQL can be run over RDDs that have been registered as tables.  
  40.         DataFrame teenagers = sqlContext.sql("SELECT name FROM people ");  
  41.   
  42.         // The results of SQL queries are DataFrames and support all the normal RDD operations.  
  43.         // The columns of a row in the result can be accessed by ordinal.  
  44.         List<String> teenagerNames = teenagers.javaRDD().map(new Function<Row, String>() {  
  45.           public String call(Row row) {  
  46.             return "Name: " + row.getString(0);  
  47.           }  
  48.         }).collect();  
  49.           
  50.         teenagers.persist(StorageLevel.MEMORY_ONLY());  
  51.         System.out.println(teenagerNames);  
  52.     }  
  53.           
  54.       
  55. }  



手动指定选项(Manually Specifying Options)

你还可以手动指定数据源，这些数据源将与任何额外的选项一同使用，你希望将这些选项传入到数据源中。数据源是通过它们的全名来指定的(如org.apache.spark.sql.parquet)，但是对于内置的数据源，你也可以使用简短的名称(json, parquet, jdbc)。任何类型的DataFrames使用这些语法可以转化成其他的数据源：

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.apache.spark.SparkConf;  
  6. import org.apache.spark.api.java.JavaSparkContext;  
  7. import org.apache.spark.api.java.function.Function;  
  8. import org.apache.spark.sql.DataFrame;  
  9. import org.apache.spark.sql.Row;  
  10. import org.apache.spark.sql.SQLContext;  
  11. import org.apache.spark.storage.StorageLevel;  
  12. /** 
  13.  * 加载指定的数据源格式并保存 
  14.  * //第二种读取方式sqlContext.read().XXX(path) 
  15.  * @author Administrator 
  16.  * 
  17.  */  
  18. public class DataSource2 {  
  19.   
  20.     public static void main(String[] args) {  
  21.         SparkConf conf = new SparkConf();  
  22.         conf.set("spark.testing.memory", "2147480000"); // 因为jvm无法获得足够的资源  
  23.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App", conf);  
  24.         System.out.println(sc);  
  25.         // sc is an existing JavaSparkContext.  
  26.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  
  27.         DataFrame df = sqlContext.read().format("json").load("hdfs://master:9000/testFile/people.json");  
  28.         df.select("name", "age").write().format("parquet").save("people.parquet");  
  29.         DataFrame parquetFile = sqlContext.read().parquet("people.parquet");  
  30.   
  31.         // Parquet files can also be registered as tables and then used in SQL statements.  
  32.         parquetFile.registerTempTable("parquetFile");  
  33.         DataFrame teenagers = sqlContext.sql("SELECT name FROM parquetFile WHERE age >= 13 AND age <= 19");  
  34.         List<String> teenagerNames = teenagers.javaRDD().map(new Function<Row, String>() {  
  35.           public String call(Row row) {  
  36.             return "Name: " + row.getString(0);  
  37.           }  
  38.         }).collect();  
  39.       
  40.           
  41.         teenagers.persist(StorageLevel.MEMORY_ONLY());  
  42.         System.out.println(teenagerNames);  
  43.     }  
  44. }  

 

保存模式(Save Modes)

Save操作可以可选择性地接收一个SaveModel，如果数据已经存在了，指定如何处理已经存在的数据。意识到这些保存模式没有利用任何锁，也不是原子的，这很重要。因此，如果有多个写入者试图往同一个地方写入，这是不安全的。此外，当执行一个Overwrite，在写入新的数据之前会将原来的数据进行删除。

df.select("name", "favorite_color").write().mode(SaveMode.Overwrite).save("namesAndFavColors.parquet");

 

Scala/Java

Python

Meaning

SaveMode.ErrorIfExists (default)

"error" (default)

When saving a DataFrame to a data source, if data already exists, an exception is expected to be thrown. 

当往一个数据源中保存一个DataFrame，如果数据已经存在，会抛出一个异常。

SaveMode.Append

"append"

When saving a DataFrame to a data source, if data/table already exists, contents of the DataFrame are expected to be appended to existing data. 

当往一个数据源中保存一个DataFrame，如果data/table已经存在，DataFrame的内容会追加到已经存在的数据后面。

SaveMode.Overwrite

"overwrite"

Overwrite mode means that when saving a DataFrame to a data source, if data/table already exists, existing data is expected to be overwritten by the contents of the DataFrame. 

Overwrite模式意味着当向数据源中保存一个DataFrame时，如果data/table已经存在了，已经存在的数据会被DataFrame中内容覆盖掉。

SaveMode.Ignore

"ignore"

Ignore mode means that when saving a DataFrame to a data source, if data already exists, the save operation is expected to not save the contents of the DataFrame and to not change the existing data. This is similar to a `CREATE TABLE IF NOT EXISTS` in SQL. 

Ignore模式意味着当向数据源中保存一个DataFrame时，如果数据已经存在，save操作不会将DataFrame的内容进行保存，也不会修改已经存在的数据。这与SQL中的`CREATE TABLE IF NOT EXISTS`相似。

 

Parquet 文件

Parquet是一种列式存储格式的文件，被许多其他数据处理系统所支持。Spark SQL支持度对Parquet文件的读和写，自动保存原有数据的模式。


代码上面用过一次

[java] view plain copy
 
 print?
  1. package com.tg.spark.sql;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.apache.spark.SparkConf;  
  6. import org.apache.spark.api.java.JavaSparkContext;  
  7. import org.apache.spark.api.java.function.Function;  
  8. import org.apache.spark.sql.DataFrame;  
  9. import org.apache.spark.sql.Row;  
  10. import org.apache.spark.sql.SQLContext;  
  11. import org.apache.spark.sql.SaveMode;  
  12. import org.apache.spark.storage.StorageLevel;  
  13. /** 
  14.  * 加载默认的数据源格式并保存 
  15.  * //第一种读取方式xxxFile(path) 
  16.  * @author Administrator 
  17.  * 
  18.  */  
  19. public class DataSource {  
  20.   
  21.     public static void main(String[] args) {  
  22.         SparkConf conf = new SparkConf();  
  23.         conf.set("spark.testing.memory", "2147480000"); // 因为jvm无法获得足够的资源  
  24.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App", conf);  
  25.         System.out.println(sc);  
  26.         // sc is an existing JavaSparkContext.  
  27.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  
  28.           
  29.         DataFrame df = sqlContext.read().load("hdfs://master:9000/testFile/users.parquet");  
  30.           
  31.         df.select("name", "favorite_color").write().save("namesAndFavColors.parquet");  
  32.         //指定保存模式  
  33.         //df.select("name", "favorite_color").write().mode(SaveMode.Overwrite).save("namesAndFavColors.parquet");  
  34.         //第一种读取方式  
  35.         DataFrame parquetFile = sqlContext.parquetFile("namesAndFavColors.parquet");  
  36.           
  37.         parquetFile.registerTempTable("people");  
  38.   
  39.         // SQL can be run over RDDs that have been registered as tables.  
  40.         DataFrame teenagers = sqlContext.sql("SELECT name FROM people ");  
  41.   
  42.         // The results of SQL queries are DataFrames and support all the normal RDD operations.  
  43.         // The columns of a row in the result can be accessed by ordinal.  
  44.         List<String> teenagerNames = teenagers.javaRDD().map(new Function<Row, String>() {  
  45.           public String call(Row row) {  
  46.             return "Name: " + row.getString(0);  
  47.           }  
  48.         }).collect();  
  49.           
  50.         teenagers.persist(StorageLevel.MEMORY_ONLY());  
  51.         System.out.println(teenagerNames);  
  52.     }  
  53.           
  54.       
  55. }  

 

JSON数据集(JSON Datasets)

Spark SQL可以自动推断出JSON数据集的模式，将它作为DataFrame进行加载。这个转换可以通过使用SQLContext中的下面两个方法中的任意一个来完成。
• jsonFile - 从一个JSON文件的目录中加载数据，文件中的每一个行都是一个JSON对象。

• jsonRDD - 从一个已经存在的RDD中加载数据，每一个RDD的元素是一个包含一个JSON对象的字符串。

代码前面都有涉及到

 

[java] view plain copy
 
 print?
  1. public class DataSource3 {  
  2.   
  3.     public static void main(String[] args) {  
  4.         SparkConf conf = new SparkConf();  
  5.         conf.set("spark.testing.memory", "2147480000"); // 因为jvm无法获得足够的资源  
  6.         JavaSparkContext sc = new JavaSparkContext("local", "First Spark App", conf);  
  7.         System.out.println(sc);  
  8.         // sc is an existing JavaSparkContext.  
  9.         SQLContext sqlContext = new org.apache.spark.sql.SQLContext(sc);  
  10.   
  11.         // A JSON dataset is pointed to by path.  
  12.         // The path can be either a single text file or a directory storing text files.  
  13.         DataFrame people = sqlContext.read().json("hdfs://master:9000/testFile/people.json");  
  14.         //DataFrame people = sqlContext.jsonFile("hdfs://master:9000/testFile/people.json");  
  15.   
  16.         // The inferred schema can be visualized using the printSchema() method.  
  17.         people.printSchema();  
  18.         // root  
  19.         //  |-- age: integer (nullable = true)  
  20.         //  |-- name: string (nullable = true)  
  21.   
  22.         // Register this DataFrame as a table.  
  23.         people.registerTempTable("people");  
  24.   
  25.         // SQL statements can be run by using the sql methods provided by sqlContext.  
  26.         DataFrame teenagers = sqlContext.sql("SELECT name FROM people WHERE age >= 13 AND age <= 19");  
  27.   
  28.         // Alternatively, a DataFrame can be created for a JSON dataset represented by  
  29.         // an RDD[String] storing one JSON object per string.  
  30.         List<String> jsonData = Arrays.asList(  
  31.           "{\"name\":\"Yin\",\"address\":{\"city\":\"Columbus\",\"state\":\"Ohio\"}}");  
  32.         JavaRDD<String> anotherPeopleRDD = sc.parallelize(jsonData);  
  33.         DataFrame anotherPeople = sqlContext.read().json(anotherPeopleRDD);  
  34.         anotherPeople.show();  
  35.     }  
  36. }  

 

Datasets

Datasets是新出的接口在1.6版本，为了使RDDS更便利（强类型，能使用强大的lambda函数），可以通过JVM对象构建或者通过熟练使用函数化转换得到（map, flatMap, filter, etc）
The unified Dataset API can be used both in Scala and Java. Python does not yet have support for the Dataset API, but due to its dynamic nature many of the benefits are already available (i.e. you can access the field of a row by name naturally row.columnName). Full python support will be added in a future release.

至于怎么用spark操作hive和其他数据库，以后再做学习

码字不易，转载请指明出处http://blog.csdn.net/tanggao1314/article/details/51594942

更多内容，请参考官网 Spark sql 编程指南

posted on 2017-11-08 14:23  csguo  阅读(2314)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 csguo
Powered by .NET 9.0 on Kubernetes