本節簡單解釋了PostgreSQL NOT IN在執行時為何會出現時快時慢的現象。

測試資料如下：
```
[local]:5432 pg12@testdb=# select count(*) from tbl;
 count 
-------
     1
(1 row)

Time: 6.009 ms
[local]:5432 pg12@testdb=# select count(*) from t_big_null;
  count   
----------
 10000001
(1 row)

Time: 633.248 ms
[local]:5432 pg12@testdb=# \d tbl
                Table "public.tbl"
 Column |  Type   | Collation | Nullable | Default 
--------+---------+-----------+----------+---------
 id     | integer |           | not null | 
 value  | integer |           | not null | 
Indexes:
    "tbl_pkey" PRIMARY KEY, btree (id)
Rules:
    rule_tbl_update AS
    ON INSERT TO tbl
   WHERE (EXISTS ( SELECT tbl_1.id,
            tbl_1.value
           FROM tbl tbl_1
          WHERE tbl_1.id = new.id)) DO INSTEAD  UPDATE tbl SET value = tbl.value + 1
  WHERE tbl.id = new.id

[local]:5432 pg12@testdb=# 
```
**注意tbl表只有一行資料(id = 1)，而t_big_null表在插入"id = 1"這一行時有意放在最後才插入**
```
truncate table t_big_null;
insert into t_big_null select generate_series(2,10000000);
insert into t_big_null values(1);
```

### 一、資料結構
**SubPlanState**
子計劃執行期狀態
```

/* ----------------
 *		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;		/* 組合表示式狀態；state of combining expression */
	List	   *args;			/* 參數列達式狀態；states of argument expression(s) */
	HeapTuple	curTuple;		/* 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;		/* 投影后的子查詢描述符；subselect desc after projection */
	ProjectionInfo *projLeft;	/* for projecting lefthand exprs */
	ProjectionInfo *projRight;	/* for projecting subselect output */
	TupleHashTable hashtable;	/* hash table for no-nulls subselect rows */
	TupleHashTable hashnulls;	/* hash table 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 func oids 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**
子查詢計劃
```

/*
 * 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.)
 * 查詢規劃器在完成子查詢的規劃後使用SubPlan節點替換表示式樹中的SubLink節點。
 * SubPlan引用了儲存在高層PlannedStmt中的subplans連結串列中的sub-plantree。
 * （避免使用直接連結，從而使得複製表示式樹相對比較簡單）
 *
 * 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.
 * 常規情況下，testexpr指向用於組合操作的可執行表示式（OpExpr、OpExprs的AND/OR樹或者RowCompareExpr）；
 * 左引數是原始的左表示式，右引數是PARAM_EXEC引數節點用以表示子查詢的輸出。
 * 與原始SubLink節點的testexpr具有相同的表示式樹，但PARAM_SUBLINK節點則使用合適的已編號PARAM_EXEC節點替代。
 *
 * 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.
 * 如果子查詢成了initplan而不是subplan，可執行的表示式是外層plan表示式樹的一部分。
 * 這種情況下，testexpr為NULL以避免重複。
 *
 * 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.)
 * 規劃器還派生了需要傳入和傳出子計劃的值的連結串列。
 * 輸入值標識位表示式的“args”連結串列，在外層查詢上下文中進行解析。
 * （這些args通常是Vars，但原則上它們可以是任意表示式）
 * 這些值以parParam為索引給全域性PARAM_EXEC引數賦值。
 * setParam是PARAM_EXEC引數連結串列，透過子查詢（如為initplan）計算所得。
 * 它們按子查詢輸出列的位置進行排序組織為連結串列形式。
 * （parParam和setParam是整型連結串列，而不是Bitmapsets連結串列）
 *
 * 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.
 * 同時，規劃器計算SubPlan啟動和每次呼叫的成本。注意：包括子查詢正常解析testexpr的成本以及雜湊表管理成本。
 */
typedef struct SubPlan
{
	Expr		xpr;//表示式
	/* Fields copied from original SubLink: */
	//從SubLink中複製而來
	SubLinkType subLinkType;	/* see above */
	/* The combining operators, transformed to an executable expression: */
	//組合運算子,轉換為可執行的表示式
	Node	   *testexpr;		/* OpExpr or RowCompareExpr expression tree */
	List	   *paramIds;		/* 引數IDs;IDs of Params embedded in the above */
	/* Identification of the Plan tree to use: */
	//Plan tree標識
	int			plan_id;		/* Index (from 1) in PlannedStmt.subplans */
	/* Identification of the SubPlan for EXPLAIN and debugging purposes: */
	//EXPLAIN和debug目的的SubPlan標識
	char	   *plan_name;		/* A name assigned during planning */
	/* Extra data useful for determining subplan's output type: */
	//用於確定subplan輸出型別的額外資訊
	Oid			firstColType;	/* subplan結果的第一個列型別;Type of first column of subplan result */
	int32		firstColTypmod; /* 第一列的Typmod;Typmod of first column of subplan result */
	Oid			firstColCollation;	/* 第一列的Collation;Collation of first column of subplan
									 * result */
	/* Information about execution strategy: */
	//執行階段的相關資訊
	bool		useHashTable;	/* 是否使用雜湊表儲存子查詢輸出;true to store subselect output in a hash
								 * table (implies we are doing "IN") */
	bool		unknownEqFalse; /* 如OK為T,如為未知則為F;快速處理null值;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 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: */
	//用於給子查詢傳入和傳出引數的資訊
	/* setParam and parParam are lists of integers (param IDs) */
	//setParam和parParam是整型連結串列(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;			/* 以parParam值進行傳遞的表示式；exprs to pass as parParam values */
	/* Estimated execution costs: */
	//估算執行成本
	Cost		startup_cost;	/* one-time setup cost */
	Cost		per_call_cost;	/* cost for each subplan evaluation */
} SubPlan;

```

**SubLinkType**
SubLink型別
```

