hash_accesses++;
hctl->accesses++;

endif

/*
 * If inserting, check if it is time to split a bucket.
 * 如正插入,检查是否需要分裂哈希桶
 *
 * NOTE: failure to expand table is not a fatal error, it just means we
 * have to run at higher fill factor than we wanted.  However, if we're
 * using the palloc allocator then it will throw error anyway on
 * out-of-memory, so we must do this before modifying the table.
 * 注意:扩展哈希表出现问题不是致命错误,只是意味着我们不得不执行比我们期望更高更高的填充因子.
 * 但是,如果我们正在使用palloc分配器,那么只要出现内存溢出则会抛出错误,
 *   因此我们不需在更新表前完成这个事情.
 */
if (action == HASH_ENTER || action == HASH_ENTER_NULL)
{
    /*
     * Can't split if running in partitioned mode, nor if frozen, nor if
     * table is the subject of any active hash_seq_search scans.  Strange
     * order of these tests is to try to check cheaper conditions first.
     * 如在分区模式/冻结/处于其他活动hash_seq_search扫描期间,则不能进行分裂.
     * 奇怪的是,这些测试的顺序是先尝试检查成本更低的条件.
     */
    if (!IS_PARTITIONED(hctl) && !hashp->frozen &&
        hctl->freeList[0].nentries / (long) (hctl->max_bucket + 1) >= hctl->ffactor &&
        !has_seq_scans(hashp))
        (void) expand_table(hashp);
}
/*
 * Do the initial lookup
 * 执行初始化检索
 */
//计算桶号
bucket = calc_bucket(hctl, hashvalue);
//计算段号和段内编号
segment_num = bucket >> hashp->sshift;
segment_ndx = MOD(bucket, hashp->ssize);
//获取directory
segp = hashp->dir[segment_num];
if (segp == NULL)
    hash_corrupted(hashp);
//记录桶号
prevBucketPtr = &segp[segment_ndx];
currBucket = *prevBucketPtr;
/*
 * Follow collision chain looking for matching key
 * 沿着哈希键冲突链搜索匹配键
 */
//匹配函数
match = hashp->match;       /* save one fetch in inner loop */
//键大小
keysize = hashp->keysize;   /* ditto */
while (currBucket != NULL)
{
    if (currBucket->hashvalue == hashvalue &&
        match(ELEMENTKEY(currBucket), keyPtr, keysize) == 0)
        break;
    prevBucketPtr = &(currBucket->link);
    currBucket = *prevBucketPtr;

if HASH_STATISTICS

    hash_collisions++;
    hctl->collisions++;

endif

}
//结果赋值
if (foundPtr)
    *foundPtr = (bool) (currBucket != NULL);
/*
 * OK, now what?
 * 根据action执行相关操作
 */
