飞书API（11）：阿里云MaxCompute分区表入库

最新推荐文章于 2024-09-11 09:00:00 发布
最新推荐文章于 2024-09-11 09:00:00 发布
阅读量1k 收藏 26
点赞数 24
分类专栏： 飞书API解读 文章标签： 飞书 阿里云 odps
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45476428/article/details/139398689
版权

一、引入

前面入库阿里云 MaxCompute 的数据都是读取之后直接写入，保留数据最新的状态，如果我要保留历史的状态，怎么办呢？
MaxCompute 表有一个分区功能，可以自行定义分区。我们可以使用 MaxCompute 表的分区功能，每天写入一个分区，保留每天每条数据的状态。
表单的分区功能，除了存储每天数据明细信息，也可以根据数据中的某个维度做分区。
本文重点来探讨下怎么建分区表以及怎么写入分区表。

二、MaxCompute 分区表

什么是分区？
分区表是指拥有分区空间的表，可以理解为分类，通过分类把不同类型的数据放到不同的目录下。分类的标准就是分区字段，可以是一个，也可以是多个。
MaxCompute 将分区列的每个值作为一个分区（目录），多级分区则是将表的多个字段作为表的分区。
分区其实就像我们常用的文件夹的概念，一级分区类比根目录，二级分区则是根目录下的子文件夹，然后数据就是子文件夹下的某个文件，事实上，底层也是这么存储数据的。

分区表的意义在于优化查询。查询表时通过WHERE子句查询指定所需查询的分区，避免全表扫描，提高处理效率，降低计算费用。使用数据时，如果指定需要访问的分区名称，则只会读取相应的分区。所以合理设计和使用分区，可以提高查询性能、简化数据管理，并支持更灵活的数据访问和操作。
多级分区结构参考：
image.png

2.1 创建分区表

创建分区表时，给分区的参数传递值即可。下面通过两种方法展开。

方法一：通过 Schema 创建分区表。
调用阿里云odps.models中的Partition，传递name、type和comment三个参数，创建一个分区对象，然后放到列表中，传递给Schema即可。
由于后面涉及定制化需要重新创建 schema，所以这里把partitions也返回，以便传递给后续的定制函数。

from odps.models import Schema, Column, Partition
def generate_create_schema(store_fields_info_df):
    columns = []
    columns_index = {}
    for index, row in store_fields_info_df.iterrows():
        name = row['tb_field_name']; type=row['mc_type']; comment=row['feishu_field_name']
        # print(name,type,comment)
        columns.append(Column(name=name, type=type, comment=comment))
        columns_index[name] = (index, comment)
    columns.append(Column(name='record_id', type='string', comment='飞书表行record_id'))
    columns.append(Column(name='last_modified_time', type='datetime', comment='数据更新时间'))
    partitions = [Partition(name='pt', type='string', comment='分区字段')]
    schema = Schema(columns=columns, partitions=partitions)
    print(f'成功生成 MaxCompute 建表 schema。关联方法：generate_create_schema。')
    return schema, columns, columns_index, partitions

def cre_mc_table(db_table_name, schema):
    if o.exist_table(db_table_name):
        print(f'表单 {db_table_name} 已存在，不需要新建。关联方法：cre_mc_table。')
    else:
        table = o.create_table(db_table_name, schema, if_not_exists=True)
        print(f'成功创建 MaxCompute 表：{db_table_name}。关联方法：cre_mc_table。')

方法二：通过类建表 DDL 创建分区表。
这个方法比较简单，以 SQL 语法的形式写一个字段的信息，比如pt string comment "分区字段"，然后直接传递给阿里云的建表函数o.create_table()即可。

def generate_create_ddl(store_fields_info_df):
    cre_ddl = ''
    for index, row in store_fields_info_df.iterrows():
        cre_ddl += f"{row['tb_field_name']} {row['mc_type']} comment '{row['feishu_field_name']}',"
    default_fields = "record_id string comment '飞书表行record_id',last_modified_time datetime comment '数据更新时间'"
    cre_ddl = cre_ddl + default_fields
    print(f'成功生成 MaxCompute 类建表 DDL。关联方法：generate_create_ddl。')
    return cre_ddl

def cre_mc_table(db_table_name, cre_ddl):
    if o.exist_table(db_table_name):
        print(f'表单 {db_table_name} 已存在，不需要新建。关联方法：cre_mysql_table。')
    else:
        table = o.create_table(db_table_name, (cre_ddl, 'pt string comment "分区字段" '), if_not_exists=True)
        print(f'创建 MaxCompute 表：{db_table_name}。关联方法：cre_mc_table。')

2.2 写入分区表

