890 "hash_stats: Caller: %s Table Name: \"%s\" Accesses: " UINT64_FORMAT " Collisions: " UINT64_FORMAT " Expansions: " UINT64_FORMAT " Entries: " INT64_FORMAT " Key Size: %zu Max Bucket: %u Segment Count: " INT64_FORMAT,

891 caller != NULL ? caller : "(unknown)", hashp->tabname, hctl->accesses,

892 hctl->collisions, hctl->expansions, hash_get_num_entries(hashp),

893 hctl->keysize, hctl->max_bucket, hctl->nsegs);

894#endif

895}

INT64_FORMAT

#define INT64_FORMAT

Definition: c.h:556

UINT64_FORMAT

#define UINT64_FORMAT

Definition: c.h:557

hash_get_num_entries

int64 hash_get_num_entries(HTAB *hashp)

Definition: dynahash.c:1336

DEBUG4

#define DEBUG4

Definition: elog.h:27

HASHHDR::nsegs

int64 nsegs

Definition: dynahash.c:185

References DEBUG4, elog, hash_get_num_entries(), HTAB::hctl, INT64_FORMAT, HASHHDR::keysize, HASHHDR::max_bucket, HASHHDR::nsegs, HTAB::tabname, and UINT64_FORMAT.

Referenced by hash_destroy().

◆ hash_update_hash_key()

bool hash_update_hash_key ( HTAB * hashp,

void * existingEntry,

const void * newKeyPtr

)

Definition at line 1140 of file dynahash.c.

1143{

1144 HASHELEMENT *existingElement = ELEMENT_FROM_KEY(existingEntry);

1145 uint32 newhashvalue;

1146 Size keysize;

1147 uint32 bucket;

1148 uint32 newbucket;

1149 HASHBUCKET currBucket;

1150 HASHBUCKET *prevBucketPtr;

1151 HASHBUCKET *oldPrevPtr;

1152 HashCompareFunc match;

1153

1154#ifdef HASH_STATISTICS

1155 HASHHDR *hctl = hashp->hctl;

1156

1157 hctl->accesses++;

1158#endif

1159

1160 /* disallow updates if frozen */

1161 if (hashp->frozen)

1162 elog(ERROR, "cannot update in frozen hashtable \"%s\"",

1163 hashp->tabname);

1164

1165 /*

1166 * Lookup the existing element using its saved hash value. We need to do

1167 * this to be able to unlink it from its hash chain, but as a side benefit

1168 * we can verify the validity of the passed existingEntry pointer.

1169 */

1170 bucket = hash_initial_lookup(hashp, existingElement->hashvalue,

1171 &prevBucketPtr);

1172 currBucket = *prevBucketPtr;

1173

1174 while (currBucket != NULL)

1175 {

1176 if (currBucket == existingElement)

1177 break;

1178 prevBucketPtr = &(currBucket->link);

1179 currBucket = *prevBucketPtr;

1180 }

1181

1182 if (currBucket == NULL)

1183 elog(ERROR, "hash_update_hash_key argument is not in hashtable \"%s\"",

1184 hashp->tabname);

1185

1186 oldPrevPtr = prevBucketPtr;

1187

1188 /*

1189 * Now perform the equivalent of a HASH_ENTER operation to locate the hash

1190 * chain we want to put the entry into.

1191 */

1192 newhashvalue = hashp->hash(newKeyPtr, hashp->keysize);

1193 newbucket = hash_initial_lookup(hashp, newhashvalue, &prevBucketPtr);

1194 currBucket = *prevBucketPtr;

1195

1196 /*

1197 * Follow collision chain looking for matching key

1198 */

1199 match = hashp->match; /* save one fetch in inner loop */

1200 keysize = hashp->keysize; /* ditto */

1201

1202 while (currBucket != NULL)

1203 {

1204 if (currBucket->hashvalue == newhashvalue &&

1205 match(ELEMENTKEY(currBucket), newKeyPtr, keysize) == 0)

1206 break;

1207 prevBucketPtr = &(currBucket->link);

1208 currBucket = *prevBucketPtr;

1209#ifdef HASH_STATISTICS

1210 hctl->collisions++;

1211#endif

1212 }

1213

1214 if (currBucket != NULL)

1215 return false; /* collision with an existing entry */

1216

1217 currBucket = existingElement;

1218

1219 /*

1220 * If old and new hash values belong to the same bucket, we need not

1221 * change any chain links, and indeed should not since this simplistic

1222 * update will corrupt the list if currBucket is the last element. (We

1223 * cannot fall out earlier, however, since we need to scan the bucket to

1224 * check for duplicate keys.)

1225 */

1226 if (bucket != newbucket)

1227 {

1228 /* OK to remove record from old hash bucket's chain. */

1229 *oldPrevPtr = currBucket->link;

1230

1231 /* link into new hashbucket chain */

1232 *prevBucketPtr = currBucket;

1233 currBucket->link = NULL;

1234 }

1235

1236 /* copy new key into record */

1237 currBucket->hashvalue = newhashvalue;

1238 hashp->keycopy(ELEMENTKEY(currBucket), newKeyPtr, keysize);

1239

1240 /* rest of record is untouched */

1241

1242 return true;

1243}

ELEMENT_FROM_KEY

#define ELEMENT_FROM_KEY(key)

Definition: dynahash.c:260

References ELEMENT_FROM_KEY, ELEMENTKEY, elog, ERROR, HTAB::frozen, HTAB::hash, hash_initial_lookup(), HASHELEMENT::hashvalue, HTAB::hctl, HTAB::keycopy, HTAB::keysize, HASHELEMENT::link, HTAB::match, and HTAB::tabname.

Referenced by PostPrepare_Locks().