/*
 * 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)
 *  我們使用SubLink表示在表示式中出現的子查詢，在某些情況下組合運算子會出現在SubLink之上。
 *  subLinkType表示表示式的形式：
 *	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.
 * 對於ALL,ANY和ROWCOMPARE,左運算子是與子查詢目標連結串列長度一致的表示式連結串列。
 * ROWCOMPARE通常有超過一個條目的連結串列；如果子查詢剛好只有一個目標列，那麼解析器會建立EXPR_SUBLINK
 * （同時所有在子查詢之上的運算子會單獨表示）
 * ROWCOMPARE, EXPR, 和MULTIEXPR要求子查詢至少輸出一行（如返回0行，則結果為NULL）。
 * ALL,ANY和ROWCOMPARE要求組合運算子輸出布林型結果。
 * ALL/ANY使用AND/OR語義來組合每一行的結果。
 *
 * 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.
 * SubLink歸類為Expr節點，但實際上並不是可執行的，必須在計劃階段透過SubPlan替代。
 *
 * 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.
 * 注意：在gram.y的裸輸出中，testexpr只包含左表示式的裸形式，operName是組合運算子的字串名稱。
 * 同時，子查詢是裸parsetree。在解析分析期間，
 * 解析器轉換testexpr為完整的布林表示式用於比較左運算子值與PARAM_SUBLINK節點所代表的子查詢輸出列值。
 * 子查詢會轉換為Query結構體。
 * 在已儲存的規則和重寫時可見的表示形式。
 *
 * In EXISTS, EXPR, MULTIEXPR, and ARRAY SubLinks, testexpr and operName
 * are unused and are always null.
 * 在EXISTS/EXPR/MULTEXPR/ARRAY SubLinks中，testexpr和operName不再使用通常是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.
 * subLinkId當前只用於MULTIEXPR，在其他SubLinks中取值為0.
 * 該數字標識了在UPDATE語句SET連結串列中不同的多個賦值子查詢。
 * 只有在特定的targetlist內是唯一的。
 * 出現在tlist其他地方的PARAM_MULTIEXPR引數依賴於MULTIEXPR的輸出列。
 *
 * The CTE_SUBLINK case never occurs in actual SubLink nodes, but it is used
 * in SubPlans generated for WITH subqueries.
 * CTE_SUBLINK不會出現在實際的SubLink節點中，但用於WITH子查詢所產生的SubPlans中。
 */
typedef enum SubLinkType
{
	EXISTS_SUBLINK,
	ALL_SUBLINK,
	ANY_SUBLINK,
	ROWCOMPARE_SUBLINK,
	EXPR_SUBLINK,
	MULTIEXPR_SUBLINK,
	ARRAY_SUBLINK,
	CTE_SUBLINK					/* 僅用於SubPlans中；for SubPlans only */
} SubLinkType;
```

**SubLink**
SubLink結構體
```

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狀態
```
/* ----------------
 *	 MaterialState information
 *
 *		materialize nodes are used to materialize the results
 *		of a subplan into a temporary file.
 *		materialize節點用於物化subplan的結果為臨時檔案。
 *
 *		ss.ss_ScanTupleSlot refers to output of underlying plan.
 *		ss.ss_ScanTupleSlot指向underlyling plan的輸出（subplan）
 * ----------------
 */
typedef struct MaterialState
{
	ScanState	ss;				/* its first field is NodeTag */
	int			eflags;			/* 傳遞給tuplestore的capability標記；capability flags to pass to tuplestore */
	bool		eof_underlying; /* 已經到達underlying plan的末尾？reached end of underlying plan? */
	Tuplestorestate *tuplestorestate;
} MaterialState;

```

**Tuplestorestate**
Tuplestore相關操作的私有狀態。
```

/*
 * Possible states of a Tuplestore object.  These denote the states that
 * persist between calls of Tuplestore routines.
 */
typedef enum
{
	TSS_INMEM,					/* Tuples still fit in memory */
	TSS_WRITEFILE,				/* Writing to temp file */
	TSS_READFILE				/* Reading from temp file */
} TupStoreStatus;

/*
 * Private state of a Tuplestore operation.
 */
struct Tuplestorestate
{
	TupStoreStatus status;		/* 狀態列舉值；enumerated value as shown above */
	int			eflags;			/* capability flags (OR of pointers' flags) */
	bool		backward;		/* store extra length words in file? */
	bool		interXact;		/* keep open through transactions? */
	bool		truncated;		/* tuplestore_trim has removed tuples? */
	int64		availMem;		/* remaining memory available, in bytes */
	int64		allowedMem;		/* total memory allowed, in bytes */
	int64		tuples;			/* number of tuples added */
	BufFile    *myfile;			/* underlying file, or NULL if none */
	MemoryContext context;		/* memory context for holding tuples */
	ResourceOwner resowner;		/* resowner for holding temp files */

/*
	 * These function pointers decouple the routines that must know what kind
	 * of tuple we are handling from the routines that don't need to know it.
	 * They are set up by the tuplestore_begin_xxx routines.
	 *
	 * (Although tuplestore.c currently only supports heap tuples, I've copied
	 * this part of tuplesort.c so that extension to other kinds of objects
	 * will be easy if it's ever needed.)
	 *
	 * Function to copy a supplied input tuple into palloc'd space. (NB: we
	 * assume that a single pfree() is enough to release the tuple later, so
	 * the representation must be "flat" in one palloc chunk.) state->availMem
	 * must be decreased by the amount of space used.
	 */
	void	   *(*copytup) (Tuplestorestate *state, void *tup);

/*
	 * Function to write a stored tuple onto tape.  The representation of the
	 * tuple on tape need not be the same as it is in memory; requirements on
	 * the tape representation are given below.  After writing the tuple,
	 * pfree() it, and increase state->availMem by the amount of memory space
	 * thereby released.
	 */
	void		(*writetup) (Tuplestorestate *state, void *tup);

/*
	 * Function to read a stored tuple from tape back into memory. 'len' is
	 * the already-read length of the stored tuple.  Create and return a
	 * palloc'd copy, and decrease state->availMem by the amount of memory
	 * space consumed.
	 */
	void	   *(*readtup) (Tuplestorestate *state, unsigned int len);

/*
	 * This array holds pointers to tuples in memory if we are in state INMEM.
	 * In states WRITEFILE and READFILE it's not used.
	 *
	 * When memtupdeleted > 0, the first memtupdeleted pointers are already
	 * released due to a tuplestore_trim() operation, but we haven't expended
	 * the effort to slide the remaining pointers down.  These unused pointers
	 * are set to NULL to catch any invalid accesses.  Note that memtupcount
	 * includes the deleted pointers.
	 */
	void	  **memtuples;		/* array of pointers to palloc'd tuples */
	int			memtupdeleted;	/* the first N slots are currently unused */
	int			memtupcount;	/* number of tuples currently present */
	int			memtupsize;		/* allocated length of memtuples array */
	bool		growmemtuples;	/* memtuples' growth still underway? */

/*
	 * These variables are used to keep track of the current positions.
	 *
	 * In state WRITEFILE, the current file seek position is the write point;
	 * in state READFILE, the write position is remembered in writepos_xxx.
	 * (The write position is the same as EOF, but since BufFileSeek doesn't
	 * currently implement SEEK_END, we have to remember it explicitly.)
	 */
	TSReadPointer *readptrs;	/* array of read pointers */
	int			activeptr;		/* index of the active read pointer */
	int			readptrcount;	/* number of pointers currently valid */
	int			readptrsize;	/* allocated length of readptrs array */

int			writepos_file;	/* file# (valid if READFILE state) */
	off_t		writepos_offset;	/* offset (valid if READFILE state) */
};

#define COPYTUP(state,tup)	((*(state)->copytup) (state, tup))
#define WRITETUP(state,tup) ((*(state)->writetup) (state, tup))
#define READTUP(state,len)	((*(state)->readtup) (state, len))
#define LACKMEM(state)		((state)->availMem < 0)
#define USEMEM(state,amt)	((state)->availMem -= (amt))
#define FREEMEM(state,amt)	((state)->availMem += (amt))

```