将数据写入分区表，需要额外指定分区字段的值。分区表的分区字段的值可以指定固定值，也可以使用处理结果中的某一列。此处直接使用 T-1 的日期，格式为：yyyymmdd。
这个指定的固定值可以使用datetime模块计算出来，也可以使用 DataWorks 的调度参数。
直接计算出来可以参考以下代码，其中datetime.datetime.today()能够获取到今天的日期，而datetime.timedelta(days=1)可以得到 1 天的时间间隔，将今天的日期减去 1 天便可得到昨天的日期，然后使用strftime('%Y%m%d')进行格式化便得到了最终的日期格式。

import datetime
pt_date = (datetime.datetime.today() - datetime.timedelta(days=1)).strftime('%Y%m%d')

使用 DataWorks 的调度参数则需要在右边侧边栏的属性里找到调度参数，新增一对参数，这里我把参数名定位仪为pt_date，参数值设置为$bizdate。参考如下：
image.png

设置完参数可以点击【调度参数预览】检查是否有问题，结果如下，结果是 T-1，且格式为：yyyymmdd，符合预期。
image.png

参数配置好了，那怎么使用呢？
阿里云提供了一个全局变量：args，可以直接使用args['ptdate']得到刚刚设置的ptdate参数的值。

了解了基本的信息之后，便可以进行开发，这里介绍两种方法：转为列表直接写入和通过 PyODPS 的 DataFrame 做中转再写入。

2.2.1 方法一：转为列表直接写入表。

直接在open_writer()传递参数值给partition参数即可，参数值的两种获取方式任选一种即可。特别注意的一点是要加上参数create_partition=True，即当分区不存在的时候创建分区。

import math

# 需要处理 nan 值
def replace_nan_with_none(data):
    """递归地将列表中的nan替换为None"""
    # math.isnan(df.values.tolist()[1][2])
    if isinstance(data, list):
        return [replace_nan_with_none(item) for item in data]
    elif isinstance(data, float) and math.isnan(data):
        return None
    else:
        return data
        
def insert_mc_table(feishu_df, table_name):
    """
    Maxcompute 插入数据
    """
    feishu_data_ary = feishu_df.values.tolist()
    feishu_data_ary = replace_nan_with_none(feishu_data_ary)
    # print(feishu_data_ary)
    t = o.get_table(table_name)
    # # 参数值获取1：使用 datetime 模块获取
    # ptdate = (datetime.datetime.today()- datetime.timedelta(days=1)).strftime('%Y%m%d')  #昨天
    # 参数值获取2：使用 DataWorks 调度参数获取
    ptdate = args['ptdate']
    with t.open_writer(partition=f"pt={ptdate}", create_partition=True) as writer:
        writer.write(feishu_data_ary)  
    print(f'成功将飞书数据写入 MaxCompute 数据表：{table_name}。关联方法：insert_mc_table。')

2.2.2 方法二：转为 PyODPS DataFrame 再写入表。

直接在persist()传递参数值给partition参数即可，参数值的两种获取方式任选一种即可。特别注意的一点是要加上参数create_partition=True，即当分区不存在的时候创建分区。

def insert_mc_table(feishu_df, mc_table_name, mc_df_astype):
    """
    生成 PyODPS DataFrame 并将数据插入 Maxcompute 表
    """
    aliyun_df = DataFrame(feishu_df,as_type=mc_df_astype)
    # # 参数值获取1：使用 datetime 模块获取
    # ptdate = (datetime.datetime.today()- datetime.timedelta(days=1)).strftime('%Y%m%d')  #昨天
    # 参数值获取2：使用 DataWorks 调度参数获取
    ptdate = args['ptdate']
    aliyun_df.persist(mc_table_name, partition=f"pt={ptdate}", create_partition=True)    
    print(f'成功将飞书数据写入 MaxCompute 数据表：{mc_table_name}。关联方法：insert_mc_table。')

另外，一个数据出入常见的问题：如果执行多次是在原分区追加插入，还是覆盖插入，或是删除原分区重新新建分区插入？
使用 列表插入，即使用write_table()方法插入，在写入数据时会追加到原有数据中，PyODPS 不提供覆盖数据的选项，如果需要覆盖数据，需要手动清除原有数据。对于非分区表，可以调用truncate()方法；对于分区表，需要删除分区后再建立新的分区。
而转为 PyODPS 的 DataFrame 再插入数据，阿里云提供了drop_partition和create_partition参数，当分区存在时，先将分区删除，然后再创建新的同名（参数值）分区。参考代码如下，即在上面的代码的persist()方法多加上一对参数drop_partition=True。

df.persist('table_name', partition='ds=test', drop_partition=True, create_partition=True)

2.3 迭代定制化函数

前面介绍了两种建表方式和两种写表方式，再进行定制化的时候，需要修改建表的逻辑和写表的逻辑，建表和写表的方法两两结合可以有四种组合，下面拿其中两种展开阐述，分别是 Schema + DataFrame 和 类 DDL+列表。

2.3.1 Schema + DataFrame

