Understanding Hive SerDes: A Detailed Guide with Examples

Apache Hive is a highly effective data warehousing tool built on top of Hadoop, providing a mechanism to manage and query structured data. One of Hive's powerful features is its ability to integrate with custom input and output formats through the use of SerDes (Serializer/Deserializer). This blog post will provide an in-depth exploration of SerDes in Hive, including their purpose, types, and usage with examples.

What are SerDes?

link to this section

SerDes is short for Serializer/Deserializer. In Hive, SerDes are used to instruct Hive on how to process a record. More specifically, a SerDe allows Hive to read in data from a table, and write it back out to HDFS in any custom format. Anyone can write their own SerDe for their own data formats.


A serializer is used to convert the objects Hive operates on (which are in a Java-friendly format) into a format that can be written out to HDFS or another system.


A deserializer does the opposite work of a serializer, translating data read from HDFS into a Java-friendly format that Hive can work with.

Why Use SerDes?

link to this section

Hive uses SerDes and other mechanisms to read data from tables. By default, Hive reads data from tables and turns it into a standard format. However, sometimes the data you're dealing with isn't in a standard format. In these cases, you need to write a custom SerDe to instruct Hive on how to process the data.

For instance, if your data is in a custom binary format, you would need to write a SerDe to parse that data into a format Hive can understand. Similarly, if you want to output data in a particular format, you might need to write a custom SerDe to serialize the data.

Creating Custom SerDes

link to this section

To create a custom SerDe, you will need to implement the org.apache.hadoop.hive.serde2.SerDe interface. This interface has several methods that you need to implement:

  • initialize : This method is used to initialize the SerDe. You can receive configuration information through the parameters of this method.

  • deserialize : This method takes a Writable object (which represents a record of data) and translates it into a standard Java object that Hive can manipulate.

  • getSerializedClass : This method returns the class of the object that the serialize method returns.

  • serialize : This method takes a Java object that Hive has been manipulating, and turns it into a Writable object that can be written into HDFS.

  • getObjectInspector : This method returns an ObjectInspector for the rows of data that the deserialize method produces. The ObjectInspector provides Hive with information about the data types for the fields in the row and how to access the fields in the object.

The above methods need to be implemented in Java, and the resulting class needs to be compiled into a JAR file, which can be added to Hive using the ADD JAR command. After adding the JAR file to Hive, you can use the ROW FORMAT SERDE clause in your CREATE TABLE statement to specify the SerDe.

Example: Creating a Custom SerDe

link to this section

Let's look at a simple example of creating a custom SerDe. In this example we are creating a hypothetical case where fields in our data are separated by a colon ( : ) character.

First, we will create the Java class that implements the SerDe:

// Import necessary libraries
import org.apache.hadoop.hive.serde2.AbstractSerDe;
import org.apache.hadoop.hive.serde2.SerDeException;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.hive.serde2.io.DoubleWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory.javaStringObjectInspector;

public class ColonDelimitedSerDe extends AbstractSerDe {

