28 changed files with 626 additions and 1241 deletions
--- a/Tools/memory_check/asan_report.pl
+++ b/Tools/memory_check/asan_report.pl
@ -1,4 +1,5 @@
 #!/usr/bin/perl
+#Again

 use warnings;
 use strict;
--- a/src/bin/gs_guc/encrypt.cpp
+++ b/src/bin/gs_guc/encrypt.cpp
@ -100,6 +100,13 @@ static int check_key_num(const char* password)
    return key_len;
 }

+/*
+function name: create_child_dir
+description: 函数作用
+arguments: A pointer to string that its type is const char
+return value: static void
+Note：函数中提醒阅读者需要注意的东西
+*/
 static void create_child_dir(const char* pathdir)
 {
    if (pathdir == NULL) {
--- a/src/common/backend/libpq/md5.cpp
+++ b/src/common/backend/libpq/md5.cpp
@ -309,7 +309,6 @@ bool pg_md5_encrypt(const char* passwd, const char* salt, size_t salt_len, char*
 {
    size_t passwd_len = strlen(passwd);
    errno_t rc = EOK;
-    /* the length of salt and password is <= SIZE_MAX */
 #ifndef WIN32
    if (unlikely(passwd_len >= SIZE_MAX - salt_len)) {
        return false;
@ -323,7 +322,6 @@ bool pg_md5_encrypt(const char* passwd, const char* salt, size_t salt_len, char*
    char* crypt_buf = (char*)malloc(passwd_len + salt_len + 1);
    bool ret = false;

-    /* the buffer is not exist */
    if (crypt_buf == NULL)
        return false;

--- a/src/common/backend/libpq/sha2.cpp
+++ b/src/common/backend/libpq/sha2.cpp
@ -772,15 +772,6 @@ bool pg_sha256_encrypt_for_md5(const char* password, const char* salt, size_t sa
    return true;
 }

-/*
- * @Description: calculate the encrypted password for GsSm3.
- * @const char* password : the password need be encrypted.
- * @const char* salt_s : the content fo the slat.
- * @size_t salt_len : the length fo the slat.
- * @char* buf : the buffer to store the encrypted key with GsSm3.
- * @char* client_key_buf : the buffer to store the key of client.
- * @int iteration_count : to record the number of the iteration.
- */
 bool GsSm3Encrypt(
    const char* password, const char* salt_s, size_t salt_len, char* buf, char* client_key_buf, int iteration_count)
 {
@ -808,7 +799,6 @@ bool GsSm3Encrypt(
    }

    password_len = strlen(password);
-    /* Tranform string(64Bytes) to binary(32Bytes) */
    sha_hex_to_bytes32(salt, (char*)salt_s);
    /* calculate k */
    pkcs_ret = PKCS5_PBKDF2_HMAC((char*)password,
--- a/src/common/backend/parser/parse_agg.cpp
+++ b/src/common/backend/parser/parse_agg.cpp
--- a/src/gausskernel/cbb/bbox/bbox_print.cpp
+++ b/src/gausskernel/cbb/bbox/bbox_print.cpp
@ -122,21 +122,15 @@ s32 bbox_put_dox(BBOX_vnprintCallBack pCallback, void* ptr, s32* piCount, u32 iS

    return iRet;
 }
-
 /*
-function name: bbox_vsnprintf
-description: The function is used to print string in corresponding array.
-arguments: The first argument is a pointer to a callback function, the next is a
-				   pointer to private data to call this function, also to buffer. 
-                   The third is used to destine buffer size. The forth is used to destine 
-                   the print format of deferent string, the last is a pointer to variable parameter list.
-return value: An integer, if iSize is big enough, then the return value is the length of
-					 string been written in destined memory successfully, not include '\0', 
-                     if function makes errors, the return value is a negative integer.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * simple signal-safe function vsnprintf
+ * in      : pCallback - call back function
+ *           ptr - private data to call this function
+ *           iSize - buffer size
+ *           pFmt - format type
+ *           ap - parameter list pointer<EFBFBD><EFBFBD>ʽ
+ * return  : length of string
+ */
 s32 bbox_vsnprintf(BBOX_vnprintCallBack pCallback, void* ptr, s32 iSize, const char* pFmt, va_list ap)
 {

@ -255,20 +249,13 @@ s32 bbox_vsnprintf(BBOX_vnprintCallBack pCallback, void* ptr, s32 iSize, const c
 }

 /*
-function name: bbox_SnprintCallback
-description: The function is used to print string in corresponding array, usually
-				    used as the first argument of function bbox_vsnprintf.
-arguments: The first argument is a character waited to be written into buffer that 
-				   pPtr directs, the second argument directs a buffer area, the third is a
-                   pointer to an integera used to record the count to call this callback function,
-                   at the same time, it represents the count of characters written into buffer, it's
-                   a pointer so that we can conveniently modify data storedin it. The last 
-                   argument destines the size of buffer, it represents the limit of length.
-return value: An integer, if written successfully, it's RET_OK, else it's RET_ERR.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * call back function of snprintf_s
+ * in      : c - string to calculate
+ *           pPtr - pointer to buffer
+ *           piCount - count of character
+ *           iSize - limit of length
+ * return  : length of string
+ */
 s32 bbox_SnprintCallback(char c, void* pPtr, s32* piCount, s32 iSize)
 {
    char** pszBuff = (char**)pPtr;
--- a/src/gausskernel/cbb/bbox/bbox_threads.cpp
+++ b/src/gausskernel/cbb/bbox/bbox_threads.cpp
@ -64,14 +64,8 @@ u8 g_szAltStackMem[BBOX_ALT_STACKSIZE]; /* independent thread stack memory */
 BBOX_ATOMIC_STRU g_isBusy = BBOX_ATOMIC_INIT(0); /* whether deal with core file. */

 /*
-function name: BBOX_ReserveZeroStack
-description: The function creat a empty stack, and its size depend on argument count.
-arguments: An integer of type s32, namely int, it destines the storage of stack.
-return value: void
-note: The stack this function creats is actually a character array.
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * reserved count bytes on current stack, and set 0
+ */
 void BBOX_ReserveZeroStack(s32 count)
 {
    char buff[count];
@ -101,14 +95,8 @@ s32 BBOX_CloneRun(u32 uFlags, s32 (*pFn)(void*), void* pArg, ...)
 }

 /*
-function name: BBOX_GetTaskNumber
-description: When get a path to specific process, this function will return count of threads below it.
-arguments: A pointer of type char*, including a path to specific process.
-return value: An integer that indicates the count of threads below specific process.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * get count of thread
+ */
 s32 BBOX_GetTaskNumber(char* szTaskPath)
 {
    struct kernel_stat stProcSB = {0};
@ -142,17 +130,8 @@ s32 BBOX_GetTaskNumber(char* szTaskPath)
 }

 /*
-function name: BBOX_GetTaskId
-description: When get a path to specific process, this function will return count of threads below it.
-arguments: The first argument is a structure pointer named pstTaskInfo,its type is struct TASK_ATTACH_INFO*,
-				   we use it as a structure array to store requisite thread infomation, the next argument destines
-                   the max size of the array that the first argument destines. The last argument is a pointer of type
-                   char*, including a path to specific process.
-return value: An integer that indicates the count of threads stored in structure array.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * get thread pid
+ */
 s32 BBOX_GetTaskId(struct TASK_ATTACH_INFO* pstTaskInfo, s32 iSize, char* szTaskPath)
 {
    s32 iProc = -1;
@ -235,19 +214,13 @@ errout:
 }

 /*
-function name: BBOX_PtraceAttachPid
-description: The function is used to check the process whose id stored in structure array pstTaskInfo work normally.
-arguments: The first argument is a structure pointer named pstTaskInfo,its type is struct TASK_ATTACH_INFO*,
-				   it is used as a structure array that has stored requisite thread infomation, the next argument destines
-                   the size of the array that the first argument destines, namely how many elements the array has. 
-                   The last argument is an integer to decide if need to check if the trace to destined process
-                   work normally, if normal, corresponding element of array pstTaskInfo's member variable cIsAttached
-                   will change from 0 to 1.
-return value: An integer, if function work normally, the value is RET_OK, else is RET_ERR.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * a ptrace debug thread
+ * in      : TASK_ATTACH_INFO - thread information
+ *           iPidCount - count of thread information
+ *           iDoPtraceCheck - check if ptrace success
+ * return  : 0 - success
+ *           err code - failed
+ */
 s32 BBOX_PtraceAttachPid(struct TASK_ATTACH_INFO* pstTaskInfo, s32 iPidCount, s32 iDoPtraceCheck)
 {
    u32 i;
@ -299,18 +272,13 @@ s32 BBOX_PtraceAttachPid(struct TASK_ATTACH_INFO* pstTaskInfo, s32 iPidCount, s3
 }

 /*
-function name: BBOX_DetachAllThread
-description: The function is used to cancel checking the process whose id stored in structure array pstTaskInfo 
-				    work normally, "work normally" means in array pstTaskInfo corresponding element's member 
-                    variable cIsAttached's value is 1.
-arguments: The first argument is a structure pointer named pstTaskInfo,its type is struct TASK_ATTACH_INFO*,
-				   it is used as a structure array that has stored requisite thread infomation, the next argument destines
-                   the size of the array that the first argument destines, namely how many elements the array has. 
-return value: void
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * cancel ptrace debug thread
+ * in      : TASK_ATTACH_INFO - thread information
+ *           iPidCount - count of thread information
+ *           iDoPtraceCheck - check if ptrace success
+ * return  : 0 - success
+ *           err code - failed
+ */
 void BBOX_DetachAllThread(struct TASK_ATTACH_INFO* pstTaskInfo, s32 iPidCount)
 {
    u32 i;
@ -355,18 +323,12 @@ void BBOX_CheckResumeThread(void* pArgs)
 }

 /*
-function name: BBOX_PtraceAndRun
-description: When get a path to specific process, this function will trace the threads below it, and get the
-				    information for example how many threads work normally then store it in pstArgs.
-arguments: The first argument is a structure pointer named pstArgs, its type is struct BBOX_ListParams*,
-				   what matters is its member variable callback function pointer, the next argument destines
-                   the max count of the thread. The last argument is a pointer of type char*, including a path
-                   to specific process.
-return value: An integer, if function work normally, the value is RET_OK, else is RET_ERR.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * ptrace thread and run function.
+ * in      : pstArgs - information of callback function
+ *           iMaxThreadCount - max count of thread
+ *           pszProcSelfTask - /proc/[pid]/task of current tracked thread.
+ * return 0 if success else err code.
+ */
 s32 BBOX_PtraceAndRun(struct BBOX_ListParams* pstArgs, s32 iMaxThreadCount, char* pszProcSelfTask)
 {
    struct TASK_ATTACH_INFO stTaskInfo[iMaxThreadCount];
@ -445,15 +407,8 @@ errout:
 }

 /*
-function name: BBOX_PrintFailedLog
-description: Write log infomation into specific file, if errors arise, print the infomation about errors.
-arguments: The only argument is a pointer of type const char* to a filename string, if this file doesn't
-				   exist, we will creat a new file named it.
-return value: An integer, if function work normally, the value is RET_OK, else is RET_ERR.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * print log information if export failed.
+ */
 void BBOX_PrintFailedLog(const char* pFileName)
 {
    ssize_t iRet = 0;
@ -482,15 +437,8 @@ void BBOX_PrintFailedLog(const char* pFileName)
 }

 /*
-function name: BBOX_ListThread
-description: Export thread information.
-arguments: The only argument is a structure pointer named pstArgs, its type is struct BBOX_ListParams*,
-				   what matters is its member variable callback function pointer and thread infomation.
-return value: void
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * export thread information.
+ */
 void BBOX_ListThread(struct BBOX_ListParams* pstArgs)
 {
    pid_t ppid = 0;
@ -597,18 +545,12 @@ errout:
 }

 /*
-function name: BBOX_GetClonePidResult
-description: The function get the status of child process at first, then according to it assign pstArgs's
-					member variables iError and iResult appropriate values.
-arguments: The first argument is a integer named iClonePid, it represents the pid of child process.
-				   The second argument is a structure pointer named pstArgs, its type is struct BBOX_ListParams*,
-				   what matters is its member variable callback function pointer and thread infomation.
-                   The third argument is a integer indicating error code. 
-return value: An integer, if function work normally, the value is RET_OK, else is RET_ERR.
-note: none
-date: 2022/8/3
-contact tel: 18720816902
-*/
+ * get return value of child process
+ * in      : iClonePid - PID of child process
+ *           pstArgs - parameter
+ *           iCloneErrno - err code
+ * return 0 if success else failed.
+ */
 s32 BBOX_GetClonePidResult(pid_t iClonePid, struct BBOX_ListParams* pstArgs, s32 iCloneErrno)
 {
    s32 iStatus = 0;
--- a/src/gausskernel/cbb/bbox/gs_bbox.cpp
+++ b/src/gausskernel/cbb/bbox/gs_bbox.cpp
@ -57,22 +57,6 @@ BlacklistItem g_blacklist_items[] = {
    {DATA_WRITER_QUEUE, "DATA_WRITER_QUEUE", false}
 };

-/*
-function name: coredump_handler
-description: When a program is abnormal, but the exception appears in the core of process and wasn't caught,
-					The function will generate a file to store the information about memory of process, status of register
-                    and running stack.
-arguments: The first argument is an integer indicating signal code that usually used in program of processing
-					signal as variable.
-				   The second argument is a structure pointer of type siginfo_t*, the memory that this pointer
-				   directs stores comprehensive information about signal, for example, which process sends
-                   and which user sends.
-                   The third argument is a pointer of type void*, other kinds of pointers can directly used here.
-return value: void
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
 static void coredump_handler(int sig, siginfo_t *si, void *uc)
 {
    static volatile int64 first_tid = INVALID_TID;
@ -100,19 +84,8 @@ static void coredump_handler(int sig, siginfo_t *si, void *uc)
 }

 /*
-function name: bbox_handler
-description: Handle signal conditions for bbox.
-arguments: The first argument is an integer indicating signal code that usually used in program of processing
-					signal as variable.
-				   The second argument is a structure pointer of type siginfo_t*, the memory that this pointer
-				   directs stores comprehensive information about signal, for example, which process sends
-                   and which user sends.
-                   The third argument is a pointer of type void*, other kinds of pointers can directly used here.
-return value: void
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
+ * bbox_handler - handle signal conditions for bbox
+ */
 static void bbox_handler(int sig, siginfo_t *si, void *uc)
 {
    static volatile int64 first_tid = INVALID_TID;
@ -152,16 +125,8 @@ static void bbox_handler(int sig, siginfo_t *si, void *uc)
 }

 /*
-function name: get_bbox_coredump_pattern_path
-description: Get the core dump file's path from the file "/proc/sys/kernel/core_pattern".
-arguments: The first argument is a pointer to string, we use it to store core dump file's path acquired
-				   from the file "/proc/sys/kernel/core_pattern", the next argument is the number of characters
-                   reading from the file "/proc/sys/kernel/core_pattern", all len-1 characters or less if appear '\n'.
-return value: void
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
+ * get_bbox_coredump_pattern_path - get the core dump path from the file "/proc/sys/kernel/core_pattern"
+ */
 static void get_bbox_coredump_pattern_path(char* path, Size len)
 {
    FILE* fp = NULL;
@ -191,17 +156,7 @@ static void get_bbox_coredump_pattern_path(char* path, Size len)
    }
 }

-/*
-function name: build_bbox_corepath
-description: Get the core dump file's path.
-arguments: The first argument is a pointer to string, we use it to store core dump file's path,
-				   the next argument is the size of the path's name, the last argument is a pointer 
-                   to string that indicates maybe store a path to configure the core dump file.
-return value: void
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
+/* compute directory into which bbox dump core files are saved. */
 static void build_bbox_corepath(char *bbox_core_path, Size path_size, char *config_path)
 {
    struct stat stat_buf;
@ -277,15 +232,6 @@ void assign_bbox_corepath(const char* newval, void* extra)
        return;
 }

-/*
-function name: show_bbox_dump_path
-description: Get the dump file's path.
-arguments: void
-return value: A pointer of type const char*, directing the path to dump or NULL.
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
 const char* show_bbox_dump_path(void)
 {
    const char* path = g_bbox_dump_path;
@ -293,15 +239,6 @@ const char* show_bbox_dump_path(void)
    return (path != NULL) ? path : "";
 }

-/*
-function name: split_string_into_blacklist
-description: Get all strings been divided into character ',' in source string.
-arguments: A pointer of type const char*, directing the source string.
-return value: A pointer of type static List*.
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
 static List* split_string_into_blacklist(const char* source)
 {
    List *result = NIL;
@ -327,6 +264,7 @@ static List* split_string_into_blacklist(const char* source)
    return result;
 }

+
 bool check_bbox_blacklist(char** newval, void** extra, GucSource source)
 {
    if (t_thrd.proc_cxt.MyProcPid != PostmasterPid)
@ -464,15 +402,10 @@ void bbox_blacklist_remove(BlacklistIndex item, void* addr)
 }

 /*
-function name: CheckFilenameValid
-description: Check if the filename is in line with norms, or if dangerous characters appear
-					the filename is invalid.
-arguments: A pointer to string indicating filename.
-return value: An integer, if function works normally, the value is RET_OK, else it's RET_ERR.
-note: none
-date: 2022/8/4
-contact tel: 18720816902
-*/
+ * @Description: check the value from environment variablethe to prevent command injection.
+ * @in input_env_value : the input value need be checked.
+ *
+ */
 int CheckFilenameValid(const char* inputEnvValue)
 {
    const int maxLen = 1024;
--- a/src/gausskernel/cbb/communication/comm_proxy/comm_common.cpp
+++ b/src/gausskernel/cbb/communication/comm_proxy/comm_common.cpp
@ -45,15 +45,6 @@

 static bool CommCheckFilterMatch(const char *filter, int len, const char *ip, int port);

-/*
-function name: SetCPUAffinity
-description: The function set the affinity of CPU or CPUs destined by argument cpu_id.
-arguments: An integer representing the id of one CPU or more.
-return value: void
-note: none
-date: 2022/8/5
-contact: 18720816902
-*/
 void SetCPUAffinity(int cpu_id)
 {
    cpu_set_t mask;
@ -279,15 +270,6 @@ IPAddrType CommLibNetGetIPType(unsigned int ip)
 #define CMD_STR_MAX 512
 #define CMD_OUTPUT_BUFFER_SIZE 1024

-/*
-function name: CommCheckLtranProcess
-description: The function check if the process currently working has loaded transactions.
-arguments: void
-return value: 0 or 1, if 1, then at least one loaded transcation exists, if 0, no one.
-note: none
-date: 2022/8/5
-contact: 18720816902
-*/
 int CommCheckLtranProcess()
 {
    AutoContextSwitch commContext(g_instance.comm_cxt.comm_global_mem_cxt);
@ -405,21 +387,6 @@ static T GetCommProxySubParameter(const char* str_attr, const char* key)
    return res;
 }

-/*
-function name: ParseCommProxyNumaBind
-description: Get the ids of CPU to bind process with specific CPU.
-arguments: The first argument is a pointer of type const char* to a string that indicating
-				   the id of CPUs below NUMA, not necessarily all CPUs.
-                   The second argument is an integer telling us we will get CPUs' id from which position
-                   of array str_attr.
-                   The third argument tells us the number of NUMA system framework.
-                   The fourth argument is a pointer to an integer array used to store CPUs' id gotten
-                   from string str_attr, we can use these ids to bind specific CPU.
-return value: void
-note: none
-date: 2022/8/5
-contact: 18720816902
-*/
 static void ParseCommProxyNumaBind(
    const char* str_attr, const int pos, const int numa_num, int* numa_bind)
 {
@ -520,22 +487,6 @@ bool ParseCommProxyAttr(CommProxyConfig* config)
    return true;
 }

-/*
-function name: CommCheckFilterMatch
-description: This function compare the ip and port allowed with ip and port gotten from
-				    Filter, if they are correspondingly same, it will return true value.
-arguments: The first argument is a pointer of type const char* to a string that indicating
-				   the id and port of the request been sent to Filter, the id and port have been 
-                   separated by character ':'.
-                   The second argument is an integer telling us we the length of the string first 
-                   argument directs.
-                   The third argument tells us the ip allowed.
-                   The fourth argument tells us the port allowed.
-return value: static bool
-note: none
-date: 2022/8/4
-contact: 18720816902
-*/
 static bool CommCheckFilterMatch(const char *filter, int len, const char *ip, int port)
 {
    char *str_ip = NULL;
--- a/src/gausskernel/cbb/communication/comm_proxy/comm_dfx.cpp
+++ b/src/gausskernel/cbb/communication/comm_proxy/comm_dfx.cpp
@ -175,24 +175,6 @@ void UpdateTxRxStats(int msg_level)
    last_rx_nbytes = current_rx_nbytes;
 }

-/*
-function name: parse_monitor_sock_queue
-description: Compare the string recv_buffer with "sockqueue fd:fd", the "fd"
-					after character ':' is an integer indicating file descriptor. If recv_buffer
-                    accords with the format, the function will takes next action to see if
-                    fd is 0, which represents stdin, so the function ends with returned value 0.
-                    If fd isn't 0, compare the third argument type with ParseMonitorTypeSet,
-                    if equal, then get a structure variable including socket descriptor 
-                    destined by the fd gotten from the first argument, if it's NULL, we can
-                    write "fd:[%d], type:[normal fd], no sock queue" into send_buffer.
-arguments: The first argument is a pointer to a string indicating request infomation.
-				   The second argument is a pointer to a string to store sent infomation.
-                   The third argument tells the kind of socket request.
-return value: 0 or 1.
-note: none
-date: 2022/8/5
-contact tel: 18720816902
-*/
 int parse_monitor_sock_queue(char* recv_buffer, char* send_buffer, ParseMonitorType type)
 {
    int length;
@ -223,25 +205,6 @@ int parse_monitor_sock_queue(char* recv_buffer, char* send_buffer, ParseMonitorT
    return 0;
 }

-/*
-function name: parse_monitor_fd
-description: Compare the string recv_buffer with "query fd:fd", the "fd"
-					after character ':' is an integer indicating file descriptor. If recv_buffer
-                    accords with the format, the function will takes next action to see if
-                    fd is 0, which represents stdin, so the function ends with returned value 0.
-                    If fd isn't 0, compare the third argument type with ParseMonitorTypeSet,
-                    if equal, then get a structure variable including socket descriptor 
-                    destined by the fd gotten from the first argument, if it's NULL, we can
-                    write "fd:[%d], type:[normal fd]"(%d--fd) into send_buffer, else write 
-                    "fd:[%d], type:[%d]"(%d--fd,%d--sock_desc->m_fd_type).
-arguments: The first argument is a pointer to a string indicating request infomation.
-				   The second argument is a pointer to a string to store sent infomation.
-                   The third argument tells the kind of socket request.
-return value: 0 or 1.
-note: none
-date: 2022/8/5
-contact tel: 18720816902
-*/
 int parse_monitor_fd(char* recv_buffer, char* send_buffer, ParseMonitorType type)
 {
    int length;
--- a/src/gausskernel/cbb/communication/comm_proxy/comm_proxy.cpp
+++ b/src/gausskernel/cbb/communication/comm_proxy/comm_proxy.cpp
@ -53,24 +53,6 @@ static void comm_wait_broadcast_end(SocketRequest** req_arr, int num);
 * export function definition
 ************************************************************************************
 */
-
-/*
-function name: comm_proxy_socket
-description: This function creates a socket file descriptor whose protocol family is 
-					domain, protocol type is type, and protocol number is protocol. If the
-                    function call is successful, it will return a file descriptor that identifies
-                    the socket. If it fails, it will return - 1.
-arguments: The first argument specifies the protocol family, it's used as domain to 
-					set up network communication.
-                    The second argument is used to set the type of socket communication.
-                    The third argument is used to specify a specific type of a protocol, which
-                    is a type in the second argument types' type. 
-return value: If the function call is successful, it will return a file descriptor that
-					 identifies the socket. If it fails, it will return - 1.
-note: none
-date: 2022/8/8
-contact tel: 18720816902 
-*/
 int comm_proxy_socket(int domain, int type, int protocol)
 {
    SocketRequest req;
@ -172,16 +154,6 @@ ssize_t comm_proxy_addr_recv(int sockfd, void *buf, size_t len, int flags)
    return comm_proxy_recv(sockfd, buf, len, flags);
 }

-/*
-function name: comm_proxy_close
-description: The function is used to release the resources allocated
-					to the socket by the system.
-arguments: The argument is the socket file descriptor to be closed.
-return value: If the call is successful, return 0; otherwise, return - 1 and set errno.
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_close(int fd)
 {
    SocketRequest req;
@ -233,18 +205,6 @@ int comm_proxy_close(int fd)
    return result.s_ret;
 }

-/*
-function name: comm_proxy_shutdown
-description: The function is used to release the resources allocated
-					to the socket by the system.
-arguments: The first argument is a descriptor used to identify a socket.
-				   The second argument is used to describe which operations
-                   are prohibited, which determines the behavior of the function. 
-return value: If the call is successful, return 0; otherwise, return - 1 and set errno.
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_shutdown(int fd, int how)
 {
    SocketRequest req;
@ -299,21 +259,6 @@ int comm_proxy_shutdown(int fd, int how)
    return result.s_ret;
 }

-/*
-function name: comm_proxy_accept
-description: This function extracts the first connection from the waiting connection queue of S, creates
-					a new socket interface similar to s and returns a handle.
-arguments: The first argument is a socket descriptor, which listens for connection after comm_proxy_listen().
-				   The second argument is a optional pointer pointing to a buffer where the address of the 
-                   connection entity known to the communication layer is received. The actual format of the
-                   addr argument is determined by the address family generated when the socket is created.
-                   The third argument is a optional pointer, used together with addr, pointing to the integer
-                   number with the length of addr address.
-return value: The return value is a new socket descriptor, which represents a new connection with the client.
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_accept(int sockfd, struct sockaddr* addr, socklen_t* addrlen)
 {
    SocketRequest req;
@ -398,17 +343,6 @@ int comm_proxy_accept4(int sockfd, struct sockaddr* addr, socklen_t* addrlen, in
    return comm_proxy_accept(sockfd, addr, addrlen);
 }

-/*
-function name: comm_proxy_connect
-description: This function is used to establish a connection with a specified socket.
-arguments: The first argument is used to identify an unconnected socket.
-				   The second argument is a pointer to the sockaddr structure to socket will be connected.
-                   The third argument is byte length of sockaddr structure.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
 {
    SocketRequest req;
@ -460,17 +394,6 @@ int comm_proxy_connect(int sockfd, const struct sockaddr *addr, socklen_t addrle
    return result.s_ret;
 }

-/*
-function name: comm_proxy_bind
-description: This function binds a local address with a set of interfaces.
-arguments: The first argument indicates the socket descriptor that has been established.
-				   The second argument is a pointer to the sockaddr structure to socket.
-                   The third argument is byte length of sockaddr structure.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_bind(int sockfd, const struct sockaddr* ServerAddr, socklen_t addrlen)
 {
    SocketRequest req;
@ -498,16 +421,6 @@ int comm_proxy_bind(int sockfd, const struct sockaddr* ServerAddr, socklen_t add
    return result.s_ret;
 }

-/*
-function name: comm_proxy_listen
-description: This function creates a socket interface and listens for the requested connection.
-arguments: The first argument is a descriptor used to identify a bundled but unconnected socket.
-				   The second argument indicates the maximum length of waiting for connection queue
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_listen(int sockfd, int backlog)
 {
    SocketRequest req;
@ -534,19 +447,6 @@ int comm_proxy_listen(int sockfd, int backlog)
    return result.s_ret;
 }

-/*
-function name: comm_proxy_setsockopt
-description: The function is used to set option values for sockets of any type and any state.
-arguments: The first argument is a descriptor that identifies a socket interface.
-				   The second argument indicates the level defined by the option.
-				   The third argument specifies the option to be set.
-				   The fourth argument is a pointer to the buffer where the new value of the option to be set is stored.
-				   The fifth argument indicates optval buffer length.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_setsockopt(int sockfd, int level, int optname, const void* optval, socklen_t optlen)
 {
    SocketRequest req;
@ -576,19 +476,6 @@ int comm_proxy_setsockopt(int sockfd, int level, int optname, const void* optval
    return result.s_ret;
 }

-/*
-function name: comm_proxy_getsockopt
-description: The function is used to obtain the current value of the option of any type and any state socket, and store the result in optval.
-arguments: The first argument is a descriptor that identifies a socket interface.
-				   The second argument indicates the level defined by the option.
-				   The third argument specifies the socket options to be obtained.
-				   The fourth argument is a pointer to the buffer where the obtained option value is stored.
-				   The fifth argument is a pointer to the length value of optval buffer.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_getsockopt(int sockfd, int level, int optname, void* optval, socklen_t* optlen)
 {
    SocketRequest req;
@ -617,18 +504,6 @@ int comm_proxy_getsockopt(int sockfd, int level, int optname, void* optval, sock
    return result.s_ret;
 }

-/*
-function name: comm_proxy_getsockname
-description: The function is used to get the name of a socket. It is used for a bundled or
-				   connected socket, and the local address will be returned.
-arguments: The first argument is a descriptor that identifies a socket interface.
-				   The second argument indicates the address of the receiving socket.
-				   The third argument specifies the length of the name buffer.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_getsockname(int sockfd, struct sockaddr* addr, socklen_t* addrlen)
 {
    SocketRequest req;
@ -655,17 +530,6 @@ int comm_proxy_getsockname(int sockfd, struct sockaddr* addr, socklen_t* addrlen
    return result.s_ret;
 }

-/*
-function name: comm_proxy_getpeername
-description: The function is used to obtain the foreign protocol address associated with a socket.
-arguments: The first argument is a descriptor that identifies a socket interface.
-				   The second argument indicates the name structure of the receiver address.
-				   The third argument specifies the length of the name structure.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_getpeername(int sockfd, struct sockaddr* addr, socklen_t* addrlen)
 {
    SocketRequest req;
@ -692,19 +556,6 @@ int comm_proxy_getpeername(int sockfd, struct sockaddr* addr, socklen_t* addrlen
    return result.s_ret;
 }

-/*
-function name: comm_proxy_fcntl
-description: The function can change the nature of the opened file, it provides control over descriptors. 
-	                The argument sockfd is a descriptor operated by the argument cmd. For the value of cmd, 
-                    fcntl can accept the third argument arg, which is a variable argument.
-arguments: The first argument is a descriptor that identifies a socket interface.
-				   The second argument represents the instruction to be operated.
-				   The third argument is a variable argument
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_fcntl(int sockfd, int cmd, ...)
 {
    SocketRequest req;
@ -771,17 +622,6 @@ int comm_proxy_fcntl(int sockfd, int cmd, ...)
    return result.s_ret;
 }

-/*
-function name: comm_proxy_poll
-description: The function is used to hang the current file pointer to the waiting queue.
-arguments: The first argument is an array of struct pollfd structure type, used to store the socket descriptor whose state needs to be detected.
-				   The second argument is used to mark the total number of structural elements in the array fdarray;
-				   The third argument is the blocking time of the comm_proxy_poll function call.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_poll(struct pollfd* fdarray, unsigned long nfds, int timeout)
 {
    CommWaitPollParam param;
@ -818,15 +658,6 @@ int comm_proxy_poll(struct pollfd* fdarray, unsigned long nfds, int timeout)
    return param.s_ret;
 }

-/*
-function name: comm_proxy_epoll_create
-description: The function is used to create a handle to epoll.
-arguments: The only argument size is used to tell the kernel how many listeners there are.
-return value: Returns a file descriptor that points to the newly created epoll instance
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_epoll_create(int size)
 {
    /*
@ -856,21 +687,6 @@ int comm_proxy_epoll_create1(int flag)
    return comm_proxy_epoll_create(1);
 }

-/*
-function name: comm_proxy_epoll_ctl
-description: This system call performs control operations on the epoll instance referenced
-				   by the file descriptor epfd. It requires the operation op to execute the target
-                   file descriptor fd. It's used as epoll's event registration function, it adds,
-                   modifies, or deletes events of interest to the epoll object.
-arguments: The first argument is a specific file descriptor for epoll generated by epoll_ create. 
-				   The second argument indicates the actions to be taken, such as registering events.
-				   The third argument is associated file descriptor.
-                   The fourth argument is a pointer of type struct epoll_event, used to tell the kernel what events and actions to listen for.
-return value: The return value is 0 if succeed, - 1 is returned for failure and error reason is stored in errno. 
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_epoll_ctl(int epfd, int op, int fd, struct epoll_event* event)
 {
    SocketRequest req;
@ -1110,23 +926,6 @@ int comm_proxy_epoll_ctl(int epfd, int op, int fd, struct epoll_event* event)
    return result.s_ret;
 }

-/*
-function name: comm_proxy_epoll_wait
-description: Wait for IO events on the specified epoll file descriptor.
-arguments: The first argument is a specific file descriptor for epoll generated by epoll_ create. 
-				   The second argument is a pointer to type epoll_ event structure, but it is now used
-                   as a container to get the collection of events from the kernel.
-				   The third argument is used to tell how large the container is (number of event 
-                   array members), that is, the number of events that can be processed each time.
-                  The fourth argument is the timeout value for waiting for IO events.
-return value: When successful, comm_proxy_epoll_wait() returns the number of file descriptors
-					 ready for the requested IO. Returns zero if no file descriptor is ready within the 
-                     requested timeout milliseconds. When an error occurs, comm_proxy_epoll_wait() 
-                     returns - 1 and sets errno correctly.
-note: none
-date: 2022/8/8
-contact tel: 18720816902
-*/
 int comm_proxy_epoll_wait(int epfd, struct epoll_event* events, int maxevents, int timeout)
 {
    CommWaitEpollWaitParam param;
--- a/src/gausskernel/cbb/communication/libcomm_core/mc_tcp.cpp
+++ b/src/gausskernel/cbb/communication/libcomm_core/mc_tcp.cpp
@ -81,27 +81,6 @@ void mc_tcp_set_keepalive(int fd)
    mc_tcp_setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, (char*)&count, sizeof(count));
 }

-/*
-function name: mc_tcp_get_peer_name
-description: This function is used to obtain the host IP and port number of the host bound to the specific socket.
-arguments: The first argument is a descriptor to a specified socket.
-				   The second argument is used to store the host IP address bound to the socket determined by the first parameter, in dotted decimal.
-                   The third parameter is used to store the port number bound to a specific socket, in the order of host bytes.
-return value: Return 0 if the function runs successfully.
-					 When the call to the getpeername() function fails：
-					 		1、Return EBADF if the socket argument is not a valid file descriptor.
-					 		2、Return EINVAL if the socket has been shut down.
-				  	 		3、Return ENOTCONN if the socket is not connected or otherwise has not had the peer pre-specified.
-					 		4、Return ENOTSOCK if the socket argument does not refer to a socket.
-					 	 	5、Return EOPNOTSUPP if the operation is not supported for the socket protocol.
-					 		6、Return ENOBUFS if insufficient resources were available in the system to complete the call.
-                     Return -2 when the host IP address belongs to IPv4 type, it fails to convert it to dotted decimal.
-                     Return -3 when the host IP address belongs to IPv6 type, it fails to convert it to dotted decimal.
-                     Return -4 when the error type is not any of the above.
-note: Allocate a certain amount of memory space for the host and port pointers respectively in advance.
-date: 2022/8/9
-contact tel: 18720816902
-*/
 int mc_tcp_get_peer_name(int fd, char* host, int* port)
 {
    struct sockaddr peeraddr = {0};
@ -142,17 +121,6 @@ int mc_tcp_set_cloexec(int fd)
    return set_socketopt(fd, 1, FD_CLOEXEC);
 }

-/*
-function name: mc_tcp_accept
-description: This function will block the process by default until a client connection is established and returns a new available socket.
-arguments: The first argument is a socket descriptor to a specific socket.
-				   The second argument is a result parameter, which is used to accept a return value that specifies the address of the client.
-                   The third argument is also a result argument, which is used to accept the size of the sockaddr structure. It indicates the number of bytes occupied by the sockaddr structure.
-return value: Return a value less than 0 if an error occurred when call the function accept4(), else return the new fd of socket.
-note: none
-date: 2022/8/9
-contact tel: 18720816902
-*/
 int mc_tcp_accept(int fd, struct sockaddr* sa, socklen_t* salenptr)
 {
    int new_fd;
@ -179,17 +147,6 @@ again:
    return (new_fd);
 }

-/*
-function name: mc_tcp_bind
-description: This function binds the specified socket to a specific IP address and port.
-arguments: The first argument indicates the socket descriptor that has been established.
-				   The second argument is a pointer to the sockaddr structure to socket.
-                   The third argument is byte length of sockaddr structure.
-return value: Return errno, the return value is 0 if succeed, else one of other error types is returned for failure. 
-note: none
-date: 2022/8/9
-contact tel: 18720816902
-*/
 int mc_tcp_bind(int fd, const struct sockaddr* sa, socklen_t salen)
 {
    int error = -1;
@ -234,20 +191,6 @@ static void mc_tcp_do_listen(int fd, int backlog)
    }
 }

-/*
-function name: mc_tcp_read_block
-description: This function receives data from the other end of TCP in a blocking manner, the receiving
-					process will not end until the data of size byte length is successfully received or a real error occurs in the receiving process
-arguments: The first argument indicates the specific socket that has been established.
-				   The second argument is a pointer to memory area, we use it to store received data.
-                   The third argument is byte length of the memory area pointed to by the data pointer.
-                   The fourth argument specifies additional operations in addition to the read operation.
-return value: If there is no error, it returns the byte length of the successfully read data. If an error
-					 occurs, return - 1.
-note: When the data is read successfully, the byte length of the data is greater than 0.
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_read_block(int fd, void* data, int size, int flags)
 {
 #ifdef LIBCOMM_FAULT_INJECTION_ENABLE
@ -318,20 +261,6 @@ int mc_tcp_read_block(int fd, void* data, int size, int flags)
    return (size_t)nbytes;
 }

-/*
-function name: mc_tcp_read_nonblock
-description: This function receives data from the other end of TCP in a non blocking manner,
-					the data receiving process is only performed once.
-arguments: The first argument indicates the specific socket that has been established.
-				   The second argument is a pointer to memory area, we use it to store received data.
-                   The third argument is byte length of the memory area pointed to by the data pointer.
-                   The fourth argument specifies additional operations in addition to the read operation.
-return value: If the error type is one of the errors represented by EAGAIN, EWOULDBLOCK and EINTR, it returns 0;
-					 other error types return - 1; if there is no error, it returns the byte length of the successfully read data.
-note: When the data is read successfully, the byte length of the data is greater than 0.
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_read_nonblock(int fd, void* data, int size, int flags)
 {
 #ifdef LIBCOMM_FAULT_INJECTION_ENABLE
@ -377,17 +306,6 @@ int mc_tcp_read_nonblock(int fd, void* data, int size, int flags)
    return (size_t)nbytes;
 }

-/*
-function name: mc_tcp_check_socket
-description: This function binds the specified socket to a specific IP address and port.
-arguments: The only argument indicates the specific socket that has been established.
-return value: Return -1 if when the recv function wait for the protocol to receive data, 
-					 the other end of TCP closes the connection or a real error occurred while
-                     reading data. In other cases, 0 is returned.
-note: none
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_check_socket(int sock)
 {
    char temp_buf[IOV_DATA_SIZE] = {0};
@ -450,19 +368,6 @@ int mc_tcp_check_socket(int sock)
    return 0;
 }

-/*
-function name: mc_tcp_write_block
-description: This function writes data to the specified socket in blocking mode, the sending process
-				   will not end until all the data are successfully sent or a real error occurs during the sending process
-arguments: The first argument indicates the specific socket that has been established.
-				   The second argument is a pointer to memory area, we use it to store data to be sent.
-                   The third argument is byte length of data to be sent.
-return value: If there is no error, it returns the byte length of the successfully sent data. If an error
-					 occurs, return - 1.
-note: none
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_write_block(int fd, const void* data, int size)
 {
 #ifdef LIBCOMM_FAULT_INJECTION_ENABLE
@ -521,21 +426,6 @@ int mc_tcp_write_block(int fd, const void* data, int size)
    return (size_t)nSend;
 }

-/*
-function name: mc_tcp_write_noblock
-description: This function writes data to the specified socket in non blocking mode,
-					the data transmission process is only performed once.
-arguments: The first argument indicates the specific socket that has been established.
-				   The second argument is a pointer to memory area, we use it to store data to be sent.
-                   The third argument is byte length of data to be sent.
-return value: If the sending fails but the failure reason is one of the error types represented by EAGAIN、
-					 EWOULDBLOCK、EINTR 和ENOBUFS, then 0 is returned; if the error type is other, then - 1
-                     is returned; If the transmission is successful, the byte length of the successfully transmitted
-                     data is returned
-note: none
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_write_noblock(int fd, const void* data, int size)
 {
 #ifdef LIBCOMM_FAULT_INJECTION_ENABLE
@ -629,17 +519,6 @@ int mc_tcp_addr_init(const char* host, int port, struct sockaddr_storage* ss, in
    return (error == 1) ? 0 : error;
 }

-/*
-function name: mc_tcp_connect_nonblock
-description: This function is used to create a socket and establish a connection with the port of the specified host
-					in non blocking mode.
-arguments: The first parameter specifies a specific host, and the second parameter specifies a specific port of the host.
-return value: If the connection is successfully established, the file descriptor of the socket connected to the port of the
-					 specified host is returned; otherwise, - 1 is returned.
-note: none
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_connect_nonblock(const char* host, int port)
 {
    int sockfd, n;
@ -687,18 +566,6 @@ int mc_tcp_connect_nonblock(const char* host, int port)
    return sockfd;
 }

-/*
-function name: mc_tcp_connect
-description: This function first obtains the ports of other hosts with the same domain name stored through
-					the ports of specific hosts, and creates a socket to establish a connection with an appropriate
-                    one of these ports.
-arguments: The first parameter specifies a specific host, and the second parameter specifies a specific port of the host.
-return value: The key is to successfully establish a connection with a port in the linked list. If the connection is successful, the
-					 socket file descriptor connected to it will be returned. Otherwise, it will return - 1.
-note: We finally get the infomation of the ports of other hosts through a linked list.
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_connect(const char* host, int port)
 {
 #ifdef LIBCOMM_FAULT_INJECTION_ENABLE
@ -789,18 +656,6 @@ retry:
    return (sockfd);
 }

-/*
-function name: mc_tcp_listen
-description: This function first obtains the ports of other hosts with the same domain name stored through
-					the ports of specific hosts, and creates a socket to bind with an appropriate one of these ports.
-arguments: The first parameter specifies a specific host, and the second parameter specifies a specific port of the host.
-				   The third is used to store size of protocol address.
-return value: The key lies in the successful binding with a port in the linked list. If the binding is successful, the socket file
-					 descriptor connected to it will be returned. Otherwise, it will return - 1.
-note: We finally get the infomation of the ports of other hosts through a linked list.
-date: 2022/8/10
-contact tel: 18720816902
-*/
 int mc_tcp_listen(const char* host, int port, socklen_t* addrlenp)
 {
 #ifdef LIBCOMM_FAULT_INJECTION_ENABLE
--- a/src/gausskernel/cbb/communication/libcomm_utils/libcomm_adapter.cpp
+++ b/src/gausskernel/cbb/communication/libcomm_utils/libcomm_adapter.cpp
@ -232,21 +232,6 @@ static int gs_tcp_write_noblock(int node_idx, int sock, const char* msg, int msg

    return send_bytes;
 }
-
-/*
-function name: libcomm_tcp_send
-description: This function is used to send the message including message head and message body,  to
-				    a specific socket.
-arguments: send_ info is a pointer of LibcommRecvInfo* type, pointing to the memory storing the data
-				   waiting to be sent.
-return value: Data will be sent twice in total. Before sending data, if it is found that the socket to receive
-					 data is not matched with the specified socket, then - 1 will be returned; If the sending of
-                     message head or message body fails, return - 1; If the function runs successfully, the byte
-                     length of the message body sent successfully is returned.
-note: none
-date: 2022/8/11
-contact tel: 18720816902
-*/
 static int libcomm_tcp_send(LibcommSendInfo* send_info)
 {
    int sock = send_info->socket;
@ -337,19 +322,6 @@ static int libcomm_tcp_send(LibcommSendInfo* send_info)
    return send_bytes;
 }

-/*
-function name: libcomm_tcp_recv_noidx
-description: This function is used to store the message transmitted from the sender, specifically to obtain
-				    the message from a specific socket.
-arguments: recv_ info is a pointer of LibcommRecvInfo* type, pointing to the memory to store the data
-				   received.
-return value: If it fails to allocate memory for  iov_ Item, return RECV_MEM_ERROR;
-					 If  it fails to obtain data, no matter it is a message header or a message body, from the specified socket in blocking mode, return RECV_NET_ERROR; 
-                     If the function runs successfully, the byte length of the read message body is returned.
-note: none
-date: 2022/8/11
-contact tel: 18720816902
-*/
 static int libcomm_tcp_recv_noidx(LibcommRecvInfo* recv_info)
 {
    int sock = recv_info->socket;
@ -399,23 +371,6 @@ static int libcomm_tcp_recv_noidx(LibcommRecvInfo* recv_info)
    return error;
 }

-/*
-function name: libcomm_tcp_recv
-description: This function is used to store the message transmitted from the sender, specifically to obtain
-				    the message from a specific socket.
-arguments: recv_ info is a pointer of LibcommRecvInfo* type, pointing to the memory to store the data
-				   received.
-return value: If the receiver has not been determined, call libcomm_tcp_recv_noidx() and take the return value 
-					 of (libcomm_tcp_recv_noidx (recv_info)); Return RECV_NET_ERROR if there is an error in the 
-                     process of reading the message heade or message body; If there is no data readable in the 
-                     receiving buffer of the specified socket at this time or the number of bytes of the data that
-                     has been read is not enough, it returns RECV_NEED_RETRY; If iov_item is NULL, it returns 
-                     RECV_MEM_ERROR if it fails to allocate space for it; If the function runs successfully, then 
-                     the byte length of the read message head and message body is returned.
-note: none
-date: 2022/8/11
-contact tel: 18720816902
-*/
 int libcomm_tcp_recv(LibcommRecvInfo* recv_info)
 {
    MsgHead* msg_head = NULL;
--- a/src/gausskernel/cbb/communication/libcomm_utils/libcomm_client_ssl.cpp
+++ b/src/gausskernel/cbb/communication/libcomm_utils/libcomm_client_ssl.cpp
@ -137,16 +137,6 @@ static int LibCommClientSSLDHVerifyCb(const SSL* s, const SSL_CTX* ctx,
    return 1;
 }

-/*
-function name: ssl_cipher_list2string
-description: This function converts the two-dimensional character array storing the key into a one-dimensional character array.
-arguments: The first argument represents the two-dimensional character array to be converted.
-				   The second argument indicates the number of one-dimensional arrays contained in this two-dimensional array.
-return value: Returns a pointer to the one-dimensional character array that has been successfully converted. If the conversion fails, NULL is returned.
-note: none
-date: 2022/8/12
-contact tel: 18720816902
-*/
 static char* ssl_cipher_list2string(const char* ciphers[], const int num) {
    int i;
    int catlen = 0;
@ -237,20 +227,7 @@ char* LibCommErrMessage(void) {
    return errBuf;
 }

-/*
-function name: LibCommClientSSLPasswd
-description: As a client, this function is used to detect whether there is a file with a valid key in the specified
-				   directory and whether there is permission to operate it. If so, the password will be decrypted by 
-                   using the file.
-arguments: The first parameter is a pointer of type (SSL *).
-				   The second parameter is used to obtain the absolute path of the certificate file.
-				   The third parameter represents the user name.
-				   The fourth parameter is a pointer of type (libcommconn *), whose member variable contains the ciphertext to be decrypted.
-return value: If the path is empty or does not have operation permission to the directory where the certificate file is located, a non-1 value is returned; otherwise, 0 is returned.
-note: none
-date: 2022/8/12
-contact tel: 18720816902
-*/
+
 int LibCommClientSSLPasswd(SSL* pstContext, const char * path, const char * userName, LibCommConn * conn) {
    char* CertFilesDir = NULL;
    char CertFilesPath[MAXPATH] = {0};
@ -274,8 +251,8 @@ int LibCommClientSSLPasswd(SSL* pstContext, const char * path, const char * user

    /*check whether the cipher and rand files begins with userName exist.
    if exist, decrypt it.
-    if not,decrypt the default cipher and rand files begins with client.
-    Because,for every client user may own certification and private key*/
+    if not,decrypt the default cipher and rand files begins with client%.
+    Because,for every client user mayown certification and private key*/
    if (NULL == userName) {
        retval = LibCommClientCheckPermissionCipherFile(CertFilesDir, conn, NULL);
        if (retval != 1)
--- a/src/gausskernel/cbb/communication/libcomm_utils/libcomm_lqueue.cpp
+++ b/src/gausskernel/cbb/communication/libcomm_utils/libcomm_lqueue.cpp
@ -33,16 +33,6 @@ inline int mc_lqueue_item_size(struct mc_lqueue_item* q_item)
    return q_item->element.data->iov_len;
 }

-/*
-function name: mc_lqueue_add
-description: Add an element to a specific queue.
-arguments: The first parameter is a pointer of type (mc_lqueue *), whose member variable list points to the target queue.
-				   The second parameter points to the element to be added to the queue.
-return value: Returns 1 if the element is successfully added to the queue, otherwise returns - 1.
-note: none
-date: 2022/8/13
-contact tel: 18720816902
-*/
 int mc_lqueue_add(struct mc_lqueue* q, struct mc_lqueue_item* q_item)
 {
    if (q == NULL || q_item == NULL) {
@ -70,17 +60,6 @@ int mc_lqueue_add(struct mc_lqueue* q, struct mc_lqueue_item* q_item)
    return 1;
 }

-/*
-function name: mc_lqueue_remove
-description: Remove the head element in a specific queue.
-arguments: The first parameter is a pointer of type (mc_lqueue *), whose member variable list points to the target queue.
-				   The second parameter points to the queue head element used to store the removal from the queue.
-return value: Return NULL if an error occurs during the removal of the queue head element, otherwise a pointer to
-					 the successfully removed queue head element is returned.
-note: none
-date: 2022/8/13
-contact tel: 18720816902
-*/
 struct mc_lqueue_item* mc_lqueue_remove(struct mc_lqueue* q, struct mc_lqueue_item* q_item)
 {
    if (q == NULL) {
@ -110,18 +89,6 @@ struct mc_lqueue_item* mc_lqueue_remove(struct mc_lqueue* q, struct mc_lqueue_it
    return q_item;
 }

-/*
-function name: mc_lqueue_init
-description: This function is used to open an area in the memory area. One part of the area is used to store a queue with
-				    a certain specification, and the other part is used to store the information of the queue, such as the specification
-                    and the number of elements. Finally, a pointer to the area is returned.
-arguments: This parameter specifies that the maximum number of elements that the queue can hold is size, but this does 
-				   not mean that the size of the queue is so large at the beginning.
-return value: If the function runs successfully, it returns a pointer to the opened memory area; otherwise, it returns NULL.
-note: none
-date: 2022/8/13
-contact tel: 18720816902
-*/
 struct mc_lqueue* mc_lqueue_init(unsigned long size)
 {
    if (size == 0) {
--- a/src/gausskernel/dbmind/tools/cmd/init.py
+++ b/src/gausskernel/dbmind/tools/cmd/init.py
@ -13,14 +13,8 @@
 import sys

 from .cli import DBMindRun
-#To import DBMindRun method from the parent file cli

-#function name: main
-#description: Get the system command parameters, pass to the DBMindRun and call this function,if an InterruptedError is reported, the program will exit( sys.exit(1)).
-#arguments: None
-#return value: None
-#date: 2022/8/3
-#contact: 1865997821
+
 def main() -> None:
    try:
        DBMindRun(sys.argv[1:])
--- a/src/gausskernel/dbmind/tools/cmd/config_utils.py
+++ b/src/gausskernel/dbmind/tools/cmd/config_utils.py
@ -55,12 +55,7 @@ CONFIG_OPTIONS = {
    'LOG-level': ['DEBUG', 'INFO', 'WARNING', 'ERROR']
 }

-#function name:  check_config_validity
-#description: Checks the validity of the passed parameter
-#arguments: section, option, value
-#return value: bool and string
-#date: 2022/8/
-#contact: 1865997821
+
 def check_config_validity(section, option, value):
    config_item = '%s-%s' % (section, option)
    # exceptional cases:
@ -92,16 +87,6 @@ def check_config_validity(section, option, value):
    return True, None


-
-#function name:  load_sys_configs
-#description: Create and load the modification file
-#arguments: The configuration to modify
-#return value: a new configuration file
-#note：To facilitate the user to modify the configuration items through the
-#configuration file easily, we add inline comments to the file, but we need to remove the inline comments while parsing.
-#Otherwise, it will cause the read configuration items to be wrong.
-#date: 2022/8/
-#contact: 1865997821
 def load_sys_configs(confile):
    # Note: To facilitate the user to modify the configuration items through the
    # configuration file easily, we add inline comments to the file, but we need
@ -111,8 +96,6 @@ def load_sys_configs(confile):
    with open(file=confile, mode='r') as fp:
        configs.read_file(fp)

-
-# Define a class that encapsulates the modification item
    class ConfigWrapper(object):
        def __getattribute__(self, name):
            try:
@ -139,7 +122,7 @@ def load_sys_configs(confile):

    return ConfigWrapper()

-# Defines a class that updates the encapsulated modification file
+
 class ConfigUpdater:
    def __init__(self, filepath):
        self.config = ConfigParser(inline_comment_prefixes=None)
@ -187,7 +170,7 @@ class ConfigUpdater:
            self.fp.flush()
        self.fp.close()

-# Defines a class that dynamically displays a modified item
+
 class DynamicConfig:
    @staticmethod
    def get(*args, **kwargs):
--- a/src/gausskernel/dbmind/tools/cmd/edbmind.py
+++ b/src/gausskernel/dbmind/tools/cmd/edbmind.py
@ -43,7 +43,6 @@ except ImportError:

 SKIP_LIST = ('COMMENT', 'LOG')

-# The global variable acts as a switch that controls whether the program runs
 dbmind_master_should_exit = False


@ -58,16 +57,8 @@ def _process_clean(force=False):
    global_vars.worker.terminate(cancel_futures=force)
    TimedTaskManager.stop()

-#function name: signal_handler
-#description: The function processes the received signal parameters, reassigns variable x according to different signals 
-#or calls other functions to complete the content indicated by signals
-#arguments: signum, frame
-#return value: bool (dbmind_master_should_exit)
-#date: 2022/8/3
-#contact: 1865997821

 def signal_handler(signum, frame):
-    # The global variable dbmind_master_should_exit can be modified in this function to continue to play a control role
    global dbmind_master_should_exit

    if signum == signal.SIGINT or signum == signal.SIGHUP:
@ -157,12 +148,10 @@ class DBMindMain(Daemon):
            time.sleep(1)
        logging.info('DBMind will close.')

-    # Emptying the execution pool
    def clean(self):
        if os.path.exists(self.pid_file):
            os.unlink(self.pid_file)
-    
-   # Reload the execution pool and solve the error
+
    def reload(self):
        pid = read_dbmind_pid_file(self.pid_file)
        if pid > 0:
--- a/src/gausskernel/dbmind/tools/common/http/controller_aop.py
+++ b/src/gausskernel/dbmind/tools/common/http/controller_aop.py
@ -27,17 +27,6 @@ def do_after(rt_result):
 def do_exception(exception):
    """Nothing"""

-
-#function name: around
-#description: Preserve the function properties and prevent an error from terminating the program
-#arguments: One or more functions
-#return value: none
-#note： Decorators are implemented in such a way that the function being decorated is actually another function (the function name and other properties change).
-#To avoid this, Python's FuncTools package provides a decorator called wraps to remove such side effects.
-#When writing a decorator, it is a good idea to wrap FuncTools before implementing it.
-#It preserves the name and properties of the original function
-#date: 2022/8/4
-#contact: 1865997821
 def around(func, *args, **kw):
    @wraps(func)
    def wrapper():
--- a/src/gausskernel/dbmind/tools/common/types/alarm.py
+++ b/src/gausskernel/dbmind/tools/common/types/alarm.py
@ -15,11 +15,7 @@ from typing import Optional, Iterable, Union
 from .root_cause import RootCause
 from .enumerations import ALARM_TYPES, ALARM_LEVEL

-#Define an Alarm class that takes the error parameters entered by the user and displays the error content and cause
-#method：Display the error content and suggestions, and retrieve suggestions provided by the system. If there are no suggestions, return “ no suggestions”
-#note：The property decorator turns a method into a property call.(root_causes、suggestions)
-#date：2022/8/4
-#contact：18365997821
+
 class Alarm:
    def __init__(self,
                 host: Union[str],
--- a/src/gausskernel/dbmind/tools/common/types/misc.py
+++ b/src/gausskernel/dbmind/tools/common/types/misc.py
@ -12,11 +12,7 @@
 # See the Mulan PSL v2 for more details.
 from .root_cause import RootCause

-#Define anSlowQuery class thatSlow query accepts user input commands and performs operations on the database
-#method：Display the error content and suggestions, and retrieve suggestions provided by the system. If there are no suggestions, return “ no suggestions”
-#note：The property decorator turns a method into a property call.(root_causes、suggestions)
-#date：2022/8/4
-#contact：18365997821
+
 class SlowQuery:
    def __init__(self, db_host, db_port, db_name, schema_name, query, start_timestamp, duration_time,
                 hit_rate=None, fetch_rate=None, cpu_time=None, data_io_time=None, template_id=None, sort_count=None,
--- a/src/gausskernel/dbmind/tools/components/index_advisor/dao/driver_execute.py
+++ b/src/gausskernel/dbmind/tools/components/index_advisor/dao/driver_execute.py
@ -18,19 +18,13 @@ import psycopg2
 from .execute_factory import ExecuteFactory
 from .execute_factory import IndexInfo

-#class name: DriverExecute （Inherits from the parent class ExecuteFactory）
-#description: The SQL statement performs the operations associated with the call
-#date: 2022/8/10
-#contact: 1865997821

 class DriverExecute(ExecuteFactory):
    def __init__(self, *arg):
-    #Call the arguments of the parent class __init__ method
        super(DriverExecute, self).__init__(*arg)
        self.conn = None
        self.cur = None

-   #Connecting to the database
    def init_conn_handle(self):
        self.conn = psycopg2.connect(dbname=self.dbname,
                                     user=self.user,
@ -39,7 +33,6 @@ class DriverExecute(ExecuteFactory):
                                     port=self.port)
        self.cur = self.conn.cursor()

-#If an error occurs after the SQL statement is executed, the error information is reported to the user
    def execute(self, sql):
        try:
            self.cur.execute(sql)
@ -48,13 +41,11 @@ class DriverExecute(ExecuteFactory):
        except Exception:
            self.conn.commit()

-#Disconnecting from the database
    def close_conn(self):
        if self.conn and self.cur:
            self.cur.close()
            self.conn.close()

-#Check whether multiple nodes exist
    def is_multi_node(self):
        self.init_conn_handle()
        try:
--- a/src/gausskernel/dbmind/tools/components/index_advisor/dao/execute_factory.py
+++ b/src/gausskernel/dbmind/tools/components/index_advisor/dao/execute_factory.py
@ -13,11 +13,6 @@

 import re

-#class name: IndexInfo
-#description: Define information about table indexes
-#methods: __init__
-#date: 2022/8/10
-#contact: 1865997821

 class IndexInfo:
    def __init__(self, schema, table, indexname, columns, indexdef):
@ -29,9 +24,7 @@ class IndexInfo:
        self.primary_key = False
        self.redundant_obj = []

-#class name:  ExecuteFactory
-#date: 2022/8/10
-#contact: 1865997821
+
 class ExecuteFactory:
    def __init__(self, dbname, user, password, host, port, schema, multi_node, max_index_storage):
        self.dbname = dbname
@ -43,11 +36,11 @@ class ExecuteFactory:
        self.max_index_storage = max_index_storage
        self.multi_node = multi_node

-# Record redundant indexes
    @staticmethod
    def record_redundant_indexes(cur_table_indexes, redundant_indexes):
        cur_table_indexes = sorted(cur_table_indexes,
                                   key=lambda index_obj: len(index_obj.columns.split(',')))
+        # record redundant indexes
        for pos, index in enumerate(cur_table_indexes[:-1]):
            is_redundant = False
            for candidate_index in cur_table_indexes[pos + 1:]:
@ -59,7 +52,6 @@ class ExecuteFactory:
            if is_redundant:
                redundant_indexes.append(index)

-#Match the name of the table against the index of the query
    @staticmethod
    def match_table_name(table_name, query_index_dict):
        for elem in query_index_dict.keys():
@ -74,7 +66,6 @@ class ExecuteFactory:
            return False, table_name
        return True, table_name

-#Retrieves a valid index based on the regular expression, adding the corresponding index and empty element if none exists
    @staticmethod
    def get_valid_indexes(record, hypoid_table_column, valid_indexes):
        tokens = record.split(' ')
@ -97,7 +88,6 @@ class ExecuteFactory:
                if columns not in valid_indexes[table_name]:
                    valid_indexes[table_name].append((columns, index_type))

-#Record invalid SQL statements and returns the corresponding help information that matches the corresponding SQL statement
    @staticmethod
    def record_ineffective_negative_sql(candidate_index, obj, ind):
        cur_table = candidate_index.table
@ -135,7 +125,6 @@ class ExecuteFactory:
                candidate_index.ineffective_pos.append(ind)
            candidate_index.total_sql_num += obj.frequency

-#Returns the last input and the corresponding result
    @staticmethod
    def match_last_result(table_name, index_column, history_indexes, history_invalid_indexes):
        for column in history_indexes.get(table_name, dict()):
@ -153,7 +142,6 @@ class ExecuteFactory:
                if not history_indexes[table_name]:
                    del history_indexes[table_name]

-#Correcting SQL statements
    @staticmethod
    def make_single_advisor_sql(ori_sql):
        sql = 'select gs_index_advise(\''
--- a/src/gausskernel/dbmind/tools/components/index_advisor/dao/gsql_execute.py
+++ b/src/gausskernel/dbmind/tools/components/index_advisor/dao/gsql_execute.py
@ -23,16 +23,12 @@ from .execute_factory import IndexInfo

 BASE_CMD = None

-#class name: GSqlExecute
-#description: Solve the optimization problem of GSQL statement execution
-#date: 2022/8/11
-#contact: 1865997821
+
 class GSqlExecute(ExecuteFactory):
    def __init__(self, *args):
        super(GSqlExecute, self).__init__(*args)

    def init_conn_handle(self):
-    #define a global variable BASE_CMD,it is a connection command statement
        global BASE_CMD
        BASE_CMD = 'gsql -p ' + str(self.port) + ' -d ' + self.dbname
        if self.host:
@ -42,7 +38,6 @@ class GSqlExecute(ExecuteFactory):
        if self.password:
            BASE_CMD += ' -W ' + self.password

-#Run the shell command in BASE_CMD
    def run_shell_cmd(self, target_sql_list):
        cmd = BASE_CMD + ' -c \"'
        if self.schema:
@ -52,7 +47,6 @@ class GSqlExecute(ExecuteFactory):
        cmd += '\"'
        proc = subprocess.Popen(
            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
-        #Read data from stdout and stderr,If an error message is displayed, an error message is displayed
        (stdout, stderr) = proc.communicate()
        stdout, stderr = stdout.decode(), stderr.decode()
        if 'gsql: FATAL:' in stderr or 'failed to connect' in stderr:
@ -80,7 +74,6 @@ class GSqlExecute(ExecuteFactory):
            print(e.output.decode(), file=sys.stderr)
        return int(ret.decode().strip().split()[2]) > 0

-#Parse the recommended result returned
    @staticmethod
    def parse_single_advisor_result(res, table_index_dict):
        if len(res) > 2 and res[0:2] == ' (':
@ -190,7 +183,6 @@ class GSqlExecute(ExecuteFactory):
        total_cost = 0
        found_plan = False
        hypo_index = False
-       # create hypo-indexes
        for line in res:
            if 'QUERY PLAN' in line:
                found_plan = True
@ -230,7 +222,6 @@ class GSqlExecute(ExecuteFactory):
            i += 1
        return total_cost

-#Production workflows consume report files
    def estimate_workload_cost_file(self, workload, index_config=None, ori_indexes_name=None):
        sql_file = str(time.time()) + '.sql'
        is_computed = False
@ -273,7 +264,6 @@ class GSqlExecute(ExecuteFactory):

        return total_cost

-#Check for empty indexes and note them to optimize the table structure
    def check_useless_index(self, history_indexes, history_invalid_indexes):
        schemas = [elem.lower()
                   for elem in filter(None, self.schema.split(','))]
--- a/src/gausskernel/optimizer/commands/user.cpp
+++ b/src/gausskernel/optimizer/commands/user.cpp
@ -5911,7 +5911,6 @@ Datum calculate_encrypted_combined_password(const char* password, const char* ro
    errno_t rc = EOK;

    /* For PG ecological compatibility, we stored both sha256 and md5 password. */
-    /* the encrypted method of sha256 */
    if (!pg_sha256_encrypt(password,
            salt_string,
            strlen(salt_string),
@ -5922,7 +5921,7 @@ Datum calculate_encrypted_combined_password(const char* password, const char* ro
        securec_check(rc, "\0", "\0");
        ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("first stage encryption password failed")));
    }
-    /* the encrypted method of md5 */
+
    if (!pg_md5_encrypt(password, rolname, strlen(rolname), encrypted_md5_password)) {
        rc = memset_s(encrypted_md5_password, MD5_PASSWD_LEN + 1, 0, MD5_PASSWD_LEN + 1);
        securec_check(rc, "\0", "\0");
@ -6053,7 +6052,6 @@ static Datum gs_calculate_encrypted_sm3_password(const char* password, const cha
 Datum calculate_encrypted_password(bool is_encrypted, const char* password, const char* rolname, 
                                   const char* salt_string)
 {
-    /* If the password is '\0' or not exist */
    if (password == NULL || password[0] == '\0') {
        ereport(ERROR, (errcode(ERRCODE_INVALID_PASSWORD), errmsg("The password could not be NULL.")));
    }
@ -6061,7 +6059,6 @@ Datum calculate_encrypted_password(bool is_encrypted, const char* password, cons
    char encrypted_md5_password[MD5_PASSWD_LEN + 1] = {0};
    Datum datum_value;

-    /* If the password has encrypted */
    if (!is_encrypted || isPWDENCRYPTED(password)) {
        return CStringGetTextDatum(password);
    }
@ -6071,7 +6068,6 @@ Datum calculate_encrypted_password(bool is_encrypted, const char* password, cons
     * if Password_encryption_type is 0, the encrypted password is md5.
     * if Password_encryption_type is 1, the encrypted password is sha256 + md5.
     * if Password_encryption_type is 2, the encrypted password is sha256.
-     * if Password_encryption_type is 3, the encrypted password is SM3.
     */
    if (u_sess->attr.attr_security.Password_encryption_type == 0) {
        if (!pg_md5_encrypt(password, rolname, strlen(rolname), encrypted_md5_password)) {
--- a/src/gausskernel/runtime/executor/execQual.cpp
+++ b/src/gausskernel/runtime/executor/execQual.cpp
@ -1901,13 +1901,6 @@ static void set_result_for_plpgsql_language_function_with_outparam(FuncExprState
 * @bool has_cursor_return - need store out-args cursor info.
 * @bool has_refcursor - need store in-args cursor info.
 * @bool isSetReturnFunc - indicate function returns a set.
- *The execution process of the ExecMakeFunctionResult function is as follows.
- * (1) Check whether funcResultStore exists, if so, get the result and return it
-(2) The calculated parameter values are stored in fcinfo.
-(3) Pass the parameter into the expression function to calculate the expression, 
-first determine whether the parameter args exists null, and then determine the return mode of the function that returns the set, 
-SFRM_ValuePerCall mode is to return a value each time the call, The SFRM_Materialize schema is the result set instantiated in Tuplestore.
-(4) Calculate and return results according to different modes.
 */
 template <bool has_refcursor, bool has_cursor_return, bool isSetReturnFunc>
 static Datum ExecMakeFunctionResult(FuncExprState* fcache, ExprContext* econtext, bool* isNull, ExprDoneCond* isDone)
@ -3089,10 +3082,6 @@ no_function_result:
 /* ----------------------------------------------------------------
 *		ExecEvalFunc
 * ----------------------------------------------------------------
- *The execution process of the ExecEvalFunc function is as follows.
-(1) Initialize the FuncExprState node by init_fcache function, including initialization parameters, memory management, etc.
-(2) Judge whether the returned result is of set type according to the data in the FuncExprState function, 
-and call the corresponding function to calculate the result.
 */
 static Datum ExecEvalFunc(FuncExprState* fcache, ExprContext* econtext, bool* isNull, ExprDoneCond* isDone)
 {
@ -3537,10 +3526,6 @@ static Datum ExecEvalNot(BoolExprState* notclause, ExprContext* econtext, bool*
 /* ----------------------------------------------------------------
 *		ExecEvalOr
 * ----------------------------------------------------------------
- *The main execution process of ExecEvalOr function is as follows.
-(1) Traverse child expression clauses.
-(2) Use the function ExecEvalExpr to call the expression calculation function in clause and calculate the result.
-(3) To judge the results, if there is a result in the or expression that meets the conditions, it will jump out of the loop and return directly.
 */
 static Datum ExecEvalOr(BoolExprState* orExpr, ExprContext* econtext, bool* isNull, ExprDoneCond* isDone)
 {
@ -5179,11 +5164,6 @@ Datum ExecEvalExprSwitchContext(ExprState* expression, ExprContext* econtext, bo
 * 'parent' may be NULL if we are preparing an expression that is not
 * associated with a plan tree.  (If so, it can't have aggs or subplans.)
 * This case should usually come through ExecPrepareExpr, not directly here.
- *The execution process of the ExecInitExpr function is as follows.
-(1) Determine whether the input node is empty. If it is empty,return NULL directly, indicating that there is no restriction for expression.
-(2) According to the type of node input,Initialize variable evalfunc which is the execution function corresponding to node,
-If the node has parameters or expressions, the function ExecInitExpr will be recursively called and ExprState tree will be generated.
-(3) Return ExprState tree, and execute the expression recursively according to ExprState tree.
 */
 ExprState* ExecInitExpr(Expr* node, PlanState* parent)
 {
@ -6143,10 +6123,6 @@ Datum fetch_lob_value_from_tuple(varatt_lob_pointer* lob_pointer, Oid update_oid
 * of *isDone = ExprMultipleResult signifies a set element, and a return
 * of *isDone = ExprEndResult signifies end of the set of tuple.
 * We assume that *isDone has been initialized to ExprSingleResult by caller.
-  * The execution process of the ExecTargetList function is as follows.
-(1) Iterate over the expressions in targetlist.
-(2) Calculation of expression results.
-(3) Judge the itemIsDone[resind] parameter in the results and generate the final tuple.
 */
 static bool ExecTargetList(List* targetlist, ExprContext* econtext, Datum* values, bool* isnull,
    ExprDoneCond* itemIsDone, ExprDoneCond* isDone)
--- a/src/test/ipv6/create_server.py
+++ b/src/test/ipv6/create_server.py
@ -17,7 +17,7 @@
 #        src/test/ipv6/create_server.py
 #
 # ---------------------------------------------------------------------------------------
-# 增加注释
+
 import getopt, sys, os
 import shutil
 import time
--- a/test.txt
+++ b/test.txt
@ -1 +0,0 @@
-sdfadfadsf