switch (action)
{
    case HASH_FIND:
        //搜索
        if (currBucket != NULL)
            return (void *) ELEMENTKEY(currBucket);
        return NULL;
    case HASH_REMOVE:
        //移除
        if (currBucket != NULL)
        {
            /* if partitioned, must lock to touch nentries and freeList */
            //如分区,在访问条目入口和空闲链表时必须先请求锁
            if (IS_PARTITIONED(hctl))
                SpinLockAcquire(&(hctl->freeList[freelist_idx].mutex));
            /* delete the record from the appropriate nentries counter. */
            //修改nentries计数器
            Assert(hctl->freeList[freelist_idx].nentries > 0);
            hctl->freeList[freelist_idx].nentries--;
            /* remove record from hash bucket's chain. */
            //在哈希桶中链中删除记录
            *prevBucketPtr = currBucket->link;
            /* add the record to the appropriate freelist. */
            //添加记录到正确的空闲链表上
            currBucket->link = hctl->freeList[freelist_idx].freeList;
            hctl->freeList[freelist_idx].freeList = currBucket;
            if (IS_PARTITIONED(hctl))
                //释放锁
                SpinLockRelease(&hctl->freeList[freelist_idx].mutex);
            /*
             * better hope the caller is synchronizing access to this
             * element, because someone else is going to reuse it the next
             * time something is added to the table
             * 调用者最好是同步访问元素,因为其他进程在下一次添加到哈希表可以复用.
             */
            return (void *) ELEMENTKEY(currBucket);
        }
        return NULL;
    case HASH_ENTER_NULL:
        /* ENTER_NULL does not work with palloc-based allocator */
        //验证分配器
        Assert(hashp->alloc != DynaHashAlloc);
        /* FALL THRU */
        //继续往下执行
    case HASH_ENTER:
        /* Return existing element if found, else create one */
        //如找到,则返回现存的元素,否则创建一个
        if (currBucket != NULL)
            return (void *) ELEMENTKEY(currBucket);
        /* disallow inserts if frozen */
        //如冻结,则不允许插入,报错
        if (hashp->frozen)
            elog(ERROR, "cannot insert into frozen hashtable \"%s\"",
                 hashp->tabname);
        //获取当前桶
        currBucket = get_hash_entry(hashp, freelist_idx);
        if (currBucket == NULL)
        {
            //如为NULL
            /* out of memory */
            //内存溢出
            if (action == HASH_ENTER_NULL)
                return NULL;
            /* report a generic message */
            //报错
            if (hashp->isshared)
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of shared memory")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_OUT_OF_MEMORY),
                         errmsg("out of memory")));
        }
        //正常
        /* link into hashbucket chain */
        //连接到哈希桶链中
        *prevBucketPtr = currBucket;
        currBucket->link = NULL;
        /* copy key into record */
        //拷贝键到记录中
        currBucket->hashvalue = hashvalue;
        hashp->keycopy(ELEMENTKEY(currBucket), keyPtr, keysize);
        /*
         * Caller is expected to fill the data field on return.  DO NOT
         * insert any code that could possibly throw error here, as doing
         * so would leave the table entry incomplete and hence corrupt the
         * caller's data structure.
         * 调用者期望在返回时已填充了数据.
         * 不要插入有可能抛出异常的代码,因为这样做可能会导致哈希表条目不完整并因此破坏调用者的数据结构
         */
        return (void *) ELEMENTKEY(currBucket);
}
//如执行到这里,那程序就有问题了.
elog(ERROR, "unrecognized hash action code: %d", (int) action);
//返回NULL,让编译器shut up
return NULL;                /* keep compiler quiet */

}

/ Convert a hash value to a bucket number /
//转换hash值为桶号
static inline uint32
calc_bucket(HASHHDR *hctl, uint32 hash_val)
{
uint32 bucket;//桶号

bucket = hash_val & hctl->high_mask;//执行&操作
if (bucket > hctl->max_bucket)//大于最大桶号,则返回low_mask
    bucket = bucket & hctl->low_mask;
return bucket;

}

### 二、跟踪分析
使用gdb跟踪LockAcquireExtended方法

(gdb) b LockAcquireExtended
Breakpoint 1 at 0x8cc3f6: file lock.c, line 739.
(gdb) c
Continuing.