**TSReadPointer**
tuplestore讀指標
```

/*
 * Possible states of a Tuplestore object.  These denote the states that
 * persist between calls of Tuplestore routines.
 */
typedef enum
{
	TSS_INMEM,					/* Tuples still fit in memory */
	TSS_WRITEFILE,				/* Writing to temp file */
	TSS_READFILE				/* Reading from temp file */
} TupStoreStatus;

/*
 * State for a single read pointer.  If we are in state INMEM then all the
 * read pointers' "current" fields denote the read positions.  In state
 * WRITEFILE, the file/offset fields denote the read positions.  In state
 * READFILE, inactive read pointers have valid file/offset, but the active
 * read pointer implicitly has position equal to the temp file's seek position.
 *
 * Special case: if eof_reached is true, then the pointer's read position is
 * implicitly equal to the write position, and current/file/offset aren't
 * maintained.  This way we need not update all the read pointers each time
 * we write.
 */
typedef struct
{
	int			eflags;			/* capability flags */
	bool		eof_reached;	/* read has reached EOF */
	int			current;		/* next array index to read */
	int			file;			/* temp file# */
	off_t		offset;			/* byte offset in file */
} TSReadPointer;

```

### 二、原始碼解讀
NOT IN在實際執行時會轉換為ALL_SUBLINK，執行的快慢取決於什麼時候會碰到符合條件的記錄，一旦遇到馬上返回。因此，SQL的執行時間與資料表的掃描順序有緊密的關係，符合條件的行越早出現，程式越早返回，需要的時間越短。
相關程式碼如下：
```
...
		//解析表示式
		rowresult = ExecEvalExprSwitchContext(node->testexpr, econtext,
											  &rownull);

if (subLinkType == ANY_SUBLINK)
		{
			//ANY : 使用OR語義組合
			/* combine across rows per OR semantics */
			if (rownull)
				*isNull = true;
			else if (DatumGetBool(rowresult))
			{
				result = BoolGetDatum(true);
				*isNull = false;
				break;			/* needn't look at any more rows */
			}
		}
```
如上程式碼所示，在全表掃描物化的時候一旦textexpr表示式測試到其中一行滿足條件，那麼就會馬上退出迴圈，而這一行如果非常幸運的出現在掃描的最開始的地方，那執行時間將會很快（掃描幾個資料塊 vs 全表掃描）。

新建一張表，插入2條記錄，其中id = 2的行出現在block編號最小的地方，而id = 1出現在block編號最大的地方，這時候pg就會出現時快時慢的情況，兩者相差3個數量級。
```
[local]:5432 pg12@testdb=# create table tbl3(id int);
CREATE TABLE
Time: 1.852 ms
[local]:5432 pg12@testdb=# insert into tbl3 values(1);
INSERT 0 1
Time: 1.276 ms
[local]:5432 pg12@testdb=# insert into tbl3 values(2);
INSERT 0 1
Time: 1.089 ms
[local]:5432 pg12@testdb=# select * from tbl3 where id not in (select b.id from t_big_null b);
 id 
----
(0 rows)

Time: 3.676 ms
[local]:5432 pg12@testdb=# select * from tbl3 where id not in (select b.id from t_big_null b);
 id 
----
(0 rows)

Time: 4925.893 ms (00:04.926)
[local]:5432 pg12@testdb=# select * from tbl3 where id not in (select b.id from t_big_null b);
 id 
----
(0 rows)

Time: 2.858 ms
[local]:5432 pg12@testdb=# select * from tbl3 where id not in (select b.id from t_big_null b);
 id 
----
(0 rows)

Time: 4588.436 ms (00:04.588)
[local]:5432 pg12@testdb=# select * from tbl3 where id not in (select b.id from t_big_null b);
 id 
----
(0 rows)

Time: 1.896 ms
[local]:5432 pg12@testdb=# select * from tbl3 where id not in (select b.id from t_big_null b);
 id 
----
(0 rows)

Time: 4653.525 ms (00:04.654)
[local]:5432 pg12@testdb=# 
```

