PostgreSQL在何处处理 sql查询之十八

接前面，由于看到对 BasicOpenFile 函数的调用。

自然想到，如果两个进程同时访问一个表(即同一文件)，会否有冲突或效率的问题。

开两个psql客户端，连接数据库后，后台生成两个进程，

分别运行 select * from tst01 进行观察...发现各进程之间互相不干扰。

我实验的方法，加入调试代码：

/*

 * BasicOpenFile --- same as open(2) except can free other FDs if needed

 *

 * This is exported for use by places that really want a plain kernel FD,

 * but need to be proof against running out of FDs.  Once an FD has been

 * successfully returned, it is the caller's responsibility to ensure that

 * it will not be leaked on ereport()!    Most users should *not* call this

 * routine directly, but instead use the VFD abstraction level, which

 * provides protection against descriptor leaks as well as management of

 * files that need to be open for more than a short period of time.

 *

 * Ideally this should be the *only* direct call of open() in the backend.

 * In practice, the postmaster calls open() directly, and there are some

 * direct open() calls done early in backend startup.  Those are OK since

 * this module wouldn't have any open files to close at that point anyway.

 */

int

BasicOpenFile(FileName fileName, int fileFlags, int fileMode)

{

    int            fd;

    //char *tst01=(char *)fileName;

    char *tst02="base/12788/16384"; //tst01 table's file is base/12788/16384



tryAgain:



    fd = open(fileName, fileFlags, fileMode);



    char *tst01=(char *)fileName;

    fprintf(stderr,"length of fileName is:%d\n",strlen(fileName));



    if ( strcmp( fileName, tst02) == 0)

    {

        fprintf(stderr,"Sleeping.....by Process:%d\n",getpid());

        sleep(120);

    }



    //fd = open(fileName, fileFlags, fileMode);



    if (fd >= 0)

        return fd;                /* success! */



    if (errno == EMFILE || errno == ENFILE)

    {

        int            save_errno = errno;



        ereport(LOG,

                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),

                 errmsg("out of file descriptors: %m; release and retry")));

        errno = 0;

        if (ReleaseLruFile())

            goto tryAgain;

        errno = save_errno;

    }



    return -1;                    /* failure */

}

那么如果同时写入的时候又会如何，这个问题还需进一步地观察代码。

至少，不同的进程同时读一个表，在文件IO级别，没有发生阻塞。