当需要局部进行定制化迭代的时候，如果是使用 Schema 需要重新生成，使用分区表时，需要多传递分区信息，此处将前面创建表单的partitions传递到函数中，并用于最终重新生成 schema。
当使用 PyODPS 的 DataFrame 中转将数据入库的时候，还需要处理 DataFrame 的 astype，值得注意的时，DataFrame 中没有 date 类型，所以时间列转为日期不需要修改 astype。

def custom_field(df_return, columns, columns_index, mc_df_astype, partitions):
    # 2.1 场景一：把数字入库为 int 类型
    # 修改 SQL 即可
    # cre_ddl = cre_ddl.replace('field_number float','field_number int')
    column = Column(name='field_number', type='bigint', comment=columns_index['field_number'][1])
    columns[columns_index['field_number'][0]] = column
    #修改mc_df_astype
    mc_df_astype['field_number'] = 'int64'
    
    # 2.2 场景二：把日期入库为 date 类型
    # 修改 df，MySQL会自动截断，Maxcompute不行，需要使用 x.date() 处理
    df_return['field_createdtime'] = df_return['field_createdtime'].apply(lambda x:x.date())
    # 修改 SQL
    # cre_ddl = cre_ddl.replace('field_createdtime datetime','field_createdtime date')
    column = Column(name='field_createdtime', type='date', comment=columns_index['field_createdtime'][1])
    columns[columns_index['field_createdtime'][0]] = column
    # #修改mc_df_astype
    # mc_df_astype['field_createdtime'] = 'date'
    
    # 2.3 场景三：日期给定默认最大值
    # 修改 df 即可
    #默认值改为 2222-01-01 00:00:00
    mask = df_return['field_date'] == pd.Timestamp('1970-01-01 08:00:01')
    df_return.loc[mask, 'field_date'] = pd.Timestamp('2222-01-01 00:00:00')
    
    # 2.4 场景四：公式保留具体值
    # 修改 df
    # 修改 SQL
    df_return['field_numformula'] = df_return['field_numformula'].apply(lambda x:json.loads(x)['value'][0])
    # cre_ddl = cre_ddl.replace('field_numformula varchar(256)','field_numformula int')
    column = Column(name='field_numformula', type='bigint', comment=columns_index['field_numformula'][1])
    columns[columns_index['field_numformula'][0]] = column
    #修改mc_df_astype
    mc_df_astype['field_numformula'] = 'int64'

    # 创建新的 schema
    schema = Schema(columns=columns, partitions=partitions)
    print('定制函数打印数据和建表语句')
    print('----------------------------------------------\n', df_return[['field_number','field_createdtime','field_date','field_numformula']].head(5))
    print('----------------------------------------------\n', schema.columns)
    return df_return, schema, mc_df_astype

2.3.2 类 DDL+列表

在定制化某些列信息时，如果是使用类 建表的 DDL 语句，根据建表的规则，识别对应的字符串进行替换即可。使用列表写入数据则不需要进行修改。


def custom_field(df_return, cre_ddl):
    # 2.1 场景一：把数字入库为 int 类型
    # 修改 SQL 即可
    cre_ddl = cre_ddl.replace('field_number float','field_number int')
    
    # 2.2 场景二：把日期入库为 date 类型
    # 修改 df，MySQL会自动截断，Maxcompute不行，需要使用 x.date() 处理
    df_return['field_createdtime'] = df_return['field_createdtime'].apply(lambda x:x.date())
    # 修改 SQL
    cre_ddl = cre_ddl.replace('field_createdtime datetime','field_createdtime date')

    # 2.3 场景三：日期给定默认最大值
    # 修改 df 即可
    #默认值改为 2222-01-01 00:00:00
    mask = df_return['field_date'] == pd.Timestamp('1970-01-01 08:00:01')
    df_return.loc[mask, 'field_date'] = pd.Timestamp('2222-01-01 00:00:00')
    
    # 2.4 场景四：公式保留具体值
    # 修改 df
    # 修改 SQL
    df_return['field_numformula'] = df_return['field_numformula'].apply(lambda x:json.loads(x)['value'][0])
    cre_ddl = cre_ddl.replace('field_numformula varchar(256)','field_numformula int')

    print('定制函数打印数据和建表语句')
    print('----------------------------------------------\n', df_return[['field_number','field_createdtime','field_date','field_numformula']].head(5))
    print('----------------------------------------------\n', schema.columns)
    return df_return, cre_ddl

三、整合代码（Schema+DataFrame）

上面介绍了两种建表方式和两种写入方式，可以有4种搭配，这里提供 schema+DataFrame 的，即在上一小节最终的代码的基础上在generate_create_schema()、custom_field()、insert_mc_table()三个函数中都加上分区字段即可。
两点说明：

  • 该代码加上分区处理逻辑：当分区存在时，删除重建，确保重复跑数据不会重复。
  • 该代码使用了 DataWorks 的调度参数，所以使用时需要配置调度参数：pt_date=$bizdate

