本節簡單介紹了PostgreSQL隱式型別轉換中選擇運算子(pg_operator)的實現函式func_select_candidate.

### 一、資料結構
**FuncCandidateList**
該結構體儲存檢索得到的所有可能選中的函式或運算子連結串列.
```

/*
 *  This structure holds a list of possible functions or operators
 *  found by namespace lookup.  Each function/operator is identified
 *  by OID and by argument types; the list must be pruned by type
 *  resolution rules that are embodied in the parser, not here.
 *  See FuncnameGetCandidates's comments for more info.
 *  該結構體儲存檢索得到的所有可能選中的函式或運算子連結串列.
 *  每一個函式/運算子透過OID和引數型別唯一確定,
 *  透過整合到分析器中的type resolution rules來確定裁剪該連結串列(但不是在這裡實現)
 *  詳細可參考FuncnameGetCandidates函式.
 */
typedef struct _FuncCandidateList
{
    struct _FuncCandidateList *next;
    //用於namespace檢索內部使用
    int         pathpos;        /* for internal use of namespace lookup */
    //OID
    Oid         oid;            /* the function or operator's OID */
    //引數個數 
    int         nargs;          /* number of arg types returned */
    //variadic array的引數個數
    int         nvargs;         /* number of args to become variadic array */
    //預設引數個數
    int         ndargs;         /* number of defaulted args */
    //引數位置索引
    int        *argnumbers;     /* args' positional indexes, if named call */
    //引數型別
    Oid         args[FLEXIBLE_ARRAY_MEMBER];    /* arg types */
}          *FuncCandidateList;

```

