Spark SQL - Parquet Files

Parquet is a columnar format, supported by many data processing systems. The advantages of having a columnar storage are as follows −
Columnar storage limits IO operations.
Columnar storage limits IO operations.
Columnar storage can fetch specific columns that you need to access.
Columnar storage can fetch specific columns that you need to access.
Columnar storage consumes less space.
Columnar storage consumes less space.
Columnar storage gives better-summarized data and follows type-specific encoding.
Columnar storage gives better-summarized data and follows type-specific encoding.
Spark SQL provides support for both reading and writing parquet files that automatically capture the schema of the original data. Like JSON datasets, parquet files follow the same procedure.
Let’s take another look at the same example of employee record data named employee.parquet placed in the same directory where spark-shell is running.
Given data − Do not bother about converting the input data of employee records into parquet format. We use the following commands that convert the RDD data into Parquet file. Place the employee.json document, which we have used as the input file in our previous examples.
$ spark-shell
Scala> val sqlContext = new org.apache.spark.sql.SQLContext(sc)
Scala> val employee = sqlContext.read.json(“emplaoyee”)
Scala> employee.write.parquet(“employee.parquet”)

It is not possible to show you the parquet file. It is a directory structure, which you can find in the current directory. If you want to see the directory and file structure, use the following command.
$ cd employee.parquet/

$ ls
_common_metadata
Part-r-00001.gz.parquet
_metadata
_SUCCESS

The following commands are used for reading, registering into table, and applying some queries on it.
Start the Spark shell using following example
$ spark-shell

Generate SQLContext using the following command. Here, sc means SparkContext object.
scala> val sqlContext = new org.apache.spark.sql.SQLContext(sc)

Create an RDD DataFrame by reading a data from the parquet file named employee.parquet using the following statement.
scala> val parqfile = sqlContext.read.parquet(“employee.parquet”)

Use the following command for storing the DataFrame data into a table named employee. After this command, we can apply all types of SQL statements into it.
scala> Parqfile.registerTempTable(“employee”)

The employee table is ready. Let us now pass some SQL queries on the table using the method SQLContext.sql().
Use the following command for selecting all records from the employee table. Here, we use the variable allrecords for capturing all records data. To display those records, call show() method on it.
scala> val allrecords = sqlContext.sql("SELeCT * FROM employee")

To see the result data of allrecords DataFrame, use the following command.
scala> allrecords.show()

+------+--------+----+
|  id  | name   |age |
+------+--------+----+
| 1201 | satish | 25 |
| 1202 | krishna| 28 |
| 1203 | amith  | 39 |
| 1204 | javed  | 23 |
| 1205 | prudvi | 23 |
+------+--------+----+


    46 Lectures 
     3.5 hours 

 Arnab Chakraborty

    31 Lectures 
     1 hours 

 Frahaan Hussain

    12 Lectures 
     1 hours 

 Pranjal Srivastava

    23 Lectures 
     1.5 hours 

 Mukund Kumar Mishra

    52 Lectures 
     1.5 hours 

 Bigdata Engineer

    23 Lectures 
     1 hours 

 Bigdata Engineer
 Print
 Add Notes
 Bookmark this page