static void
ReadTempFileBlock(BufFile *file, long blknum, void *ptr)
{
+ size_t nread;
+
if (BufFileSeekBlock(file, blknum) != 0)
- elog(ERROR, "could not seek temporary file: %m");
- if (BufFileRead(file, ptr, BLCKSZ) != BLCKSZ)
- elog(ERROR, "could not read temporary file: %m");
+ elog(ERROR, "could not seek to block %ld in temporary file", blknum);
+ nread = BufFileRead(file, ptr, BLCKSZ);
+ if (nread != BLCKSZ)
+ elog(ERROR, "could not read temporary file: read only %zu of %zu bytes",
+ nread, (size_t) BLCKSZ);
}
static void
WriteTempFileBlock(BufFile *file, long blknum, void *ptr)
{
if (BufFileSeekBlock(file, blknum) != 0)
- elog(ERROR, "could not seek temporary file: %m");
- if (BufFileWrite(file, ptr, BLCKSZ) != BLCKSZ)
- {
- /*
- * the other errors in Read/WriteTempFileBlock shouldn't happen, but
- * an error at write can easily happen if you run out of disk space.
- */
- ereport(ERROR,
- (errcode_for_file_access(),
- errmsg("could not write block %ld of temporary file: %m",
- blknum)));
- }
+ elog(ERROR, "could not seek to block %ld in temporary file", blknum);
+ BufFileWrite(file, ptr, BLCKSZ);
}
if (BufFileSeek(innerFile, 0, 0L, SEEK_SET))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not rewind hash-join temporary file: %m")));
+ errmsg("could not rewind hash-join temporary file")));
while ((slot = ExecHashJoinGetSavedTuple(hjstate,
innerFile,
if (BufFileSeek(hashtable->outerBatchFile[curbatch], 0, 0L, SEEK_SET))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not rewind hash-join temporary file: %m")));
+ errmsg("could not rewind hash-join temporary file")));
}
return true;
BufFile **fileptr)
{
BufFile *file = *fileptr;
- size_t written;
if (file == NULL)
{
*fileptr = file;
}
- written = BufFileWrite(file, (void *) &hashvalue, sizeof(uint32));
- if (written != sizeof(uint32))
- ereport(ERROR,
- (errcode_for_file_access(),
- errmsg("could not write to hash-join temporary file: %m")));
-
- written = BufFileWrite(file, (void *) tuple, tuple->t_len);
- if (written != tuple->t_len)
- ereport(ERROR,
- (errcode_for_file_access(),
- errmsg("could not write to hash-join temporary file: %m")));
+ BufFileWrite(file, (void *) &hashvalue, sizeof(uint32));
+ BufFileWrite(file, (void *) tuple, tuple->t_len);
}
/*
if (nread != sizeof(header))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read from hash-join temporary file: %m")));
+ errmsg("could not read from hash-join temporary file: read only %zu of %zu bytes",
+ nread, sizeof(header))));
*hashvalue = header[0];
tuple = (MinimalTuple) palloc(header[1]);
tuple->t_len = header[1];
if (nread != header[1] - sizeof(uint32))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read from hash-join temporary file: %m")));
+ errmsg("could not read from hash-join temporary file: read only %zu of %zu bytes",
+ nread, header[1] - sizeof(uint32))));
return ExecStoreMinimalTuple(tuple, tupleSlot, true);
}
static void extendBufFile(BufFile *file);
static void BufFileLoadBuffer(BufFile *file);
static void BufFileDumpBuffer(BufFile *file);
-static int BufFileFlush(BufFile *file);
-
+static void BufFileFlush(BufFile *file);
/*
* Create a BufFile given the first underlying physical file.
if (file->curOffset != file->offsets[file->curFile])
{
if (FileSeek(thisfile, file->curOffset, SEEK_SET) != file->curOffset)
- return; /* seek failed, read nothing */
+ ereport(ERROR,
+ (errcode_for_file_access(),
+ errmsg("could not seek in file \"%s\": %m",
+ FilePathName(thisfile))));
file->offsets[file->curFile] = file->curOffset;
}
sizeof(file->buffer),
WAIT_EVENT_BUFFILE_READ);
if (file->nbytes < 0)
+ {
file->nbytes = 0;
+ ereport(ERROR,
+ (errcode_for_file_access(),
+ errmsg("could not read file \"%s\": %m",
+ FilePathName(thisfile))));
+ }
+
file->offsets[file->curFile] += file->nbytes;
/* we choose not to advance curOffset here */
if (file->curOffset != file->offsets[file->curFile])
{
if (FileSeek(thisfile, file->curOffset, SEEK_SET) != file->curOffset)
- return; /* seek failed, give up */
+ ereport(ERROR,
+ (errcode_for_file_access(),
+ errmsg("could not seek in file \"%s\": %m",
+ FilePathName(thisfile))));
file->offsets[file->curFile] = file->curOffset;
}
bytestowrite = FileWrite(thisfile,
bytestowrite,
WAIT_EVENT_BUFFILE_WRITE);
if (bytestowrite <= 0)
- return; /* failed to write */
+ ereport(ERROR,
+ (errcode_for_file_access(),
+ errmsg("could not write to file \"%s\" : %m",
+ FilePathName(thisfile))));
+
file->offsets[file->curFile] += bytestowrite;
file->curOffset += bytestowrite;
wpos += bytestowrite;
/*
* BufFileRead
*
- * Like fread() except we assume 1-byte element size.
+ * Like fread() except we assume 1-byte element size and report I/O errors via
+ * ereport().
*/
size_t
BufFileRead(BufFile *file, void *ptr, size_t size)
size_t nread = 0;
size_t nthistime;
- if (file->dirty)
- {
- if (BufFileFlush(file) != 0)
- return 0; /* could not flush... */
- Assert(!file->dirty);
- }
+ BufFileFlush(file);
while (size > 0)
{
/*
* BufFileWrite
*
- * Like fwrite() except we assume 1-byte element size.
+ * Like fwrite() except we assume 1-byte element size and report errors via
+ * ereport().
*/
size_t
BufFileWrite(BufFile *file, void *ptr, size_t size)
{
/* Buffer full, dump it out */
if (file->dirty)
- {
BufFileDumpBuffer(file);
- if (file->dirty)
- break; /* I/O error */
- }
else
{
/* Hmm, went directly from reading to writing? */
/*
* BufFileFlush
*
- * Like fflush()
+ * Like fflush(), except that I/O errors are reported with ereport().
*/
-static int
+static void
BufFileFlush(BufFile *file)
{
if (file->dirty)
- {
BufFileDumpBuffer(file);
- if (file->dirty)
- return EOF;
- }
- return 0;
+ Assert(!file->dirty);
}
/*
* Like fseek(), except that target position needs two values in order to
* work when logical filesize exceeds maximum value representable by long.
* We do not support relative seeks across more than LONG_MAX, however.
+ * I/O errors are reported by ereport().
*
* Result is 0 if OK, EOF if not. Logical position is not moved if an
* impossible seek is attempted.
return 0;
}
/* Otherwise, must reposition buffer, so flush any dirty data */
- if (BufFileFlush(file) != 0)
- return EOF;
+ BufFileFlush(file);
/*
* At this point and no sooner, check for seek past last segment. The
}
/* Write the requested block */
- if (BufFileSeekBlock(lts->pfile, blocknum) != 0 ||
- BufFileWrite(lts->pfile, buffer, BLCKSZ) != BLCKSZ)
+ if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not write block %ld of temporary file: %m",
+ errmsg("could not seek to block %ld of temporary file",
blocknum)));
+ BufFileWrite(lts->pfile, buffer, BLCKSZ);
/* Update nBlocksWritten, if we extended the file */
if (blocknum == lts->nBlocksWritten)
static void
ltsReadBlock(LogicalTapeSet *lts, long blocknum, void *buffer)
{
- if (BufFileSeekBlock(lts->pfile, blocknum) != 0 ||
- BufFileRead(lts->pfile, buffer, BLCKSZ) != BLCKSZ)
+ size_t nread;
+
+ if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read block %ld of temporary file: %m",
+ errmsg("could not seek to block %ld of temporary file",
blocknum)));
+ nread = BufFileRead(lts->pfile, buffer, BLCKSZ);
+ if (nread != BLCKSZ)
+ ereport(ERROR,
+ (errcode_for_file_access(),
+ errmsg("could not read block %ld of temporary file: read only %zu of %zu bytes",
+ blocknum, nread, (size_t) BLCKSZ)));
}
/*
SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
}
else
{
SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
}
break;
default:
SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
state->status = TSS_WRITEFILE;
/*
SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
state->status = TSS_READFILE;
/* FALL THRU into READFILE case */
SEEK_CUR) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
Assert(!state->truncated);
return NULL;
}
SEEK_CUR) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
tup = READTUP(state, tuplen);
return tup;
if (BufFileSeek(state->myfile, 0, 0L, SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
break;
default:
elog(ERROR, "invalid tuplestore state");
SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
}
else
{
SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in tuplestore temporary file: %m")));
+ errmsg("could not seek in tuplestore temporary file")));
}
}
else if (srcptr == state->activeptr)
if (nbytes != 0 || !eofOK)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read from tuplestore temporary file: %m")));
+ errmsg("could not read from tuplestore temporary file: read only %zu of %zu bytes",
+ nbytes, sizeof(len))));
return 0;
}
/* total on-disk footprint: */
unsigned int tuplen = tupbodylen + sizeof(int);
- if (BufFileWrite(state->myfile, (void *) &tuplen,
- sizeof(tuplen)) != sizeof(tuplen))
- ereport(ERROR,
- (errcode_for_file_access(),
- errmsg("could not write to tuplestore temporary file: %m")));
- if (BufFileWrite(state->myfile, (void *) tupbody,
- tupbodylen) != (size_t) tupbodylen)
- ereport(ERROR,
- (errcode_for_file_access(),
- errmsg("could not write to tuplestore temporary file: %m")));
+ BufFileWrite(state->myfile, (void *) &tuplen, sizeof(tuplen));
+ BufFileWrite(state->myfile, (void *) tupbody, tupbodylen);
if (state->backward) /* need trailing length word? */
- if (BufFileWrite(state->myfile, (void *) &tuplen,
- sizeof(tuplen)) != sizeof(tuplen))
- ereport(ERROR,
- (errcode_for_file_access(),
- errmsg("could not write to tuplestore temporary file: %m")));
+ BufFileWrite(state->myfile, (void *) &tuplen, sizeof(tuplen));
FREEMEM(state, GetMemoryChunkSpace(tuple));
heap_free_minimal_tuple(tuple);
unsigned int tuplen = tupbodylen + MINIMAL_TUPLE_DATA_OFFSET;
MinimalTuple tuple = (MinimalTuple) palloc(tuplen);
char *tupbody = (char *) tuple + MINIMAL_TUPLE_DATA_OFFSET;
+ size_t nread;
USEMEM(state, GetMemoryChunkSpace(tuple));
/* read in the tuple proper */
tuple->t_len = tuplen;
- if (BufFileRead(state->myfile, (void *) tupbody,
- tupbodylen) != (size_t) tupbodylen)
+ nread = BufFileRead(state->myfile, (void *) tupbody, tupbodylen);
+ if (nread != (size_t) tupbodylen)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read from tuplestore temporary file: %m")));
+ errmsg("could not read from tuplestore temporary file: read only %zu of %zu bytes",
+ nread, (size_t) tupbodylen)));
if (state->backward) /* need trailing length word? */
- if (BufFileRead(state->myfile, (void *) &tuplen,
- sizeof(tuplen)) != sizeof(tuplen))
+ {
+ nread = BufFileRead(state->myfile, (void *) &tuplen, sizeof(tuplen));
+ if (nread != sizeof(tuplen))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read from tuplestore temporary file: %m")));
+ errmsg("could not read from tuplestore temporary file: read only %zu of %zu bytes",
+ nread, sizeof(tuplen))));
+ }
return (void *) tuple;
}
projects / thirdparty / postgresql.git / commitdiff
