Spark Schema、Hive和Python的数据类型关系，以及Pyspark数据类型详解

1 概念阐述

Spark SQL使用时需要有若干“表”或“视图”的存在，这些“表”可以来自于Hive，也可以来来自RDD创建的DataFrame。如果“表”来自于Hive，它的模式(列名、列类型等)在创建时已经确定，一般情况下我们直接通过Spark SQL分析表中的数据即可；如果“表”来自DataFrame，我们就需要考虑两个要素：

通过Spark的官方文档可以了解到，生成一张DataFrame需要两个要素：

1. RDD中的数据；
2. 定义的数据模式，即Schema；

也就是说，我们需要将数据模式应用于关联着数据的RDD，然后就可以将该RDD注册为一张DataFrame。在这个过程中，最为重要的就是数据(模式)的数据类型，它直接影响着Pyspark的计算过程以及计算结果的正确性。

1.1 Spark中支持的数据类型

目前pyspark.sql.types支持的数据类型：NullType、StringType、BinaryType、BooleanType、DateType、TimestampType、DecimalType、DoubleType、FloatType、ByteType、IntegerType、LongType、ShortType、ArrayType、MapType、StructType(StructField)。

其中ArrayType、MapType、StructType我们称之为“复合类型”，其余称之为“基本类型”，“复合类型”在是“基本类型”的基础上构建而来的。

1.2 Spark中的基本类型与Python数据类型、Hive表数据类型的对应关系

这里的“Spark中的基本类型”指Spark-Sql模块下的，DataFrame里的Schema中的数据类型。

Spark中的基本类型	Python数据类型	Hive数据类型（未经过源码验证，仅猜测）	值范围
NullType	None
StringType	basestring	STRING、VARCHAR、CHAR
BinaryType	bytearray	BINARY	字节数组
BooleanType	bool	BOOLEAN
DateType	datetime.date	DATE	yyyy-MM-dd格式，其余格式都是错误的，会变为NULL
TimestampType	datetime.datetime	TIMESTAMPS	yyyy-MM-dd HH:mm:ss.fffffffff，即最多支持纳秒级，如果长度超出，则会变成NULL
DecimalType	decimal.Decimal	decimal	任意精度的最大38位的十进制数字
DoubleType	float(double precision floats)	double	[4.9E-324, 1.7976931348623157E308]
FloatType	float(single precision floats)	float	[1.4E-45, 3.4028235E38]
ByteType	int(a signed integer)	tinyint	[-128, 127]（-2^7, 2^7-1）
ShortType	int(a signed 16-bit integer)	smallint	[-32768, 32767]（-2^15, 2^15-1）
IntegerType	int(a signed 32-bit integer)	int	[-2147483648, 2147483647]（-2^31，2^31-1）
LongType	long(a signed 64-bit integer)	bigint	[-9223372036854775808, 9223372036854775807]（-2^63，2^63-1）

注意在Hive表中保存的Spark Schema缓存信息中，类型信息中的’Type’都要删除，即StringType是String。

1.3 Hive中数字类型各自的表示范围

基于以下官方文档中的数字类型的范围，笔者推断出了其和Spark中DataFrame里的Schema中的数据类型的对应关系。

关于更多Hive数据类型的介绍，可以查看这篇文章，不过注意其中对数字范围的描述有一些是错的：Hive数据类型详解

将Hive中各数据类型的数字范围和Spark基本类型中的数字范围做对比，我们可以猜想Hive tinyint、smallint、int、bigint、float、double与Java Byte、Short、Integer、Long、Float、Double是一一对应的（仅仅是猜想，并没有实际查看源码验证）。所以得出了前文表格中的结论。

2 分类型介绍每种数据类型的详情

2.1 数字类型(ByteType、ShortType、IntegerType、LongType、FloatType、DoubleType、DecimalType)

数字类型可分为两类：

1. 整数类型：ByteType、ShortType、IntegerType、LongType，使用时需要注意各自的整数表示范围；
2. 浮点类型：FloatType、DoubleType、DecimalType，使用时不但需要注意各自的浮点数表示范围，还需要注意各自的精度范围。

