Update execGrouping.cpp

src/gausskernel/runtime/executor/execGrouping.cpp

@@ -48,6 +48,25 @@ static int TupleHashTableMatch(const void* key1, const void* key2, Size keysize)
  *
  * NB: evalContext is reset each time!
  */
+/*The main purpose of this code is to compare whether two Tuple are equal. 
+In database, tuple is a basic data structure, which is used to store a series of related values.
+The function execTuplesMatch receives two TupleTableSlot pointers (slot1 and slot2), 
+which point to the tuple to be compared, as well as the number of columns (numCols), 
+the matching column index (matchColIdx), the equation functions (eqfunctions) and an evalContext.
+
+It first switches to a temporary memory context (evalContext), and then loops through each column, 
+starting with the last column (the least important sort key). This is because the last column 
+is most likely to be different when processing sorted input.
+
+For each column, it gets the property values in two tuples and checks whether they are empty. 
+If one is empty and the other is not, they are not equal, and the function sets the result to false 
+and jumps out of the loop. If both of them are empty, they are regarded as equal and continue the next cycle.
+
+If both attributes are not empty, then a specific type of equality function will be used to compare whether 
+they are equal. If not, the function sets the result to false and jumps out of the loop.
+
+Finally, the function switches back to the old memory context and returns the result. If all columns match, 
+the function will return true, otherwise it will return false.*/
 bool execTuplesMatch(TupleTableSlot* slot1, TupleTableSlot* slot2, int numCols, AttrNumber* matchColIdx,
     FmgrInfo* eqfunctions, MemoryContext evalContext)
 {
@@ -166,6 +185,26 @@ bool execTuplesUnequal(TupleTableSlot* slot1, TupleTableSlot* slot2, int numCols
  *
  * The result is a palloc'd array.
  */
+/*The main purpose of this code is to generate an array of function information for 
+each pair of equality operators for subsequent tuple comparison.
+
+The function execTuplesMatchPrepare takes the number of columns (numCols) and
+the array of equality eqOperators (`eq operators`) as parameters.
+
+First, it uses `p palloc to allocate memory for the function information array, 
+and the length of the array is the number of columns.
+
+Then, it enters a loop, and each iteration in the loop corresponds to a column. 
+For each column, it gets the equality operator (` eq _ opr`) and the corresponding 
+function (` eq _ function`). This is done by calling the get_opcode function.
+
+Next, it uses the fmgr_info function to fill the corresponding position 
+of the function information array.
+
+Finally, the function returns the generated function information array.
+
+This function is usually called before performing tuple matching to 
+prepare the required function information.*/
 FmgrInfo* execTuplesMatchPrepare(int numCols, Oid* eqOperators)
 {
     FmgrInfo* eqFunctions = (FmgrInfo*)palloc(numCols * sizeof(FmgrInfo));
@@ -192,6 +231,26 @@ FmgrInfo* execTuplesMatchPrepare(int numCols, Oid* eqOperators)
  *
  * Note: we expect that the given operators are not cross-type comparisons.
  */
+/*The purpose of this code is to prepare equality function and hash function for tuple hash table.
+
+The' executtupleshahprep' function receives four parameters: number of columns ('numCols'), 
+equality operator array ('eqOperators'), equality function array ('eqFunctions') and hash function array ('hashFunctions').
+
+First, the function allocates memory for the array of equality functions and hash functions.
+
+Then, it enters a loop, and each iteration in the loop corresponds to a column. For each column,
+it gets the equality operator (` eq _ opr`) and the corresponding function (` eq _ function`). This is done by calling the get_opcode function.
+
+Next, it tries to get the hash function of the equality operator. If the hash function cannot be found,
+it will report an error and call the `ereport' function, which will send the error information to the error handling system of PostgreSQL.
+
+Then, it asserts that the left and right hash functions are the same, which 
+means that it does not support cross-type cases.
+
+Finally, it uses the fmgr_info function to fill the corresponding positions
+of the array of equality functions and hash functions.
+
+This function is usually called before performing tuple hashing to prepare the required function information.*/
 void execTuplesHashPrepare(int numCols, Oid* eqOperators, FmgrInfo** eqFunctions, FmgrInfo** hashFunctions)
 {
     int i;
@@ -248,6 +307,29 @@ void execTuplesHashPrepare(int numCols, Oid* eqOperators, FmgrInfo** eqFunctions
  * Note that keyColIdx, eqfunctions, and hashfunctions must be allocated in
  * storage that will live as long as the hashtable does.
  */
+/*The main purpose of this code is to create a TupleHashTable, which is a data structure for storing tuples, 
+which is the basic data structure for storing a series of related values in the database.
+
+The function' BuildTupleHashTable' receives a series of parameters, including the number of columns ('numCols'),
+key column index ('keyColIdx'), equation function ('eqfunctions'), hash function ('hashfunctions'), number of buckets ('nbuckets'), entrysize ('entrysize').
+
+First, the function checks whether the number of buckets and the entry size are valid. Then,
+it limits the request for the initial table size according to the working memory.
+
+Then, it allocates memory in the table context to store TupleHashTableData.
+
+Then, it sets various fields, including column number, key column index, hash function,
+equality function, table context, temporary context, entry size, etc.
+
+Then, it clears the memory of the hash_ctl structure and sets its various fields, including key size, 
+entry size, hash function, matching function and hash context.
+
+Finally, it creates a hashtable using the hash_create function and stores it in the hashtab' field of `hashtable'.
+
+Function returns the created ` hashtable'.
+
+This function is usually called when creating a tuple hash when executing a database query, 
+and is used to prepare the required data structure.*/
 TupleHashTable BuildTupleHashTable(int numCols, AttrNumber* keyColIdx, FmgrInfo* eqfunctions, FmgrInfo* hashfunctions,
     long nbuckets, Size entrysize, MemoryContext tablecxt, MemoryContext tempcxt, int workMem)
 {
@@ -309,6 +391,21 @@ TupleHashTable BuildTupleHashTable(int numCols, AttrNumber* keyColIdx, FmgrInfo*
  * hash table if it is new
  *
  */
+/*The main purpose of this code is to find the TupleTableSlot in the TupleHashTable and insert it as needed. 
+TupleHashTable is a data structure used to store tuples, which are the basic data structures used to store a series of related values in the database.
+
+The function LookupTupleHashEntry receives four parameters: a TupleHashTable(`hashtable), a TupleTableSlot pointer (`slot`), 
+a Boolean pointer (isnew) and a Boolean value (isinserthashtbl).
+
+The function first checks whether it is the first time to pass, and if it is, it will clone 
+the input time slot to make the table time slot.
+
+Then, the function switches to the temporary context, sets the hash and the data needed 
+by the matching function, and saves the current tuple hash table.
+
+Next, it searches the hash table. If' isinserthashtbl' is true, it will search the hash table and return the found entry 
+if it is found; If it is not found and' isnew' is not NULL, set' isnew' to true, indicating a new entry. If' isinserthashtbl' is false, 
+it will only search the hash table, and if it is found, it will return the found entry; If it is not found, it will create a new table.*/
 TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot* slot, bool* isnew, bool isinserthashtbl)
 {
     TupleHashEntry entry;
@@ -510,6 +607,21 @@ static uint32 TupleHashTableHash(const void* key, Size keysize)
  * Also, the caller must select an appropriate memory context for running
  * the compare functions.  (dynahash.c doesn't change CurrentMemoryContext.)
  */
+/*This code is used to process a part of tuple hash table, which is a data 
+structure used to store and retrieve tuple data in PostgreSQL.
+
+The function TupleHashTableMatch' is a comparison function, which is used to compare
+whether two tuples are equal. This function is designed to be used with dynahash.c library, 
+which is a general hash table library and can be used to store and retrieve data.
+
+The function receives three parameters: key1, key2 and keysize. Key1' and' key2' are pointers 
+to two tuples to be compared, and' keysize' is the size of tuples.
+
+Within the function, firstly, ` key1' and ` key2' are converted into tuples, and then the tuples are stored
+in the table slots and input slots of the hash table by using the ` ExecStoreMinimalTuple' function.
+
+Finally, compare whether two tuples are equal by using the execTuplesMatch function. 
+If two tuples are equal, the function returns 0, otherwise it returns 1.*/
 static int TupleHashTableMatch(const void* key1, const void* key2, Size keysize)
 {
     MinimalTuple tuple1 = ((const TupleHashEntryData*)key1)->firstTuple;