Shulou(Shulou.com)05/31 Report--

This article introduces the knowledge of "how to use the ExecMaterial function in PostgreSQ". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

I. data structure

SubPlanState

Run time status of subplan

/ *-* SubPlanState node *-* / typedef struct SubPlanState {NodeTag type; SubPlan * subplan; / * expression plan node * / struct PlanState * planstate; / * subselect plan's state tree * / struct PlanState * parent; / * parent plan node's state tree * / ExprState * testexpr / * combined expression status State of combining expression * / List * args; / * parameter expression status; states of argument _ expression (s) * / HeapTuple curTuple; / * the nearest tuple of subplan Copy of most recent tuple from subplan * / Datum curArray; / * most recent array from ARRAY () subplan * / / * these are used when hashing the subselect's output: * / TupleDesc descRight; / * projected subquery descriptor Subselect desc after projection * / ProjectionInfo * projLeft; / * for projecting lefthand exprs * / ProjectionInfo * projRight; / * for projecting subselect output * / TupleHashTable hashtable; / * hashtable for no-nulls subselect rows * / TupleHashTable hashnulls; / * hashtable for rows with null (s) * / bool havehashrows; / * true if hashtable is not empty * / bool havenullrows; / * true if hashnulls is not empty * / MemoryContext hashtablecxt / * memory context containing hash tables * / MemoryContext hashtempcxt; / * temp memory context for hash tables * / ExprContext * innerecontext; / * econtext for computing inner tuples * / AttrNumber * keyColIdx; / * control data for hash tables * / Oid * tab_eq_funcoids; / * equality funcoids for table * datatype (s) * / Oid * tab_collations / * collations for hash and comparison * / FmgrInfo * tab_hash_funcs; / * hash functions for table datatype (s) * / FmgrInfo * tab_eq_funcs; / * equality functions for table datatype (s) * / FmgrInfo * lhs_hash_funcs; / * hash functions for lefthand datatype (s) * / FmgrInfo * cur_eq_funcs; / * equality functions for LHS vs. Table * / ExprState * cur_eq_comp / * equality comparator for LHS vs. Table * /} SubPlanState

SubPlan

Subquery plan

/ * SubPlan-executable expression node for a subplan (sub-SELECT) * * The planner replaces SubLink nodes in expression trees with SubPlan * nodes after it has finished planning the subquery. SubPlan references * a sub-plantree stored in the subplans list of the toplevel PlannedStmt. * (We avoid a direct link to make it easier to copy expression trees * without causing multiple processing of the subplan.) * the query planner replaces the SubLink node in the expression tree with the SubPlan node after completing the planning of the subquery. * SubPlan refers to the sub-plantree stored in the subplans linked list in the high-level PlannedStmt. * (avoid using direct links, which makes copying expression trees relatively simple) * * In an ordinary subplan, testexpr points to an executable expression * (OpExpr, an AND/OR tree of OpExprs, or RowCompareExpr) for the combining * operator (s); the left-hand arguments are the original lefthand expressions, * and the right-hand arguments are PARAM_EXEC Param nodes representing the * outputs of the sub-select. (NOTE: runtime coercion functions may be * inserted as well.) This is just the same expression tree as testexpr in * the original SubLink node, but the PARAM_SUBLINK nodes are replaced by * suitably numbered PARAM_EXEC nodes. * normally, testexpr points to the executable expression (OpExpr, AND/OR tree of OpExprs, or RowCompareExpr) used for combining operations; * the left parameter is the original left expression, and the right parameter is the PARAM_EXEC parameter node used to represent the output of the subquery. * has the same expression tree as the testexpr of the original SubLink node, but the PARAM_SUBLINK node is replaced with the appropriate numbered PARAM_EXEC node. * * If the sub-select becomes an initplan rather than a subplan, the executable * expression is part of the outer plan's expression tree (and the SubPlan * node itself is not, but rather is found in the outer plan's initPlan * list). In this case testexpr is NULL to avoid duplication. * if the subquery becomes initplan instead of subplan, the executable expression is part of the outer plan expression tree. * in this case, testexpr is NULL to avoid repetition. * The planner also derives lists of the values that need to be passed into * and out of the subplan. Input values are represented as a list "args" of * expressions to be evaluated in the outer-query context (currently these * args are always just Vars, but in principle they could be any expression). * The values are assigned to the global PARAM_EXEC params indexed by parParam * (the parParam and args lists must have the same ordering). SetParam is a * list of the PARAM_EXEC params that are computed by the sub-select, if it * is an initplan; they are listed in order by sub-select output column * position. (parParam and setParam are integer Lists, not Bitmapsets, * because their ordering is significant.) * the planner also derives a linked list of values that need to be passed in and out of the subplan. * enter the "args" linked list of the value identification bit expression, which is parsed in the context of the outer query. * (these args are usually Vars, but in principle they can be arbitrary expressions) * these values assign values to the global PARAM_EXEC parameter with parParam as the index. * setParam is a linked list of PARAM_EXEC parameters, which is calculated by a subquery, such as initplan. * they are sorted and organized into linked lists according to the location of the output columns of the subquery. * (parParam and setParam are integer linked lists, not Bitmapsets linked lists) * * Also, the planner computes startup and per-call costs for use of the * SubPlan. Note that these include the cost of the subquery proper, * evaluation of the testexpr if any, and any hashtable management overhead. * at the same time, the planner calculates the cost of SubPlan startup and each call. Note: it includes the cost of parsing testexpr normally by subquery and the cost of hash table management. * / typedef struct SubPlan {Expr xpr;// expression / * Fields copied from original SubLink: * / / copied from SubLink SubLinkType subLinkType; / * see above * / * The combining operators, transformed to an executable expression: * / combined operator, converted to executable expression Node * testexpr; / * OpExpr or RowCompareExpr expression tree * / List * paramIds / * Parameter IDs;IDs of Params embedded in the above * / / * Identification of the Plan tree to use: * / Plan tree ID int plan_id; / * Index (from 1) in PlannedStmt.subplans * / / * Identification of the SubPlan for EXPLAIN and debugging purposes: * / EXPLAIN and SubPlan ID char * plan_name for debug purposes / * A name assigned during planning * / * Extra data useful for determining subplan's output type: * / additional information used to determine the subplan output type Oid firstColType; / * the first column type of the subplan result; Type of first column of subplan result * / int32 firstColTypmod; / * Typmod;Typmod of first column of subplan result * / Oid firstColCollation; / * first column Collation of the first column Collation of first column of subplan * result * / / * Information about execution strategy: * / related information about the execution phase bool useHashTable; / * whether to use hash tables to store the output of subqueries; true to store subselect output in a hash * table (implies we are doing "IN") * / bool unknownEqFalse / * T if OK, F if unknown; Fast processing of null values; true if it's okay to return FALSE when the * spec result is UNKNOWN; this allows much * simpler handling of null values * / bool parallel_safe / * is it secure in parallel? is the subplan parallel-safe? * / * Note: parallel_safe does not consider contents of testexpr or args * / / * Information for passing params into and out of the subselect: * / / Information used to pass in and out parameters to subqueries / * setParam and parParam are lists of integers (param IDs) * / / setParam and parParam are param IDs List * setParam / * initplan subqueries have to set these * Params for parent plan * / List * parParam; / * indices of input Params from parent plan * / List * args; / * expressions passed by parParam value Exprs to pass as parParam values * / * Estimated execution costs: * / / estimated execution cost Cost startup_cost; / * one-time setup cost * / Cost per_call_cost; / * cost for each subplan evaluation * /} SubPlan

SubLinkType

SubLink Typ

/ * SubLink * * A SubLink represents a subselect appearing in an expression, and in some * cases also the combining operator (s) just above it. The subLinkType * indicates the form of the expression represented: * EXISTS_SUBLINK EXISTS (SELECT...) * ALL_SUBLINK (lefthand) op ALL (SELECT...) * ANY_SUBLINK (lefthand) op ANY (SELECT..) * ROWCOMPARE_SUBLINK (lefthand) op (SELECT...) * EXPR_SUBLINK (SELECT with single targetlist item...) * MULTIEXPR_SUBLINK (SELECT with multiple targetlist items...) * ARRAY_SUBLINK ARRAY (SELECT with single targetlist item...) * CTE_SUBLINK WITH query (never actually part of an expression) * For ALL ANY, and ROWCOMPARE, the lefthand is a list of expressions of the * same length as the subselect's targetlist. ROWCOMPARE will * always* have * a list with more than one entry; if the subselect has just one target * then the parser will create an EXPR_SUBLINK instead (and any operator * above the subselect will be represented separately). * ROWCOMPARE, EXPR, and MULTIEXPR require the subselect to deliver at most * one row (if it returns no rows, the result is NULL). * ALL, ANY, and ROWCOMPARE require the combining operators to deliver boolean * results. ALL and ANY combine the per-row results using AND and OR * semantics respectively. * ARRAY requires just one target column, and creates an array of the target * column's type using any number of rows resulting from the subselect. * * SubLink is classed as an Expr node, but it is not actually executable; * it must be replaced in the expression tree by a SubPlan node during * planning. * * NOTE: in the raw output of gram.y, testexpr contains just the raw form * of the lefthand _ expression (if any), and operName is the String name of * the combining operator. Also, subselect is a raw parsetree. During parse * analysis, the parser transforms testexpr into a complete boolean expression * that compares the lefthand value (s) to PARAM_SUBLINK nodes representing the * output columns of the subselect. And subselect is transformed to a Query. * This is the representation seen in saved rules and in the rewriter. * * In EXISTS, EXPR, MULTIEXPR, and ARRAY SubLinks, testexpr and operName * are unused and are always null. * subLinkId is currently used only for MULTIEXPR SubLinks, and is zero in * other SubLinks. This number identifies different multiple-assignment * subqueries within an UPDATE statement's SET list. It is unique only * within a particular targetlist. The output column (s) of the MULTIEXPR * are referenced by PARAM_MULTIEXPR Params appearing elsewhere in the tlist. * The CTE_SUBLINK case never occurs in actual SubLink nodes, but it is used * in SubPlans generated for WITH subqueries. * / typedef enum SubLinkType {EXISTS_SUBLINK, ALL_SUBLINK, ANY_SUBLINK, ROWCOMPARE_SUBLINK, EXPR_SUBLINK, MULTIEXPR_SUBLINK, ARRAY_SUBLINK, CTE_SUBLINK / * for SubPlans only * /} SubLinkType

SubLink

SubLink structure

Typedef struct SubLink {Expr xpr; SubLinkType subLinkType; / * see above * / int subLinkId; / * ID (1.. n); 0 if not MULTIEXPR * / Node * testexpr; / * outer-query test for ALL/ANY/ROWCOMPARE * / List * operName; / * originally specified operator name * / Node * subselect / * subselect as Query* or raw parsetree * / int location; / * token location, or-1 if unknown * /} SubLink

MaterialState

Material statu

/ *-* MaterialState information * materialize nodes are used to materialize the results * of a subplan into a temporary file. * materialize node is used to materialize the result of subplan as a temporary file. * * ss.ss_ScanTupleSlot refers to output of underlying plan. * the output from ss.ss_ScanTupleSlot to underlyling plan (subplan) *-* / typedef struct MaterialState {ScanState ss; / * its first field is NodeTag * / int eflags; / * is passed to the capability tag of tuplestore; capability flags to pass to tuplestore * / bool eof_underlying; / * has reached the end of underlying plan? Reached end of underlying plan? * / Tuplestorestate * tuplestorestate;} MaterialState 2. Source code interpretation / *-* ExecMaterial * * As long as we are at the end of the data collected in the tuplestore, * we collect one new row from the subplan on each call And stash it * aside in the tuplestore before returning it. The tuplestore is * only read if we are asked to scan backwards, rescan, or mark/restore. * whenever data collection ends in tuplestore, a new row is collected from subplan on each call, * and saved in tuplestore before being returned. * tuplestore is read only when it is scanned, rescanned, or marked / restored. * *-* / static TupleTableSlot * / * the result returned from subplan Result tuple from subplan * / ExecMaterial (PlanState * pstate) {MaterialState * node = castNode (MaterialState, pstate); / / materialization node EState * estate;// runtime status ScanDirection dir;// scan direction bool forward;// forward scan Tuplestorestate * tuplestorestate;//Tuplestorestate structure pointer bool eof_tuplestore;// completed? TupleTableSlot * slot;// storage tuple slot CHECK_FOR_INTERRUPTS (); / * get state info from node * get relevant information from the materialization node * / estate = node- > ss.ps.state; dir = estate- > es_direction;// direction forward = ScanDirectionIsForward (dir); / / whether to scan tuplestorestate = node- > tuplestorestate; / * * If first time through, and we need a tuplestore, initialize it. * for the first time, you need tuplestore and initialize * / if (tuplestorestate = = NULL & & node- > eflags! = 0) {tuplestorestate = tuplestore_begin_heap (true, false, work_mem); tuplestore_set_eflags (tuplestorestate, node- > eflags); if (node- > eflags & EXEC_FLAG_MARK) {/ * Allocate a second read pointer to serve as the mark. We know it * must have index 1, so needn't store that. * assign a read pointer for mark * / int ptrno PG_USED_FOR_ASSERTS_ONLY; ptrno = tuplestore_alloc_read_pointer (tuplestorestate, node- > eflags); Assert (ptrno = = 1);} node- > tuplestorestate = tuplestorestate } / * * If we are not at the end of the tuplestore, or are going backwards, try * to fetch a tuple from tuplestore. * if it is not at the end of tuplestore or is scanning back, try to extract a tuple from tuplestore * / eof_tuplestore = (tuplestorestate = = NULL) | | tuplestore_ateof (tuplestorestate); if (! forward & & eof_tuplestore) {if (! node- > eof_underlying) {/ * * When reversing direction at tuplestore EOF, the first * gettupleslot call will fetch the last-added tuple But we want * to return the one before that, if possible. So do an extra * fetch. * reverse the direction at EOF, and the first gettupleslot call will extract the last added tuple; * but if possible, you want to return the tuple before that and perform additional extraction operations. * / if (! tuplestore_advance (tuplestorestate, forward) return NULL; / * the tuplestore must be empty * /} eof_tuplestore = false;} / * * If we can fetch another tuple from the tuplestore, return it. * if you can extract another tuple from tuplestore, return * / slot = node- > ss.ps.ps_ResultTupleSlot; if (! eof_tuplestore) {if (tuplestore_gettupleslot (tuplestorestate, forward, false, slot)) return slot; if (forward) eof_tuplestore = true;} / * * If necessary, try to fetch another row from the subplan. * if necessary (end of tuplestore), try to extract another line from subplan * * Note: the eof_underlying state variable exists to short-circuit further * subplan calls. It's not optional, unfortunately, because some plan * node types are not robust about being called again when they've already * returned NULL. * / if (eof_tuplestore & &! node- > eof_underlying) {PlanState * outerNode; TupleTableSlot * outerslot; / * * We can only get here with forward==true, so no need to worry about * which direction the subplan will go. * / outerNode = outerPlanState (node); outerslot = ExecProcNode (outerNode); if (TupIsNull (outerslot)) {node- > eof_underlying = true; return NULL;} / * * Append a copy of the returned tuple to tuplestore. NOTE: because * the tuplestore is certainly in EOF state, its read position will * move forward over the added tuple. This is what we want. * append the returned tuples to tuplestore. * Note: because tuplestore is currently in EOF state, the read position will be moved forward to the tuple that has been added, which is what we want to see. * / if (tuplestorestate) tuplestore_puttupleslot (tuplestorestate, outerslot); ExecCopySlot (slot, outerslot); return slot;} / * * Nothing left... * / return ExecClearTuple (slot); 3. Tracking and analysis

Perform SQL:

[pg12@localhost] $psql-d testdbTiming is on.Expanded display is used automatically.psql Type "help" for help. [local]: 5432 pg12@testdb=# [local]: 5432 pg12@testdb=# select * from tbl; id | value-+-1 | 2 (1 row) Time: 2.678 ms [local]: 5432 pg12@testdb=# select count (*) from t_big_null Count-10000001 (1 row) Time: 679.972 ms [local]: 5432 pg12@testdb=# analyze tbl;ANALYZETime: 64.442 ms [local]: 5432 pg12@testdb=# analyze tweets. [ms]: 434.702 ms [local]: 5432 pg12@testdb=# [local]: 5432 pg12@testdb=# select pg_backend_pid () Pg_backend_pid-18758 (1 row) Time: 1.990 ms [local]: 5432 pg12@testdb=# select * from tbl a where a.id not in (select b.id from t_big_null b)

Start gdb trace

(gdb) b ExecMaterialBreakpoint 1 at 0x720edb: file nodeMaterial.c, line 41. (gdb) cContinuing.Breakpoint 1, ExecMaterial (pstate=0x1230128) at nodeMaterial.c:4141 MaterialState * node = castNode (MaterialState, pstate); (gdb)

Input parameters

(gdb) p * pstate$4 = {type = T_MaterialState, plan = 0x1211858, state = 0x122fe88, ExecProcNode = 0x720ecf, ExecProcNodeReal = 0x720ecf, instrument = 0x0, worker_instrument = 0x0, worker_jit_instrument = 0x0, qual = 0x0, lefttree = 0x1230240, righttree = 0x0, initPlan = 0x0, subPlan = 0x0, chgParam = 0x0, ps_ResultTupleDesc = 0x1230660, ps_ResultTupleSlot = 0x1230778, ps_ExprContext = 0x0, ps_ProjInfo = 0x1230660, ps_ResultTupleSlot = 0x1230778, ps_ExprContext = 0x0, ps_ProjInfo = ps_ProjInfo, ps_ProjInfo = 0x0, 0x0 = 0x0, scandesc =, Inneropsfixed = false, resultopsfixed = true, scanopsset = true, outeropsset = false, inneropsset = false, resultopsset = true} (gdb)

MaterialState structure pointer data

(gdb) p * node$1 = {ss = {ps = {type = T_MaterialState, plan = 0x1211858, state = 0x122fe88, ExecProcNode = 0x720ecf, ExecProcNodeReal = 0x720ecf, instrument = 0x0, worker_instrument = 0x0, worker_jit_instrument = 0x0, qual = 0x0, lefttree = 0x1230240, righttree = 0x0, initPlan = 0x0, subPlan = 0x0, chgParam = 0x0, ps_ResultTupleDesc = 0x1230660, ps_ResultTupleSlot = 0x1230778, 0x1230778 = 0x0, ps_ResultTupleDesc = 0x1230660, ps_ResultTupleSlot = 0x1230778, 0x1230778 = ps_ExprContext, 0x0 = 0x0, 0x0 = 0x0, = Innerops = 0x0, resultops = 0xc3e720, scanopsfixed = true, outeropsfixed = false, inneropsfixed = false, resultopsfixed = true, scanopsset = true, outeropsset = false, inneropsset = false, resultopsset = true}, ss_currentRelation = 0x0, ss_currentScanDesc = 0x0, ss_ScanTupleSlot = 0x1230838}, eflags = 2, eof_underlying = false, tuplestorestate = 0x0} (gdb) p * node- > ss- > ps- > plan$2 = {type, type = 0, T_Material = 233310.685, T_Material = 9999979 Plan_width = 4, parallel_aware = false, parallel_safe = true, plan_node_id = 1, targetlist = 0x1257600, qual = 0x0, lefttree = 0x1210f58, righttree = 0x0, initPlan = 0x0, extParam = 0x0, allParam = 0x0} (gdb)

Run-time information and direction

(gdb) p * estate$5 = {type = T_EState, es_direction = ForwardScanDirection, es_snapshot = 0x1164d50, es_crosscheck_snapshot = 0x0, es_range_table = 0x1257328, es_range_table_array = 0x12300d8, es_range_table_size = 2, es_relations = 0x1230100, es_rowmarks = 0x0, es_plannedstmt = 0x1257748, es_sourceText = 0x113cd88 "select * from tbl a where a.id not in (select b.id from t_big_null b) ", es_junkFilter = 0x0, es_output_cid = 0, es_result_relations = 0x0, es_num_result_relations = 0, es_result_relation_info = 0x0, es_root_result_relations = 0x0, es_num_root_result_relations = 0, es_partition_directory = 0x0, es_tuple_routing_result_relations = 0x0, es_trig_target_relations = 0x0, es_param_list_info = 0x0, es_param_exec_vals = 0x12300a0, es_queryEnv = 0x0 Es_query_cxt = 0x122fd70, es_tupleTable = 0x1230510, es_processed = 0, es_top_eflags = 16, es_instrument = 0, es_finished = false, es_exprcontexts = 0x1230418, es_subplanstates = 0x1230920, es_auxmodifytables = 0x0, es_per_tuple_exprcontext = 0x0, es_epq_active = 0x0, es_use_parallel_mode = false, es_query_dsa = 0x0, es_jit_flags = 25, es_jit = 0x0 Es_jit_worker_instr = 0x0} (gdb) p dir$6 = ForwardScanDirection (gdb)

Initialize tuplestore

(gdb) n64 tuplestorestate = tuplestore_begin_heap (true, false, work_mem); (gdb) n65 tuplestore_set_eflags (tuplestorestate, node- > eflags) (gdb) p * tuplestorestate$7 = {status = TSS_INMEM, eflags = 6, backward = false, interXact = false, truncated = false, availMem = 4177896, allowedMem = 4194304, tuples = 0, myfile = 0x0, context = 0x122fd70, resowner = 0x116e308, copytup = 0xaba7bd, writetup = 0xaba811, readtup = 0xaba9d9, memtuples = 0x1219e60, memtupdeleted = 0, memtupcount = 0, memtupsize = 2048, growmemtuples = true, readptrs = 0x123ca50, activeptr = 0, activeptr = 1, readptrcount = 8, readptrcount = 0 Writepos_offset = 0} (gdb) n66 if (node- > eflags & EXEC_FLAG_MARK) (gdb) 78 node- > tuplestorestate = tuplestorestate (gdb) 85 eof_tuplestore = (tuplestorestate = = NULL) | | (gdb) p * tuplestorestate$8 = {status = TSS_INMEM, eflags = 2, backward = false, interXact = false, truncated = false, availMem = 4177896, allowedMem = 4194304, tuples = 0, myfile = 0x0, context = 0x122fd70, resowner = 0x116e308, copytup = 0xaba7bd, writetup = 0xaba811, readtup = 0xaba9d9, memtuples = 0x1219e60, memtupdeleted = 0, memtupcount = 0, memtupsize = 2048, growmemtuples = growmemtuples, true = true, true = 0, true = 1, true = 8, readptrs = 0 Writepos_offset = 0} (gdb)

Neither scanned back nor reached EOF

(gdb) N86 tuplestore_ateof (tuplestorestate); (gdb) 85 eof_tuplestore = (tuplestorestate = = NULL) | | (gdb) 88 if (! forward & & eof_tuplestore) (gdb) p eof_tuplestore$9 = false (gdb) p forward$10 = true (gdb)

If another tuple can be extracted from tuplestore, this slot is returned.

(gdb) n107 slot = node- > ss.ps.ps_ResultTupleSlot (gdb) 108 if (! eof_tuplestore) (gdb) p * slot$11 = {type = T_TupleTableSlot, tts_flags = 18, tts_nvalid = 0, tts_ops = 0xc3e720, tts_tupleDescriptor = 0x1230660, tts_values = 0x12307e8, tts_isnull = 0x12307f0, tts_mcxt = 0x122fd70, tts_tid = {ip_blkid = {bi_hi = 65535, bi_lo = 65535}, ip_posid = 0} Tts_tableOid = 0} (gdb) p slot- > tts_values [0] $12 = 0 (gdb) n110 if (tuplestore_gettupleslot (tuplestorestate, forward, false, slot)) (gdb)

If the scanning direction is forward, set eof_tuplestore to T and fill tuple into tuplestore

112 if (forward) (gdb) 113 eof_tuplestore = true; (gdb)

If necessary (at the end of tuplestore), try to extract another line from subplan (scan t_big_null)

124 if (eof_tuplestore & &! node- > eof_underlying) (gdb) p node- > eof_underlying$13 = false (gdb) n133 outerNode = outerPlanState (node); (gdb) n134 outerslot = ExecProcNode (outerNode) (gdb) 135if (TupIsNull (outerslot)) (gdb) p * outerNode$14 = {type = T_SeqScanState, plan = 0x1210f58, state = 0x122fe88, ExecProcNode = 0x72b904, ExecProcNodeReal = 0x72b904, instrument = 0x0, worker_instrument = 0x0, worker_jit_instrument = 0x0, qual = 0x0, lefttree = 0x0, righttree = 0x0, initPlan = 0x0, subPlan = 0x0, chgParam = 0x0, ps_ResultTupleDesc = 0x1230548, 0x1230548 = 0x1230548, ps_ResultTupleSlot = ps_ResultTupleSlot, ps_ResultTupleSlot = 0x0, 0x0 = 0x0, ps_ExprContext =, = Innerops = 0x0, resultops = 0xc3e780, scanopsfixed = true, outeropsfixed = false, inneropsfixed = false, resultopsfixed = true, scanopsset = true, outeropsset = false, inneropsset = false, resultopsset = true} (gdb) p * outerslot$15 = {type = T_TupleTableSlot, tts_flags = 16, tts_nvalid = 0, tts_ops = 0xc3e780, tts_tupleDescriptor = 0x7f6ec53386a8, tts_values = 0x12304c0, tts_isnull = 0x12304c8, tts_mcxt = 0x122fd70, tts_tid = {ip_blkid = 0, tts_tid = 44240} Ip_posid = 1}, tts_tableOid = 49155} (gdb) p outerslot- > tts_values [0] $16 = 0 (gdb) p outerslot- > tts_values [1] $17 = 0 (gdb) # [local]: 5432 pg12@testdb=# select oid,relname from pg_class where oid = 49155 Oid | relname-+-49155 | t_big_null (1 row) #

Copy to tuplestore and return slot

(gdb) n146 if (tuplestorestate) (gdb) 147 tuplestore_puttupleslot (tuplestorestate, outerslot); (gdb) 149 ExecCopySlot (slot, outerslot); (gdb) 150 return slot (gdb) p * slot$18 = {type = T_TupleTableSlot, tts_flags = 20, tts_nvalid = 0, tts_ops = 0xc3e720, tts_tupleDescriptor = 0x1230660, tts_values = 0x12307e8, tts_isnull = 0x12307f0, tts_mcxt = 0x122fd70, tts_tid = {ip_blkid = {bi_hi = 65535, bi_lo = 65535}, ip_posid = 0}, tts_tableOid = 0} (gdb) p * slot- > tts_values$19 = 0 (gdb)

Continue to execute

(gdb) p slot- > tts_values [0] $24 = 9998243 (gdb) cContinuing.Breakpoint 1, ExecMaterial (pstate=0x1230128) at nodeMaterial.c:4141 MaterialState * node = castNode (MaterialState, pstate); (gdb) n49 CHECK_FOR_INTERRUPTS (); (gdb) 54 estate = node- > ss.ps.state; (gdb) 55 dir = estate- > es_direction; (gdb) 56 forward = ScanDirectionIsForward (dir); (gdb) 57 tuplestorestate = node- > tuplestorestate (gdb) 62 if (tuplestorestate = = NULL & & node- > eflags! = 0) (gdb) 85 eof_tuplestore = (tuplestorestate = = NULL) | | (gdb) 86 tuplestore_ateof (tuplestorestate); (gdb) 85 eof_tuplestore = (tuplestorestate = = NULL) | | (gdb) 88 if (! forward & eof_tuplestore) (gdb) 107 slot = node- > ss.ps.ps_ResultTupleSlot (gdb) 108 if (! eof_tuplestore) (gdb) 124 if (eof_tuplestore & &! node- > eof_underlying) (gdb) 133 outerNode = outerPlanState (node); (gdb) 134 outerslot = ExecProcNode (outerNode); (gdb) 135if (TupIsNull (outerslot)) (gdb) 146if (tuplestorestate) (gdb) 147tuplestore_puttupleslot (tuplestorestate, outerslot) (gdb) 149 ExecCopySlot (slot, outerslot); (gdb) 150 return slot; (gdb) p slot- > tts_values [0] $25 = 9998244 (gdb). " This is the end of how to use the ExecMaterial function in PostgreSQ. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.