import requests
import json
import datetime
import pandas as pd
from sqlalchemy import create_engine, text
from urllib.parse import urlparse, parse_qs
from odps.models import Schema, Column, Partition
import math

def get_table_params(bitable_url):
    # bitable_url = "https://feishu.cn/base/aaaaaaaa?table=tblccc&view=vewddd"
    parsed_url = urlparse(bitable_url)              #解析url：(ParseResult(scheme='https', netloc='feishu.cn', path='/base/aaaaaaaa', params='', query='table=tblccc&view=vewddd', fragment='')
    query_params = parse_qs(parsed_url.query)       #解析url参数：{'table': ['tblccc'], 'view': ['vewddd']}
    app_token = parsed_url.path.split('/')[-1]
    table_id = query_params.get('table', [None])[0]
    view_id = query_params.get('view', [None])[0]
    print(f'成功解析链接，app_token：{app_token}，table_id：{table_id}，view_id：{view_id}。关联方法：get_table_params。')
    return app_token, table_id, view_id

def get_tenant_access_token(app_id, app_secret):
    url = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal"
    payload = json.dumps({
        "app_id": app_id,
        "app_secret": app_secret
    })
    headers = {'Content-Type': 'application/json'}
    response = requests.request("POST", url, headers=headers, data=payload)
    tenant_access_token = response.json()['tenant_access_token']
    print(f'成功获取tenant_access_token：{tenant_access_token}。关联函数：get_table_params。')
    return tenant_access_token

def get_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_token='', page_size=20):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/search?page_size={page_size}&page_token={page_token}&user_id_type=user_id"
    payload = json.dumps({"view_id": view_id})
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {tenant_access_token}'
    }
    response = requests.request("POST", url, headers=headers, data=payload)
    print(f'成功获取page_token为【{page_token}】的数据。关联函数：get_bitable_datas。')
    return response.json()


def get_all_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_token='', page_size=20):
    has_more = True
    feishu_datas = []
    while has_more:
        response = get_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_token, page_size)
        if response['code'] == 0:
            page_token = response['data'].get('page_token')
            has_more = response['data'].get('has_more')
            # print(response['data'].get('items'))
            # print('\n--------------------------------------------------------------------\n')
            feishu_datas.extend(response['data'].get('items'))
        else:
            raise Exception(response['msg'])
    print(f'成功获取飞书多维表所有数据，返回 feishu_datas。关联函数：get_all_bitable_datas。')
    return feishu_datas

def get_bitable_fields(tenant_access_token, app_token, table_id, page_size=500):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/fields?page_size={page_size}"
    payload = ''
    headers = {'Authorization': f'Bearer {tenant_access_token}'}
    
    response = requests.request("GET", url, headers=headers, data=payload)
    field_infos = response.json().get('data').get('items')
    print('成功获取飞书字段信息，关联函数：get_bitable_fields。')
    return field_infos

def merge_list(ls_from, ls_join, on=None, left_on=None, right_on=None):
    """将两个[{},{}]结构的数据合并"""
    df_from = pd.DataFrame(ls_from)
    df_join = pd.DataFrame(ls_join)
    if on is not None:
        df_merge = df_from.merge(df_join, how='left', on=on)
    else:
        df_merge = df_from.merge(df_join, how='left', left_on=left_on, right_on=right_on) # , suffixes=('', '_y')
    print(f'成功合并列表或DataFrame。关联方法：merge_list。')
    return df_merge


def extract_key_fields(feishu_datas, store_fields_info_df):
    """处理飞书数据类型编号的数据"""
    print('开始处理飞书多维表关键字段数据...')
    # 需要record_id 和 订单号，用于和数据库数据匹配
    df_feishu = pd.DataFrame(feishu_datas)
    df_return = pd.DataFrame()
    
    #根据列的数据类型，分别处理对应的数据。注意：仅返回以下列举的数据类型，如果fields_map的内容包含按钮、流程等数据类型的飞书列，忽略。
    for index, row in store_fields_info_df.iterrows():
        if row['type'] == 1:       #文本
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:x.get(row['field_name'],[{}])[0].get('text'))
        
        elif row['type'] in (2, 3, 4, 7, 13, 1005):  #数字、单选、多选、复选框、手机号、自动编号
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:x.get(row['field_name']))
        
        elif row['type'] in (5, 1001, 1002):         #日期(包含创建和更新)，需要加 8 小时，即 8*60*60*1000=28800 秒
            df_return[row['tb_field_name']] = pd.to_datetime(df_feishu['fields'].apply(lambda x:28800 + int(x.get(row['field_name'],1000)/1000)), unit='s')
        
        elif row['type'] in(11, 23, 1003, 1004):       #人员、群组、创建人、修改人，遍历取name
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x: ','.join([i.get('name') for i in x.get(row['field_name'],[{"name":""}])]))  # 需要遍历

        elif row['type'] == 15:    #链接
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:x.get(row['field_name'],{}).get('link'))
        
        elif row['type'] == 17:    #附件，遍历取url
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:[i.get('url') for i in x.get(row['field_name'],[{}])]) #需要遍历
    
        elif row['type'] in(18, 21):    #单向关联、双向关联，取link_record_ids
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:x.get(row['field_name'],{}).get('link_record_ids'))
    
        elif row['type'] in(19, 20):    #查找引用和公式
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:json.dumps(x.get(row['field_name'])))
    
        elif row['type'] == 22:    #地理位置
            df_return[row['tb_field_name']] = df_feishu['fields'].apply(lambda x:x.get(row['field_name'],{}).get('location'))
            
    #加上record_id
    df_return['record_id'] = df_feishu.record_id
    #加上表更新字段
    df_return['last_modified_time'] = datetime.datetime.now()
    print(f'成功提取入库字段的数据。关联方法：extract_key_fields。')
    return df_return