2.1.1 PySpark创建RDD对象，并通过SQL接口查询的示例

我们以常见的数据类型IntegerType来说明数字类型的使用方法：

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, IntegerType

# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
# 两个数字为-2^31，2^31-1，即IntergerType的数字范围
source = sc.parallelize([(-2147483648, 2147483647)])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
第一列的列名为col1，列类型为IntegerType，不可包含空(Null)值(False)；第二列的列名为col2，列类型为IntegerType，不可包含空(Null)值(False)。
(注意：实际使用中每列的数据类型并不一定相同)
'''

schema = StructType([StructField('col1', IntegerType(), False),
                    StructField('col2', IntegerType(), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select col1+col2 from temp_table').collect()
    
print(rows)

for row in rows:
    print(row[0], type(row[0]))

程序返回结果如下：

到此我们就完成了创建RDD、创建Schema、注册Table的整个过程，接下来就可以使用这张表(temp_table)通过Spark(Hive) SQL完成分析。其它数字类型的使用方式类似。

从前文中各数据类型的范围可以看出，虽然我们使用Python编写程序，然而这些数据类型的表示范围与Java中的Byte、Short、Integer、Long、Float、Double是一致的。其原因是，Spark是Scala实现的，而Scala运行于Java虚拟机之上，因此Spark SQL中的数据类型ByteType、ShortType、IntegerType、LongType、FloatType、DoubleType、DecimalType在运行过程中对应的数据实际上是由Java中的Byte、Short、Integer、Long、Float、Double表示的。

2.1.2 数据溢出现象

在使用Python编写Spark Application时需要牢记：为分析的数据选择合适的数据类型，避免因为数据溢出导致输入数据异常，但这仅仅能够解决数据输入的溢出问题，还不能解决数据在计算过程中可能出现的溢出问题。

我们将上述例子中的示例数据修改为（9223372036854775807, 9223372036854775807），数据类型修改为LongType，现在的示例数据实际是LongType所能表示的最大值，如果我们将这两例值相加，是否会出现溢出的情况呢？

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, LongType

# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
source = sc.parallelize([(9223372036854775807,9223372036854775807)])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
第一列的列名为col1，列类型为LongType，不可包含空(Null)值(False)；第二列的列名为col2，列类型为LongType，不可包含空(Null)值(False)。
(注意：实际使用中每列的数据类型并不一定相同)
'''