**ExecScanSubPlan**
```

/*
 * ExecScanSubPlan: default case where we have to rescan subplan each time
 * 預設情況下每次都不得不重新掃描subplan
 */
static Datum
ExecScanSubPlan(SubPlanState *node,
				ExprContext *econtext,
				bool *isNull)
{
	SubPlan    *subplan = node->subplan;//子計劃
	PlanState  *planstate = node->planstate;//計劃執行期狀態
	SubLinkType subLinkType = subplan->subLinkType;//子連結型別
	MemoryContext oldcontext;//原記憶體上下文
	TupleTableSlot *slot;//元組slot
	Datum		result;//結果指標
	bool		found = false;	/* 如找到至少一個元組,則返回T;true if got at least one subplan tuple */
	ListCell   *pvar;//臨時變數
	ListCell   *l;//臨時變數
	ArrayBuildStateAny *astate = NULL;//

/*
	 * MULTIEXPR subplans, when "executed", just return NULL; but first we
	 * mark the subplan's output parameters as needing recalculation.  (This
	 * is a bit of a hack: it relies on the subplan appearing later in its
	 * targetlist than any of the referencing Params, so that all the Params
	 * have been evaluated before we re-mark them for the next evaluation
	 * cycle.  But in general resjunk tlist items appear after non-resjunk
	 * ones, so this should be safe.)  Unlike ExecReScanSetParamPlan, we do
	 * *not* set bits in the parent plan node's chgParam, because we don't
	 * want to cause a rescan of the parent.
	 *
	 * MULTIEXPR處理邏輯
	 */
	if (subLinkType == MULTIEXPR_SUBLINK)
	{
		EState	   *estate = node->parent->state;

foreach(l, subplan->setParam)
		{
			int			paramid = lfirst_int(l);
			ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);

prm->execPlan = node;
		}
		*isNull = true;
		return (Datum) 0;
	}

/* Initialize ArrayBuildStateAny in caller's context, if needed */
	//陣列
	if (subLinkType == ARRAY_SUBLINK)
		astate = initArrayResultAny(subplan->firstColType,
									CurrentMemoryContext, true);

/*
	 * We are probably in a short-lived expression-evaluation context. Switch
	 * to the per-query context for manipulating the child plan's chgParam,
	 * calling ExecProcNode on it, etc.
	 */
	//切換上下文
	oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);

/*
	 * Set Params of this plan from parent plan correlation values. (Any
	 * calculation we have to do is done in the parent econtext, since the
	 * Param values don't need to have per-query lifetime.)
	 */
	//透過父計劃相關值中設定子計劃引數
	Assert(list_length(subplan->parParam) == list_length(node->args));

forboth(l, subplan->parParam, pvar, node->args)
	{
		int			paramid = lfirst_int(l);
		ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);

prm->value = ExecEvalExprSwitchContext((ExprState *) lfirst(pvar),
											   econtext,
											   &(prm->isnull));
		planstate->chgParam = bms_add_member(planstate->chgParam, paramid);
	}

/*
	 * Now that we've set up its parameters, we can reset the subplan.
	 */
	//執行ReScan
	//Reset a plan node so that its output can be re-scanned.
	ExecReScan(planstate);

/*
	 * For all sublink types except EXPR_SUBLINK and ARRAY_SUBLINK, the result
	 * is boolean as are the results of the combining operators. We combine
	 * results across tuples (if the subplan produces more than one) using OR
	 * semantics for ANY_SUBLINK or AND semantics for ALL_SUBLINK.
	 * (ROWCOMPARE_SUBLINK doesn't allow multiple tuples from the subplan.)
	 * NULL results from the combining operators are handled according to the
	 * usual SQL semantics for OR and AND.  The result for no input tuples is
	 * FALSE for ANY_SUBLINK, TRUE for ALL_SUBLINK, NULL for
	 * ROWCOMPARE_SUBLINK.
	 * 除EXPR_SUBLINK和ARRAY_SUBLINK外的所有sublink,結果是布林值(組合運算子的結果).
	 * PG透過跨元組(如子計劃產生多個元組)合併結果,對於ANY_SUBLINK使用OR語義,ALL_SUBLINK則使用AND語義.
	 * (ROWCOMPARE_SUBLINK不允許子計劃返回多個元組)
	 * 從組合運算子中返回的NULL遵循SQL中的OR和AND語義.
	 * 如沒有輸入元組,ANY_SUBLINK為FALSE,ALL_SUBLINK為TRUE,ROWCOMPARE_SUBLINK為NULL.
	 *
	 * For EXPR_SUBLINK we require the subplan to produce no more than one
	 * tuple, else an error is raised.  If zero tuples are produced, we return
	 * NULL.  Assuming we get a tuple, we just use its first column (there can
	 * be only one non-junk column in this case).
	 * 對於EXPR_SUBLINK,需要subplan產生不超過一個元組,否則報錯.如果沒有元組產生,返回NULL.
	 * 假定獲取到一個元組,則使用第一個列(這種情況下只有一個non-junk列).
	 *
	 * For ARRAY_SUBLINK we allow the subplan to produce any number of tuples,
	 * and form an array of the first column's values.  Note in particular
	 * that we produce a zero-element array if no tuples are produced (this is
	 * a change from pre-8.3 behavior of returning NULL).
	 * 對於ARRAY_SUBLINK,允許subplan產生任意數目的元組,使用第一個列值組成陣列.
	 * 特別注意的是如沒有元組產生則產生0個元素的陣列(8.3以前是返回NULL).
	 */
	result = BoolGetDatum(subLinkType == ALL_SUBLINK);//ALL為T,否則為F
	*isNull = false;

for (slot = ExecProcNode(planstate);
		 !TupIsNull(slot);
		 slot = ExecProcNode(planstate))//迴圈獲取元組,直至沒有元組為NULL(即已完成)
	{
		//元組描述符
		TupleDesc	tdesc = slot->tts_tupleDescriptor;
		Datum		rowresult;//結果
		bool		rownull;//是否為空?
		int			col;//列計數器
		ListCell   *plst;//臨時變數

if (subLinkType == EXISTS_SUBLINK)//EXISTS
		{
			found = true;
			result = BoolGetDatum(true);
			break;
		}

if (subLinkType == EXPR_SUBLINK)//EXPR表示式
		{
			/* cannot allow multiple input tuples for EXPR sublink */
			if (found)
				ereport(ERROR,
						(errcode(ERRCODE_CARDINALITY_VIOLATION),
						 errmsg("more than one row returned by a subquery used as an expression")));
			found = true;

/*
			 * We need to copy the subplan's tuple in case the result is of
			 * pass-by-ref type --- our return value will point into this
			 * copied tuple!  Can't use the subplan's instance of the tuple
			 * since it won't still be valid after next ExecProcNode() call.
			 * node->curTuple keeps track of the copied tuple for eventual
			 * freeing.
			 */
			if (node->curTuple)
				heap_freetuple(node->curTuple);
			node->curTuple = ExecCopySlotHeapTuple(slot);

result = heap_getattr(node->curTuple, 1, tdesc, isNull);
			/* keep scanning subplan to make sure there's only one tuple */
			continue;
		}

if (subLinkType == ARRAY_SUBLINK)//陣列
		{
			Datum		dvalue;
			bool		disnull;

found = true;
			/* stash away current value */
			Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
			dvalue = slot_getattr(slot, 1, &disnull);
			astate = accumArrayResultAny(astate, dvalue, disnull,
										 subplan->firstColType, oldcontext);
			/* keep scanning subplan to collect all values */
			continue;
		}

/* cannot allow multiple input tuples for ROWCOMPARE sublink either */
		if (subLinkType == ROWCOMPARE_SUBLINK && found)//行比較
			ereport(ERROR,
					(errcode(ERRCODE_CARDINALITY_VIOLATION),
					 errmsg("more than one row returned by a subquery used as an expression")));

found = true;//初始為T

/*
		 * For ALL, ANY, and ROWCOMPARE sublinks, load up the Params
		 * representing the columns of the sub-select, and then evaluate the
		 * combining expression.
		 * 對於ALL,ANY和ROWCOMPARE子連結,載入表示子查詢列的Params,並解析組合表示式
		 */
		col = 1;//列從1計數
		foreach(plst, subplan->paramIds)//迴圈遍歷子查詢引數
		{
			int			paramid = lfirst_int(plst);
			ParamExecData *prmdata;

prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
			Assert(prmdata->execPlan == NULL);
			//獲取引數值
			prmdata->value = slot_getattr(slot, col, &(prmdata->isnull));
			//下一個列
			col++;
		}
		//解析表示式
		rowresult = ExecEvalExprSwitchContext(node->testexpr, econtext,
											  &rownull);

if (subLinkType == ANY_SUBLINK)
		{
			//ANY : 使用OR語義組合
			/* combine across rows per OR semantics */
			if (rownull)
				*isNull = true;
			else if (DatumGetBool(rowresult))
			{
				result = BoolGetDatum(true);
				*isNull = false;
				break;			/* needn't look at any more rows */
			}
		}
		else if (subLinkType == ALL_SUBLINK)
		{
			//ALL : 使用AND語義
			/* combine across rows per AND semantics */
			if (rownull)
				*isNull = true;
			else if (!DatumGetBool(rowresult))
			{
				result = BoolGetDatum(false);
				*isNull = false;
				break;			/* needn't look at any more rows */
			}
		}
		else
		{
			/* must be ROWCOMPARE_SUBLINK */
			//這裡一定是ROWCOMPARE
			result = rowresult;
			*isNull = rownull;
		}
	}

MemoryContextSwitchTo(oldcontext);

if (subLinkType == ARRAY_SUBLINK)
	{
		/* We return the result in the caller's context */
		//在呼叫者上下文中返回結果
		result = makeArrayResultAny(astate, oldcontext, true);
	}
	else if (!found)
	{
		/*
		 * deal with empty subplan result.  result/isNull were previously
		 * initialized correctly for all sublink types except EXPR and
		 * ROWCOMPARE; for those, return NULL.
		 * subplan沒有結果返回,設定result&isNull值
		 */
		if (subLinkType == EXPR_SUBLINK ||
			subLinkType == ROWCOMPARE_SUBLINK)
		{
			result = (Datum) 0;
			*isNull = true;
		}
	}
	//返回結果
	return result;
}

```

