PostgreSQL源码分析——常量表达式化简

常量表达式化简

常量表达式可以进行化简，可降低执行器计算表达式的代价。在逻辑优化阶段，会判断是否可以进行常量表达式化简，如果可以，则在执行器执行之前就预先对常量表达式树进行计算，计算出常量后，以新计算出的常量表达式代替原有的表达式。当进入执行器时，此时表达式已被替换为常量，避免了在执行器中频繁的计算表达式。

化简示例

我们以下面的SQL为例，条件表达式为a > 1 + 1，是常量表达式，可以进行化简。

-- 常量表达式可以进行化简
postgres=# explain select * from t1 where a >  1 + 1;   QUERY PLAN                      
-----------------------------------------------------Seq Scan on t1  (cost=0.00..17.50 rows=998 width=8)Filter: (a > 2)   -- 进入执行器中， 表达式已被提前替换为常量，每扫描一个元组，不用再进行1+1的表达式计算了
(2 rows)
-- 不满足常量表达式化简的条件
postgres=# explain select * from t1 where a >  1 + random();  QUERY PLAN                               
------------------------------------------------------------------------Seq Scan on t1  (cost=0.00..25.00 rows=333 width=8)Filter: ((a)::double precision > ('1'::double precision + random()))     --  执行器中每扫描一个元组，都要进行一次表达式计算
(2 rows)

除了常量表达式，常量函数也可以在逻辑优化阶段提前执行，计算得到常量，用常量替换原有的函数表达式。

源码分析

我们以select * from t1 where a = 1 + 1;这条语句为例，分析一下在PostgreSQL中是如何进行化简的。主流程如下

exec_simple_query
--> pg_parse_query--> raw_parser--> base_yyparse
--> pg_analyze_and_rewrite--> transformStmt--> transformSelectStmt--> transformWhereClause--> transformExpr
--> pg_plan_queries--> pg_plan_query--> planner--> standard_planner--> subquery_planner--> preprocess_qual_conditions--> preprocess_expression--> eval_const_expressions  // 在这里完成常量表达式化简，完成1+1表达式替换为常量2--> eval_const_expressions_mutator--> simplify_function--> evaluate_function--> evaluate_expr  // 1+1的表达式被计算为常量2--> create_plan
--> PortalStart
--> PortalRun  // 执行器执行
--> PortalDrop

可以看到，在逻辑优化阶段，常量表达式已被化简为常量，进入执行器时，表达式树已被替换为常量。下面为详细实现。

