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为我们提供了丰富的数据类型,我们需要根据分析数据的实际情况为其选取合适的数据类型(基本类型、复合类型)、尤其是数据类型各自的表示(精度)范围以及数据溢出的情况处理。