def generate_create_schema(store_fields_info_df):
    columns = []
    columns_index = {}
    for index, row in store_fields_info_df.iterrows():
        name = row['tb_field_name']; type=row['mc_type']; comment=row['feishu_field_name']
        # print(name,type,comment)
        columns.append(Column(name=name, type=type, comment=comment))
        columns_index[name] = (index, comment)
    columns.append(Column(name='record_id', type='string', comment='飞书表行record_id'))
    columns.append(Column(name='last_modified_time', type='datetime', comment='数据更新时间'))
    partitions = [Partition(name='pt', type='string', comment='分区字段')]
    schema = Schema(columns=columns, partitions=partitions)
    print(f'成功生成 MaxCompute 建表 schema。关联方法：generate_create_schema。')
    return schema, columns, columns_index, partitions

def cre_mc_table(db_table_name, schema):
    if o.exist_table(db_table_name):
        print(f'表单 {db_table_name} 已存在，不需要新建。关联方法：cre_mc_table。')
    else:
        table = o.create_table(db_table_name, schema, if_not_exists=True)
        print(f'成功创建 MaxCompute 表：{db_table_name}。关联方法：cre_mc_table。')

def generate_astype(store_fields_info_df):
    """
    功能：对整合了飞书列入库的列、飞书列类型、和阿里云 DataFrame 数据类型的 pandas DataFrame，提取字段名和阿里云DataFrame 数据类型
    """
    #生成阿里云DataFrame的as_type，用于将处理好的数据转为阿里云DataFrame，格式：{'field_no': 'string', 'field_select': 'float64', 'field_text': 'datatime'}
    mc_df_astype = store_fields_info_df.set_index('tb_field_name').to_dict()['mc_df_type']
    #加上record_id
    mc_df_astype['record_id'] = 'string'
    #加一个表更新时间
    mc_df_astype['last_modified_time'] = 'DATETIME'
    # print(mc_df_astype)
    print('成功生成阿里云 DataFrame 的 as_type。方法：generate_astype')
    return mc_df_astype

def insert_mc_table(feishu_df, mc_table_name, mc_df_astype):
    """
    生成 PyODPS DataFrame 并将数据插入 Maxcompute 表
    """
    aliyun_df = DataFrame(feishu_df,as_type=mc_df_astype)
    # # 参数值获取1：使用 datetime 模块获取
    # ptdate = (datetime.datetime.today()- datetime.timedelta(days=1)).strftime('%Y%m%d')  #昨天
    # 参数值获取2：使用 DataWorks 调度参数获取
    ptdate = args['ptdate']
    aliyun_df.persist(mc_table_name, partition=f"pt={ptdate}", drop_partition=True, create_partition=True)    
    print(f'成功将飞书数据写入 MaxCompute 数据表：{mc_table_name}。关联方法：insert_mc_table。')