schema = StructType([StructField('col1', LongType(), False),
                    StructField('col2', LongType(), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select col1+col2 from temp_table').collect()
    
print(rows)

for row in rows:
    print(row[0], type(row[0]))

程序返回结果如下：

可以看出，实际计算结果与我们预想的完全一样，这是因为col1与col2的类型为LongType，那么col1 + col2的类型也应为LongType（原因见后文），然而col1 + col2的结果值18446744073709551614已经超过LongType所能表示的范围（[-9223372036854775808, 9223372036854775807]），必然导致溢出。

尝试在查询时，在SQL语句中将该数字转换为bingint，看看是否还会出现数据溢出的情况。

rows = spark.sql(
    'select cast(col1 as bigint)+cast(col2 as bigint) from temp_table').collect()

发现结果如下：

即数据还是溢出的。原因就是：Hive BIGINT的表示范围与LongType是一致的，毕竟Hive是Java实现的。所以我们将LongType的数据类型转换为BIGINT的方式是行不通的。

2.1.3 解决数据溢出问题

2.1.3.1 通过在SQL查询中使用decimal格式来解决

那么我们应该如何解决溢出问题呢？注意到Hive Numeric Types中的最后一个数字类型：DECIMAL，从Hive 0.11.0引入，Hive 0.13.0开始支持用户可以自定义“precision”和“scale”。Decimal基于Java BigDecimal实现，可以表示不可变的任务精度的十进制数字，支持常规的数学运算（+，-，*，/）和UDF（floor、ceil、round等），也可以与其它数字类型相互转换（cast）。使用示例如下：

rows = spark.sql(
    'select cast(col1 as decimal(38,0))+cast(col2 as decimal(38,0)) from temp_table').collect()

使用Decimal时需要注意“precision”和“scale”值的选取，Java BigDecimal（BigInteger，后续会提到）取值范围理论上取决于（虚拟）内存的大小，可见它们是比较消耗内存资源的，因此我们需要根据我们的实际需要为它们选取合适的值，并且需要满足下述条件：

整数部分位数（precision - scale） + 小数部分位数（scale） = precision

LongType所能表示的最大位数：19，因为在我们的示例中会导致溢出问题，因此我们将数值转换为Decimal，并指定precision为38，scale为0，这样我们便可以得到正确的结果：

需要注意的是计算结果类型也变成decimal.Decimal（Python）

2.1.3.1 通过在pyspark定义RDD和DataFrame时使用decimal格式来解决

使用Python编写Spark Application时，pyspark也提供了DecimalType，它是一种比较特殊的数据类型，它不是Python内建的数据类型，使用时需要导入模块decimal，使用方式如下：

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, DecimalType
from decimal import Decimal

# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
source = sc.parallelize([(Decimal('1.0'),Decimal('2.0'))])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
第一列的列名为col1，DecimalType，不可包含空(Null)值(False)；第二列的列名为col2，列类型为LongType，不可包含空(Null)值(False)。
(注意：实际使用中每列的数据类型并不一定相同)
'''

schema = StructType([StructField('col1', DecimalType(), False),
                    StructField('col2', DecimalType(), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select col1+col2, col2+1.0 from temp_table').collect()
    
print(rows)

for row in rows:
    print(row[0], type(row[0]))

程序返回结果：

**注意红字标识出来的两种不同的计算过程：**在将decimal数字转为DataFrame之后，一个是直接用两个值相加；而另一个是将一个值和小数常量相加。两者显示出来的计算结果不同，一个是不带小数点，一个是带的。然而，即便是不带小数点的结果，其类型仍然是decimal.Decimal（Python）。

在Pyspark中使用数据类型DecimalType时有两个地方需要注意:

1. 创建RDD时需要使用模块decimal中的Decimal生成数据；

2. DecimalType在Spark 1.2.0环境下使用时会出现异常：java.lang.ClassCastException: java.math.BigDecimal cannot be cast to org.apache.spark.sql.catalyst.types.decimal.Decimal，在Spark 1.5.0环境下可以正常使用，但需要将模块名称由“pyspark.sql”修改为“pyspark.sql.types”。

2.1.4 数据运算后的数据类型是如何决定的

我们明确指定数据的类型是什么，那么什么决定我们常规数学运算（+，-，*，/）之后的结果类型呢？这些数学运行在Hive中实际都是由UDF实现的（org.apache.hadoop.hive.ql.exec.FunctionRegistry）

1. +类型
   
2. -类型
   
3. *类型
   
4. /类型
   
5. %类型（取模）
   

从上述代码可以看出：“+”，“-”，“*”，“%”通过重载支持的数据类型：byte、short、int、long、float、double、decimal，而“/”通过重载仅仅支持数据类型：double、decimal，计算的结果类型与输入类型是相同的，这也意味着：

1. 数学运算“+”、“-”，“*”，“%”时可能会出现隐式转换（如int + long => long + long）;
2. 数学运算“/”则统一将输入数据转换为数据类型double或decimal进行运算，这一点也意味着，计算结果相应地为数据类型double或decimal。

2.2 时间类型（DateType，TimestampType）

DateType可以理解为年、月、日，TimestampType可以理解为年、月、日、时、分、秒，它们分别对着着Python datetime中的date，datetime，使用示例如下：

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from datetime import datetime, date
from pyspark.sql.types import StructType, StructField, DateType, TimestampType


# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
source = sc.parallelize([(date(2022, 4, 4), datetime(2022, 4, 4, 19, 25, 30))])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
第一列的列名为col1，DecimalType，不可包含空(Null)值(False)；第二列的列名为col2，列类型为LongType，不可包含空(Null)值(False)。
(注意：实际使用中每列的数据类型并不一定相同)
'''

schema = StructType([StructField('date', DateType(), False),
                    StructField('datetime', TimestampType(), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select date, datetime from temp_table').collect()
    
print(rows)

for row in rows:
    print(row[0], type(row[0]))

程序结果如下：

2.3 其他类型：StringType、BooleanType、BinaryType、NoneType

这几种数据类型的使用方法大致相同，就不一一讲解了，注意BinaryType对应着使用了Python中的bytearray。

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, StringType, BooleanType, BinaryType, NullType


# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
# 两个数字为-2^31，2^31-1，即IntergerType的数字范围
source = sc.parallelize([('str', False, bytearray(range(0, 10)), None)])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
'''

schema = StructType([StructField('str', StringType()),
                    StructField('bool', BooleanType()),
                    StructField('bytes', BinaryType()),
                    StructField('none', NullType())])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select str, bool, bytes, none from temp_table').collect()
    
print(rows)

for row in rows:
    print((row[0], type(row[0])), (row[1], type(row[1])), (row[2], type(row[2])), sep='|')

运行结果如下：

2.4 复合数据类型（ArrayType、MapType、StructType）

复合数据类型共有三种：数组（ArrayType）、字典（MapType）、结构体（StructType）。其中：

• 数组（ArrayType）要求数组元素类型一致；
• 字典（MapType）要求所有“key”的类型一致，所有“value”的类型一致，但“key”、“value”的类型可以不一致；
• 结构体（StructType）的元素类型可以不一致。

2.4.1 ArrayType

ArrayType要求指定数组元素类型。

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, ArrayType, IntegerType


# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
# 两个数字为-2^31，2^31-1，即IntergerType的数字范围
source = sc.parallelize([([1, 2, 3], )])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
'''

schema = StructType([StructField('array', ArrayType(IntegerType(), False), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select array[0], array[1], array[2] from temp_table').collect()
    
print(rows)

结果如下：

2.4.2 MapType

MapType要求指定键（key）类型和值（value）类型。

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, MapType, StringType, IntegerType


# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
# 两个数字为-2^31，2^31-1，即IntergerType的数字范围
source = sc.parallelize([({'key1': 1, 'key2': 2}, )])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
'''

schema = StructType([StructField('col_map', MapType(StringType(), IntegerType(), False), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select col_map["key1"], col_map["key2"] from temp_table').collect()
    
print(rows)

结果如下：

2.4.3 StructType

StructType包含的元素类型可不一致，需要根据元素的次序依次为其指定合适的名称与数据类型。

%pyspark
# 如果是通过Zeppelin （Apache开源框架）来运行，那么SparkSession和SparkContext对象应该是提前创建好的，不用再创建。
# 所以创建sc对象部分注释掉了
# from pyspark import SparkConf, SparkContext
from pyspark.sql.types import StructType, StructField, MapType, IntegerType, FloatType, StringType


# spark = SparkSession.builer\
#         appName('test').\
#         master('yarn').\
#         getOrCreate()
# sc = spark.sparkContext


# Step1：模拟“一行两列”的数据，并通过parallelize方法将其转换为一个RDD source，这个RDD就是关联着数据的RDD。
# 两个数字为-2^31，2^31-1，即IntergerType的数字范围
source = sc.parallelize([((1, 2.0, '3.0'), )])

'''
Step2：
创建数据模式，需要分别为这两列指定列名、列类型、可否包含空(Null)值；
其中模式（Schema）需要使用StructType表示，每一列的各个属性(列名称、列类型、可否包含空(Null)值)需要使用StructField表示；
'''

schema = StructType([StructField('struct', StructType([StructField('first', IntegerType(), False),
                                                        StructField('second', FloatType(), False),
                                                        StructField('third', StringType(), False)]), False)])

# Step3：通过rdd的toDF方法，可以创建一个DataFrame；
df = source.toDF(schema)
df.printSchema()
df.show()

# Step4：可以将DataFrame注册为临时视图
df.createOrReplaceTempView('temp_table')


rows = spark.sql(
    'select struct.first, struct.second, struct.third from temp_table').collect()
    
print(rows)

结果如下：

综上所述，Spark（Hive）SQL为我们提供了丰富的数据类型，我们需要根据分析数据的实际情况为其选取合适的数据类型（基本类型、复合类型）、尤其是数据类型各自的表示（精度）范围以及数据溢出的情况处理。