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

文章目录

  • 1 概念阐述
    • 1.1 Spark中支持的数据类型
    • 1.2 Spark中的基本类型与Python数据类型、Hive表数据类型的对应关系
    • 1.3 Hive中数字类型各自的表示范围
  • 2 分类型介绍每种数据类型的详情
    • 2.1 数字类型(ByteType、ShortType、IntegerType、LongType、FloatType、DoubleType、DecimalType)
      • 2.1.1 PySpark创建RDD对象,并通过SQL接口查询的示例
      • 2.1.2 数据溢出现象
      • 2.1.3 解决数据溢出问题
        • 2.1.3.1 通过在SQL查询中使用decimal格式来解决
        • 2.1.3.1 通过在pyspark定义RDD和DataFrame时使用decimal格式来解决
      • 2.1.4 数据运算后的数据类型是如何决定的
    • 2.2 时间类型(DateType,TimestampType)
    • 2.3 其他类型:StringType、BooleanType、BinaryType、NoneType
    • 2.4 复合数据类型(ArrayType、MapType、StructType)
      • 2.4.1 ArrayType
      • 2.4.2 MapType
      • 2.4.3 StructType

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中的数据类型的对应关系。
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第1张图片
关于更多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]))

程序返回结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第2张图片

到此我们就完成了创建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]))

程序返回结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第3张图片
可以看出,实际计算结果与我们预想的完全一样,这是因为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()

发现结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第4张图片
即数据还是溢出的。原因就是: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,这样我们便可以得到正确的结果:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第5张图片
需要注意的是计算结果类型也变成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]))

程序返回结果:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第6张图片
**注意红字标识出来的两种不同的计算过程:**在将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)
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第7张图片

  1. +类型
    Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第8张图片
  2. -类型
    Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第9张图片
  3. *类型
    Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第10张图片
  4. /类型
    在这里插入图片描述
  5. %类型(取模)
    Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第11张图片

从上述代码可以看出:“+”,“-”,“*”,“%”通过重载支持的数据类型: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]))

程序结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第12张图片

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='|')

运行结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第13张图片

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)

结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第14张图片

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)

结果如下:
Spark Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第15张图片

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 Schema、Hive和Python的数据类型关系,以及Pyspark数据类型详解_第16张图片

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

你可能感兴趣的