def custom_field(df_return, columns, columns_index, mc_df_astype, partitions):
    # 2.1 场景一：把数字入库为 int 类型
    # 修改 SQL 即可
    # cre_ddl = cre_ddl.replace('field_number float','field_number int')
    column = Column(name='field_number', type='bigint', comment=columns_index['field_number'][1])
    columns[columns_index['field_number'][0]] = column
    #修改mc_df_astype
    mc_df_astype['field_number'] = 'int64'
    
    # 2.2 场景二：把日期入库为 date 类型
    # 修改 df，MySQL会自动截断，Maxcompute不行，需要使用 x.date() 处理
    df_return['field_createdtime'] = df_return['field_createdtime'].apply(lambda x:x.date())
    # 修改 SQL
    # cre_ddl = cre_ddl.replace('field_createdtime datetime','field_createdtime date')
    column = Column(name='field_createdtime', type='date', comment=columns_index['field_createdtime'][1])
    columns[columns_index['field_createdtime'][0]] = column
    # #修改mc_df_astype
    # mc_df_astype['field_createdtime'] = 'date'
    
    # 2.3 场景三：日期给定默认最大值
    # 修改 df 即可
    #默认值改为 2222-01-01 00:00:00
    mask = df_return['field_date'] == pd.Timestamp('1970-01-01 08:00:01')
    df_return.loc[mask, 'field_date'] = pd.Timestamp('2222-01-01 00:00:00')
    
    # 2.4 场景四：公式保留具体值
    # 修改 df
    # 修改 SQL
    df_return['field_numformula'] = df_return['field_numformula'].apply(lambda x:json.loads(x)['value'][0])
    # cre_ddl = cre_ddl.replace('field_numformula varchar(256)','field_numformula int')
    column = Column(name='field_numformula', type='bigint', comment=columns_index['field_numformula'][1])
    columns[columns_index['field_numformula'][0]] = column
    #修改mc_df_astype
    mc_df_astype['field_numformula'] = 'int64'

    # 创建新的 schema
    schema = Schema(columns=columns, partitions=partitions)
    print('定制函数打印数据和建表语句')
    print('----------------------------------------------\n', df_return[['field_number','field_createdtime','field_date','field_numformula']].head(5))
    print('----------------------------------------------\n', schema.columns)
    return df_return, schema, mc_df_astype

def main(mc_table_name, bitable_url, fields_map):
    # 基本配置
    app_token, table_id, view_id = get_table_params(bitable_url)
    app_id = 'your_app_id'
    app_secret = 'your_app_secret'
    tenant_access_token = get_tenant_access_token(app_id, app_secret)
    page_size = 50
    
    # 获取飞书多维表所有数据
    feishu_datas = get_all_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_size=page_size)

    #获取飞书字段信息
    feishu_fields = get_bitable_fields(tenant_access_token, app_token, table_id)

    # 以 fields_map 为准关联数据
    store_fields_info_df = merge_list(fields_map, feishu_fields, left_on='feishu_field_name', right_on='field_name')

    # 处理入库字段数据
    feishu_df = extract_key_fields(feishu_datas, store_fields_info_df)
    
    # 关联入库数据类型
    data_type_map = [{"feishu_type": 1   ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 2   ,"mc_type": "double"        ,"mc_df_type": "float64"       }
                    ,{"feishu_type": 3   ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 4   ,"mc_type": "array<string>" ,"mc_df_type": "list<string>"  }
                    ,{"feishu_type": 5   ,"mc_type": "datetime"      ,"mc_df_type": "datetime"      }
                    ,{"feishu_type": 7   ,"mc_type": "boolean"       ,"mc_df_type": "boolean"       }
                    ,{"feishu_type": 11  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 13  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 15  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 17  ,"mc_type": "array<string>" ,"mc_df_type": "list<string>"  }
                    ,{"feishu_type": 18  ,"mc_type": "array<string>" ,"mc_df_type": "list<string>"  }
                    ,{"feishu_type": 19  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 20  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 21  ,"mc_type": "array<string>" ,"mc_df_type": "list<string>"  }
                    ,{"feishu_type": 22  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 23  ,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 1001,"mc_type": "datetime"      ,"mc_df_type": "datetime"      }
                    ,{"feishu_type": 1002,"mc_type": "datetime"      ,"mc_df_type": "datetime"      }
                    ,{"feishu_type": 1003,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 1004,"mc_type": "string"        ,"mc_df_type": "string"        }
                    ,{"feishu_type": 1005,"mc_type": "string"        ,"mc_df_type": "string"        }]

    store_fields_info_df = merge_list(store_fields_info_df, data_type_map, left_on='type', right_on='feishu_type')

    # 生成 MaxCompute schema
    schema, columns, columns_index, partitions = generate_create_schema(store_fields_info_df)

    # 生成 DataFrame astype
    mc_df_astype = generate_astype(store_fields_info_df)
    
    # 定制化
    feishu_df, schema, mc_df_astype = custom_field(feishu_df, columns, columns_index, mc_df_astype, partitions)

    # 建 MaxCompute 数据表
    cre_mc_table(mc_table_name, schema)

    # MaxCompute 表插入数据
    insert_mc_table(feishu_df, mc_table_name, mc_df_astype)
    
    print(f'成功将飞书多维表（{bitable_url}）的数据入库到 mysql 数据表：{mc_table_name}。')