Breakpoint 1, LockAcquireExtended (locktag=0x7ffdd23a8940, lockmode=3, sessionLock=false, dontWait=false,
reportMemoryError=true, locallockp=0x7ffdd23a8938) at lock.c:739
739 LOCKMETHODID lockmethodid = locktag->locktag_lockmethodid;
(gdb) p locktag
$1 = {locktag_field1 = 74840, locktag_field2 = 2662, locktag_field3 = 0, locktag_field4 = 0,
locktag_type = 0 ‘\000’, locktag_lockmethodid = 1 ‘\001’}
(gdb) n
750 bool log_lock = false;
(gdb)
752 if (lockmethodid <= 0 || lockmethodid >= lengthof(LockMethods))
(gdb)
754 lockMethodTable = LockMethods[lockmethodid];
(gdb) n
755 if (lockmode <= 0 || lockmode > lockMethodTable->numLockModes)
(gdb)
758 if (RecoveryInProgress() && !InRecovery &&
(gdb)
776 if (sessionLock)
(gdb)
779 owner = CurrentResourceOwner;
(gdb)
784 MemSet(&localtag, 0, sizeof(localtag)); / must clear padding /
(gdb)
785 localtag.lock = locktag;
(gdb)
786 localtag.mode = lockmode;
(gdb)
788 locallock = (LOCALLOCK ) hash_search(LockMethodLocalHash,
(gdb)
795 if (!found)
(gdb)
797 locallock->lock = NULL;
(gdb)
798 locallock->proclock = NULL;
(gdb)
799 locallock->hashcode = LockTagHashCode(&(localtag.lock));
(gdb)
800 locallock->nLocks = 0;
(gdb)
801 locallock->holdsStrongLockCount = false;
(gdb)
802 locallock->lockCleared = false;
(gdb)
803 locallock->numLockOwners = 0;
(gdb)
804 locallock->maxLockOwners = 8;
(gdb)
805 locallock->lockOwners = NULL; / in case next line fails /
(gdb)
808 locallock->maxLockOwners sizeof(LOCALLOCKOWNER));
(gdb)
807 MemoryContextAlloc(TopMemoryContext,
(gdb)
806 locallock->lockOwners = (LOCALLOCKOWNER )
(gdb)
823 hashcode = locallock->hashcode;
(gdb) p locallock
$2 = {tag = {lock = {locktag_field1 = 74840, locktag_field2 = 2662, locktag_field3 = 0, locktag_field4 = 0,
locktag_type = 0 ‘\000’, locktag_lockmethodid = 1 ‘\001’}, mode = 3}, hashcode = 3819421354, lock = 0x0,
proclock = 0x0, nLocks = 0, numLockOwners = 0, maxLockOwners = 8, lockOwners = 0x1c01348,
holdsStrongLockCount = false, lockCleared = false}
(gdb) n
825 if (locallockp)
(gdb)
826 locallockp = locallock;
(gdb)
834 if (locallock->nLocks > 0)
(gdb)
855 if (lockmode >= AccessExclusiveLock &&
(gdb)
874 if (EligibleForRelationFastPath(locktag, lockmode) &&
(gdb)
875 FastPathLocalUseCount < FP_LOCK_SLOTS_PER_BACKEND)
(gdb)
874 if (EligibleForRelationFastPath(locktag, lockmode) &&
(gdb)
877 uint32 fasthashcode = FastPathStrongLockHashPartition(hashcode);
(gdb)
886 LWLockAcquire(&MyProc->backendLock, LW_EXCLUSIVE);
(gdb) p fasthashcode
$3 = 682
(gdb) p MyProc
$4 = {links = {prev = 0x0, next = 0x0}, procgloballist = 0x7fc1b21a4318, sem = 0x7fc190090138, waitStatus = 0,
procLatch = {is_set = 0, is_shared = true, owner_pid = 19985}, lxid = 40047, pid = 19985, pgprocno = 98,
backendId = 2, databaseId = 74840, roleId = 10, tempNamespaceId = 0, isBackgroundWorker = false,
recoveryConflictPending = false, lwWaiting = false, lwWaitMode = 0 ‘\000’, lwWaitLink = {next = 0, prev = 0},
cvWaitLink = {next = 0, prev = 0}, waitLock = 0x0, waitProcLock = 0x0, waitLockMode = 0, heldLocks = 0,
waitLSN = 0, syncRepState = 0, syncRepLinks = {prev = 0x0, next = 0x0}, myProcLocks = {{prev = 0x7fc1b1ed9b30,
next = 0x7fc1b255cea0}, {prev = 0x7fc1b1ede8b0, next = 0x7fc1b255ccc0}, {prev = 0x7fc1b1edda50,
next = 0x7fc1b1ee8220}, {prev = 0x7fc1b1f1c5c0, next = 0x7fc1b1ee2730}, {prev = 0x7fc1b1eddd70,
next = 0x7fc1b1ee2690}, {prev = 0x7fc1b2507400, next = 0x7fc1b1ee2aa0}, {prev = 0x7fc1b1ee2cd0,
next = 0x7fc1b1f311a0}, {prev = 0x7fc1b1f30ed0, next = 0x7fc1b1f31010}, {prev = 0x7fc1b1ee2550,
next = 0x7fc1b1ee8270}, {prev = 0x7fc1b1ee8130, next = 0x7fc1b1f3ab10}, {prev = 0x7fc1b2581ea0,
next = 0x7fc1b1f3a7a0}, {prev = 0x7fc1b2551000, next = 0x7fc1b2550ce0}, {prev = 0x7fc1b1f48da0,
next = 0x7fc1b1f49390}, {prev = 0x7fc1b1f4d5d0, next = 0x7fc1b1f4dad0}, {prev = 0x7fc1b1f09e70,
next = 0x7fc1b255cc20}, {prev = 0x7fc1b1f1cc00, next = 0x7fc1b255cb80}}, subxids = {xids = {
0 }}, procArrayGroupMember = false, procArrayGroupNext = {value = 2147483647},
procArrayGroupMemberXid = 0, wait_event_info = 0, clogGroupMember = false, clogGroupNext = {
value = 2147483647}, clogGroupMemberXid = 0, clogGroupMemberXidStatus = 0, clogGroupMemberPage = -1,
clogGroupMemberLsn = 0, backendLock = {tranche = 57, state = {value = 536870912}, waiters = {
head = 2147483647, tail = 2147483647}}, fpLockBits = 140737488355328, fpRelId = {2841, 2840, 2655, 2603,
2659, 2658, 2704, 2703, 3164, 3085, 2674, 2674, 2674, 2673, 1247, 1259}, fpVXIDLock = true,
fpLocalTransactionId = 40047, lockGroupLeader = 0x0, lockGroupMembers = {head = {prev = 0x7fc1b21b8b50,
next = 0x7fc1b21b8b50}}, lockGroupLink = {prev = 0x7fc1b21b8b50, next = 0x7fc1b21b8b50}}
(gdb) n
887 if (FastPathStrongRelationLocks->count[fasthashcode] != 0)
(gdb)
888 acquired = false;
(gdb)
892 LWLockRelease(&MyProc->backendLock);
(gdb)
893 if (acquired)
(gdb)
913 if (ConflictsWithRelationFastPath(locktag, lockmode))
(gdb)
941 partitionLock = LockHashPartitionLock(hashcode);
(gdb)
943 LWLockAcquire(partitionLock, LW_EXCLUSIVE);
(gdb)
954 proclock = SetupLockInTable(lockMethodTable, MyProc, locktag,
(gdb)
956 if (!proclock)
(gdb) p *proclock
$5 = {tag = {myLock = 0x7fc1b1e4b210, myProc = 0x7fc1b21b8820}, groupLeader = 0x7fc1b21b8820, holdMask = 0,
releaseMask = 0, lockLink = {prev = 0x7fc1b1e4b228, next = 0x7fc1b1e4b228}, procLink = {prev = 0x7fc1b2581ea0,
next = 0x7fc1b21b8958}}
(gdb) n
972 locallock->proclock = proclock;
(gdb)
973 lock = proclock->tag.myLock;
(gdb)
974 locallock->lock = lock;
(gdb)
981 if (lockMethodTable->conflictTab[lockmode] & lock->waitMask)
(gdb)
984 status = LockCheckConflicts(lockMethodTable, lockmode,
(gdb)
987 if (status == STATUS_OK)
(gdb)
990 GrantLock(lock, proclock, lockmode);
(gdb)
991 GrantLockLocal(locallock, owner);
(gdb)
1086 FinishStrongLockAcquire();
(gdb)
1088 LWLockRelease(partitionLock);
(gdb)
1094 if (log_lock)
(gdb)
1105 return LOCKACQUIRE_OK;
(gdb)
1106 }
(gdb)

使用gdb跟踪，条件是lockmode=8(对应的是AccessExclusiveLock),这时候意味着relation已创建。