    public void initialize(Configuration conf, Properties tbl) throws SerDeException {
        // Initialization code can go here

    public Object deserialize(Writable blob) throws SerDeException {
        // Input processing can be handled here
        String row = blob.toString();
        String[] fields = row.split(":");
        return Arrays.asList(fields);

    public ObjectInspector getObjectInspector() throws SerDeException {
        ArrayList<String> structFieldNames = new ArrayList<String>();
        ArrayList<ObjectInspector> structFieldObjectInspectors = new ArrayList<ObjectInspector>();

        // fill struct field names

        // fill struct field object inspectors

        return ObjectInspectorFactory.getStandardStructObjectInspector(structFieldNames, structFieldObjectInspectors);

    public Class<? extends Writable> getSerializedClass() {
        return Text.class;

    public Writable serialize(Object obj, ObjectInspector objInspector) throws SerDeException {
        // Serialization code can go here

After implementing your SerDe, you can compile the Java class into a JAR file:

javac -classpath $HIVE_HOME/lib/hive-serde-*.jar:$HIVE_HOME/lib/hive-exec-*.jar ColonDelimitedSerDe.java 
jar cf colon_delimited_serde.jar ColonDelimitedSerDe.class 

Then, you can use the ADD JAR command in Hive to add the JAR file:

ADD JAR /path/to/colon_delimited_serde.jar; 

Finally, when creating a table, you can specify the SerDe to use with the ROW FORMAT SERDE clause:

CREATE TABLE my_table(field1 STRING, field2 STRING, field3 STRING) 
ROW FORMAT SERDE 'ColonDelimitedSerDe'; 

Common Hive SerDes

link to this section

Apache Hive comes with several built-in SerDes that cover most of the standard use cases for structured and semi-structured data. Here are some of the most commonly used ones:

  1. LazySimpleSerDe : This is the default SerDe for most Hive tables. It can handle all primitive data types as well as complex types like arrays, maps, and structs. It supports customizable serialization formats and can process delimited data such as CSV, TSV, and custom delimited data.

    This is the default SerDe for Hive and it's used when you create a table without specifying the SerDe. Here's an example of creating a table with this SerDe:

    CREATE TABLE employee ( 
        id INT, 
        name STRING, 
        salary DOUBLE, 
        department STRING) 
  2. AvroSerDe : Avro is a popular data serialization system that supports schema evolution - you can change the schema over time, which can be useful for long-lived data. The AvroSerDe allows you to read or write Avro data from or to Hive tables.

    To use the AvroSerDe, you need to specify it when creating the table:

    CREATE TABLE employee_avro 
  3. OrcSerDe : ORC (Optimized Row Columnar) is a highly efficient way to store Hive data. It was designed to overcome limitations of the other Hive file formats. Using ORC files improves performance when Hive is reading, writing, and processing data.

    When creating an ORC table, you can specify the STORED AS ORC clause:

    CREATE TABLE employee_orc ( 
        id INT, 
        name STRING, 
        salary DOUBLE, 
        department STRING) 
  4. ParquetHiveSerDe : Parquet is a columnar storage file format available to any project in the Hadoop ecosystem. ParquetHiveSerDe is used for Parquet file format and it offers advantages of compressed, efficient columnar data representation.

    To create a Parquet table, you can use the STORED AS PARQUET clause:

    CREATE TABLE employee_parquet ( 
        id INT, 
        name STRING, 
        salary DOUBLE, 
        department STRING) 
  5. RegExSerDe : This SerDe allows users to define tables with fields deriving from a configured regular expression pattern. It's particularly useful for parsing data with a regular structure.

    Here's an example of using the RegExSerDe to parse log files where each line is of the format "IP - - [date] 'request' response bytes":

    CREATE TABLE logs ( 
        ip STRING, 
        date STRING, 
        request STRING, 
        response INT, 
        bytes INT) 
        "input.regex" = "([^ ]*) - - \\[([^\\]]*)\\] \"([^\"]*)\" ([^ ]*) ([^ ]*)", 
        "output.format.string" = "%1$s %2$s \"%3$s\" %4$s %5$s") 
  6. JsonSerDe : JSON is a common semi-structured data format. Hive includes the org.openx.data.jsonserde.JsonSerDe for parsing JSON data. This SerDe is used for parsing JSON data and can be used in defining tables.

    To create a table for JSON data, you can use the JsonSerDe:

    CREATE TABLE employee_json ( 
        id INT, 
        name STRING, 
        salary DOUBLE, 
        department STRING) 

    Note that these examples assume that the respective SerDes are available in your Hive environment. Some SerDes like org.openx.data.jsonserde.JsonSerDe for JSON may require additional JAR files to be added to Hive.

Each of these SerDes has its own strengths and is suited to different types of data, so the best one to use depends on the specifics of the data you're working with. It's also possible to create custom SerDes if the built-in ones don't meet your needs.

In conclusion, SerDes provide a powerful way to instruct Hive on how to read and write data in custom formats. By understanding the concepts and the usage of SerDes, you can make your Hive operations more flexible and compatible with any data format.