if __name__ == '__main__':
    mc_table_name = 'for_ods.feishu_data_type_test'
    bitable_url = "https://forchangesz.feishu.cn/base/SpY3b9LMFaodpOsE0kdcGEyonbg?table=tbl5BZE0Aubjz5Yy&view=vewDM4NGlP"
    fields_map = [{'tb_field_name': 'field_text','feishu_field_name': '文本'}
            ,{'tb_field_name': 'field_email','feishu_field_name': 'email'}
            ,{'tb_field_name': 'field_select','feishu_field_name': '单选'}
            ,{'tb_field_name': 'field_mobile','feishu_field_name': '电话号码'}
            ,{'tb_field_name': 'field_no','feishu_field_name': '自动编号'}
            ,{'tb_field_name': 'field_member1','feishu_field_name': '人员1'}
            ,{'tb_field_name': 'field_group1','feishu_field_name': '群组1'}
            ,{'tb_field_name': 'field_creator','feishu_field_name': '创建人'}
            ,{'tb_field_name': 'field_modifier','feishu_field_name': '修改人'}
            ,{'tb_field_name': 'field_member2','feishu_field_name': '人员2'}
            ,{'tb_field_name': 'field_group2','feishu_field_name': '群组2'}
            ,{'tb_field_name': 'field_url','feishu_field_name': '超链接'}
            ,{'tb_field_name': 'field_location','feishu_field_name': '地理位置'}
            ,{'tb_field_name': 'field_findnum','feishu_field_name': '查找引用数值'}
            ,{'tb_field_name': 'field_numformula','feishu_field_name': '数字公式'}
            ,{'tb_field_name': 'field_number','feishu_field_name': '数字'}
            ,{'tb_field_name': 'field_progress','feishu_field_name': '进度'}
            ,{'tb_field_name': 'field_money','feishu_field_name': '货币'}
            ,{'tb_field_name': 'field_Rating','feishu_field_name': '评分'}
            ,{'tb_field_name': 'field_bool','feishu_field_name': '复选框'}
            ,{'tb_field_name': 'field_date','feishu_field_name': '日期'}
            ,{'tb_field_name': 'field_createdtime','feishu_field_name': '创建时间'}
            ,{'tb_field_name': 'field_updatedtime','feishu_field_name': '更新时间'}
            ,{'tb_field_name': 'field_mulselect','feishu_field_name': '多选'}
            ,{'tb_field_name': 'field_singleunion','feishu_field_name': '单向关联'}
            ,{'tb_field_name': 'field_doubleunion','feishu_field_name': '双向关联'}
            ,{'tb_field_name': 'field_file','feishu_field_name': '附件'}
            ]
    main(mc_table_name, bitable_url, fields_map)

写入成功之后，查询数据看看结构长什么样。执行以下 SQL：

select * from for_ods.feishu_data_type_test;

最终执行的结果参考如下，最后多了一个分区列pt，记录一个昨天的日期：
image.png

image.png

image.png

四、小结

本文探讨了将飞书多维表数据入库 MaxCompute 分区表的方法，介绍了MaxCompute分区表的概念和建表方法，并探讨了如何写入分区表。
分区表可以按照定义的分区字段将数据分为不同的目录，通过分区可以优化查询效率，提高查询性能。
建表时，可以先创建 Schema，再根据 schema 建表；也可以直接使用类建表的 DDL 直接建表。
写表时，可以将 Pandas 的 DataFrame 转为列表直接写入；也可以先转为 PyODPS 的 DataFrame 再写入。
两种创建分区表的方法和两种写入分区表的方法，它们可以两两组合搭配使用。

至此，关于飞书多维表的读取和入库基本介绍完了。/手动撒花

