Spark SQL使用时需要有若干“表”或“视图”的存在，这些“表”可以来自于Hive，也可以来来自RDD创建的DataFrame。如果“表”来自于Hive，它的模式(列名、列类型等)在创建时已经确定，一般情况下我们直接通过Spark SQL分析表中的数据即可；如果“表”来自DataFrame，我们就需要考虑两个要素：
通过Spark的官方文档可以了解到，生成一张DataFrame需要两个要素：
也就是说，我们需要将数据模式应用于关联着数据的RDD，然后就可以将该RDD注册为一张DataFrame。在这个过程中，最为重要的就是数据(模式)的数据类型，它直接影响着Pyspark的计算过程以及计算结果的正确性。
目前pyspark.sql.types支持的数据类型：NullType、StringType、BinaryType、BooleanType、DateType、TimestampType、DecimalType、DoubleType、FloatType、ByteType、IntegerType、LongType、ShortType、ArrayType、MapType、StructType(StructField)。
其中ArrayType、MapType、StructType我们称之为“复合类型”，其余称之为“基本类型”，“复合类型”在是“基本类型”的基础上构建而来的。
这里的“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。
基于以下官方文档中的数字类型的范围，笔者推断出了其和Spark中DataFrame里的Schema中的数据类型的对应关系。
关于更多Hive数据类型的介绍，可以查看这篇文章，不过注意其中对数字范围的描述有一些是错的：Hive数据类型详解
将Hive中各数据类型的数字范围和Spark基本类型中的数字范围做对比，我们可以猜想Hive tinyint、smallint、int、bigint、float、double与Java Byte、Short、Integer、Long、Float、Double是一一对应的（仅仅是猜想，并没有实际查看源码验证）。所以得出了前文表格中的结论。
数字类型可分为两类：
我们以常见的数据类型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表示的。
在使用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的方式是行不通的。
那么我们应该如何解决溢出问题呢？注意到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）
使用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时有两个地方需要注意:
创建RDD时需要使用模块decimal中的Decimal生成数据；
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”。
我们明确指定数据的类型是什么，那么什么决定我们常规数学运算（+，-，*，/）之后的结果类型呢？这些数学运行在Hive中实际都是由UDF实现的（org.apache.hadoop.hive.ql.exec.FunctionRegistry）
从上述代码可以看出：“+”，“-”，“*”，“%”通过重载支持的数据类型：byte、short、int、long、float、double、decimal，而“/”通过重载仅仅支持数据类型：double、decimal，计算的结果类型与输入类型是相同的，这也意味着：
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]))
程序结果如下：
这几种数据类型的使用方法大致相同，就不一一讲解了，注意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='|')
运行结果如下：
复合数据类型共有三种：数组（ArrayType）、字典（MapType）、结构体（StructType）。其中：
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)
结果如下：
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)
结果如下：
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为我们提供了丰富的数据类型，我们需要根据分析数据的实际情况为其选取合适的数据类型（基本类型、复合类型）、尤其是数据类型各自的表示（精度）范围以及数据溢出的情况处理。