59{
66 int64 blocks_done = 0;
70 char *forkString;
71 char *ttype;
74
75 /* Basic sanity checking. */
78 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
79 errmsg(
"relation cannot be null")));
83 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
84 errmsg(
"prewarm type cannot be null")));
87 if (strcmp(ttype, "prefetch") == 0)
89 else if (strcmp(ttype, "read") == 0)
91 else if (strcmp(ttype, "buffer") == 0)
93 else
94 {
96 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
97 errmsg(
"invalid prewarm type"),
98 errhint(
"Valid prewarm types are \"prefetch\", \"read\", and \"buffer\".")));
100 }
103 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
104 errmsg(
"relation fork cannot be null")));
108
109 /* Open relation and check privileges. */
114
115 /* Check that the relation has storage. */
116 if (!RELKIND_HAS_STORAGE(rel->
rd_rel->relkind))
118 (
errcode(ERRCODE_WRONG_OBJECT_TYPE),
119 errmsg(
"relation \"%s\" does not have storage",
122
123 /* Check that the fork exists. */
126 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
127 errmsg(
"fork \"%s\" does not exist for this relation",
128 forkString)));
129
130 /* Validate block numbers, or handle nulls. */
133 first_block = 0;
134 else
135 {
137 if (first_block < 0 || first_block >= nblocks)
139 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
140 errmsg(
"starting block number must be between 0 and %" PRId64,
141 (nblocks - 1))));
142 }
144 last_block = nblocks - 1;
145 else
146 {
148 if (last_block < 0 || last_block >= nblocks)
150 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
151 errmsg(
"ending block number must be between 0 and %" PRId64,
152 (nblocks - 1))));
153 }
154
155 /* Now we're ready to do the real work. */
157 {
158#ifdef USE_PREFETCH
159
160 /*
161 * In prefetch mode, we just hint the OS to read the blocks, but we
162 * don't know whether it really does it, and we don't wait for it to
163 * finish.
164 *
165 * It would probably be better to pass our prefetch requests in chunks
166 * of a megabyte or maybe even a whole segment at a time, but there's
167 * no practical way to do that at present without a gross modularity
168 * violation, so we just do this.
169 */
170 for (block = first_block; block <= last_block; ++block)
171 {
174 ++blocks_done;
175 }
176#else
178 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
179 errmsg(
"prefetch is not supported by this build")));
180#endif
181 }
183 {
184 /*
185 * In read mode, we actually read the blocks, but not into shared
186 * buffers. This is more portable than prefetch mode (it works
187 * everywhere) and is synchronous.
188 */
189 for (block = first_block; block <= last_block; ++block)
190 {
193 ++blocks_done;
194 }
195 }
197 {
200
201 /*
202 * In buffer mode, we actually pull the data into shared_buffers.
203 */
204
205 /* Set up the private state for our streaming buffer read callback. */
208
209 /*
210 * It is safe to use batchmode as block_range_read_stream_cb takes no
211 * locks.
212 */
216 NULL,
217 rel,
218 forkNumber,
220 &p,
221 0);
222
223 for (block = first_block; block <= last_block; ++block)
224 {
226
230 ++blocks_done;
231 }
234 }
235
236 /* Close relation, release lock. */
238
240}
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode)
PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
BlockNumber RelationGetNumberOfBlocksInFork(Relation relation, ForkNumber forkNum)
void ReleaseBuffer(Buffer buffer)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
#define PG_GETARG_TEXT_PP(n)
#define PG_RETURN_INT64(x)
#define PG_GETARG_INT64(n)
Assert(PointerIsAligned(start, uint64))
char * get_rel_name(Oid relid)
#define CHECK_FOR_INTERRUPTS()
ObjectType get_relkind_objtype(char relkind)
int errdetail_relkind_not_supported(char relkind)
static PGIOAlignedBlock blockbuffer
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
void read_stream_end(ReadStream *stream)
BlockNumber block_range_read_stream_cb(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
#define READ_STREAM_MAINTENANCE
#define READ_STREAM_USE_BATCHING
static SMgrRelation RelationGetSmgr(Relation rel)
#define RelationGetRelationName(relation)
ForkNumber forkname_to_number(const char *forkName)
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
static void smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, void *buffer)
void relation_close(Relation relation, LOCKMODE lockmode)
Relation relation_open(Oid relationId, LOCKMODE lockmode)
BlockNumber last_exclusive
BlockNumber current_blocknum
char * text_to_cstring(const text *t)