Py之PyODPS：PyODPS(MaxCompute平台上的大数据处理和分析框架)的简介、安装、使用方法之详细攻略
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
09-11 3432
​ Py之PyODPS：PyODPS(MaxCompute平台上的大数据处理和分析框架)的简介、安装、使用方法之详细攻略 目录 PyODPS的简介 PyODPS的安装 PyODPS的使用方法 PyODPS的简介 PyODPS是MaxCompute的Python版本的SDK，提供了简单方便的Python编程接口，提供了对MaxCompute对象的基本操作和DataFrame框架，让用户可以轻松地在MaxCompute上进行数据分析。MaxCompute大多数开发都
pyodps分区表
Phillip_xian的博客
06-14 1593
为了获得****_odps_prod空间下的所有表的信息（部门、表名、表注释、表记录统计、表字节大小、写入时间），如下脚本可以实现该需求，表为分区表。
阿里云大数据利器Maxcompute学习之--分区表的使用
weixin_34358365的博客
05-15 1532
初学大数据Maxcompute时部分用户不是很熟悉Maxcompute分区表的概念和使用，那这篇文章来简单介绍下分区表的概念及使用场景。 实际上，分区在很多框架中都有这个概念，比如开源框架中的hive等。打个比喻，某城市粮仓里存放麦子，粮仓里按照县城分为很多区域，每个县城都有自己的一块地方，每个县城的麦子放在自己对应的区域上。如果上级领导来检查，想看某...
MaxCompute基础概论
最新发布
hello.reader
09-11 1283
随着大数据技术的发展，企业和组织面临着处理海量数据的挑战。传统的数据存储和处理工具难以应对高并发、复杂计算以及海量数据的快速增长需求。为了解决这些问题，阿里云推出了MaxCompute（原名 ODPS），这是一种面向大数据的全托管云数据仓库解决方案，专门用于处理 TB 级到 PB 级的数据计算任务。MaxCompute 采用存储与计算分离的架构，为用户提供高效的数据存储和分布式计算能力。
Maxcompute分区表操作
小东的博客
08-13 1566
1.创建分区表 create table aaa(id bigint,name string) partitioned by (address string); 2.创建分区字段 alter table aaa add if not exists partition (address = ‘fujian’); 3.向分区表里插入数据 insert into aaa partition(address = ‘fujian’) values(1,‘xxd’); 4.查询分区表数据 select * from a
Maxcompute 分区
基咯咯
03-06 2168
分区表是指在创建表时指定分区空间，即指定表内的某几个字段作为分区列。分区表实际就是对应分布式文件系统上的的独立的文件夹，该文件夹下是该分区所有数据文件。而分区可以理解为分类，通过分类把不同类型的数据放到不同的目录下。分类的标准就是分区字段，可以是一个，也可以是多个。 分区表的意义在于优化查询。查询表时通过where字句查询指定所需查询的分区，避免全表扫描，提高处理效率，降低计算费用。 MaxC...
MaxCompute 往分区表插入数据
我从雨中来的博客
07-25 6688
一、创建分区表user CREATE TABLE user ( user_id BIGINT, gender BIGINT COMMENT '0 unknow,1 male, 2 Female', age BIGINT) PARTITIONED BY (region string, dt string); 二、添加分区 ALTER TABLE user ADD IF NOT EXIS...
Maxcompute分区表插入数据
Tinson写字的地方
07-04 1819
1.创建分区表 create table aaa(id bigint,name string) partitioned by (adress string); 2.创建分区字段 alter table aaa add if not exists partition (adress = ‘shanghai’); 3.向分区表里插入数据 insert into aaa partition(adress...
MaxCompute分区数达到上限处理
胜利的曙光的博客
06-17 487
MaxCompute分区数达到上限报错解决方案。
阿里云MaxCompute SQL用户指南：大数据处理必备
"阿里云大数据计算服务MaxCompute SQL用户指南提供了关于使用MaxCompute（原ODPS）进行大数据处理的SQL操作详细指导。此文档适用于产品版本V2.0.0，日期为20160616。" 阿里云大数据计算服务MaxCompute，又称为ODPS...
Maxcompute分区表的简单操作
小健的博客
08-25 3013
分区概述： 不介绍了，看图就一目了然了。 从图就可以看出，分区的好处是： 1.能方便对数据的管理。 2.可以优化查询。查询表时通过WHERE子句查询指定所需查询的分区。 避免全表扫描，提高处理效率，降低计算费用...
阿里云大数据利器之-RDS迁移到Maxcompute实现自动分区
DONGYUXIA15810857916的博客
08-31 449
点击查看全文 当前，很多用户的业务数据存放在传统关系型数据库上，例如阿里云的RDS，做业务读写操作。当数据量非常大的时候，此时传统关系型数据库会显得有些吃力，那么会经常有将mysql数据库的数据迁移到[大数据处理平台-大数据计算服务（Maxcompute，原ODPS）(https://www.aliyun.com/product/odps?spm=5176.doc27800.76
maxcomputer的分区表相关操作
m0_46914845的博客
02-01 1159
maxcomputer的分区表相关操作
MaxCompute分区和列操作
胜利的曙光的博客
10-18 2921
MaxCompute分区和列操作语法整理。
MaxCompute分区表和非分区表使用对比
aikudemn的博客
07-06 2281
原文链接 摘要： 本文我们将通过对有同样数据量、表结构除分区列其他都一模一样的表,从查询计算、写入、删除数据几个简单操作进行对比，了解MaxCompute分区表和非分区表在使用上有什么差异。 在介绍之前，需要大家先了解MaxCompute分区的概念。 本文我们将通过对有同样数据量、表结构除分区列其他都一模一样的表,从查询计算、写入、删除数据几个简单操作进行对比，了解MaxCom
maxcomputer分区表动态分区设置
m0_66646638的博客
04-25 443
在maxcomputer中进行数据同步中，对于分区表的分区信息的动态配置时，默认更新固定参数的分区信息（静态分区），如果想要配置动态分区的话，可以根据下图进行相应的配置。通过报错我们可以看到此时pt后面加的过滤条件不可以使用maxcomputer sql语法，应该使用sqlite语法，进行以下修改后运行成功。使用/*query*/进行pt的条件过滤（p1），直接使用maxcomputer sql时，会报错。
【大数据】-- 插入或覆写动态分区数据（MaxCompute/Hive）
欢迎来到我的博客，一起探索代码里的世界！
08-23 240
问题：在一些业务场景中，我们需要插入动态分区数据（DYNAMIC PARTITION），如何实现？答：实现如下注意：在 select 时，必须要将 partition_name 添加上。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Xin学数据

为你点亮一盏灯，愿你前进无阻。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值