### 三、跟蹤分析
執行SQL：
```
[local]:5432 pg12@testdb=# select * from tbl a where a.id not in (select b.id from t_big_null b);

```
啟動gdb跟蹤，設定斷點，觀察到斷點hit 1760次後就會退出，因此設定為忽略前1758次，只跟蹤最後2次。
```
(gdb) info b
Num     Type           Disp Enb Address            What
13      breakpoint     keep y   0x0000000000721126 in ExecMaterial at nodeMaterial.c:150
	breakpoint already hit 1760 times
	ignore next 3360 hits
...
(gdb) b nodeSubplan.c:328
Breakpoint 17 at 0x7303b9: file nodeSubplan.c, line 328.
(gdb) del 16
(gdb) info b
Num     Type           Disp Enb Address            What
17      breakpoint     keep y   0x00000000007303b9 in ExecScanSubPlan at nodeSubplan.c:328
(gdb) ignore 17 1758
Will ignore next 1758 crossings of breakpoint 17.
(gdb) c
Continuing.
```
開始跟蹤，這是第1759次，這時候從SubPlan獲取的資料是id = 10000000
```
Breakpoint 17, ExecScanSubPlan (node=0x3069268, econtext=0x3068aa0, isNull=0x3068dbd)
    at nodeSubplan.c:328
328			TupleDesc	tdesc = slot->tts_tupleDescriptor;
(gdb) n
334			if (subLinkType == EXISTS_SUBLINK)
(gdb) 
341			if (subLinkType == EXPR_SUBLINK)
(gdb) 
367			if (subLinkType == ARRAY_SUBLINK)
(gdb) 
383			if (subLinkType == ROWCOMPARE_SUBLINK && found)
(gdb) 
388			found = true;
(gdb) 
395			col = 1;
(gdb) 
396			foreach(plst, subplan->paramIds)
(gdb) 
398				int			paramid = lfirst_int(plst);
(gdb) 
401				prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
(gdb) 
402				Assert(prmdata->execPlan == NULL);
(gdb) 
403				prmdata->value = slot_getattr(slot, col, &(prmdata->isnull));
(gdb) p *prmdata
$109 = {execPlan = 0x0, value = 9999999, isnull = false}
(gdb) n
404				col++;
(gdb) p *prmdata
$110 = {execPlan = 0x0, value = 10000000, isnull = false}
(gdb) n
396			foreach(plst, subplan->paramIds)
(gdb) 
```
解析表示式
```
407			rowresult = ExecEvalExprSwitchContext(node->testexpr, econtext,
(gdb) step
ExecEvalExprSwitchContext (state=0x3069380, econtext=0x3068aa0, isNull=0x7ffd184750ef)
    at ../../../src/include/executor/executor.h:306
306		oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
(gdb) n
307		retDatum = state->evalfunc(state, econtext, isNull);
(gdb) step
ExecInterpExpr (state=0x3069380, econtext=0x3068aa0, isnull=0x7ffd184750ef)
    at execExprInterp.c:404
404		if (unlikely(state == NULL))
(gdb) n
411		op = state->steps;
(gdb) p *state
$111 = {tag = {type = T_ExprState}, flags = 6 '\006', resnull = false, resvalue = 0, 
  resultslot = 0x0, steps = 0x3069418, evalfunc = 0x6e2d4d <execinterpexpr>, 
  expr = 0x30917a8, evalfunc_private = 0x6e2d4d <execinterpexpr>, steps_len = 5, 
  steps_alloc = 16, parent = 0x3068988, ext_params = 0x0, innermost_caseval = 0x0, 
  innermost_casenull = 0x0, innermost_domainval = 0x0, innermost_domainnull = 0x0}
(gdb) n
412		resultslot = state->resultslot;
(gdb) 
413		innerslot = econtext->ecxt_innertuple;
(gdb) 
414		outerslot = econtext->ecxt_outertuple;
(gdb) 
415		scanslot = econtext->ecxt_scantuple;
(gdb) p *innerslot
Cannot access memory at address 0x0
(gdb) p *outerslot
Cannot access memory at address 0x0
(gdb) n
418		EEO_DISPATCH();
(gdb) p *scanslot
$112 = {type = T_TupleTableSlot, tts_flags = 16, tts_nvalid = 1, 
  tts_ops = 0xc3e780 <ttsopsbufferheaptuple>, tts_tupleDescriptor = 0x7fab449c99f0, 
  tts_values = 0x3068bd0, tts_isnull = 0x3068be0, tts_mcxt = 0x3067da0, tts_tid = {
    ip_blkid = {bi_hi = 0, bi_lo = 0}, ip_posid = 2}, tts_tableOid = 40960}
(gdb) p *scanslot->tts_values
$113 = 1
(gdb) n
448				CheckOpSlotCompatibility(op, scanslot);
(gdb) n
450				slot_getsomeattrs(scanslot, op->d.fetch.last_var);
(gdb) 
452				EEO_NEXT();
(gdb) 
487				int			attnum = op->d.var.attnum;
(gdb) 
491				Assert(attnum >= 0 && attnum < scanslot->tts_nvalid);
(gdb) 
492				*op->resvalue = scanslot->tts_values[attnum];
(gdb) 
493				*op->resnull = scanslot->tts_isnull[attnum];
(gdb) 
495				EEO_NEXT();
(gdb) p *op->resvalue
$114 = 1
(gdb) n
962				ExecEvalParamExec(state, op, econtext);
(gdb) 
964				EEO_NEXT();
(gdb) p *op
$115 = {opcode = 7224136, resvalue = 0x30698b8, resnull = 0x30698c0, d = {fetch = {
      last_var = 0, fixed = 23, known_desc = 0x0, kind = 0x0}, var = {attnum = 0, 
      vartype = 23}, wholerow = {var = 0x1700000000, first = false, slow = false, 
      tupdesc = 0x0, junkFilter = 0x0}, assign_var = {resultnum = 0, attnum = 23}, 
    assign_tmp = {resultnum = 0}, constval = {value = 98784247808, isnull = false}, 
    func = {finfo = 0x1700000000, fcinfo_data = 0x0, fn_addr = 0x0, nargs = 0}, 
    boolexpr = {anynull = 0x1700000000, jumpdone = 0}, qualexpr = {jumpdone = 0}, jump = {
      jumpdone = 0}, nulltest_row = {argdesc = 0x1700000000}, param = {paramid = 0, 
      paramtype = 23}, cparam = {paramfunc = 0x1700000000, paramarg = 0x0, paramid = 0, 
      paramtype = 0}, casetest = {value = 0x1700000000, isnull = 0x0}, make_readonly = {
      value = 0x1700000000, isnull = 0x0}, iocoerce = {finfo_out = 0x1700000000, 
      fcinfo_data_out = 0x0, finfo_in = 0x0, fcinfo_data_in = 0x0}, sqlvaluefunction = {
      svf = 0x1700000000}, nextvalueexpr = {seqid = 0, seqtypid = 23}, arrayexpr = {
      elemvalues = 0x1700000000, elemnulls = 0x0, nelems = 0, elemtype = 0, 
      elemlength = 0, elembyval = false, elemalign = 0 '\000', multidims = false}, 
    arraycoerce = {elemexprstate = 0x1700000000, resultelemtype = 0, amstate = 0x0}, 
    row = {tupdesc = 0x1700000000, elemvalues = 0x0, elemnulls = 0x0}, rowcompare_step = {
      finfo = 0x1700000000, fcinfo_data = 0x0, fn_addr = 0x0, jumpnull = 0, 
      jumpdone = 0}, rowcompare_final = {rctype = 0}, minmax = {values = 0x1700000000, 
      nulls = 0x0, nelems = 0, op = IS_GREATEST, finfo = 0x0, fcinfo_data = 0x0}, 
    fieldselect = {fieldnum = 0, resulttype = 23, argdesc = 0x0}, fieldstore = {
      fstore = 0x1700000000, argdesc = 0x0, values = 0x0, nulls = 0x0, ncolumns = 0}, 
    sbsref_subscript = {state = 0x1700000000, off = 0, isupper = false, jumpdone = 0}, 
    sbsref = {state = 0x1700000000}, domaincheck = {
      constraintname = 0x1700000000 <address out="" of="" bounds="">, 
      checkvalue = 0x0, checknull = 0x0, resulttype = 0}, convert_rowtype = {
      convert = 0x1700000000, indesc = 0x0, outdesc = 0x0, map = 0x0, 
      initialized = false}, scalararrayop = {element_type = 0, useOr = 23, typlen = 0, 
      typbyval = false, typalign = 0 '\000', finfo = 0x0, fcinfo_data = 0x0, 
      fn_addr = 0x0}, xmlexpr = {xexpr = 0x1700000000, named_argvalue = 0x0, 
      named_argnull = 0x0, argvalue = 0x0, argnull = 0x0}, aggref = {
      astate = 0x1700000000}, grouping_func = {parent = 0x1700000000, clauses = 0x0}, 
    window_func = {wfstate = 0x1700000000}, subplan = {sstate = 0x1700000000}, 
    alternative_subplan = {asstate = 0x1700000000}, agg_deserialize = {
      aggstate = 0x1700000000, fcinfo_data = 0x0, jumpnull = 0}, 
    agg_strict_input_check = {args = 0x1700000000, nulls = 0x0, nargs = 0, jumpnull = 0}, 
    agg_init_trans = {aggstate = 0x1700000000, pertrans = 0x0, aggcontext = 0x0, 
      setno = 0, transno = 0, setoff = 0, jumpnull = 0}, agg_strict_trans_check = {
      aggstate = 0x1700000000, setno = 0, transno = 0, setoff = 0, jumpnull = 0}, 
    agg_trans = {aggstate = 0x1700000000, pertrans = 0x0, aggcontext = 0x0, setno = 0, 
      transno = 0, setoff = 0}}}
(gdb) p *state
$116 = {tag = {type = T_ExprState}, flags = 6 '\006', resnull = false, resvalue = 0, 
  resultslot = 0x0, steps = 0x3069418, evalfunc = 0x6e2d4d <execinterpexpr>, 
  expr = 0x30917a8, evalfunc_private = 0x6e2d4d <execinterpexpr>, steps_len = 5, 
  steps_alloc = 16, parent = 0x3068988, ext_params = 0x0, innermost_caseval = 0x0, 
  innermost_casenull = 0x0, innermost_domainval = 0x0, innermost_domainnull = 0x0}
(gdb) n
634				FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
(gdb) 
635				NullableDatum *args = fcinfo->args;
(gdb) p *fcinfo
$117 = {flinfo = 0x3069830, context = 0x0, resultinfo = 0x0, fncollation = 0, 
  isnull = false, nargs = 2, args = 0x30698a8}
(gdb) p *fcinfo->args
$118 = {value = 1, isnull = false}
(gdb) n
640				for (argno = 0; argno < op->d.func.nargs; argno++)
(gdb) p op->d.func.nargs
$119 = 2
(gdb) p *op
$120 = {opcode = 7222440, resvalue = 0x3069388, resnull = 0x3069385, d = {fetch = {
      last_var = 50763824, fixed = false, known_desc = 0x3069888, 
      kind = 0x96c2b2 <int4eq>}, var = {attnum = 50763824, vartype = 0}, wholerow = {
      var = 0x3069830, first = 136, slow = 152, tupdesc = 0x96c2b2 <int4eq>, 
      junkFilter = 0x2}, assign_var = {resultnum = 50763824, attnum = 0}, assign_tmp = {
      resultnum = 50763824}, constval = {value = 50763824, isnull = 136}, func = {
      finfo = 0x3069830, fcinfo_data = 0x3069888, fn_addr = 0x96c2b2 <int4eq>, 
      nargs = 2}, boolexpr = {anynull = 0x3069830, jumpdone = 50763912}, qualexpr = {
      jumpdone = 50763824}, jump = {jumpdone = 50763824}, nulltest_row = {
      argdesc = 0x3069830}, param = {paramid = 50763824, paramtype = 0}, cparam = {
      paramfunc = 0x3069830, paramarg = 0x3069888, paramid = 9880242, paramtype = 0}, 
    casetest = {value = 0x3069830, isnull = 0x3069888}, make_readonly = {
      value = 0x3069830, isnull = 0x3069888}, iocoerce = {finfo_out = 0x3069830, 
      fcinfo_data_out = 0x3069888, finfo_in = 0x96c2b2 <int4eq>, fcinfo_data_in = 0x2}, 
    sqlvaluefunction = {svf = 0x3069830}, nextvalueexpr = {seqid = 50763824, 
      seqtypid = 0}, arrayexpr = {elemvalues = 0x3069830, elemnulls = 0x3069888, 
      nelems = 9880242, elemtype = 0, elemlength = 2, elembyval = false, 
      elemalign = 0 '\000', multidims = false}, arraycoerce = {elemexprstate = 0x3069830, 
      resultelemtype = 50763912, amstate = 0x96c2b2 <int4eq>}, row = {
      tupdesc = 0x3069830, elemvalues = 0x3069888, elemnulls = 0x96c2b2 <int4eq>}, 
    rowcompare_step = {finfo = 0x3069830, fcinfo_data = 0x3069888, 
      fn_addr = 0x96c2b2 <int4eq>, jumpnull = 2, jumpdone = 0}, rowcompare_final = {
      rctype = 50763824}, minmax = {values = 0x3069830, nulls = 0x3069888, 
      nelems = 9880242, op = IS_GREATEST, finfo = 0x2, fcinfo_data = 0x0}, fieldselect = {
      fieldnum = -26576, resulttype = 0, argdesc = 0x3069888}, fieldstore = {
      fstore = 0x3069830, argdesc = 0x3069888, values = 0x96c2b2 <int4eq>, nulls = 0x2, 
      ncolumns = 0}, sbsref_subscript = {state = 0x3069830, off = 50763912, 
      isupper = false, jumpdone = 9880242}, sbsref = {state = 0x3069830}, domaincheck = {
      constraintname = 0x3069830 "\262\302\226", checkvalue = 0x3069888, 
      checknull = 0x96c2b2 <int4eq>, resulttype = 2}, convert_rowtype = {
      convert = 0x3069830, indesc = 0x3069888, outdesc = 0x96c2b2 <int4eq>, map = 0x2, 
      initialized = false}, scalararrayop = {element_type = 50763824, useOr = false, 
      typlen = 0, typbyval = 136, typalign = -104 '\230', finfo = 0x96c2b2 <int4eq>, 
      fcinfo_data = 0x2, fn_addr = 0x0}, xmlexpr = {xexpr = 0x3069830, 
      named_argvalue = 0x3069888, named_argnull = 0x96c2b2 <int4eq>, argvalue = 0x2, 
      argnull = 0x0}, aggref = {astate = 0x3069830}, grouping_func = {parent = 0x3069830, 
      clauses = 0x3069888}, window_func = {wfstate = 0x3069830}, subplan = {
      sstate = 0x3069830}, alternative_subplan = {asstate = 0x3069830}, 
    agg_deserialize = {aggstate = 0x3069830, fcinfo_data = 0x3069888, 
      jumpnull = 9880242}, agg_strict_input_check = {args = 0x3069830, nulls = 0x3069888, 
      nargs = 9880242, jumpnull = 0}, agg_init_trans = {aggstate = 0x3069830, 
      pertrans = 0x3069888, aggcontext = 0x96c2b2 <int4eq>, setno = 2, transno = 0, 
      setoff = 0, jumpnull = 0}, agg_strict_trans_check = {aggstate = 0x3069830, 
      setno = 50763912, transno = 0, setoff = 9880242, jumpnull = 0}, agg_trans = {
      aggstate = 0x3069830, pertrans = 0x3069888, aggcontext = 0x96c2b2 <int4eq>, 
      setno = 2, transno = 0, setoff = 0}}}
(gdb) p op->d->func
$121 = {finfo = 0x3069830, fcinfo_data = 0x3069888, fn_addr = 0x96c2b2 <int4eq>, 
  nargs = 2}
(gdb) p op->d->func->finfo
$122 = (FmgrInfo *) 0x3069830
(gdb) p *op->d->func->finfo
$123 = {fn_addr = 0x96c2b2 <int4eq>, fn_oid = 65, fn_nargs = 2, fn_strict = true, 
  fn_retset = false, fn_stats = 2 '\002', fn_extra = 0x0, fn_mcxt = 0x3067da0, 
  fn_expr = 0x30917a8}
(gdb) p *op->d->func->fcinfo_data
$124 = {flinfo = 0x3069830, context = 0x0, resultinfo = 0x0, fncollation = 0, 
  isnull = false, nargs = 2, args = 0x30698a8}
(gdb) p *op->d->func->fcinfo_data->flinfo
$125 = {fn_addr = 0x96c2b2 <int4eq>, fn_oid = 65, fn_nargs = 2, fn_strict = true, 
  fn_retset = false, fn_stats = 2 '\002', fn_extra = 0x0, fn_mcxt = 0x3067da0, 
  fn_expr = 0x30917a8}
(gdb) p *op->d->func->fcinfo_data->args
$126 = {value = 1, isnull = false}
(gdb) n
642					if (args[argno].isnull)
(gdb) 
640				for (argno = 0; argno < op->d.func.nargs; argno++)
(gdb) 
642					if (args[argno].isnull)
(gdb) 
640				for (argno = 0; argno < op->d.func.nargs; argno++)
(gdb) 
648				fcinfo->isnull = false;
(gdb) p *args
$127 = {value = 1, isnull = false}
(gdb) n
649				d = op->d.func.fn_addr(fcinfo);
(gdb) 
650				*op->resvalue = d;
(gdb) p d
$128 = 0
(gdb) n
651				*op->resnull = fcinfo->isnull;
(gdb) 
654				EEO_NEXT();
(gdb) 
425				goto out;
(gdb) n
1747		*isnull = state->resnull;
(gdb) 
1748		return state->resvalue;
(gdb) p *state
$129 = {tag = {type = T_ExprState}, flags = 6 '\006', resnull = false, resvalue = 0, 
  resultslot = 0x0, steps = 0x3069418, evalfunc = 0x6e2d4d <execinterpexpr>, 
  expr = 0x30917a8, evalfunc_private = 0x6e2d4d <execinterpexpr>, steps_len = 5, 
  steps_alloc = 16, parent = 0x3068988, ext_params = 0x0, innermost_caseval = 0x0, 
  innermost_casenull = 0x0, innermost_domainval = 0x0, innermost_domainnull = 0x0}
(gdb) n
1749	}
(gdb) 
ExecEvalExprSwitchContext (state=0x3069380, econtext=0x3068aa0, isNull=0x7ffd184750ef)
    at ../../../src/include/executor/executor.h:308
308		MemoryContextSwitchTo(oldContext);
(gdb) 
309		return retDatum;
(gdb) p retDatum
$130 = 0
(gdb) n
310	}
(gdb) 
```
這是第1760次呼叫
```
ExecScanSubPlan (node=0x3069268, econtext=0x3068aa0, isNull=0x3068dbd)
    at nodeSubplan.c:410
410			if (subLinkType == ANY_SUBLINK)
(gdb) 
413				if (rownull)
(gdb) 
415				else if (DatumGetBool(rowresult))
(gdb) p rowresult
$131 = 0
(gdb) n
326			 slot = ExecProcNode(planstate))
(gdb) 
324		for (slot = ExecProcNode(planstate);
(gdb) 
325			 !TupIsNull(slot);
(gdb)

Breakpoint 17, ExecScanSubPlan (node=0x3069268, econtext=0x3068aa0, isNull=0x3068dbd)
    at nodeSubplan.c:328
328			TupleDesc	tdesc = slot->tts_tupleDescriptor;
(gdb) 
334			if (subLinkType == EXISTS_SUBLINK)
(gdb) 
341			if (subLinkType == EXPR_SUBLINK)
(gdb) 
367			if (subLinkType == ARRAY_SUBLINK)
(gdb) 
383			if (subLinkType == ROWCOMPARE_SUBLINK && found)
(gdb) 
388			found = true;
(gdb) 
395			col = 1;
(gdb) p *slot->tts_values
$132 = 10000000 --> 上一次的資料
(gdb) n
396			foreach(plst, subplan->paramIds)
(gdb) 
398				int			paramid = lfirst_int(plst);
(gdb) 
401				prmdata = &(econtext->ecxt_param_exec_vals[paramid]);
(gdb) 
402				Assert(prmdata->execPlan == NULL);
(gdb) p *prmdata
$133 = {execPlan = 0x0, value = 10000000, isnull = false}
(gdb) n
403				prmdata->value = slot_getattr(slot, col, &(prmdata->isnull));
(gdb) 
404				col++;
(gdb) p *prmdata
$134 = {execPlan = 0x0, value = 1, isnull = false} --> 本次資料，值為1
(gdb) info b
Num     Type           Disp Enb Address            What
17      breakpoint     keep y   0x00000000007303b9 in ExecScanSubPlan at nodeSubplan.c:328
	breakpoint already hit 1760 times
(gdb) n
396			foreach(plst, subplan->paramIds)
(gdb) 
407			rowresult = ExecEvalExprSwitchContext(node->testexpr, econtext,
(gdb) 
410			if (subLinkType == ANY_SUBLINK)
(gdb) 
413				if (rownull)
(gdb) 
415				else if (DatumGetBool(rowresult))
(gdb) 
417					result = BoolGetDatum(true);
(gdb) 
418					*isNull = false;
(gdb) 
419					break;			/* needn't look at any more rows */
(gdb) 
442		MemoryContextSwitchTo(oldcontext);
(gdb) 
444		if (subLinkType == ARRAY_SUBLINK)
(gdb) 
449		else if (!found)
(gdb) 
464		return result;
(gdb) 
(gdb) p result
$135 = 1 --> 滿足條件
```
**DONE**

### 四、參考資料
N/A</execinterpexpr></execinterpexpr></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></int4eq></execinterpexpr></execinterpexpr></address></ttsopsbufferheaptuple></execinterpexpr></execinterpexpr>

PostgreSQL 原始碼解讀（233）- 查詢#126(NOT IN實現#4)

相關文章