### 二、原始碼解讀
**func_select_candidate**
處理邏輯與PG文件中的型別轉換規則一樣,其規則詳見參考資料中的Operator部分.
```
/*
create table t_tmp(c1 int,c2 int);
insert into t_tmp values(1,1);

create cast(integer as text) with inout as implicit;

testdb=# select c1||'-'||c2 from t_tmp;
psql: ERROR:  operator is not unique: integer || unknown
LINE 1: select c1||'-'||c2 from t_tmp;
                 ^
HINT:  Could not choose a best candidate operator. You might need to add explicit type casts.
*/

/* func_select_candidate()
 *      Given the input argtype array and more than one candidate
 *      for the function, attempt to resolve the conflict.
 *      給定引數型別和多於1個的候選函式,嘗試解決衝突選中合適的函式.
 *
 * Returns the selected candidate if the conflict can be resolved,
 * otherwise returns NULL.
 * 如衝突解決,則返回選中的函式,否則返回NULL.
 *
 * Note that the caller has already determined that there is no candidate
 * exactly matching the input argtypes, and has pruned away any "candidates"
 * that aren't actually coercion-compatible with the input types.
 * 注意 : 呼叫者已確定沒有那個函式完全滿足輸入的引數型別,
 *        已清除了所有與輸入引數型別不相容的函式.
 *
 * This is also used for resolving ambiguous operator references.  Formerly
 * parse_oper.c had its own, essentially duplicate code for the purpose.
 * The following comments (formerly in parse_oper.c) are kept to record some
 * of the history of these heuristics.
 * 本例程同時用於解決模糊運算子引用.以前parse_oper.c有自己的程式碼,本質上是重複的程式碼.
 * 接下來的註釋(先前在parse_oper.c中)保留用於記錄這些啟發式的歷史.
 *
 * OLD COMMENTS:
 *
 * This routine is new code, replacing binary_oper_select_candidate()
 * which dates from v4.2/v1.0.x days. It tries very hard to match up
 * operators with types, including allowing type coercions if necessary.
 * The important thing is that the code do as much as possible,
 * while _never_ doing the wrong thing, where "the wrong thing" would
 * be returning an operator when other better choices are available,
 * or returning an operator which is a non-intuitive possibility.
 * - thomas 1998-05-21
 * 本例程努力的透過型別與operators進行匹配,包括在需要時允許型別強制轉換.
 *
 * The comments below came from binary_oper_select_candidate(), and
 * illustrate the issues and choices which are possible:
 * - thomas 1998-05-20
 *
 * current wisdom holds that the default operator should be one in which
 * both operands have the same type (there will only be one such
 * operator)
 * 當前我們認為 : 預設運算子應該是兩個運算元具有相同型別的運算子(只有一個這樣的運算子).
 *
 * 7.27.93 - I have decided not to do this; it's too hard to justify, and
 * it's easy enough to typecast explicitly - avi
 * [the rest of this routine was commented out since then - ay]
 *
 * 6/23/95 - I don't complete agree with avi. In particular, casting
 * floats is a pain for users. Whatever the rationale behind not doing
 * this is, I need the following special case to work.
 *
 * In the WHERE clause of a query, if a float is specified without
 * quotes, we treat it as float8. I added the float48* operators so
 * that we can operate on float4 and float8. But now we have more than
 * one matching operator if the right arg is unknown (eg. float
 * specified with quotes). This break some stuff in the regression
 * test where there are floats in quotes not properly casted. Below is
 * the solution. In addition to requiring the operator operates on the
 * same type for both operands [as in the code Avi originally
 * commented out], we also require that the operators be equivalent in
 * some sense. (see equivalentOpersAfterPromotion for details.)
 * - ay 6/95
 * 在WHERE語句中,如果float不帶引號,PG會把該值視為float8型別.
 * 新增了float48*運算子的目的是可以處理float4和float8兩種型別.
 * 但如果右運算元的型別是unknown(如帶有引號的浮點數)的話,會有超過一個匹配的operator存在.
 * 這會導致迴歸測試中出現浮點數使用引號引住而沒有被正確轉換的情況而失敗.
 * 除了要求運算子在同樣型別的運算元外,還要求運算子在某些場景是等價的.
 */
FuncCandidateList
func_select_candidate(int nargs,
                      Oid *input_typeids,
                      FuncCandidateList candidates)
{
    FuncCandidateList current_candidate,
                first_candidate,
                last_candidate;
    Oid        *current_typeids;
    Oid         current_type;
    int         i;
    int         ncandidates;
    int         nbestMatch,
                nmatch,
                nunknowns;
    Oid         input_base_typeids[FUNC_MAX_ARGS];
    TYPCATEGORY slot_category[FUNC_MAX_ARGS],
                current_category;
    bool        current_is_preferred;
    bool        slot_has_preferred_type[FUNC_MAX_ARGS];
    bool        resolved_unknowns;

/* protect local fixed-size arrays */
    //校驗
    if (nargs > FUNC_MAX_ARGS)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg_plural("cannot pass more than %d argument to a function",
                               "cannot pass more than %d arguments to a function",
                               FUNC_MAX_ARGS,
                               FUNC_MAX_ARGS)));

/*
     * If any input types are domains, reduce them to their base types. This
     * ensures that we will consider functions on the base type to be "exact
     * matches" in the exact-match heuristic; it also makes it possible to do
     * something useful with the type-category heuristics. Note that this
     * makes it difficult, but not impossible, to use functions declared to
     * take a domain as an input datatype.  Such a function will be selected
     * over the base-type function only if it is an exact match at all
     * argument positions, and so was already chosen by our caller.
     *
     * While we're at it, count the number of unknown-type arguments for use
     * later.
     * 計算unknown型別的引數個數
     */
    /*
    If any input argument is of a domain type, treat it as being of the domain's 
    base type for all subsequent steps. This ensures that domains act like their 
    base types for purposes of ambiguous-operator resolution.
    */
    nunknowns = 0;
    for (i = 0; i < nargs; i++)
    {
        if (input_typeids[i] != UNKNOWNOID)
            input_base_typeids[i] = getBaseType(input_typeids[i]);//基本型別
        else
        {
            //unknown 型別
            /* no need to call getBaseType on UNKNOWNOID */
            input_base_typeids[i] = UNKNOWNOID;
            nunknowns++;
        }
    }

/*
     * Run through all candidates and keep those with the most matches on
     * exact types. Keep all candidates if none match.
     * 遍歷所有候選,保留那些型別一致的那些.如無匹配的,保留所有候選.
     */
    /*
    Run through all candidates and keep those with the most exact matches on input types.
    Keep all candidates if none have exact matches. If only one candidate remains, use it; 
    else continue to the next step.
    */
    ncandidates = 0;//候選數
    nbestMatch = 0;//最佳匹配數
    last_candidate = NULL;//最後一個候選
    for (current_candidate = candidates;
         current_candidate != NULL;
         current_candidate = current_candidate->next)//遍歷
    {
        //獲取候選函式的引數
        current_typeids = current_candidate->args;
        nmatch = 0;
        for (i = 0; i < nargs; i++)
        {
            //計算引數匹配個數
            if (input_base_typeids[i] != UNKNOWNOID &&
                current_typeids[i] == input_base_typeids[i])
                nmatch++;
        }

/* take this one as the best choice so far? */
        //就拿這個作為最好的選擇?
        if ((nmatch > nbestMatch) || (last_candidate == NULL))
        {
            //1.比最佳引數匹配個數要大,調整最佳匹配數(引數個數)
            //2.last_candidate == NULL,第一次迴圈
            nbestMatch = nmatch;
            candidates = current_candidate;
            last_candidate = current_candidate;
            ncandidates = 1;
        }
        /* no worse than the last choice, so keep this one too? */
        //不會比最後一個選項更糟，所以也保留這個選項
        else if (nmatch == nbestMatch)
        {
            //放到連結串列中
            last_candidate->next = current_candidate;
            last_candidate = current_candidate;
            ncandidates++;
        }
        /* otherwise, don't bother keeping this one... */
        //否則,無需保留
    }

if (last_candidate)         /* terminate rebuilt list */
        last_candidate->next = NULL;

if (ncandidates == 1)//只有一個候選,返回
        return candidates;

/*
     * Still too many candidates? Now look for candidates which have either
     * exact matches or preferred types at the args that will require
     * coercion. (Restriction added in 7.4: preferred type must be of same
     * category as input type; give no preference to cross-category
     * conversions to preferred types.)  Keep all candidates if none match.
     * 仍有太多的候選?
     * 檢索args精確匹配或強制型別轉換後有首選型別的候選項.
     * (首選型別必須與輸入型別是相同的目錄).
     * 如無匹配,保留所有候選.
     */
    /*
    Run through all candidates and keep those that accept preferred types 
    (of the input data type's type category) at the most positions where type 
    conversion will be required. Keep all candidates if none accept preferred types. 
    If only one candidate remains, use it; else continue to the next step.
    */
    for (i = 0; i < nargs; i++) /* avoid multiple lookups */
        slot_category[i] = TypeCategory(input_base_typeids[i]);//獲取型別目錄
    ncandidates = 0;
    nbestMatch = 0;
    last_candidate = NULL;
    for (current_candidate = candidates;
         current_candidate != NULL;
         current_candidate = current_candidate->next)//遍歷
    {
        current_typeids = current_candidate->args;//引數
        nmatch = 0;
        for (i = 0; i < nargs; i++)
        {
            if (input_base_typeids[i] != UNKNOWNOID)
            {
                if (current_typeids[i] == input_base_typeids[i] ||
                    IsPreferredType(slot_category[i], current_typeids[i]))
                    nmatch++;//不要求精確匹配,存在首選項一樣的引數也可以了
            }
        }

if ((nmatch > nbestMatch) || (last_candidate == NULL))
        {
            //1.比最佳引數匹配個數要大,調整最佳匹配數(引數個數)
            //2.last_candidate == NULL,第一次迴圈
            nbestMatch = nmatch;
            candidates = current_candidate;
            last_candidate = current_candidate;
            ncandidates = 1;
        }
        else if (nmatch == nbestMatch)
        {
            //保留跟最佳匹配一樣的候選
            last_candidate->next = current_candidate;
            last_candidate = current_candidate;
            ncandidates++;
        }
    }

if (last_candidate)         /* terminate rebuilt list */
        last_candidate->next = NULL;

if (ncandidates == 1)
        return candidates;//

/*
     * Still too many candidates?  Try assigning types for the unknown inputs.
     * 仍有過多的候選?嘗試為unknown型別賦值
     *
     * If there are no unknown inputs, we have no more heuristics that apply,
     * and must fail.
     * 如無unknown型別,沒有更多的啟發式可用,就此失敗
     */
    if (nunknowns == 0)//失敗
        return NULL;            /* failed to select a best candidate */

/*
     * The next step examines each unknown argument position to see if we can
     * determine a "type category" for it.  If any candidate has an input
     * datatype of STRING category, use STRING category (this bias towards
     * STRING is appropriate since unknown-type literals look like strings).
     * Otherwise, if all the candidates agree on the type category of this
     * argument position, use that category.  Otherwise, fail because we
     * cannot determine a category.
     * 下一步,檢查每一個unknown型別的引數位置來確定是否可以找到該引數的型別目錄.
     * 如果候選存在STRING目錄的輸入資料型別,使用STRING目錄(因為unknown literals看起來像是string)
     * 否則,如果所有候選認同該引數位置上的型別目錄,則使用此目錄.
     * 不能確定目錄,則失敗.
     *
     * If we are able to determine a type category, also notice whether any of
     * the candidates takes a preferred datatype within the category.
     * 如果可以確定型別目錄,還要注意候選項中是否有一個在目錄中採用首選資料型別.
     *
     * Having completed this examination, remove candidates that accept the
     * wrong category at any unknown position.  Also, if at least one
     * candidate accepted a preferred type at a position, remove candidates
     * that accept non-preferred types.  If just one candidate remains, return
     * that one.  However, if this rule turns out to reject all candidates,
     * keep them all instead.
     * 完成該檢查後,去掉在unknown位置上接受錯誤目錄的候選.
     * 同時,如果至少有一個候選接受該位置上的首選型別,去掉無首選型別的候選.
     * 如果只有一個候選保留,則返回該候選.
     * 否則,拒絕所有的候選,保留所有.
     */
    /*
    If any input arguments are unknown, check the type categories accepted at 
    those argument positions by the remaining candidates. At each position, 
    select the string category if any candidate accepts that category. 
    (This bias towards string is appropriate since an unknown-type literal looks like a string.) 
    Otherwise, if all the remaining candidates accept the same type category, 
    select that category; otherwise fail because the correct choice cannot be 
    deduced without more clues. Now discard candidates that do not accept the 
    selected type category. Furthermore, if any candidate accepts a preferred 
    type in that category, discard candidates that accept non-preferred types 
    for that argument. Keep all candidates if none survive these tests. 
    If only one candidate remains, use it; else continue to the next step.
    */
    resolved_unknowns = false;//是否已解決unknown型別標記
    for (i = 0; i < nargs; i++)//遍歷引數
    {
        bool        have_conflict;//是否存在衝突標記

if (input_base_typeids[i] != UNKNOWNOID)
            continue;//非unknown型別
        resolved_unknowns = true;   /* 假定可以搞掂 assume we can do it */
        slot_category[i] = TYPCATEGORY_INVALID;
        slot_has_preferred_type[i] = false;
        have_conflict = false;
        for (current_candidate = candidates;
             current_candidate != NULL;
             current_candidate = current_candidate->next)//遍歷所有候選
        {
            current_typeids = current_candidate->args;
            current_type = current_typeids[i];
            get_type_category_preferred(current_type,
                                        &current_category,
                                        &current_is_preferred);
            if (slot_category[i] == TYPCATEGORY_INVALID)
            {
                /* first candidate */
                //第一個候選
                slot_category[i] = current_category;
                slot_has_preferred_type[i] = current_is_preferred;
            }
            else if (current_category == slot_category[i])
            {
                /* more candidates in same category */
                //同樣的目錄有更多的候選
                slot_has_preferred_type[i] |= current_is_preferred;
            }
            else
            {
                /* category conflict! */
                //目錄衝突
                if (current_category == TYPCATEGORY_STRING)
                {
                    /* STRING always wins if available */
                    //如可能,首選STRING
                    slot_category[i] = current_category;
                    slot_has_preferred_type[i] = current_is_preferred;
                }
                else
                {
                    /*
                     * Remember conflict, but keep going (might find STRING)
                     * 存在衝突,但繼續處理
                     */
                    have_conflict = true;
                }
            }
        }
        if (have_conflict && slot_category[i] != TYPCATEGORY_STRING)
        {
            //存在衝突,並且目錄不是STRING
            /* Failed to resolve category conflict at this position */
            //無法解決衝突
            resolved_unknowns = false;
            break;
        }
    }

if (resolved_unknowns)
    {
        //已解決了衝突
        /* Strip non-matching candidates */
        ncandidates = 0;
        first_candidate = candidates;
        last_candidate = NULL;
        for (current_candidate = candidates;
             current_candidate != NULL;
             current_candidate = current_candidate->next)//再次遍歷
        {
            bool        keepit = true;
            //如果至少有一個候選接受該位置上的首選型別,去掉無首選型別的候選.
            current_typeids = current_candidate->args;
            for (i = 0; i < nargs; i++)//遍歷引數
            {
                if (input_base_typeids[i] != UNKNOWNOID)
                    continue;//非unknown引數,跳過
                current_type = current_typeids[i];//當前型別
                get_type_category_preferred(current_type,
                                            &current_category,
                                            &current_is_preferred);//首選型別
                if (current_category != slot_category[i])
                {
                    //當前目錄不等於slot中的目錄,退出引數迴圈
                    keepit = false;
                    break;
                }
                if (slot_has_preferred_type[i] && !current_is_preferred)
                {
                    //存在首選型別但當前首選型別為NULL,退出引數迴圈
                    keepit = false;
                    break;
                }
            }
            if (keepit)
            {
                /* keep this candidate */
                //保留該候選
                last_candidate = current_candidate;
                ncandidates++;
            }
            else
            {
                /* forget this candidate */
                //
                if (last_candidate)
                    last_candidate->next = current_candidate->next;
                else
                    first_candidate = current_candidate->next;
            }
        }

/* if we found any matches, restrict our attention to those */
        if (last_candidate)
        {
            candidates = first_candidate;
            /* terminate rebuilt list */
            last_candidate->next = NULL;
        }

if (ncandidates == 1)
            return candidates;
    }

/*
     * Last gasp: if there are both known- and unknown-type inputs, and all
     * the known types are the same, assume the unknown inputs are also that
     * type, and see if that gives us a unique match.  If so, use that match.
     * 最後 : 如果存在known和unknown型別同時存在,
     *        並且已知型別是一樣的,那麼假定unknown輸入也是該型別,然後看看是否有唯一匹配,如有則使用該候選.
     *
     * NOTE: for a binary operator with one unknown and one non-unknown input,
     * we already tried this heuristic in binary_oper_exact().  However, that
     * code only finds exact matches, whereas here we will handle matches that
     * involve coercion, polymorphic type resolution, etc.
     * 注意 : 對於帶有一個unknown和一個已知型別引數的二元運算子,
     * 已在binary_oper_exact()函式中使用該啟發式.
     * 但是,那些程式碼只能發現準確的匹配,而這裡我們將處理涉及強制、多型型別解析等的匹配。
     */
    /*
    If there are both unknown and known-type arguments, and all the known-type arguments 
    have the same type, assume that the unknown arguments are also of that type, and check 
    which candidates can accept that type at the unknown-argument positions. 
    If exactly one candidate passes this test, use it. Otherwise, fail.
    */
    if (nunknowns < nargs)
    {
        Oid         known_type = UNKNOWNOID;

for (i = 0; i < nargs; i++)//找到基本型別,找不到則失敗
        {
            if (input_base_typeids[i] == UNKNOWNOID)
                continue;
            if (known_type == UNKNOWNOID)   /* first known arg? */
                known_type = input_base_typeids[i];
            else if (known_type != input_base_typeids[i])
            {
                /* oops, not all match */
                known_type = UNKNOWNOID;
                break;
            }
        }

if (known_type != UNKNOWNOID)//找到了基本型別
        {
            /* okay, just one known type, apply the heuristic */
            for (i = 0; i < nargs; i++)
                input_base_typeids[i] = known_type;//使用該基本型別
            ncandidates = 0;
            last_candidate = NULL;
            for (current_candidate = candidates;
                 current_candidate != NULL;
                 current_candidate = current_candidate->next)//遍歷
            {
                current_typeids = current_candidate->args;
                if (can_coerce_type(nargs, input_base_typeids, current_typeids,
                                    COERCION_IMPLICIT))
                {
                    if (++ncandidates > 1)
                        break;  /* not unique, give up */
                    last_candidate = current_candidate;
                }
            }
            if (ncandidates == 1)
            {
                /* successfully identified a unique match */
                //成功!
                last_candidate->next = NULL;
                return last_candidate;
            }
        }
    }
    //返回NULL
    return NULL;                /* failed to select a best candidate */
}                               /* func_select_candidate() */

```