/** preprocess_qual_conditions*		Recursively scan the query's jointree and do subquery_planner's*		preprocessing work on each qual condition found therein.*/
static void preprocess_qual_conditions(PlannerInfo *root, Node *jtnode)
{if (jtnode == NULL)return;if (IsA(jtnode, RangeTblRef)){/* nothing to do here */}else if (IsA(jtnode, FromExpr)){FromExpr   *f = (FromExpr *) jtnode;ListCell   *l;foreach(l, f->fromlist)preprocess_qual_conditions(root, lfirst(l));f->quals = preprocess_expression(root, f->quals, EXPRKIND_QUAL);}else if (IsA(jtnode, JoinExpr)){// ...}elseelog(ERROR, "unrecognized node type: %d",(int) nodeTag(jtnode));
}/** preprocess_expression*		Do subquery_planner's preprocessing work for an expression,*		which can be a targetlist, a WHERE clause (including JOIN/ON*		conditions), a HAVING clause, or a few other things.*/
static Node *preprocess_expression(PlannerInfo *root, Node *expr, int kind)
{// .../** Simplify constant expressions.  For function RTEs, this was already* done by preprocess_function_rtes.  */if (kind != EXPRKIND_RTFUNC)expr = eval_const_expressions(root, expr);/* If it's a qual or havingQual, canonicalize it. */if (kind == EXPRKIND_QUAL)expr = (Node *) canonicalize_qual((Expr *) expr, false);// .../** If it's a qual or havingQual, convert it to implicit-AND format. (We* don't want to do this before eval_const_expressions, since the latter* would be unable to simplify a top-level AND correctly. Also,* SS_process_sublinks expects explicit-AND format.)*/if (kind == EXPRKIND_QUAL)expr = (Node *) make_ands_implicit((Expr *) expr);return expr;
}/*--------------------* eval_const_expressions** Reduce any recognizably constant subexpressions of the given* expression tree, for example "2 + 2" => "4".  More interestingly,* we can reduce certain boolean expressions even when they contain* non-constant subexpressions: "x OR true" => "true" no matter what* the subexpression x is.  */
Node *eval_const_expressions(PlannerInfo *root, Node *node)
{eval_const_expressions_context context;if (root)context.boundParams = root->glob->boundParams;	/* bound Params */elsecontext.boundParams = NULL;context.root = root;		/* for inlined-function dependencies */context.active_fns = NIL;	/* nothing being recursively simplified */context.case_val = NULL;	/* no CASE being examined */context.estimate = false;	/* safe transformations only */return eval_const_expressions_mutator(node, &context);
}/* Recursive guts of eval_const_expressions/estimate_expression_value */
static Node *eval_const_expressions_mutator(Node *node,eval_const_expressions_context *context)
{if (node == NULL)return NULL;switch (nodeTag(node)){case T_FuncExpr:{// ...}case T_OpExpr:{OpExpr	   *expr = (OpExpr *) node;List	   *args = expr->args;Expr	   *simple;OpExpr	   *newexpr;/* Need to get OID of underlying function.  Okay to scribble on input to this extent. */set_opfuncid(expr);/** Code for op/func reduction is pretty bulky, so split it out* as a separate function. */simple = simplify_function(expr->opfuncid,expr->opresulttype, -1,expr->opcollid,expr->inputcollid,&args,false,true,true,context);if (simple)		/* successfully simplified it */return (Node *) simple;/** If the operator is boolean equality or inequality, we know* how to simplify cases involving one constant and one* non-constant argument.*/if (expr->opno == BooleanEqualOperator ||expr->opno == BooleanNotEqualOperator){simple = (Expr *) simplify_boolean_equality(expr->opno,args);if (simple) /* successfully simplified it */return (Node *) simple;}/** The expression cannot be simplified any further, so build* and return a replacement OpExpr node using the* possibly-simplified arguments.*/newexpr = makeNode(OpExpr);newexpr->opno = expr->opno;newexpr->opfuncid = expr->opfuncid;newexpr->opresulttype = expr->opresulttype;newexpr->opretset = expr->opretset;newexpr->opcollid = expr->opcollid;newexpr->inputcollid = expr->inputcollid;newexpr->args = args;newexpr->location = expr->location;return (Node *) newexpr;}// ...default:break;}/** For any node type not handled above, copy the node unchanged but* const-simplify its subexpressions.  This is the correct thing for node* types whose behavior might change between planning and execution, such* as CurrentOfExpr.  It's also a safe default for new node types not* known to this routine.*/return ece_generic_processing(node);
}/** Subroutine for eval_const_expressions: try to simplify a function call* (which might originally have been an operator; we don't care)*/
static Expr *
simplify_function(Oid funcid, Oid result_type, int32 result_typmod,Oid result_collid, Oid input_collid, List **args_p,bool funcvariadic, bool process_args, bool allow_non_const,eval_const_expressions_context *context)
{// .../* Now attempt simplification of the function call proper. */newexpr = evaluate_function(funcid, result_type, result_typmod,result_collid, input_collid,args, funcvariadic,func_tuple, context);// ...return newexpr;
}/** evaluate_function: try to pre-evaluate a function call*/
static Expr *
evaluate_function(Oid funcid, Oid result_type, int32 result_typmod,Oid result_collid, Oid input_collid, List *args,bool funcvariadic,HeapTuple func_tuple,eval_const_expressions_context *context)
{// ...return evaluate_expr((Expr *) newexpr, result_type, result_typmod,result_collid);
}/** evaluate_expr: pre-evaluate a constant expression** We use the executor's routine ExecEvalExpr() to avoid duplication of* code and ensure we get the same result as the executor would get.*/
Expr *
evaluate_expr(Expr *expr, Oid result_type, int32 result_typmod,Oid result_collation)
{EState	   *estate;ExprState  *exprstate;MemoryContext oldcontext;Datum		const_val;bool		const_is_null;int16		resultTypLen;bool		resultTypByVal;/** To use the executor, we need an EState.*/estate = CreateExecutorState();/* We can use the estate's working context to avoid memory leaks. */oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);/* Make sure any opfuncids are filled in. */fix_opfuncids((Node *) expr);/** Prepare expr for execution.  (Note: we can't use ExecPrepareExpr* because it'd result in recursively invoking eval_const_expressions.)*/exprstate = ExecInitExpr(expr, NULL);/** And evaluate it.** It is OK to use a default econtext because none of the ExecEvalExpr()* code used in this situation will use econtext.  That might seem* fortuitous, but it's not so unreasonable --- a constant expression does* not depend on context, by definition, n'est ce pas?*/const_val = ExecEvalExprSwitchContext(exprstate,GetPerTupleExprContext(estate),&const_is_null);  // 计算表达式 1 + 1/* Get info needed about result datatype */get_typlenbyval(result_type, &resultTypLen, &resultTypByVal);/* Get back to outer memory context */MemoryContextSwitchTo(oldcontext);/** Must copy result out of sub-context used by expression eval.** Also, if it's varlena, forcibly detoast it.  This protects us against* storing TOAST pointers into plans that might outlive the referenced* data.  (makeConst would handle detoasting anyway, but it's worth a few* extra lines here so that we can do the copy and detoast in one step.)*/if (!const_is_null){if (resultTypLen == -1)const_val = PointerGetDatum(PG_DETOAST_DATUM_COPY(const_val));elseconst_val = datumCopy(const_val, resultTypByVal, resultTypLen);}/* Release all the junk we just created */FreeExecutorState(estate);/** Make the constant result node.*/return (Expr *) makeConst(result_type, result_typmod, result_collation,resultTypLen,const_val, const_is_null,resultTypByVal);
}

如果对源码不熟悉，可以补充看一下这里关于解析层的代码，有助于理解PostgreSQL源码中表达式处理相关的逻辑。

补充解析层相关代码

我们看一下在解析层表达式是如何表示的，1+1表示为A_Expr，类型为AEXPR_OP。where a = 1 + 1则是A_Expr，左子树为变量a，右子树为1+1的表达式A_Expr。

where_clause:WHERE a_expr		{ $$ = $2; }| /*EMPTY*/			{ $$ = NULL; };
a_expr:		c_expr			{ $$ = $1; }| a_expr '+' a_expr     // 表示 1 + 1{ $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "+", $1, $3, @2); }| a_expr '=' a_expr{ $$ = (Node *) makeSimpleA_Expr(AEXPR_OP, "=", $1, $3, @2); }
c_expr:		columnref		{ $$ = $1; }| AexprConst	{ $$ = $1; }
AexprConst: Iconst{$$ = makeIntConst($1, @1);}
Iconst:		ICONST	{ $$ = $1; };       // 1 A_Expr *
makeSimpleA_Expr(A_Expr_Kind kind, char *name,Node *lexpr, Node *rexpr, int location)
{A_Expr	   *a = makeNode(A_Expr);a->kind = kind;a->name = list_make1(makeString((char *) name));a->lexpr = lexpr;a->rexpr = rexpr;a->location = location;return a;
}typedef struct A_Expr
{NodeTag		type;A_Expr_Kind kind;			/* see above */List	   *name;			/* possibly-qualified name of operator */Node	   *lexpr;			/* left argument, or NULL if none */Node	   *rexpr;			/* right argument, or NULL if none */int			location;		/* token location, or -1 if unknown */
} A_Expr;/* A_Const - a literal constant */
typedef struct A_Const
{NodeTag		type;Value		val;			/* value (includes type info, see value.h) */int			location;		/* token location, or -1 if unknown */
} A_Const;

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/855456.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux系统之mtr命令的基本使用

Linux系统之mtr命令的基本使用

Linux系统之mtr命令的基本使用 一、mtr命令介绍二、mtr命令使用帮助2.1 mtr命令的帮助信息2.2 mtr帮助信息解释 三、安装mtr工具四、mtr命令的基本使用4.1 直接使用4.2 设定ping次数4.3 禁用DNS解析4.4 显示IP地址4.5 调整间隔 五、总结 一、mtr命令介绍 mtr命令是一个网络诊断…
阅读更多...
Multisim软件仿真之频谱分析仪

Multisim软件仿真之频谱分析仪

网络上有很多Multisim文件，有些是不能复现的，比如频谱仪，按照下面链接去操作，怎么也测试不出来波形，multisim频谱仪使用_multisim输入输出端口-CSDN博客。 原因分析： 1、博主设置参数未讲全，按…
阅读更多...
Oracle基本数据类型

Oracle基本数据类型

在Oracle数据库中，数据类型是描述数据存储格式的属性。不同的数据类型允许存储不同种类的数据。以下是Oracle中的一些基本数据类型： 1. 字符数据类型 - CHAR(size): 定长字符数据，最大长度为2000字节。 - VARCHAR2(size): 变长字符数据…
阅读更多...
Redis 常见问题

Redis 常见问题

什么是Reids Redis是一个使用C语言写的开源的高性能key-value非关系型数据库. Redis中包含string, list ,set, zset, hash 等数据类型. Redis的数据都基于缓存的, 每秒可以处理10万次读写, 是已知最快的key-value 数据库. Redis可以实现写入磁盘, 保证数据安全. Redi…
阅读更多...
【GUI软件】小红书蒲公英数据批量采集！高效筛选优质博主，助力品牌商

【GUI软件】小红书蒲公英数据批量采集！高效筛选优质博主，助力品牌商

文章目录 一、背景介绍1.0 爬取目标1.1 演示视频1.2 软件说明 二、代码讲解2.0 关于接口2.1 爬虫采集模块2.2 cookie获取2.3 软件界面模块2.4 日志模块 三、获取采集软件 一、背景介绍 1.0 爬取目标 众所周知，蒲公英是小红书推出的优质创作者商业合作服务平台&…
阅读更多...
海思SS928/SD3403开发笔记1——使用串口调试开发板

海思SS928/SD3403开发笔记1——使用串口调试开发板

该板子使用串口可以调试，下面是win11 调试 该板子步骤 1、给板子接入鼠标、键盘、usb转串口 2、下载SecureCRT，并科学使用 下载地址： 链接：https://pan.baidu.com/s/11dIkZVstvHQUhE8uS1YO0Q 提取码：vinv 3、安装c…
阅读更多...
2024最新宝塔面板8.1.0企业版开心版

2024最新宝塔面板8.1.0企业版开心版

官方更新记录 【增加】增加【网站】-【HTML项目】 【优化】优化Docker模块使用体验 【优化】优化文件压缩和解压的速度 【修复】修复在上一版本中出现的所有已知问题 开心版更新记录 1.在 PHP切换页面，出现报错弹窗属于正常情况，是因爲没安装 企业…
阅读更多...
uni-app实现扫码

uni-app实现扫码

uni.scanCode(OBJECT) 调起客户端扫码界面，扫码成功后返回对应的结果。 平台差异说明 AppH5微信小程序支付宝小程序百度小程序抖音小程序、飞书小程序QQ小程序快手小程序京东小程序√x√√√√√√√ OBJECT 参数说明 参数名类型必填说明平台差异说明onlyFromC…
阅读更多...
JAVA反射代码

JAVA反射代码

java在运行过程中&#xff0c;构建类&#xff0c;并获取方法集和属性集&#xff0c;构建实例并调用方法。 package com;import java.lang.reflect.Method;public class Test {public static void main(String args[]) {Class<?> c1 null; // 声明Class对象c1Person pe…
阅读更多...
服务器上线的一些事

服务器上线的一些事

最近不少人在上线上遇到问题 对于最近的上戏 进行一个坑或操作步骤的总结 以及遇到这些之后如何做 关于选项的选择 1 对于是否要在一个小时前释放 这个是看个人的 2 对于选择一台服务器还是两台呢&#xff1f;这个是最后限制 一台 这个免费的服务器 是有一个两百的额度的 选择…
阅读更多...
【C语言】解决C语言报错：Undefined Reference

【C语言】解决C语言报错：Undefined Reference

文章目录 简介什么是Undefined ReferenceUndefined Reference的常见原因如何检测和调试Undefined Reference解决Undefined Reference的最佳实践详细实例解析示例1&#xff1a;缺少函数定义示例2&#xff1a;函数声明和定义不匹配示例3&#xff1a;未链接必要的库示例4&#xff…
阅读更多...
Linux驱动开发（一）--字符设备驱动开发基础

Linux驱动开发（一）--字符设备驱动开发基础

1、字符设备驱动简介 字符设备是 Linux 驱动中最基本的一类设备驱动&#xff0c;字符设备就是一个一个字节&#xff0c;按照字节 流进行读写操作的设备&#xff0c;读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI&#xff0c; LCD 等等都是字符设备&#xff0c…
阅读更多...
【自动驾驶技术】自动驾驶汽车AI芯片汇总——TESLA篇（FSD介绍）

【自动驾驶技术】自动驾驶汽车AI芯片汇总——TESLA篇（FSD介绍）

0. 前言 按照国际惯例&#xff0c;首先声明&#xff1a;本文只是我自己学习的理解&#xff0c;虽然参考了他人的宝贵见解及成果&#xff0c;但是内容可能存在不准确的地方。如果发现文中错误&#xff0c;希望批评指正&#xff0c;共同进步。 本篇文章是这个自动驾驶汽车AI芯片系…
阅读更多...
ObTypeIndexTable 在win7x86 和win10x64对比

ObTypeIndexTable 在win7x86 和win10x64对比

当作备忘录,其他概念请自行搜索 对象类型和对象结构体类型 win7 x86win10 x64 寻找_object_type结构的地址 过程不一样,但是总归是在全局变量_ObTypeIndexTable数组中寻找 win7 的寻找过程
阅读更多...
基于稀疏学习现代信号处理方法的旋转机械故障诊断（MATLAB）

基于稀疏学习现代信号处理方法的旋转机械故障诊断（MATLAB）

通过对滚动轴承故障诊断研究现状及稀疏表示方法在滚动轴承故障诊断领域中应用现状的调研&#xff0c;发现稀疏表示方法与故障特征提取和故障分类的关联&#xff0c;针对故障诊断问题&#xff0c;通过构造合理的故障稀疏表示模型&#xff0c;选取适合的模型优化算法&#xff0c;…
阅读更多...
Pycharm的基础使用

Pycharm的基础使用

Pycharm的基础使用 一、修改主题 第一步&#xff1a;点击file->settings 第二步&#xff1a;找到Appearance&Behavior->Appearance->Theme选择主题 有五种主题可以选 二、修改默认字体和大小 第一步&#xff1a;打开设置与上面修改主题第一步一样&#xff1b…
阅读更多...
C# 索引器与迭代器分部类详情

C# 索引器与迭代器分部类详情

文章目录 一、迭代器二、查看Foreach执行中间语言三、foreach实现过程总结四、实现迭代器最常用的方法五、分布类概述及其使用六、索引器概述及声明七、索引器在类中的使用八、索引器在接口中的使用九、总结 一、迭代器 1、迭代器&#xff08;iterator&#xff09;解决的是集合…
阅读更多...
零信任是对抗AI威胁的“解药”

零信任是对抗AI威胁的“解药”

人工智能的变革力量正在重塑众多行业的业务运营。通过机器人流程自动化&#xff08;RPA&#xff09;&#xff0c;人工智能正在将人力资源从重复的、基于规则的任务中解放出来&#xff0c;并将其重点放在战略性的、复杂的操作上。此外&#xff0c;人工智能和机器学习算法可以以前…
阅读更多...
线程池内的交响乐章：揭秘线程间通信的奥秘

线程池内的交响乐章：揭秘线程间通信的奥秘

1. 线程池概述 线程池是一种多线程处理模式，旨在通过维护一组预先创建的线程，来优化线程的管理和调度。线程池中的线程是后台线程，它们被组织起来以处理添加到队列中的任务。线程池的主要目标是减少线程创建和销毁的开销，同时保证内核的充分利用和防止过分调度。 2. 线程池…
阅读更多...
ASM之FieldVisitor创建变量

ASM之FieldVisitor创建变量

FieldVisitor使用abstract 修饰&#xff0c;用于创建变量&#xff0c;在使用时调用 ClassWriter.visitField即可创建FieldVisitor 方法介绍 visitField(Opcodes.ACC_PUBLIC, “str”, “Ljava/lang/String;”, null, “Hello World”) 第一个参数是修饰类型&#xff0c;第二…
阅读更多...
最新文章

Copyright @ 2022~2023