2168 lines
76 KiB
Python
2168 lines
76 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding:utf-8 -*-
|
|
#############################################################################
|
|
# Copyright (c) 2023 Huawei Technologies Co.,Ltd.
|
|
#
|
|
# openGauss is licensed under Mulan PSL v2.
|
|
# You can use this software according to the terms
|
|
# and conditions of the Mulan PSL v2.
|
|
# You may obtain a copy of Mulan PSL v2 at:
|
|
#
|
|
# http://license.coscl.org.cn/MulanPSL2
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OF ANY KIND,
|
|
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
# See the Mulan PSL v2 for more details.
|
|
# ----------------------------------------------------------------------------
|
|
# Description : gs_upgradechk is a utility to check meta data in gaussdb after upgrade.
|
|
#############################################################################
|
|
|
|
"""
|
|
校验规则的元数据，根据这些数据、结构，生成校验规则。
|
|
"""
|
|
|
|
from enum import Enum
|
|
from upgrade_checker.rules.category import Category
|
|
|
|
|
|
class Accuracy(Enum):
|
|
STRICT = 0 # 严格精确
|
|
ALLOW_MORE = 1 # 查询允许多数据，对于完全无法区分是用户数据还是内建数据的检验sql，我们只能够通过允许多数据来解决。
|
|
ALLOW_LACK = 2 # 查询允许少数据，用于在系统表不稳定存在时，可以允许缺少这些查询数据。
|
|
|
|
|
|
class Meta(object):
|
|
def __init__(self, category=Category.UNKNOWN, desc="", certain=True, content_meta=None):
|
|
self.category = category
|
|
self.desc = desc
|
|
self.certain = certain
|
|
self.content_rules_meta = content_meta if content_meta is not None else []
|
|
|
|
|
|
class ContentRulesMeta(object):
|
|
def __init__(self, key=None, filters=None, ignore_col=None, oid_col=None,
|
|
complete_sql=None, complete_sql_desc=None,
|
|
key_desc="内容哈希值为%s的行", accuracy=Accuracy.STRICT):
|
|
"""
|
|
用来生成校验一个表的内容的信息。这些入参有两种使用方式，
|
|
1、可以使用第一行的几个入参，拼凑出来一句完成的SQL语句
|
|
2、在第二行的入参中，如果提供了完整的SQL，则不再去进行拼接。
|
|
第三行的入参为前两中方式共用的。
|
|
建议尽可能使用第一种方式，因为这样的话当表结构发生变化时，会具有一定的自适应能力。
|
|
|
|
:param key: sql的键，必须是明确的一个投影，None表示用所有需要校验的列进行字符串连接做投影。
|
|
:param filters: where过滤条件，用与区分用户数据和builtin数据。None表示不过滤
|
|
:param ignore_col: 需要忽略的列。None表示使用所有列。
|
|
:param oid_col: 需要校验的列中，类型为oid的需要特殊处理列。特殊处理的话，这些会被0-9999，1W-16383的区分处理，1W以上安0。None表示没有
|
|
:param complete_sql: 完整的SQL规则，如果提供这个选项，则不会再用前面的拼接参数去拼接组装。
|
|
:param complete_sql_desc: 完整的SQL描述。
|
|
:param key_desc: sql的键的描述，注意必现带一个%s
|
|
:param accuracy: 校验精度, 默认严格
|
|
"""
|
|
self.key = key
|
|
self.key_desc = key_desc
|
|
self.filters = filters if filters is not None else 'true'
|
|
self.ignore_col = ignore_col.split(',') if ignore_col is not None else []
|
|
self.oid_col = oid_col.split(',') if oid_col is not None else []
|
|
self.complete_sql = complete_sql
|
|
self.complete_sql_desc = complete_sql_desc
|
|
self.accuracy = accuracy
|
|
|
|
|
|
META = {
|
|
'default.default': Meta(
|
|
Category.UNKNOWN,
|
|
'未知系统表',
|
|
True,
|
|
[
|
|
ContentRulesMeta()
|
|
]
|
|
),
|
|
'pg_catalog.pg_default_acl': Meta(
|
|
Category.AUTHENTICATION,
|
|
'存储新建对象设置的初始权限',
|
|
True
|
|
),
|
|
'pg_catalog.pg_pltemplate': Meta(
|
|
Category.FUNCTION,
|
|
'存储过程语言的"模板"信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='tmplname',
|
|
key_desc='名称为%s的模板',
|
|
ignore_col='tmplacl'
|
|
)
|
|
]
|
|
),
|
|
'pg_catalog.pg_tablespace': Meta(
|
|
Category.TABLESPACE,
|
|
'所有表空间的信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='spcname',
|
|
key_desc='名称为%s的表空间',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='spcacl'
|
|
)
|
|
]
|
|
),
|
|
'pg_catalog.pg_shdepend': Meta(
|
|
Category.DEPEND,
|
|
'记录数据库对象和共享对象之间的依赖性关系',
|
|
True
|
|
# 暂时不进行校验，原因同 pg_depend
|
|
),
|
|
'pg_catalog.pg_type': Meta(
|
|
Category.TYPE,
|
|
'记录所有的数据类型信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的数据类型',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='tydefaultbin,typacl',
|
|
oid_col='typnamespace,typrelid,typelem'
|
|
),
|
|
ContentRulesMeta(
|
|
key="(select nspname from pg_namespace n where n.oid = typnamespace) || '.' || typname",
|
|
key_desc='数据类型%s',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='oid,tydefaultbin,typacl',
|
|
oid_col='typnamespace,typowner,typrelid,typelem,typarray,typbasetype,typcollation'
|
|
)
|
|
]
|
|
),
|
|
'pg_catalog.pg_attribute': Meta(
|
|
Category.TABLE,
|
|
"存储了所有表、视图的所有列的基础信息",
|
|
True,
|
|
[
|
|
# builtin的需要严格一致
|
|
ContentRulesMeta(
|
|
key="format('%s(%s)',"
|
|
" (select format('%s.%s', nspname, relname)"
|
|
" from pg_class c left join pg_namespace n on c.relnamespace = n.oid "
|
|
" where c.oid=attrelid),"
|
|
" attname"
|
|
")",
|
|
key_desc='模式.关系名(列名)为%s的列',
|
|
filters=' attrelid < 10000 ',
|
|
ignore_col='attacl'
|
|
),
|
|
# initdb的。但忽略toast表，因为表名里也带oid，会变，无法校验。
|
|
ContentRulesMeta(
|
|
complete_sql="select format('%s.%s(%s)', n.nspname, c.relname, a.attname),"
|
|
" md5(format('%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s', "
|
|
" t.typname, a.attstattarget, a.attlen, a.attnum, a.attndims,"
|
|
" a.attcacheoff, a.atttypmod, a.attbyval, a.attstorage, a.attalign,"
|
|
" a.attnotnull, a.atthasdef,a.attisdropped, a.attislocal, a.attcmprmode,"
|
|
" a.attinhcount, a.attcollation, a.attoptions, a.attfdwoptions,"
|
|
" a.attinitdefval, a.attkvtype))"
|
|
"from pg_attribute a left join pg_class c on a.attrelid = c.oid "
|
|
" left join pg_namespace n on c.relnamespace = n.oid "
|
|
" left join pg_type t on a.atttypid = t.oid "
|
|
"where a.attrelid > 9999 and "
|
|
" a.attrelid < 16384 and "
|
|
" a.attisdropped = false and "
|
|
" n.nspname not in ('pg_toast')",
|
|
key_desc='模式.关系名(列名)为%s的列',
|
|
complete_sql_desc='校验initdb阶段(1W <= oid <= 16384)创建的表、索引、视图等的列信息。'
|
|
)
|
|
]
|
|
),
|
|
'pg_catalog.pg_proc': Meta(
|
|
Category.FUNCTION,
|
|
'存储了所有的函数、存储过程',
|
|
True,
|
|
[
|
|
ContentRulesMeta(Category.FUNCTION,
|
|
complete_sql = "select 'count(*)', count(*) from pg_proc where oid < 16384",
|
|
key_desc = '数量统计方法%s',
|
|
complete_sql_desc = 'pg_proc内 oid < 16384 的系统对象(包括函数、存储过程)总数量'
|
|
),
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的函数或存储过程',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='proargdefaults,proacl'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s(%s)',"
|
|
" (select nspname from pg_namespace n where n.oid = pronamespace),"
|
|
" proname,"
|
|
" pg_get_function_arguments(oid)"
|
|
")",
|
|
key_desc='函数%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid,proargtypes,proallargtypes,proargdefaults,proacl,proargtypesext,allargtypes,allargtypesext',
|
|
oid_col='pronamespace,prolang,provariadic,prorettype,propackageid'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select format('def:%s.%s(%s)', "
|
|
" n.nspname, "
|
|
" p.proname, "
|
|
" pg_get_function_arguments(p.oid)), "
|
|
" md5(pg_get_functiondef(p.oid)::text) "
|
|
"from pg_proc p left join pg_namespace n on p.pronamespace = n.oid "
|
|
"where p.oid < 16384 and p.proisagg=false and p.proiswindow=false",
|
|
key_desc='函数%s的定义',
|
|
complete_sql_desc='通过pg_get_functiondef()来检查一般函数的定义'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_class": Meta(
|
|
Category.TABLE,
|
|
'存储了所有表、索引、视图、序列等的基础信息。',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
complete_sql="select 'count(*)', count(*) from pg_class where oid < 16384",
|
|
key_desc='数量统计方法%s',
|
|
complete_sql_desc='pg_class内oid < 16384(包括表、索引、视图、序列等)总数量'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s',(select nspname from pg_namespace n where n.oid = relnamespace), relname)",
|
|
key_desc='名为%s的表或索引或视图等',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='relfilenode,relpages,reltuples,relallvisible,relacl,relfrozenxid,relfrozenxid64,relminmxid',
|
|
oid_col='oid,reltype,reloftype',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s',(select nspname from pg_namespace n where n.oid = relnamespace), relname)",
|
|
key_desc='名为%s的表或索引或视图等',
|
|
filters=" 9999 < oid and oid < 16384 and relnamespace not in (99) ",
|
|
ignore_col='oid,relfilenode,relpages,reltuples,relallvisible,reltoastrelid,reltoastidxid,'
|
|
'relfrozenxid,relacl,relfrozenxid64,relminmxid',
|
|
oid_col='relnamespace,reltype,reloftype,relowner,reltablespace',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
# 表的会在第一步的校验系统表结构的时候校验pg_get_tabledef。
|
|
# 索引等会在对应的扩展系统表校验，此处仅校验视图即可
|
|
ContentRulesMeta(
|
|
complete_sql="select format('def:%s.%s', n.nspname, c.relname), "
|
|
" md5(pg_get_viewdef(c.oid)) "
|
|
"from pg_class c left join pg_namespace n on c.relnamespace=n.oid "
|
|
"where c.oid < 16384 and "
|
|
" c.relkind in ('v') and "
|
|
" n.nspname not in ('pg_toast', 'snapshot') ",
|
|
key_desc='视图定义%s',
|
|
complete_sql_desc='pg_get_viewdef()来检查视图的定义'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_authid": Meta(
|
|
Category.AUTHENTICATION,
|
|
"存储有关数据库认证标识符（角色）的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的角色',
|
|
filters=' oid = 10 ',
|
|
ignore_col='rolname,rolpassword,rolvalidbegin,rolvaliduntil,rolrespool,rolpasswordext'
|
|
),
|
|
|
|
# 其余角色的各种属性理论都可以通过alter修改，无需校验
|
|
ContentRulesMeta(
|
|
complete_sql='select oid, rolname from pg_authid where oid < 10000 and oid != 10',
|
|
key_desc='oid为%s的角色',
|
|
complete_sql_desc='校验角色的信息'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql='select rolname, rolname from pg_authid where 9999 < oid and oid < 16384',
|
|
key_desc='角色%s',
|
|
complete_sql_desc='校验角色的信息'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_auth_members": Meta(
|
|
Category.AUTHENTICATION,
|
|
"存储显示角色之间的成员关系",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
filters=' roleid < 16384 '
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_database": Meta(
|
|
Category.DATABASE,
|
|
"存储database信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='datname',
|
|
key_desc='数据库%s',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='encoding,datcollate,datctype,datlastsysoid,datfrozenxid,datacl,datfrozenxid64,datminmxid'
|
|
),
|
|
ContentRulesMeta(
|
|
key='datname',
|
|
key_desc='数据库%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid,encoding,datcollate,datctype,datlastsysoid,datfrozenxid,datacl,datfrozenxid64,datminmxid'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_foreign_server": Meta(
|
|
Category.FDW,
|
|
"存储外表服务器",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='srvname',
|
|
key_desc='外表服务器%s',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='srvacl'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select srvname, "
|
|
" md5(fw.fdwname || fs.srvtype::text || fs.srvversion::text || fs.srvoptions::text) "
|
|
"from pg_foreign_server fs left join pg_foreign_data_wrapper fw on fs.srvfdw = fw.oid "
|
|
"where 9999 < fs.oid and fs.oid < 16384 ;",
|
|
key_desc='外表服务器%s',
|
|
complete_sql_desc='校验系统表pg_foreign_server的内容'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_user_mapping": Meta(
|
|
Category.FDW,
|
|
"存储外表用户映射关系",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
filters=' umuser < 16384 and umserver < 16384 '
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_foreign_data_wrapper": Meta(
|
|
Category.FDW,
|
|
"存外部数据包装器",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='fdwname',
|
|
key_desc='外部数据包装器%s',
|
|
ignore_col='fdwacl',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select fdw.fdwname, format('hander(%s),validator(%s)', p1.proname, p2.proname) "
|
|
"from pg_foreign_data_wrapper fdw left join pg_proc p1 on fdwhandler = p1.oid "
|
|
" left join pg_proc p2 on fdwvalidator=p2.oid "
|
|
"where 9999 < fdw.oid and fdw.oid < 16384 ",
|
|
key_desc='外部数据包装器%s',
|
|
complete_sql_desc='校验表pg_foreign_data_wrapper的内容'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_shdescription": Meta(
|
|
Category.DESCRIPTION,
|
|
"存储共享数据库对象的注释",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
filters=' objoid < 16384 and classoid < 16384 ',
|
|
oid_col='objoid,classoid',
|
|
accuracy=Accuracy.ALLOW_MORE
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_aggregate": Meta(
|
|
Category.FUNCTION,
|
|
"存储聚集函数",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='aggfnoid::oid',
|
|
key_desc='oid为%s的聚集函数',
|
|
filters=' aggfnoid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s %s %s %s', aggfnoid, aggtransfn, aggcollectfn, aggfinalfn)",
|
|
key_desc='函数名、三阶段为%s的聚集函数',
|
|
filters=' 9999 < aggfnoid and aggfnoid < 16384 '
|
|
# aggfnoid是regproc类型，自动会按照字符串打印，无需做oid特殊处理
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_am": Meta(
|
|
Category.AM,
|
|
"存储数据库索引相关相关的访问方法",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='amname',
|
|
key_desc='访问方法%s',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="amname",
|
|
key_desc='访问方法%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='amkeytype'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_amop": Meta(
|
|
Category.AM,
|
|
"存储有关和访问方法操作符族关联的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s-%s-%s-%s', amopfamily, amoplefttype, amoprighttype, amopstrategy)",
|
|
key_desc='family-ltype-rtype-stg为%s的操作符访问族',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s-%s-%s-%s', amopfamily, amoplefttype, amoprighttype, amopstrategy)",
|
|
key_desc='family-ltype-rtype-stg为%s的操作符访问族',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='amopfamily,amoplefttype,amoprighttype,amopopr,amopmethod,amopsortfamily'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_amproc": Meta(
|
|
Category.AM,
|
|
"存储有关与访问方法操作符族相关联的支持过程的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s-%s-%s-%s', amprocfamily, amproclefttype, amprocrighttype, amprocnum)",
|
|
key_desc='family-ltype-rtype-prn为%s的函数访问族',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s-%s-%s-%s', amprocfamily, amproclefttype, amprocrighttype, amprocnum)",
|
|
key_desc='family-ltype-rtype-prn为%s的函数访问族',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='amprocfamily,amproclefttype,amprocrighttype'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_attrdef": Meta(
|
|
Category.TABLE,
|
|
"存储列的默认值",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid编号为%s的列默认值',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='adbin_on_update,adbin'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s-%s', (select relname from pg_class c where c.oid=adrelid), adnum)",
|
|
key_desc='表名-列号为%s的列默认值',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid,adbin_on_update,adbin',
|
|
oid_col='adrelid'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_cast": Meta(
|
|
Category.TYPE,
|
|
"存储数据类型转换方式",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid编号为%s的数据类型转换方式',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s-%s', (select typname from pg_type t where t.oid=castsource), "
|
|
"(select typname from pg_type t where t.oid=casttarget))",
|
|
key_desc='左右类型为%s的转换方法',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='castsource,casttarget,castfunc,castowner',
|
|
accuracy=Accuracy.ALLOW_MORE
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_constraint": Meta(
|
|
Category.CONSTRAINT,
|
|
"存储表上的检查约束、主键和唯一约束",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid编号为%s的约束',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='conbin'
|
|
),
|
|
ContentRulesMeta(
|
|
key="conname",
|
|
key_desc='约束%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid,conpfeqop,conppeqop,conffeqop,conexclop,conbin',
|
|
oid_col='connamespace,conrelid,contypid,conindid,confrelid'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select format('def:%s', conname), md5(pg_get_constraintdef(oid)) "
|
|
"from pg_constraint "
|
|
"where oid < 16384 ",
|
|
key_desc='约束%s的定义',
|
|
complete_sql_desc='通过pg_get_constraintdef()函数检查oid < 16384的约束的定义'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_conversion": Meta(
|
|
Category.LOCALE,
|
|
"存储编码转换信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的编码转换方式',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s', (select nspname from pg_namespace n where n.oid=connamespace), conname)",
|
|
key_desc='编码转换方式%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
oid_col='oid,connamespace,conowner,conforencoding,contoencoding,conproc'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_depend": Meta(
|
|
Category.DEPEND,
|
|
"记录数据库非共享对象之间的依赖性关系",
|
|
True
|
|
# pg_depend的内容太多且场景太复杂，暂时无法总结规律并写出SQL。
|
|
# 在直接安装时，很多内置对象直接写入系统表，进而未配置依赖关系，例如一些函数等，但通过升级脚本创建的则可以。
|
|
# 同时夹杂着太多的1W~16384的内容
|
|
# 考虑此系统表的含义，仅是一个依赖的属性，对应的实体对象会在其他系统表内校验，因此暂时不进行此系统表的校验
|
|
),
|
|
"pg_catalog.pg_description": Meta(
|
|
Category.DESCRIPTION,
|
|
"存储数据库对象的描述",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s-%s-%s', objoid, classoid, objsubid)",
|
|
key_desc='obj-class-subid为%s的描述',
|
|
filters=' objoid < 10000 and classoid < 10000 and objsubid < 10000 ',
|
|
oid_col='objoid,classoid'
|
|
),
|
|
# 1W+比较难写，仅测试数量，问题不大。
|
|
ContentRulesMeta(
|
|
complete_sql = "select format('%s-%s-%s', "
|
|
" (case when objoid < 9999 then objoid else 0 end), "
|
|
" (case when classoid < 9999 then classoid else 0 end), "
|
|
" (case when objsubid < 9999 then objsubid else 0 end) "
|
|
" ) as key,"
|
|
" count(*) as val "
|
|
"from pg_description "
|
|
"where (9999 < objoid and objoid < 16384) or "
|
|
" (9999 < classoid and classoid < 16384) or "
|
|
" (9999 < objsubid and objsubid < 16384) "
|
|
"group by key;",
|
|
key_desc = '(9999,16384)的范围内的键值为%s(1W+显示0)的注释数量',
|
|
complete_sql_desc = '统计(9999,16384)的范围内的(oid在1W+时显示0)的注释数量'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_index": Meta(
|
|
Category.INDEX,
|
|
"存储索引的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='indexrelid',
|
|
key_desc='indexrelid为%s的索引',
|
|
filters=' indexrelid < 10000 ',
|
|
ignore_col='indpred,indexprs'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s-%s',"
|
|
" (select relname from pg_class c where c.oid=indrelid),"
|
|
" (select relname from pg_class c where c.oid=indexrelid)"
|
|
")",
|
|
key_desc='表名-索引名为%s的索引',
|
|
filters=" 9999 < indexrelid and indexrelid < 16384 and "
|
|
"(select relkind from pg_class c where c.oid=indrelid) != 't'",
|
|
ignore_col='indcollation,indclass',
|
|
oid_col='indexrelid,indrelid'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select format('def:%s(%s)', ct.relname, ci.relname), "
|
|
" md5(pg_get_indexdef(indexrelid)) "
|
|
"from pg_index i left join pg_class ct on i.indrelid = ct.oid "
|
|
" left join pg_class ci on i.indexrelid = ci.oid "
|
|
"where indexrelid < 16384 and ct.relnamespace not in (99, 4989)",
|
|
key_desc='索引定义%s',
|
|
complete_sql_desc='通过函数pg_get_indexdef()校验索引的定义（排除pg_toast、snapshot的索引，因为有会变OID名字等原因）'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_inherits": Meta(
|
|
Category.TABLE,
|
|
"记录关于表继承层次的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s-%s', (case when inhrelid < 10000 then inhrelid else 0 end), inhseqno)",
|
|
key_desc='表-继承号为%s的继承关系',
|
|
oid_col='inhrelid,inhparent',
|
|
accuracy=Accuracy.ALLOW_MORE
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_language": Meta(
|
|
Category.LANGUAGE,
|
|
"存储编程语言，用户可以用这些语言或接口写函数或者存储过程",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='lanname',
|
|
key_desc='oid为%s的语言',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='lanacl'
|
|
),
|
|
ContentRulesMeta(
|
|
key='lanname',
|
|
key_desc='名称为%s的语言',
|
|
filters=' 9999 < oid and oid < 10000 ',
|
|
ignore_col='lanacl',
|
|
oid_col='oid,lanplcallfoid,laninline,lanvalidator'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_largeobject": Meta(
|
|
Category.LOB,
|
|
"保存那些标记着'大对象'的数据",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s %s', loid, pageno)",
|
|
key_desc='loid-pageno为%s的大对象',
|
|
accuracy=Accuracy.ALLOW_MORE
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_namespace": Meta(
|
|
Category.SCHEMA,
|
|
"存储名称空间，即schema相关的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='nspname',
|
|
key_desc='名称为%s的schema',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='nsptimeline,nspacl,in_redistribution,nspblockchain,nspcollation'
|
|
),
|
|
ContentRulesMeta(
|
|
key='nspname',
|
|
key_desc='名称为%s的schema',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='nsptimeline,nspacl,in_redistribution,nspblockchain,nspcollation',
|
|
oid_col='oid,nspowner'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_opclass": Meta(
|
|
Category.OPERATOR,
|
|
"存储索引访问方法操作符类",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的操作符类',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s(of am %s)',"
|
|
" opcnamespace,"
|
|
" opcname,"
|
|
" (select amname from pg_am a where a.oid=opcmethod)"
|
|
")",
|
|
key_desc='操作符类%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
oid_col='oid,opcmethod,opcnamespace,opcowner,opcfamily,opcintype,opckeytype'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_operator": Meta(
|
|
Category.OPERATOR,
|
|
"存储有关操作符的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的操作符',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='oprnamespace,oprowner,oprleft,oprright,oprresult,oprcom,oprnegate'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.(%s %s %s)',"
|
|
" (select nspname from pg_namespace where oid=oprnamespace), "
|
|
" (select typname from pg_type t where t.oid=oprleft), "
|
|
" oprname, "
|
|
" (select typname from pg_type t where t.oid=oprright) "
|
|
")",
|
|
key_desc='操作符 %s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
oid_col='oid,oprnamespace,oprowner,oprleft,oprright,oprresult,oprcom,oprnegate'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_rewrite": Meta(
|
|
Category.RULE,
|
|
"存储为表和视图定义的重写规则",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的操作符',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='ev_action,ev_qual'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s(on %s)', rulename, (select relname from pg_class c where c.oid=ev_class))",
|
|
key_desc='重写规则%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='ev_qual,ev_action',
|
|
oid_col='oid,ev_class'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select format('def:%s.%s(%s)', n.nspname, c.relname, r.rulename), "
|
|
" md5(pg_get_ruledef(r.oid)) "
|
|
"from pg_rewrite r left join pg_class c on r.ev_class = c.oid "
|
|
" left join pg_namespace n on c.relnamespace = n.oid "
|
|
"where r.oid < 16384 and "
|
|
" n.nspname not in ('pg_toast', 'snapshot');",
|
|
key_desc='规则定义%s',
|
|
complete_sql_desc='使用函数pg_get_ruledef校验重写规则的定义'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_statistic": Meta(
|
|
Category.OPTIMIZER,
|
|
"存储用于优化器行数估算的统计信息",
|
|
True
|
|
# 不用校验内容
|
|
),
|
|
"pg_catalog.pg_trigger": Meta(
|
|
Category.TRIGGER,
|
|
"存储触发器信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的触发器',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='tgtime,tgqual'
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s(on %s)', tgname, (select relname from pg_class c where c.oid=tgrelid))",
|
|
key_desc='触发器%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
oid_col='oid,tgrelid',
|
|
ignore_col='tgtime,tgqual'
|
|
),
|
|
ContentRulesMeta(
|
|
complete_sql="select format('def:%s(%s)', c.relname, t.tgname), "
|
|
" md5(pg_get_triggerdef(t.oid)) "
|
|
"from pg_trigger t left join pg_class c on t.tgrelid=c.oid "
|
|
"where t.oid < 16384 ",
|
|
key_desc='触发器定义%s',
|
|
complete_sql_desc='通过函数pg_get_triggerdef()检查触发器的定义'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_opfamily": Meta(
|
|
Category.OPERATOR,
|
|
"存储操作符族",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的触发器',
|
|
filters=' oid < 10000 '
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s(for %s)', "
|
|
" (select nspname from pg_namespace n where n.oid=opfnamespace), "
|
|
" opfname, "
|
|
" (select amname from pg_am a where a.oid=opfmethod) "
|
|
")",
|
|
key_desc='操作符族%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
oid_col='opfmethod,opfnamespace,opfowner'
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_db_role_setting": Meta(
|
|
Category.AUTHENTICATION,
|
|
"存储数据库运行时每个角色与数据绑定的配置项的默认值",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s(of db %s)', "
|
|
" setrole, "
|
|
" (select datname from pg_database d where d.oid=setdatabase) "
|
|
")",
|
|
key_desc='用户%s的配置默认值',
|
|
filters=' setdatabase < 16384 and setrole < 16384 '
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_largeobject_metadata": Meta(
|
|
Category.LOB,
|
|
"存储与大数据相关的元数据",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="lomowner",
|
|
key_desc='oid为%s的大对象元数据',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='lomacl',
|
|
accuracy=Accuracy.ALLOW_MORE
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_extension": Meta(
|
|
Category.EXTENSION,
|
|
"存储关于所安装扩展的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="extname",
|
|
key_desc='扩展%s',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="extname",
|
|
key_desc='扩展%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='extconfig',
|
|
oid_col='oid,extowner,extnamespace',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_foreign_table": Meta(
|
|
Category.TABLE,
|
|
"存储外部表的辅助信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="ftrelid",
|
|
key_desc='oid为%s的外表',
|
|
filters=' ftrelid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="(select relname from pg_class c where c.oid=ftrelid)",
|
|
key_desc='外表%s',
|
|
filters=' 9999 < ftrelid and ftrelid < 10000 ',
|
|
oid_col='ftrelid,ftserver',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_statistic_ext": Meta(
|
|
Category.OPTIMIZER,
|
|
"存储有关该数据库中表的扩展统计数据，包括多列统计数据和表达式统计数据",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.pg_rlspolicy": Meta(
|
|
Category.PRIVILEGE,
|
|
"存储行级访问控制策略",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的行级访问控制策略',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='polqual',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s(on %s)', polname, (select relname from pg_class c where c.oid=polrelid))",
|
|
key_desc='行级访问控制策略%s',
|
|
filters=' 9999 < oid and oid < 10000 ',
|
|
ignore_col='polqual',
|
|
oid_col='oid,polrelid',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_resource_pool": Meta(
|
|
Category.WLM,
|
|
"提供了数据库资源池的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='oid',
|
|
key_desc='oid为%s的资源池',
|
|
filters=' oid < 10000 ',
|
|
ignore_col='mem_percent,cpu_affinity,control_group,active_statements,max_dop,memory_limit,parentid,'
|
|
'io_limits,io_priority,nodegroup,is_foreign,max_worker',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="respool_name",
|
|
key_desc='资源池respool_name',
|
|
filters=' 9999 < oid and oid < 10000 ',
|
|
ignore_col='mem_percent,cpu_affinity,control_group,active_statements,max_dop,memory_limit,parentid,'
|
|
'io_limits,io_priority,nodegroup,is_foreign,max_worker',
|
|
oid_col='oid',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_workload_group": Meta(
|
|
Category.WLM,
|
|
"提供了数据库负载组的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key='workload_gpname',
|
|
key_desc='负载组%s',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='act_statements',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_collation": Meta(
|
|
Category.LOCALE,
|
|
"存储了排序规则，本质上从一个SQL名称映射到操作系统本地类别",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的排序规则',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
# initdb阶段的不需要校验，因为这部分的是gs_initdb读取了环境locale -a之后配置到pg_collation的，因此也算是纯用户数据。
|
|
]
|
|
),
|
|
"pg_catalog.pg_auth_history": Meta(
|
|
Category.AUTHENTICATION,
|
|
"存储了角色的认证历史",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.pg_user_status": Meta(
|
|
Category.AUTHENTICATION,
|
|
"存储了访问数据库用户的状态",
|
|
True,
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.pg_app_workloadgroup_mapping": Meta(
|
|
Category.WLM,
|
|
"存储了数据库负载映射组的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="appname",
|
|
key_desc='负载映射组%s',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_event_trigger": Meta(
|
|
Category.TRIGGER,
|
|
"存储每个事件触发器的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="evtname",
|
|
key_desc='事件触发器%s',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_enum": Meta(
|
|
Category.TYPE,
|
|
"存储枚举类型相关信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的枚举值',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s(%s)',"
|
|
" (select typname from pg_type t where t.oid=enumtypid),"
|
|
" enumlabel"
|
|
")",
|
|
key_desc='枚举类型值%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_set": Meta(
|
|
Category.TYPE,
|
|
"存储集合数据类型定义的元数据",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的集合值',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s(%s)',"
|
|
" (select typname from pg_type t where t.oid=settypid),"
|
|
" setlabel"
|
|
")",
|
|
key_desc='集合类型值%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_range": Meta(
|
|
Category.TYPE,
|
|
"存储关于范围类型的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="rngtypid",
|
|
key_desc='rngtypid为%s的范围类型',
|
|
filters=' rngtypid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_synonym": Meta(
|
|
Category.SYNONYM,
|
|
"存储同义词",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的同义词',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s', (select nspname from pg_namespace n where n.oid=synnamespace), synname)",
|
|
key_desc='同义词%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='synnamespace,synowner',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_shseclabel": Meta(
|
|
Category.SECURITY,
|
|
"存储共享数据对象上的安全标签",
|
|
True
|
|
# 安全标签用户可以自行设置或取消，无需校验内容
|
|
),
|
|
"pg_catalog.pg_seclabel": Meta(
|
|
Category.SECURITY,
|
|
"存储数据对象上的安全标签",
|
|
True
|
|
# 安全标签用户可以自行设置或取消，无需校验内容
|
|
),
|
|
"pg_catalog.pg_ts_dict": Meta(
|
|
Category.TS,
|
|
"存储定义文本搜索字典的记录",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的文本搜索字典',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s', (select nspname from pg_namespace n where n.oid=dictnamespace), dictname)",
|
|
key_desc='文本搜索字典%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='dictnamespace,dictowner,dicttemplate',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_ts_parser": Meta(
|
|
Category.TS,
|
|
"包含定义文本解析器的记录",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的文本解析器',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s', (select nspname from pg_namespace n where n.oid=prsnamespace), prsname)",
|
|
key_desc='文本解析器%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='prsnamespace',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_ts_config": Meta(
|
|
Category.TS,
|
|
"包含表示文本搜索配置的记录",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的文本搜索配置',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s', (select nspname from pg_namespace n where n.oid=cfgnamespace), cfgname)",
|
|
key_desc='文本搜索配置%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='cfgnamespace,cfgowner,cfgparser',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_ts_config_map": Meta(
|
|
Category.TS,
|
|
"包含为每个文本搜索配置的解析器的每个输出符号类型，显示哪个文本搜索字典应该被咨询、以什么顺序搜索的记录",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s %s %s', mapcfg, maptokentype, mapseqno)",
|
|
key_desc='键值为%s的行',
|
|
filters=' mapcfg < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
# 1W+的在common rule内
|
|
ContentRulesMeta(
|
|
complete_sql="select format('%s %s %s', c.cfgname, cm.maptokentype, mapseqno),"
|
|
" md5(d.dictname)"
|
|
"from pg_ts_config_map cm left join pg_ts_config c on cm.mapcfg = c.oid "
|
|
" left join pg_ts_dict d on cm.mapdict = d.oid "
|
|
"where 9999 < cm.mapcfg and cm.mapcfg < 16384;",
|
|
key_desc='(9999,16384)的mapcfg范围内的键值为%s的文本搜索配置',
|
|
complete_sql_desc='(9999,16384)的mapcfg范围内的所有文本搜索配置项目',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_ts_template": Meta(
|
|
Category.TS,
|
|
"存储文本搜索模板",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的文本搜索模板',
|
|
filters=' oid < 10000 ',
|
|
accuracy=Accuracy.STRICT
|
|
),
|
|
ContentRulesMeta(
|
|
key="format('%s.%s', (select nspname from pg_namespace n where n.oid=tmplnamespace), tmplname)",
|
|
key_desc='文本搜索模板%s',
|
|
filters=' 9999 < oid and oid < 16384 ',
|
|
ignore_col='oid',
|
|
oid_col='tmplnamespace',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_model_warehouse": Meta(
|
|
Category.AI,
|
|
"存储AI引擎训练模型，其中包含模型，训练过程的详细描述",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的训练模型',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_extension_data_source": Meta(
|
|
Category.EXTENSION,
|
|
"存储外部数据源对象的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的外部数据源对象的信息',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='srcacl',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_directory": Meta(
|
|
Category.DIRECTORY,
|
|
"保存用户添加的directory对象",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的文件夹',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='srcacl',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_db_privilege": Meta(
|
|
Category.PRIVILEGE,
|
|
"记录ANY权限的授予情况，每条记录对应一条授权信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的授权记录',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_obsscaninfo": Meta(
|
|
Category.OBS,
|
|
"OBS扫描信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_obsscaninfo": Meta(
|
|
Category.OBS,
|
|
"OBS扫描信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_global_chain": Meta(
|
|
Category.SECURITY,
|
|
"记录用户对防篡改用户表的修改操作信息，每条记录对应一次表级修改操作",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.pg_subscription": Meta(
|
|
Category.PUB_SUB,
|
|
"存储所有现有的逻辑复制订阅",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的复制订阅',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_publication": Meta(
|
|
Category.PUB_SUB,
|
|
"存储所有现有的逻辑复制发布",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的复制发布',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_publication_rel": Meta(
|
|
Category.PUB_SUB,
|
|
"存储当前数据库中的表和publication之间的映射，这是一种多对多映射",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的发布表映射',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_replication_origin": Meta(
|
|
Category.REPLICATION,
|
|
"包含所有已创建的复制源，该表为全局共享表，即在每个节点上只有一份pg_replication_origin，而不是每个数据库一份",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="roident",
|
|
key_desc='roident为%s的复制源',
|
|
filters=' roident < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_subscription_rel": Meta(
|
|
Category.PUB_SUB,
|
|
"包含每个订阅中每个被复制表的状态，是多对多的映射关系",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="format('%s->%s', srsubid, srrelid)",
|
|
key_desc='从复制源%s表的赋值关系',
|
|
filters=' srsubid < 16384 or srrelid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_package": Meta(
|
|
Category.PACKAGE,
|
|
'存储PACKAGE内的信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的package',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='pkgacl',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_recyclebin": Meta(
|
|
Category.RECYCLE_BIN,
|
|
'描述了回收站对象的详细信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的垃圾桶',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_txn_snapshot": Meta(
|
|
Category.TRANSACTION,
|
|
'"时间戳-CSN"映射表，周期性采样，并维护适当的时间范围，用于估算范围内的时间戳对应的CSN值',
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_uid": Meta(
|
|
Category.TABLE,
|
|
'存储了数据库中使用hasuids属性表的唯一标识元信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="relid",
|
|
key_desc='relid为%s的uid',
|
|
filters=' relid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pgxc_class": Meta(
|
|
Category.DISTRIBUTE,
|
|
'存储每张表的复制或分布信息(openGauss此表无意义)',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="pcrelid",
|
|
key_desc='pcrelid为%s的表',
|
|
filters=' pcrelid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pgxc_group": Meta(
|
|
Category.DISTRIBUTE,
|
|
'存储集群节点组信息',
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的节点组',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='group_acl',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pgxc_node": Meta(
|
|
Category.DISTRIBUTE,
|
|
"存储集群节点信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的节点',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_partition": Meta(
|
|
Category.TABLE,
|
|
"存储数据库内所有分区表（partitioned table）、分区（table partition）、分区上toast表和分区索引（index partition）四类对象的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的分区或分区索引',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_job": Meta(
|
|
Category.JOB,
|
|
"存储用户创建的定时任务的任务详细信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的定时任务',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_job_proc": Meta(
|
|
Category.JOB,
|
|
"对应PG_JOB表中每个任务的作业内容（包括：PL/SQL代码块、匿名块）",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的定时任务作业内容',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pg_object": Meta(
|
|
Category.OBJECT,
|
|
"存储限定类型对象（普通表、索引、序列、视图、存储过程和函数）的创建用户、创建时间和最后修改时间",
|
|
True
|
|
# 此表无法记录builtin与initdb阶段的对象，因此无需校验内容。
|
|
),
|
|
"pg_catalog.pg_hashbucket": Meta(
|
|
Category.TABLE,
|
|
"存储hash bucket表的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的bucket',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.streaming_stream": Meta(
|
|
Category.DISTRIBUTE,
|
|
"存储流相关的信息(openGauss内此表无意义)",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.streaming_cont_query": Meta(
|
|
Category.DISTRIBUTE,
|
|
"存储流相关的信息(openGauss内此表无意义)",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.streaming_reaper_status": Meta(
|
|
Category.DISTRIBUTE,
|
|
"存储流相关的信息(openGauss内此表无意义)",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_job_attribute": Meta(
|
|
Category.JOB,
|
|
"存储定时任务的相关属性",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的定时任务属性',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.pgxc_slice": Meta(
|
|
Category.DISTRIBUTE,
|
|
"针对range范围分布和list分布创建的系统表，用来记录分布具体信息(openGauss内此表无意义)",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_job_argument": Meta(
|
|
Category.JOB,
|
|
"存储定时任务的相关内容",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的定时任务内容',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_sql_patch": Meta(
|
|
Category.OPTIMIZER,
|
|
"存储所有SQL_PATCH的状态信息",
|
|
True
|
|
# 纯用户行为数据，无需校验内容。
|
|
),
|
|
"pg_catalog.gs_global_config": Meta(
|
|
Category.GUC,
|
|
"记录了数据库实例初始化时，用户指定的参数值",
|
|
True
|
|
# 纯用户行为数据，无需校验内容。
|
|
),
|
|
"pg_catalog.gs_policy_label": Meta(
|
|
Category.WLM,
|
|
"记录资源标签配置信息，一个资源标签对应着一条或多条记录，每条记录标记了数据库资源所属的资源标签",
|
|
True
|
|
# 纯用户行为数据，无需校验内容。
|
|
),
|
|
"pg_catalog.gs_auditing_policy": Meta(
|
|
Category.AUTHENTICATION,
|
|
"记录统一审计的主体信息，每条记录对应一个设计策略",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的审计策略',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_auditing_policy_access": Meta(
|
|
Category.AUTHENTICATION,
|
|
"记录与DML数据库相关操作的统一审计信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的信息',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_auditing_policy_privileges": Meta(
|
|
Category.AUTHENTICATION,
|
|
"记录统一审计DDL数据库相关操作信息，每条记录对应一个设计策略",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的设计策略',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_asp": Meta(
|
|
Category.DFX,
|
|
"存储被持久化的ACTIVE SESSION PROFILE样本",
|
|
True
|
|
# 不需要校验内容
|
|
),
|
|
"pg_catalog.gs_auditing_policy_filters": Meta(
|
|
Category.AUTHENTICATION,
|
|
"记录统一审计相关的过滤策略相关信息，每条记录对应一个设计策略",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的过滤策略',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_masking_policy": Meta(
|
|
Category.SECURITY,
|
|
"记录动态数据脱敏策略的主体信息，每条记录对应一个脱敏策略",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的动态数据脱敏策略',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_masking_policy_filters": Meta(
|
|
Category.SECURITY,
|
|
"记录动态数据脱敏策略对应的用户过滤条件，当用户条件满足FILTER条件时，对应的脱敏策略才会生效",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的用户过滤条件',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_masking_policy_actions": Meta(
|
|
Category.SECURITY,
|
|
"记录动态数据脱敏策略中相应的脱敏策略包含的脱敏行为，一个脱敏策略对应着该表的一行或多行记录",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的脱敏行为',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_encrypted_columns": Meta(
|
|
Category.SECURITY,
|
|
"记录密态等值特性中表的加密列相关信息，每条记录对应一条加密列信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的加密列',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_client_global_keys": Meta(
|
|
Category.SECURITY,
|
|
"记录密态等值特性中客户端加密主密钥相关信息，每条记录对应一个客户端加密主密钥",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的加密主密钥',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='key_acl',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_column_keys": Meta(
|
|
Category.SECURITY,
|
|
"记录密态等值特性中列加密密钥相关信息，每条记录对应一个列加密密钥",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的列加密密钥',
|
|
filters=' oid < 16384 ',
|
|
ignore_col='key_acl',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_client_global_keys_args": Meta(
|
|
Category.SECURITY,
|
|
"记录密态等值特性中客户端加密主密钥相关元数据信息，每条记录对应客户端加密主密钥的一个键值对信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的加密主密钥键值对信息',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_column_keys_args": Meta(
|
|
Category.SECURITY,
|
|
"记录密态等值特性中客户端加密主密钥相关元数据信息，每条记录对应客户端加密主密钥的一个键值对信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的键值对信息',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_encrypted_proc": Meta(
|
|
Category.SECURITY,
|
|
"提供了密态函数/存储过程函数参数、返回值的原始数据类型，加密列等信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的加密信息',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_matview": Meta(
|
|
Category.VIEW,
|
|
"提供了关于数据库中每一个物化视图的信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的物化视图条目',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_matview_dependency": Meta(
|
|
Category.VIEW,
|
|
"提供了关于数据库中每一个增量物化视图、基表和mlog表的关联信息",
|
|
True,
|
|
[
|
|
ContentRulesMeta(
|
|
key="oid",
|
|
key_desc='oid为%s的增量物化视图信息',
|
|
filters=' oid < 16384 ',
|
|
accuracy=Accuracy.STRICT
|
|
)
|
|
]
|
|
),
|
|
"pg_catalog.gs_opt_model": Meta(
|
|
Category.AI,
|
|
"是启用AiEngine执行计划时间预测功能时的数据表，记录机器学习模型的配置、训练结果、功能、对应系统函数、训练历史等相关信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_user_resource_history": Meta(
|
|
Category.WLM,
|
|
"存储与用户使用资源相关的信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_instance_history": Meta(
|
|
Category.WLM,
|
|
"存储与实例（数据库主节点或数据库节点）相关的资源使用相关信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_session_query_info_all": Meta(
|
|
Category.WLM,
|
|
"显示当前数据库实例执行作业结束后的负载管理记录",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_operator_info": Meta(
|
|
Category.WLM,
|
|
"显示执行作业结束后的算子相关的记录",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_plan_operator_info": Meta(
|
|
Category.WLM,
|
|
"显示执行作业结束后计划算子级的相关的记录",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_plan_encoding_table": Meta(
|
|
Category.WLM,
|
|
"显示计划算子级的编码信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.gs_wlm_ec_operator_info": Meta(
|
|
Category.WLM,
|
|
"存储执行EC（Extension Connector）作业结束后的算子相关的记录",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.plan_table_data": Meta(
|
|
Category.OPTIMIZER,
|
|
"存储了用户通过执行EXPLAIN PLAN收集到的计划信息",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"pg_catalog.statement_history": Meta(
|
|
Category.DFX,
|
|
"存储SQL语句的性能诊断信息",
|
|
True
|
|
# 不需要校验内容
|
|
),
|
|
"dbe_pldeveloper.gs_source": Meta(
|
|
Category.FUNCTION,
|
|
"记录PLPGSQL对象（存储过程、函数、包、包体）编译相关信息",
|
|
True
|
|
# 此表文档注明了只记录用户自定义数据，因此不需要校验内容
|
|
|
|
),
|
|
"dbe_pldeveloper.gs_errors": Meta(
|
|
Category.FUNCTION,
|
|
"用于记录PLPGSQL对象（存储过程、函数、包、包体）编译过程中遇到的报错信息",
|
|
True
|
|
# 此表与gs_source一类，因此不需要校验内容
|
|
),
|
|
"information_schema.sql_features": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些sql特性相关信息",
|
|
True,
|
|
),
|
|
"information_schema.sql_implementation_info": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些sql特性相关信息",
|
|
True,
|
|
),
|
|
"information_schema.sql_languages": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些语言特性相关信息",
|
|
True,
|
|
),
|
|
"information_schema.sql_packages": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些package特性相关信息",
|
|
True,
|
|
),
|
|
"information_schema.sql_parts": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些sql parts特性相关信息",
|
|
True,
|
|
),
|
|
"information_schema.sql_sizing": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些sql sizing特性相关信息",
|
|
True,
|
|
),
|
|
"information_schema.sql_sizing_profiles": Meta(
|
|
Category.INFO_SCHEMA,
|
|
"用于记录一些sql profiles特性相关信息",
|
|
True,
|
|
),
|
|
"db4ai.snapshot": Meta(
|
|
Category.AI,
|
|
"记录当前用户通过特性DB4AI.SNAPSHOT存储的快照",
|
|
True
|
|
# 无需校验内容
|
|
),
|
|
"snapshot.tables_snap_timestamp": Meta(
|
|
Category.WDR,
|
|
"记录所有存储的WDR snapshot中数据库、表对象、以及数据采集的开始和结束时间",
|
|
False
|
|
),
|
|
"snapshot.snapshot": Meta(
|
|
Category.WDR,
|
|
"存储的WDR快照数据的索引信息、开始时间和结束时间",
|
|
False
|
|
),
|
|
"snapshot.snap_global_os_runtime": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_os_threads": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_instance_time": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_workload_sql_count": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_workload_sql_elapse_time": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_workload_transaction": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_workload_transaction": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_thread_wait_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_memory_node_detail": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False,
|
|
),
|
|
"snapshot.snap_global_shared_memory_detail": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_db_cu": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_database": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_stat_database": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_database_conflicts": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_stat_database_conflicts": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_bad_block": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_stat_bad_block": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_file_redo_iostat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_file_redo_iostat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_rel_iostat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_rel_iostat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_file_iostat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_file_iostat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_replication_slots": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_bgwriter_stat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_replication_stat": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_transactions_running_xacts": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_transactions_running_xacts": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_transactions_prepared_xacts": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_transactions_prepared_xacts": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_statement": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_statement_count": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_statement_count": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_config_settings": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_wait_events": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_user_login": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_ckpt_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_double_write_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_pagewriter_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_redo_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_rto_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_recovery_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_threadpool_status": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_statement_responsetime_percentile": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_statio_all_indexes": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_statio_all_indexes": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_statio_all_sequences": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_statio_all_sequences": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_statio_all_tables": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_statio_all_tables": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_all_indexes": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_stat_all_indexes": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_stat_user_functions": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_user_functions": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_stat_all_tables": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_summary_stat_all_tables": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_class_vital_info": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
),
|
|
"snapshot.snap_global_record_reset_time": Meta(
|
|
Category.WDR,
|
|
"存储用于生成WDR报告的相关数据",
|
|
False
|
|
)
|
|
}
|
|
|
|
|
|
def filter_uncertain_metas():
|
|
uncertain_metas = []
|
|
for key, meta in META.items():
|
|
if not meta.certain:
|
|
uncertain_metas.append(key)
|
|
return uncertain_metas
|
|
|