### 三、跟蹤分析
測試指令碼
```
create cast(integer as text) with inout as implicit;

select id||'X' from t_cast;

```
跟蹤分析
```

Breakpoint 1, func_select_candidate (nargs=2, input_typeids=0x7fff5f3ac6c0, candidates=0x2daa6f0) at parse_func.c:1021
1021        if (nargs > FUNC_MAX_ARGS)
(gdb) p *input_typeids
$6 = 23
(gdb) p *candidates
$7 = {next = 0x2daa720, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb)  p *candidates->next
$8 = {next = 0x2daa7e0, pathpos = 0, oid = 2779, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa748}
(gdb) p *candidates->next->next
$9 = {next = 0x2daa810, pathpos = 0, oid = 374, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa808}
(gdb) p *candidates->next->next->next
$10 = {next = 0x0, pathpos = 0, oid = 2780, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa838}
(gdb) p *candidates->next->next->next->next
Cannot access memory at address 0x0
(gdb) n
1042        nunknowns = 0;
(gdb) 
1043        for (i = 0; i < nargs; i++)
(gdb) 
1045            if (input_typeids[i] != UNKNOWNOID)
(gdb) 
1046                input_base_typeids[i] = getBaseType(input_typeids[i]);
(gdb) 
1043        for (i = 0; i < nargs; i++)
(gdb) p input_base_typeids[0]
$12 = 23
(gdb) n
1045            if (input_typeids[i] != UNKNOWNOID)
(gdb) 
1050                input_base_typeids[i] = UNKNOWNOID;
(gdb) p input_typeids[i]
$13 = 705
(gdb) p UNKNOWNOID
$14 = 705
(gdb) n
1051                nunknowns++;
(gdb) 
1043        for (i = 0; i < nargs; i++)
(gdb) 
1059        ncandidates = 0;
(gdb) 
1060        nbestMatch = 0;
(gdb) 
1061        last_candidate = NULL;
(gdb) 
1062        for (current_candidate = candidates;
(gdb) 
1066            current_typeids = current_candidate->args;
(gdb) 
1067            nmatch = 0;
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1071                    current_typeids[i] == input_base_typeids[i])
(gdb) p current_typeids[i]
$15 = 25
(gdb) p input_base_typeids[i]
$16 = 23
(gdb) n
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1076            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1078                nbestMatch = nmatch;
(gdb) 
1079                candidates = current_candidate;
(gdb) 
1080                last_candidate = current_candidate;
(gdb) 
1081                ncandidates = 1;
(gdb) 
1064             current_candidate = current_candidate->next)
(gdb) 
1062        for (current_candidate = candidates;
(gdb) 
1066            current_typeids = current_candidate->args;
(gdb) 
1067            nmatch = 0;
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1071                    current_typeids[i] == input_base_typeids[i])
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1076            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1084            else if (nmatch == nbestMatch)
(gdb) 
1086                last_candidate->next = current_candidate;
(gdb) p *last_candidate
$17 = {next = 0x2daa720, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb) p *current_candidate
$18 = {next = 0x2daa7e0, pathpos = 0, oid = 2779, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa748}
(gdb) n
1087                last_candidate = current_candidate;
(gdb) 
1088                ncandidates++;
(gdb) 
1064             current_candidate = current_candidate->next)
(gdb) 
1062        for (current_candidate = candidates;
(gdb) 
1066            current_typeids = current_candidate->args;
(gdb) 
1067            nmatch = 0;
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1071                    current_typeids[i] == input_base_typeids[i])
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1076            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) p *candidates
$19 = {next = 0x2daa720, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb) n
1084            else if (nmatch == nbestMatch)
(gdb) 
1086                last_candidate->next = current_candidate;
(gdb) 
1087                last_candidate = current_candidate;
(gdb) 
1088                ncandidates++;
(gdb) n
1064             current_candidate = current_candidate->next)
(gdb) 
1062        for (current_candidate = candidates;
(gdb) 
1066            current_typeids = current_candidate->args;
(gdb) 
1067            nmatch = 0;
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1071                    current_typeids[i] == input_base_typeids[i])
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1070                if (input_base_typeids[i] != UNKNOWNOID &&
(gdb) 
1068            for (i = 0; i < nargs; i++)
(gdb) 
1076            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1084            else if (nmatch == nbestMatch)
(gdb) 
1086                last_candidate->next = current_candidate;
(gdb) 
1087                last_candidate = current_candidate;
(gdb) 
1088                ncandidates++;
(gdb) 
1064             current_candidate = current_candidate->next)
(gdb) 
1062        for (current_candidate = candidates;
(gdb) 
1093        if (last_candidate)         /* terminate rebuilt list */
(gdb) 
1094            last_candidate->next = NULL;
(gdb) 
1096        if (ncandidates == 1)
(gdb) p *last_candidate
$20 = {next = 0x0, pathpos = 0, oid = 2780, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa838}
(gdb) n
1106        for (i = 0; i < nargs; i++) /* avoid multiple lookups */
(gdb) 
1107            slot_category[i] = TypeCategory(input_base_typeids[i]);
(gdb) 
1106        for (i = 0; i < nargs; i++) /* avoid multiple lookups */
(gdb) p slot_category[i] 
$21 = 78 'N'
(gdb) n
1107            slot_category[i] = TypeCategory(input_base_typeids[i]);
(gdb) 
1106        for (i = 0; i < nargs; i++) /* avoid multiple lookups */
(gdb) p slot_category[i] 
$22 = 88 'X'
(gdb) n
1108        ncandidates = 0;
(gdb) 
1109        nbestMatch = 0;
(gdb) 
1110        last_candidate = NULL;
(gdb) 
1111        for (current_candidate = candidates;
(gdb) 
1115            current_typeids = current_candidate->args;
(gdb) 
1116            nmatch = 0;
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) p current_typeids[i]
$23 = 25
(gdb) n
1122                        IsPreferredType(slot_category[i], current_typeids[i]))
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1127            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1129                nbestMatch = nmatch;
(gdb) 
1130                candidates = current_candidate;
(gdb) 
1131                last_candidate = current_candidate;
(gdb) 
1132                ncandidates = 1;
(gdb) 
1113             current_candidate = current_candidate->next)
(gdb) 
1111        for (current_candidate = candidates;
(gdb) 
1115            current_typeids = current_candidate->args;
(gdb) 
1116            nmatch = 0;
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1122                        IsPreferredType(slot_category[i], current_typeids[i]))
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1127            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1134            else if (nmatch == nbestMatch)
(gdb) 
1136                last_candidate->next = current_candidate;
(gdb) 
1137                last_candidate = current_candidate;
(gdb) 
1138                ncandidates++;
(gdb) 
1113             current_candidate = current_candidate->next)
(gdb) 
1111        for (current_candidate = candidates;
(gdb) 
1115            current_typeids = current_candidate->args;
(gdb) 
1116            nmatch = 0;
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1122                        IsPreferredType(slot_category[i], current_typeids[i]))
(gdb) p *last_candidate
$24 = {next = 0x2daa7e0, pathpos = 0, oid = 2779, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa748}
(gdb) n
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1127            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1134            else if (nmatch == nbestMatch)
(gdb) 
1136                last_candidate->next = current_candidate;
(gdb) 
1137                last_candidate = current_candidate;
(gdb) 
1138                ncandidates++;
(gdb) 
1113             current_candidate = current_candidate->next)
(gdb) 
1111        for (current_candidate = candidates;
(gdb) 
1115            current_typeids = current_candidate->args;
(gdb) 
1116            nmatch = 0;
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1122                        IsPreferredType(slot_category[i], current_typeids[i]))
(gdb) 
1121                    if (current_typeids[i] == input_base_typeids[i] ||
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1119                if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1117            for (i = 0; i < nargs; i++)
(gdb) 
1127            if ((nmatch > nbestMatch) || (last_candidate == NULL))
(gdb) 
1134            else if (nmatch == nbestMatch)
(gdb) 
1136                last_candidate->next = current_candidate;
(gdb) 
1137                last_candidate = current_candidate;
(gdb) 
1138                ncandidates++;
(gdb) 
1113             current_candidate = current_candidate->next)
(gdb) 
1111        for (current_candidate = candidates;
(gdb) 
1142        if (last_candidate)         /* terminate rebuilt list */
(gdb) 
1143            last_candidate->next = NULL;
(gdb) 
1145        if (ncandidates == 1)
(gdb) 
1154        if (nunknowns == 0)
(gdb) 
1176        resolved_unknowns = false;
(gdb) 
1177        for (i = 0; i < nargs; i++)
(gdb) 
1181            if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1182                continue;
(gdb) 
1177        for (i = 0; i < nargs; i++)
(gdb) 
1181            if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1183            resolved_unknowns = true;   /* assume we can do it */
(gdb) 
1184            slot_category[i] = TYPCATEGORY_INVALID;
(gdb) 
1185            slot_has_preferred_type[i] = false;
(gdb) 
1186            have_conflict = false;
(gdb) 
1187            for (current_candidate = candidates;
(gdb) 
1191                current_typeids = current_candidate->args;
(gdb) 
1192                current_type = current_typeids[i];
(gdb) 
1193                get_type_category_preferred(current_type,
(gdb) 
1196                if (slot_category[i] == TYPCATEGORY_INVALID)
(gdb) p current_type
$25 = 25
(gdb) p current_category
$26 = 83 'S'
(gdb) p current_is_preferred
$27 = true
(gdb) p slot_category[i]
$28 = 0 '\000'
(gdb) n
1199                    slot_category[i] = current_category;
(gdb) 
1200                    slot_has_preferred_type[i] = current_is_preferred;
(gdb) 
1189                 current_candidate = current_candidate->next)
(gdb) p current_category
$29 = 83 'S'
(gdb) p current_is_preferred
$30 = true
(gdb) n
1187            for (current_candidate = candidates;
(gdb) 
1191                current_typeids = current_candidate->args;
(gdb) 
1192                current_type = current_typeids[i];
(gdb) 
1193                get_type_category_preferred(current_type,
(gdb) 
1196                if (slot_category[i] == TYPCATEGORY_INVALID)
(gdb) p current_category
$31 = 80 'P'
(gdb) p current_is_preferred
$32 = false
(gdb) n
1202                else if (current_category == slot_category[i])
(gdb) 
1210                    if (current_category == TYPCATEGORY_STRING)
(gdb) 
1221                        have_conflict = true;
(gdb) 
1189                 current_candidate = current_candidate->next)
(gdb) 
1187            for (current_candidate = candidates;
(gdb) 
1191                current_typeids = current_candidate->args;
(gdb) 
1192                current_type = current_typeids[i];
(gdb) 
1193                get_type_category_preferred(current_type,
(gdb) 
1196                if (slot_category[i] == TYPCATEGORY_INVALID)
(gdb) p current_type
$33 = 2277
(gdb) p current_is_preferred
$34 = false
(gdb) p current_category
$35 = 80 'P'
(gdb) n
1202                else if (current_category == slot_category[i])
(gdb) 
1210                    if (current_category == TYPCATEGORY_STRING)
(gdb) 
1221                        have_conflict = true;
(gdb) 
1189                 current_candidate = current_candidate->next)
(gdb) 
1187            for (current_candidate = candidates;
(gdb) 
1191                current_typeids = current_candidate->args;
(gdb) 
1192                current_type = current_typeids[i];
(gdb) 
1193                get_type_category_preferred(current_type,
(gdb) 
1196                if (slot_category[i] == TYPCATEGORY_INVALID)
(gdb) 
1202                else if (current_category == slot_category[i])
(gdb) 
1205                    slot_has_preferred_type[i] |= current_is_preferred;
(gdb) p current_category
$36 = 83 'S'
(gdb) n
1189                 current_candidate = current_candidate->next)
(gdb) 
1187            for (current_candidate = candidates;
(gdb) 
1225            if (have_conflict && slot_category[i] != TYPCATEGORY_STRING)
(gdb) 
1177        for (i = 0; i < nargs; i++)
(gdb) p resolved_unknowns
$37 = true
(gdb) n
1233        if (resolved_unknowns)
(gdb) 
1236            ncandidates = 0;
(gdb) 
1237            first_candidate = candidates;
(gdb) 
1238            last_candidate = NULL;
(gdb) 
1239            for (current_candidate = candidates;
(gdb) 
1243                bool        keepit = true;
(gdb) 
1245                current_typeids = current_candidate->args;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1249                        continue;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1250                    current_type = current_typeids[i];
(gdb) 
1251                    get_type_category_preferred(current_type,
(gdb) p current_type
$38 = 25
(gdb) n
1254                    if (current_category != slot_category[i])
(gdb) p current_category
$39 = 83 'S'
(gdb) p slot_category[i]
$40 = 83 'S'
(gdb) n
1259                    if (slot_has_preferred_type[i] && !current_is_preferred)
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1265                if (keepit)
(gdb) 
1268                    last_candidate = current_candidate;
(gdb) p *current_candidate
$41 = {next = 0x2daa720, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb) n
1269                    ncandidates++;
(gdb) 
1241                 current_candidate = current_candidate->next)
(gdb) n
1239            for (current_candidate = candidates;
(gdb) 
1243                bool        keepit = true;
(gdb) 
1245                current_typeids = current_candidate->args;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1249                        continue;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1250                    current_type = current_typeids[i];
(gdb) 
1251                    get_type_category_preferred(current_type,
(gdb) 
1254                    if (current_category != slot_category[i])
(gdb) p current_type
$42 = 2776
(gdb) p current_category
$43 = 80 'P'
(gdb) n
1256                        keepit = false;
(gdb) 
1257                        break;
(gdb) 
1265                if (keepit)
(gdb) 
1274                    if (last_candidate)
(gdb) 
1275                        last_candidate->next = current_candidate->next;
(gdb) 
1241                 current_candidate = current_candidate->next)
(gdb) p *last_candidate
$44 = {next = 0x2daa7e0, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb) n
1239            for (current_candidate = candidates;
(gdb) 
1243                bool        keepit = true;
(gdb) 
1245                current_typeids = current_candidate->args;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1249                        continue;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1250                    current_type = current_typeids[i];
(gdb) 
1251                    get_type_category_preferred(current_type,
(gdb) p current_type
$45 = 2277
(gdb) p current_category
$46 = 80 'P'
(gdb) n
1254                    if (current_category != slot_category[i])
(gdb) 
1256                        keepit = false;
(gdb) 
1257                        break;
(gdb) 
1265                if (keepit)
(gdb) 
1274                    if (last_candidate)
(gdb) 
1275                        last_candidate->next = current_candidate->next;
(gdb) 
1241                 current_candidate = current_candidate->next)
(gdb) 
1239            for (current_candidate = candidates;
(gdb) 
1243                bool        keepit = true;
(gdb) 
1245                current_typeids = current_candidate->args;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1249                        continue;
(gdb) 
1246                for (i = 0; i < nargs; i++)
(gdb) 
1248                    if (input_base_typeids[i] != UNKNOWNOID)
(gdb) 
1250                    current_type = current_typeids[i];
(gdb) 
1251                    get_type_category_preferred(current_type,
(gdb) 
1254                    if (current_category != slot_category[i])
(gdb) 
1259                    if (slot_has_preferred_type[i] && !current_is_preferred)
(gdb) p current_category
$47 = 83 'S'
(gdb) p *current_candidate
$48 = {next = 0x0, pathpos = 0, oid = 2780, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa838}
(gdb) n
1246                for (i = 0; i < nargs; i++)
(gdb) 
1265                if (keepit)
(gdb) 
1268                    last_candidate = current_candidate;
(gdb) 
1269                    ncandidates++;
(gdb) 
1241                 current_candidate = current_candidate->next)
(gdb) 
1239            for (current_candidate = candidates;
(gdb) 
1282            if (last_candidate)
(gdb) 
1284                candidates = first_candidate;
(gdb) p *first_candidate
$49 = {next = 0x2daa810, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb) p *last_candidate
$50 = {next = 0x0, pathpos = 0, oid = 2780, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa838}
(gdb) n
1286                last_candidate->next = NULL;
(gdb) n
1289            if (ncandidates == 1)
(gdb) 
1303        if (nunknowns < nargs)
(gdb) p *candidates
$51 = {next = 0x2daa810, pathpos = 0, oid = 654, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa718}
(gdb) p *candidates->next
$52 = {next = 0x0, pathpos = 0, oid = 2780, nargs = 2, nvargs = 0, ndargs = 0, argnumbers = 0x0, args = 0x2daa838}
(gdb) n
1305            Oid         known_type = UNKNOWNOID;
(gdb) 
1307            for (i = 0; i < nargs; i++)
(gdb) 
1309                if (input_base_typeids[i] == UNKNOWNOID)
(gdb) 
1311                if (known_type == UNKNOWNOID)   /* first known arg? */
(gdb) 
1312                    known_type = input_base_typeids[i];
(gdb) 
1307            for (i = 0; i < nargs; i++)
(gdb) p known_type
$53 = 23
(gdb) n
1309                if (input_base_typeids[i] == UNKNOWNOID)
(gdb) 
1310                    continue;
(gdb) 
1307            for (i = 0; i < nargs; i++)
(gdb) 
1321            if (known_type != UNKNOWNOID)
(gdb) 
1324                for (i = 0; i < nargs; i++)
(gdb) 
1325                    input_base_typeids[i] = known_type;
(gdb) 
1324                for (i = 0; i < nargs; i++)
(gdb) p known_type
$54 = 23
(gdb) n
1325                    input_base_typeids[i] = known_type;
(gdb) 
1324                for (i = 0; i < nargs; i++)
(gdb) 
1326                ncandidates = 0;
(gdb) 
1327                last_candidate = NULL;
(gdb) 
1328                for (current_candidate = candidates;
(gdb) 
1332                    current_typeids = current_candidate->args;
(gdb) 
1333                    if (can_coerce_type(nargs, input_base_typeids, current_typeids,
(gdb) 
1336                        if (++ncandidates > 1)
(gdb) n
1338                        last_candidate = current_candidate;
(gdb) 
1330                     current_candidate = current_candidate->next)
(gdb) 
1328                for (current_candidate = candidates;
(gdb) 
1332                    current_typeids = current_candidate->args;
(gdb) 
1333                    if (can_coerce_type(nargs, input_base_typeids, current_typeids,
(gdb) 
1336                        if (++ncandidates > 1)
(gdb) 
1337                            break;  /* not unique, give up */
(gdb) 
1341                if (ncandidates == 1)
(gdb) 
1350        return NULL;                /* failed to select a best candidate */
(gdb)

```
DONE!

### 四、參考資料
[PostgreSQL Type Conversion](https://www.postgresql.org/docs/11/typeconv-overview.html)

PostgreSQL 原始碼解讀（209）- 隱式型別轉換(func_select_candidate)

相關文章