Line data Source code
1 : /*
2 : * dbsize.c
3 : * Database object size functions, and related inquiries
4 : *
5 : * Copyright (c) 2002-2020, PostgreSQL Global Development Group
6 : *
7 : * IDENTIFICATION
8 : * src/backend/utils/adt/dbsize.c
9 : *
10 : */
11 :
12 : #include "postgres.h"
13 :
14 : #include <sys/stat.h>
15 :
16 : #include "access/htup_details.h"
17 : #include "access/relation.h"
18 : #include "catalog/catalog.h"
19 : #include "catalog/namespace.h"
20 : #include "catalog/pg_authid.h"
21 : #include "catalog/pg_tablespace.h"
22 : #include "commands/dbcommands.h"
23 : #include "commands/tablespace.h"
24 : #include "miscadmin.h"
25 : #include "storage/fd.h"
26 : #include "utils/acl.h"
27 : #include "utils/builtins.h"
28 : #include "utils/numeric.h"
29 : #include "utils/rel.h"
30 : #include "utils/relfilenodemap.h"
31 : #include "utils/relmapper.h"
32 : #include "utils/syscache.h"
33 :
34 : /* Divide by two and round towards positive infinity. */
35 : #define half_rounded(x) (((x) + ((x) < 0 ? 0 : 1)) / 2)
36 :
37 : /* Return physical size of directory contents, or 0 if dir doesn't exist */
38 : static int64
39 0 : db_dir_size(const char *path)
40 : {
41 0 : int64 dirsize = 0;
42 : struct dirent *direntry;
43 : DIR *dirdesc;
44 : char filename[MAXPGPATH * 2];
45 :
46 0 : dirdesc = AllocateDir(path);
47 :
48 0 : if (!dirdesc)
49 0 : return 0;
50 :
51 0 : while ((direntry = ReadDir(dirdesc, path)) != NULL)
52 : {
53 : struct stat fst;
54 :
55 0 : CHECK_FOR_INTERRUPTS();
56 :
57 0 : if (strcmp(direntry->d_name, ".") == 0 ||
58 0 : strcmp(direntry->d_name, "..") == 0)
59 0 : continue;
60 :
61 0 : snprintf(filename, sizeof(filename), "%s/%s", path, direntry->d_name);
62 :
63 0 : if (stat(filename, &fst) < 0)
64 : {
65 0 : if (errno == ENOENT)
66 0 : continue;
67 : else
68 0 : ereport(ERROR,
69 : (errcode_for_file_access(),
70 : errmsg("could not stat file \"%s\": %m", filename)));
71 : }
72 0 : dirsize += fst.st_size;
73 : }
74 :
75 0 : FreeDir(dirdesc);
76 0 : return dirsize;
77 : }
78 :
79 : /*
80 : * calculate size of database in all tablespaces
81 : */
82 : static int64
83 0 : calculate_database_size(Oid dbOid)
84 : {
85 : int64 totalsize;
86 : DIR *dirdesc;
87 : struct dirent *direntry;
88 : char dirpath[MAXPGPATH];
89 : char pathname[MAXPGPATH + 21 + sizeof(TABLESPACE_VERSION_DIRECTORY)];
90 : AclResult aclresult;
91 :
92 : /*
93 : * User must have connect privilege for target database or be a member of
94 : * pg_read_all_stats
95 : */
96 0 : aclresult = pg_database_aclcheck(dbOid, GetUserId(), ACL_CONNECT);
97 0 : if (aclresult != ACLCHECK_OK &&
98 0 : !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_STATS))
99 : {
100 0 : aclcheck_error(aclresult, OBJECT_DATABASE,
101 0 : get_database_name(dbOid));
102 : }
103 :
104 : /* Shared storage in pg_global is not counted */
105 :
106 : /* Include pg_default storage */
107 0 : snprintf(pathname, sizeof(pathname), "base/%u", dbOid);
108 0 : totalsize = db_dir_size(pathname);
109 :
110 : /* Scan the non-default tablespaces */
111 0 : snprintf(dirpath, MAXPGPATH, "pg_tblspc");
112 0 : dirdesc = AllocateDir(dirpath);
113 :
114 0 : while ((direntry = ReadDir(dirdesc, dirpath)) != NULL)
115 : {
116 0 : CHECK_FOR_INTERRUPTS();
117 :
118 0 : if (strcmp(direntry->d_name, ".") == 0 ||
119 0 : strcmp(direntry->d_name, "..") == 0)
120 0 : continue;
121 :
122 0 : snprintf(pathname, sizeof(pathname), "pg_tblspc/%s/%s/%u",
123 0 : direntry->d_name, TABLESPACE_VERSION_DIRECTORY, dbOid);
124 0 : totalsize += db_dir_size(pathname);
125 : }
126 :
127 0 : FreeDir(dirdesc);
128 :
129 0 : return totalsize;
130 : }
131 :
132 : Datum
133 0 : pg_database_size_oid(PG_FUNCTION_ARGS)
134 : {
135 0 : Oid dbOid = PG_GETARG_OID(0);
136 : int64 size;
137 :
138 0 : size = calculate_database_size(dbOid);
139 :
140 0 : if (size == 0)
141 0 : PG_RETURN_NULL();
142 :
143 0 : PG_RETURN_INT64(size);
144 : }
145 :
146 : Datum
147 0 : pg_database_size_name(PG_FUNCTION_ARGS)
148 : {
149 0 : Name dbName = PG_GETARG_NAME(0);
150 0 : Oid dbOid = get_database_oid(NameStr(*dbName), false);
151 : int64 size;
152 :
153 0 : size = calculate_database_size(dbOid);
154 :
155 0 : if (size == 0)
156 0 : PG_RETURN_NULL();
157 :
158 0 : PG_RETURN_INT64(size);
159 : }
160 :
161 :
162 : /*
163 : * Calculate total size of tablespace. Returns -1 if the tablespace directory
164 : * cannot be found.
165 : */
166 : static int64
167 0 : calculate_tablespace_size(Oid tblspcOid)
168 : {
169 : char tblspcPath[MAXPGPATH];
170 : char pathname[MAXPGPATH * 2];
171 0 : int64 totalsize = 0;
172 : DIR *dirdesc;
173 : struct dirent *direntry;
174 : AclResult aclresult;
175 :
176 : /*
177 : * User must be a member of pg_read_all_stats or have CREATE privilege for
178 : * target tablespace, either explicitly granted or implicitly because it
179 : * is default for current database.
180 : */
181 0 : if (tblspcOid != MyDatabaseTableSpace &&
182 0 : !is_member_of_role(GetUserId(), DEFAULT_ROLE_READ_ALL_STATS))
183 : {
184 0 : aclresult = pg_tablespace_aclcheck(tblspcOid, GetUserId(), ACL_CREATE);
185 0 : if (aclresult != ACLCHECK_OK)
186 0 : aclcheck_error(aclresult, OBJECT_TABLESPACE,
187 0 : get_tablespace_name(tblspcOid));
188 : }
189 :
190 0 : if (tblspcOid == DEFAULTTABLESPACE_OID)
191 0 : snprintf(tblspcPath, MAXPGPATH, "base");
192 0 : else if (tblspcOid == GLOBALTABLESPACE_OID)
193 0 : snprintf(tblspcPath, MAXPGPATH, "global");
194 : else
195 0 : snprintf(tblspcPath, MAXPGPATH, "pg_tblspc/%u/%s", tblspcOid,
196 : TABLESPACE_VERSION_DIRECTORY);
197 :
198 0 : dirdesc = AllocateDir(tblspcPath);
199 :
200 0 : if (!dirdesc)
201 0 : return -1;
202 :
203 0 : while ((direntry = ReadDir(dirdesc, tblspcPath)) != NULL)
204 : {
205 : struct stat fst;
206 :
207 0 : CHECK_FOR_INTERRUPTS();
208 :
209 0 : if (strcmp(direntry->d_name, ".") == 0 ||
210 0 : strcmp(direntry->d_name, "..") == 0)
211 0 : continue;
212 :
213 0 : snprintf(pathname, sizeof(pathname), "%s/%s", tblspcPath, direntry->d_name);
214 :
215 0 : if (stat(pathname, &fst) < 0)
216 : {
217 0 : if (errno == ENOENT)
218 0 : continue;
219 : else
220 0 : ereport(ERROR,
221 : (errcode_for_file_access(),
222 : errmsg("could not stat file \"%s\": %m", pathname)));
223 : }
224 :
225 0 : if (S_ISDIR(fst.st_mode))
226 0 : totalsize += db_dir_size(pathname);
227 :
228 0 : totalsize += fst.st_size;
229 : }
230 :
231 0 : FreeDir(dirdesc);
232 :
233 0 : return totalsize;
234 : }
235 :
236 : Datum
237 0 : pg_tablespace_size_oid(PG_FUNCTION_ARGS)
238 : {
239 0 : Oid tblspcOid = PG_GETARG_OID(0);
240 : int64 size;
241 :
242 0 : size = calculate_tablespace_size(tblspcOid);
243 :
244 0 : if (size < 0)
245 0 : PG_RETURN_NULL();
246 :
247 0 : PG_RETURN_INT64(size);
248 : }
249 :
250 : Datum
251 0 : pg_tablespace_size_name(PG_FUNCTION_ARGS)
252 : {
253 0 : Name tblspcName = PG_GETARG_NAME(0);
254 0 : Oid tblspcOid = get_tablespace_oid(NameStr(*tblspcName), false);
255 : int64 size;
256 :
257 0 : size = calculate_tablespace_size(tblspcOid);
258 :
259 0 : if (size < 0)
260 0 : PG_RETURN_NULL();
261 :
262 0 : PG_RETURN_INT64(size);
263 : }
264 :
265 :
266 : /*
267 : * calculate size of (one fork of) a relation
268 : *
269 : * Note: we can safely apply this to temp tables of other sessions, so there
270 : * is no check here or at the call sites for that.
271 : */
272 : static int64
273 278 : calculate_relation_size(RelFileNode *rfn, BackendId backend, ForkNumber forknum)
274 : {
275 278 : int64 totalsize = 0;
276 : char *relationpath;
277 : char pathname[MAXPGPATH];
278 278 : unsigned int segcount = 0;
279 :
280 278 : relationpath = relpathbackend(*rfn, backend, forknum);
281 :
282 278 : for (segcount = 0;; segcount++)
283 122 : {
284 : struct stat fst;
285 :
286 400 : CHECK_FOR_INTERRUPTS();
287 :
288 400 : if (segcount == 0)
289 278 : snprintf(pathname, MAXPGPATH, "%s",
290 : relationpath);
291 : else
292 122 : snprintf(pathname, MAXPGPATH, "%s.%u",
293 : relationpath, segcount);
294 :
295 400 : if (stat(pathname, &fst) < 0)
296 : {
297 278 : if (errno == ENOENT)
298 278 : break;
299 : else
300 0 : ereport(ERROR,
301 : (errcode_for_file_access(),
302 : errmsg("could not stat file \"%s\": %m", pathname)));
303 : }
304 122 : totalsize += fst.st_size;
305 : }
306 :
307 278 : return totalsize;
308 : }
309 :
310 : Datum
311 88 : pg_relation_size(PG_FUNCTION_ARGS)
312 : {
313 88 : Oid relOid = PG_GETARG_OID(0);
314 88 : text *forkName = PG_GETARG_TEXT_PP(1);
315 : Relation rel;
316 : int64 size;
317 :
318 88 : rel = try_relation_open(relOid, AccessShareLock);
319 :
320 : /*
321 : * Before 9.2, we used to throw an error if the relation didn't exist, but
322 : * that makes queries like "SELECT pg_relation_size(oid) FROM pg_class"
323 : * less robust, because while we scan pg_class with an MVCC snapshot,
324 : * someone else might drop the table. It's better to return NULL for
325 : * already-dropped tables than throw an error and abort the whole query.
326 : */
327 88 : if (rel == NULL)
328 2 : PG_RETURN_NULL();
329 :
330 86 : size = calculate_relation_size(&(rel->rd_node), rel->rd_backend,
331 86 : forkname_to_number(text_to_cstring(forkName)));
332 :
333 86 : relation_close(rel, AccessShareLock);
334 :
335 86 : PG_RETURN_INT64(size);
336 : }
337 :
338 : /*
339 : * Calculate total on-disk size of a TOAST relation, including its indexes.
340 : * Must not be applied to non-TOAST relations.
341 : */
342 : static int64
343 0 : calculate_toast_table_size(Oid toastrelid)
344 : {
345 0 : int64 size = 0;
346 : Relation toastRel;
347 : ForkNumber forkNum;
348 : ListCell *lc;
349 : List *indexlist;
350 :
351 0 : toastRel = relation_open(toastrelid, AccessShareLock);
352 :
353 : /* toast heap size, including FSM and VM size */
354 0 : for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
355 0 : size += calculate_relation_size(&(toastRel->rd_node),
356 : toastRel->rd_backend, forkNum);
357 :
358 : /* toast index size, including FSM and VM size */
359 0 : indexlist = RelationGetIndexList(toastRel);
360 :
361 : /* Size is calculated using all the indexes available */
362 0 : foreach(lc, indexlist)
363 : {
364 : Relation toastIdxRel;
365 :
366 0 : toastIdxRel = relation_open(lfirst_oid(lc),
367 : AccessShareLock);
368 0 : for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
369 0 : size += calculate_relation_size(&(toastIdxRel->rd_node),
370 : toastIdxRel->rd_backend, forkNum);
371 :
372 0 : relation_close(toastIdxRel, AccessShareLock);
373 : }
374 0 : list_free(indexlist);
375 0 : relation_close(toastRel, AccessShareLock);
376 :
377 0 : return size;
378 : }
379 :
380 : /*
381 : * Calculate total on-disk size of a given table,
382 : * including FSM and VM, plus TOAST table if any.
383 : * Indexes other than the TOAST table's index are not included.
384 : *
385 : * Note that this also behaves sanely if applied to an index or toast table;
386 : * those won't have attached toast tables, but they can have multiple forks.
387 : */
388 : static int64
389 48 : calculate_table_size(Relation rel)
390 : {
391 48 : int64 size = 0;
392 : ForkNumber forkNum;
393 :
394 : /*
395 : * heap size, including FSM and VM
396 : */
397 240 : for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
398 192 : size += calculate_relation_size(&(rel->rd_node), rel->rd_backend,
399 : forkNum);
400 :
401 : /*
402 : * Size of toast relation
403 : */
404 48 : if (OidIsValid(rel->rd_rel->reltoastrelid))
405 0 : size += calculate_toast_table_size(rel->rd_rel->reltoastrelid);
406 :
407 48 : return size;
408 : }
409 :
410 : /*
411 : * Calculate total on-disk size of all indexes attached to the given table.
412 : *
413 : * Can be applied safely to an index, but you'll just get zero.
414 : */
415 : static int64
416 0 : calculate_indexes_size(Relation rel)
417 : {
418 0 : int64 size = 0;
419 :
420 : /*
421 : * Aggregate all indexes on the given relation
422 : */
423 0 : if (rel->rd_rel->relhasindex)
424 : {
425 0 : List *index_oids = RelationGetIndexList(rel);
426 : ListCell *cell;
427 :
428 0 : foreach(cell, index_oids)
429 : {
430 0 : Oid idxOid = lfirst_oid(cell);
431 : Relation idxRel;
432 : ForkNumber forkNum;
433 :
434 0 : idxRel = relation_open(idxOid, AccessShareLock);
435 :
436 0 : for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
437 0 : size += calculate_relation_size(&(idxRel->rd_node),
438 : idxRel->rd_backend,
439 : forkNum);
440 :
441 0 : relation_close(idxRel, AccessShareLock);
442 : }
443 :
444 0 : list_free(index_oids);
445 : }
446 :
447 0 : return size;
448 : }
449 :
450 : Datum
451 48 : pg_table_size(PG_FUNCTION_ARGS)
452 : {
453 48 : Oid relOid = PG_GETARG_OID(0);
454 : Relation rel;
455 : int64 size;
456 :
457 48 : rel = try_relation_open(relOid, AccessShareLock);
458 :
459 48 : if (rel == NULL)
460 0 : PG_RETURN_NULL();
461 :
462 48 : size = calculate_table_size(rel);
463 :
464 48 : relation_close(rel, AccessShareLock);
465 :
466 48 : PG_RETURN_INT64(size);
467 : }
468 :
469 : Datum
470 0 : pg_indexes_size(PG_FUNCTION_ARGS)
471 : {
472 0 : Oid relOid = PG_GETARG_OID(0);
473 : Relation rel;
474 : int64 size;
475 :
476 0 : rel = try_relation_open(relOid, AccessShareLock);
477 :
478 0 : if (rel == NULL)
479 0 : PG_RETURN_NULL();
480 :
481 0 : size = calculate_indexes_size(rel);
482 :
483 0 : relation_close(rel, AccessShareLock);
484 :
485 0 : PG_RETURN_INT64(size);
486 : }
487 :
488 : /*
489 : * Compute the on-disk size of all files for the relation,
490 : * including heap data, index data, toast data, FSM, VM.
491 : */
492 : static int64
493 0 : calculate_total_relation_size(Relation rel)
494 : {
495 : int64 size;
496 :
497 : /*
498 : * Aggregate the table size, this includes size of the heap, toast and
499 : * toast index with free space and visibility map
500 : */
501 0 : size = calculate_table_size(rel);
502 :
503 : /*
504 : * Add size of all attached indexes as well
505 : */
506 0 : size += calculate_indexes_size(rel);
507 :
508 0 : return size;
509 : }
510 :
511 : Datum
512 0 : pg_total_relation_size(PG_FUNCTION_ARGS)
513 : {
514 0 : Oid relOid = PG_GETARG_OID(0);
515 : Relation rel;
516 : int64 size;
517 :
518 0 : rel = try_relation_open(relOid, AccessShareLock);
519 :
520 0 : if (rel == NULL)
521 0 : PG_RETURN_NULL();
522 :
523 0 : size = calculate_total_relation_size(rel);
524 :
525 0 : relation_close(rel, AccessShareLock);
526 :
527 0 : PG_RETURN_INT64(size);
528 : }
529 :
530 : /*
531 : * formatting with size units
532 : */
533 : Datum
534 96 : pg_size_pretty(PG_FUNCTION_ARGS)
535 : {
536 96 : int64 size = PG_GETARG_INT64(0);
537 : char buf[64];
538 96 : int64 limit = 10 * 1024;
539 96 : int64 limit2 = limit * 2 - 1;
540 :
541 96 : if (Abs(size) < limit)
542 64 : snprintf(buf, sizeof(buf), INT64_FORMAT " bytes", size);
543 : else
544 : {
545 32 : size >>= 9; /* keep one extra bit for rounding */
546 32 : if (Abs(size) < limit2)
547 8 : snprintf(buf, sizeof(buf), INT64_FORMAT " kB",
548 8 : half_rounded(size));
549 : else
550 : {
551 24 : size >>= 10;
552 24 : if (Abs(size) < limit2)
553 8 : snprintf(buf, sizeof(buf), INT64_FORMAT " MB",
554 8 : half_rounded(size));
555 : else
556 : {
557 16 : size >>= 10;
558 16 : if (Abs(size) < limit2)
559 8 : snprintf(buf, sizeof(buf), INT64_FORMAT " GB",
560 8 : half_rounded(size));
561 : else
562 : {
563 8 : size >>= 10;
564 8 : snprintf(buf, sizeof(buf), INT64_FORMAT " TB",
565 8 : half_rounded(size));
566 : }
567 : }
568 : }
569 : }
570 :
571 96 : PG_RETURN_TEXT_P(cstring_to_text(buf));
572 : }
573 :
574 : static char *
575 96 : numeric_to_cstring(Numeric n)
576 : {
577 96 : Datum d = NumericGetDatum(n);
578 :
579 96 : return DatumGetCString(DirectFunctionCall1(numeric_out, d));
580 : }
581 :
582 : static bool
583 240 : numeric_is_less(Numeric a, Numeric b)
584 : {
585 240 : Datum da = NumericGetDatum(a);
586 240 : Datum db = NumericGetDatum(b);
587 :
588 240 : return DatumGetBool(DirectFunctionCall2(numeric_lt, da, db));
589 : }
590 :
591 : static Numeric
592 240 : numeric_absolute(Numeric n)
593 : {
594 240 : Datum d = NumericGetDatum(n);
595 : Datum result;
596 :
597 240 : result = DirectFunctionCall1(numeric_abs, d);
598 240 : return DatumGetNumeric(result);
599 : }
600 :
601 : static Numeric
602 64 : numeric_half_rounded(Numeric n)
603 : {
604 64 : Datum d = NumericGetDatum(n);
605 : Datum zero;
606 : Datum one;
607 : Datum two;
608 : Datum result;
609 :
610 64 : zero = NumericGetDatum(int64_to_numeric(0));
611 64 : one = NumericGetDatum(int64_to_numeric(1));
612 64 : two = NumericGetDatum(int64_to_numeric(2));
613 :
614 64 : if (DatumGetBool(DirectFunctionCall2(numeric_ge, d, zero)))
615 32 : d = DirectFunctionCall2(numeric_add, d, one);
616 : else
617 32 : d = DirectFunctionCall2(numeric_sub, d, one);
618 :
619 64 : result = DirectFunctionCall2(numeric_div_trunc, d, two);
620 64 : return DatumGetNumeric(result);
621 : }
622 :
623 : static Numeric
624 160 : numeric_shift_right(Numeric n, unsigned count)
625 : {
626 160 : Datum d = NumericGetDatum(n);
627 : Datum divisor_numeric;
628 : Datum result;
629 :
630 160 : divisor_numeric = NumericGetDatum(int64_to_numeric(((int64) 1) << count));
631 160 : result = DirectFunctionCall2(numeric_div_trunc, d, divisor_numeric);
632 160 : return DatumGetNumeric(result);
633 : }
634 :
635 : Datum
636 96 : pg_size_pretty_numeric(PG_FUNCTION_ARGS)
637 : {
638 96 : Numeric size = PG_GETARG_NUMERIC(0);
639 : Numeric limit,
640 : limit2;
641 : char *result;
642 :
643 96 : limit = int64_to_numeric(10 * 1024);
644 96 : limit2 = int64_to_numeric(10 * 1024 * 2 - 1);
645 :
646 96 : if (numeric_is_less(numeric_absolute(size), limit))
647 : {
648 32 : result = psprintf("%s bytes", numeric_to_cstring(size));
649 : }
650 : else
651 : {
652 : /* keep one extra bit for rounding */
653 : /* size >>= 9 */
654 64 : size = numeric_shift_right(size, 9);
655 :
656 64 : if (numeric_is_less(numeric_absolute(size), limit2))
657 : {
658 16 : size = numeric_half_rounded(size);
659 16 : result = psprintf("%s kB", numeric_to_cstring(size));
660 : }
661 : else
662 : {
663 : /* size >>= 10 */
664 48 : size = numeric_shift_right(size, 10);
665 48 : if (numeric_is_less(numeric_absolute(size), limit2))
666 : {
667 16 : size = numeric_half_rounded(size);
668 16 : result = psprintf("%s MB", numeric_to_cstring(size));
669 : }
670 : else
671 : {
672 : /* size >>= 10 */
673 32 : size = numeric_shift_right(size, 10);
674 :
675 32 : if (numeric_is_less(numeric_absolute(size), limit2))
676 : {
677 16 : size = numeric_half_rounded(size);
678 16 : result = psprintf("%s GB", numeric_to_cstring(size));
679 : }
680 : else
681 : {
682 : /* size >>= 10 */
683 16 : size = numeric_shift_right(size, 10);
684 16 : size = numeric_half_rounded(size);
685 16 : result = psprintf("%s TB", numeric_to_cstring(size));
686 : }
687 : }
688 : }
689 : }
690 :
691 96 : PG_RETURN_TEXT_P(cstring_to_text(result));
692 : }
693 :
694 : /*
695 : * Convert a human-readable size to a size in bytes
696 : */
697 : Datum
698 204 : pg_size_bytes(PG_FUNCTION_ARGS)
699 : {
700 204 : text *arg = PG_GETARG_TEXT_PP(0);
701 : char *str,
702 : *strptr,
703 : *endptr;
704 : char saved_char;
705 : Numeric num;
706 : int64 result;
707 204 : bool have_digits = false;
708 :
709 204 : str = text_to_cstring(arg);
710 :
711 : /* Skip leading whitespace */
712 204 : strptr = str;
713 216 : while (isspace((unsigned char) *strptr))
714 12 : strptr++;
715 :
716 : /* Check that we have a valid number and determine where it ends */
717 204 : endptr = strptr;
718 :
719 : /* Part (1): sign */
720 204 : if (*endptr == '-' || *endptr == '+')
721 88 : endptr++;
722 :
723 : /* Part (2): main digit string */
724 204 : if (isdigit((unsigned char) *endptr))
725 : {
726 156 : have_digits = true;
727 : do
728 300 : endptr++;
729 300 : while (isdigit((unsigned char) *endptr));
730 : }
731 :
732 : /* Part (3): optional decimal point and fractional digits */
733 204 : if (*endptr == '.')
734 : {
735 68 : endptr++;
736 68 : if (isdigit((unsigned char) *endptr))
737 : {
738 32 : have_digits = true;
739 : do
740 32 : endptr++;
741 32 : while (isdigit((unsigned char) *endptr));
742 : }
743 : }
744 :
745 : /* Complain if we don't have a valid number at this point */
746 204 : if (!have_digits)
747 32 : ereport(ERROR,
748 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
749 : errmsg("invalid size: \"%s\"", str)));
750 :
751 : /* Part (4): optional exponent */
752 172 : if (*endptr == 'e' || *endptr == 'E')
753 : {
754 : long exponent;
755 : char *cp;
756 :
757 : /*
758 : * Note we might one day support EB units, so if what follows 'E'
759 : * isn't a number, just treat it all as a unit to be parsed.
760 : */
761 20 : exponent = strtol(endptr + 1, &cp, 10);
762 : (void) exponent; /* Silence -Wunused-result warnings */
763 20 : if (cp > endptr + 1)
764 20 : endptr = cp;
765 : }
766 :
767 : /*
768 : * Parse the number, saving the next character, which may be the first
769 : * character of the unit string.
770 : */
771 172 : saved_char = *endptr;
772 172 : *endptr = '\0';
773 :
774 172 : num = DatumGetNumeric(DirectFunctionCall3(numeric_in,
775 : CStringGetDatum(strptr),
776 : ObjectIdGetDatum(InvalidOid),
777 : Int32GetDatum(-1)));
778 :
779 168 : *endptr = saved_char;
780 :
781 : /* Skip whitespace between number and unit */
782 168 : strptr = endptr;
783 248 : while (isspace((unsigned char) *strptr))
784 80 : strptr++;
785 :
786 : /* Handle possible unit */
787 168 : if (*strptr != '\0')
788 : {
789 140 : int64 multiplier = 0;
790 :
791 : /* Trim any trailing whitespace */
792 140 : endptr = str + VARSIZE_ANY_EXHDR(arg) - 1;
793 :
794 168 : while (isspace((unsigned char) *endptr))
795 28 : endptr--;
796 :
797 140 : endptr++;
798 140 : *endptr = '\0';
799 :
800 : /* Parse the unit case-insensitively */
801 140 : if (pg_strcasecmp(strptr, "bytes") == 0)
802 12 : multiplier = (int64) 1;
803 128 : else if (pg_strcasecmp(strptr, "kb") == 0)
804 28 : multiplier = (int64) 1024;
805 100 : else if (pg_strcasecmp(strptr, "mb") == 0)
806 24 : multiplier = ((int64) 1024) * 1024;
807 :
808 76 : else if (pg_strcasecmp(strptr, "gb") == 0)
809 32 : multiplier = ((int64) 1024) * 1024 * 1024;
810 :
811 44 : else if (pg_strcasecmp(strptr, "tb") == 0)
812 24 : multiplier = ((int64) 1024) * 1024 * 1024 * 1024;
813 :
814 : else
815 20 : ereport(ERROR,
816 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
817 : errmsg("invalid size: \"%s\"", text_to_cstring(arg)),
818 : errdetail("Invalid size unit: \"%s\".", strptr),
819 : errhint("Valid units are \"bytes\", \"kB\", \"MB\", \"GB\", and \"TB\".")));
820 :
821 120 : if (multiplier > 1)
822 : {
823 : Numeric mul_num;
824 :
825 108 : mul_num = int64_to_numeric(multiplier);
826 :
827 108 : num = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
828 : NumericGetDatum(mul_num),
829 : NumericGetDatum(num)));
830 : }
831 : }
832 :
833 148 : result = DatumGetInt64(DirectFunctionCall1(numeric_int8,
834 : NumericGetDatum(num)));
835 :
836 140 : PG_RETURN_INT64(result);
837 : }
838 :
839 : /*
840 : * Get the filenode of a relation
841 : *
842 : * This is expected to be used in queries like
843 : * SELECT pg_relation_filenode(oid) FROM pg_class;
844 : * That leads to a couple of choices. We work from the pg_class row alone
845 : * rather than actually opening each relation, for efficiency. We don't
846 : * fail if we can't find the relation --- some rows might be visible in
847 : * the query's MVCC snapshot even though the relations have been dropped.
848 : * (Note: we could avoid using the catcache, but there's little point
849 : * because the relation mapper also works "in the now".) We also don't
850 : * fail if the relation doesn't have storage. In all these cases it
851 : * seems better to quietly return NULL.
852 : */
853 : Datum
854 4584 : pg_relation_filenode(PG_FUNCTION_ARGS)
855 : {
856 4584 : Oid relid = PG_GETARG_OID(0);
857 : Oid result;
858 : HeapTuple tuple;
859 : Form_pg_class relform;
860 :
861 4584 : tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
862 4584 : if (!HeapTupleIsValid(tuple))
863 0 : PG_RETURN_NULL();
864 4584 : relform = (Form_pg_class) GETSTRUCT(tuple);
865 :
866 4584 : if (RELKIND_HAS_STORAGE(relform->relkind))
867 : {
868 9168 : if (relform->relfilenode)
869 4344 : result = relform->relfilenode;
870 : else /* Consult the relation mapper */
871 240 : result = RelationMapOidToFilenode(relid,
872 240 : relform->relisshared);
873 : }
874 : else
875 : {
876 : /* no storage, return NULL */
877 0 : result = InvalidOid;
878 : }
879 :
880 4584 : ReleaseSysCache(tuple);
881 :
882 4584 : if (!OidIsValid(result))
883 0 : PG_RETURN_NULL();
884 :
885 4584 : PG_RETURN_OID(result);
886 : }
887 :
888 : /*
889 : * Get the relation via (reltablespace, relfilenode)
890 : *
891 : * This is expected to be used when somebody wants to match an individual file
892 : * on the filesystem back to its table. That's not trivially possible via
893 : * pg_class, because that doesn't contain the relfilenodes of shared and nailed
894 : * tables.
895 : *
896 : * We don't fail but return NULL if we cannot find a mapping.
897 : *
898 : * InvalidOid can be passed instead of the current database's default
899 : * tablespace.
900 : */
901 : Datum
902 4584 : pg_filenode_relation(PG_FUNCTION_ARGS)
903 : {
904 4584 : Oid reltablespace = PG_GETARG_OID(0);
905 4584 : Oid relfilenode = PG_GETARG_OID(1);
906 4584 : Oid heaprel = InvalidOid;
907 :
908 4584 : heaprel = RelidByRelfilenode(reltablespace, relfilenode);
909 :
910 4584 : if (!OidIsValid(heaprel))
911 0 : PG_RETURN_NULL();
912 : else
913 4584 : PG_RETURN_OID(heaprel);
914 : }
915 :
916 : /*
917 : * Get the pathname (relative to $PGDATA) of a relation
918 : *
919 : * See comments for pg_relation_filenode.
920 : */
921 : Datum
922 2802 : pg_relation_filepath(PG_FUNCTION_ARGS)
923 : {
924 2802 : Oid relid = PG_GETARG_OID(0);
925 : HeapTuple tuple;
926 : Form_pg_class relform;
927 : RelFileNode rnode;
928 : BackendId backend;
929 : char *path;
930 :
931 2802 : tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
932 2802 : if (!HeapTupleIsValid(tuple))
933 2 : PG_RETURN_NULL();
934 2800 : relform = (Form_pg_class) GETSTRUCT(tuple);
935 :
936 2800 : if (RELKIND_HAS_STORAGE(relform->relkind))
937 : {
938 : /* This logic should match RelationInitPhysicalAddr */
939 2276 : if (relform->reltablespace)
940 188 : rnode.spcNode = relform->reltablespace;
941 : else
942 2088 : rnode.spcNode = MyDatabaseTableSpace;
943 2276 : if (rnode.spcNode == GLOBALTABLESPACE_OID)
944 172 : rnode.dbNode = InvalidOid;
945 : else
946 2104 : rnode.dbNode = MyDatabaseId;
947 4552 : if (relform->relfilenode)
948 1968 : rnode.relNode = relform->relfilenode;
949 : else /* Consult the relation mapper */
950 308 : rnode.relNode = RelationMapOidToFilenode(relid,
951 308 : relform->relisshared);
952 : }
953 : else
954 : {
955 : /* no storage, return NULL */
956 524 : rnode.relNode = InvalidOid;
957 : /* some compilers generate warnings without these next two lines */
958 524 : rnode.dbNode = InvalidOid;
959 524 : rnode.spcNode = InvalidOid;
960 : }
961 :
962 2800 : if (!OidIsValid(rnode.relNode))
963 : {
964 524 : ReleaseSysCache(tuple);
965 524 : PG_RETURN_NULL();
966 : }
967 :
968 : /* Determine owning backend. */
969 2276 : switch (relform->relpersistence)
970 : {
971 2276 : case RELPERSISTENCE_UNLOGGED:
972 : case RELPERSISTENCE_PERMANENT:
973 2276 : backend = InvalidBackendId;
974 2276 : break;
975 0 : case RELPERSISTENCE_TEMP:
976 0 : if (isTempOrTempToastNamespace(relform->relnamespace))
977 0 : backend = BackendIdForTempRelations();
978 : else
979 : {
980 : /* Do it the hard way. */
981 0 : backend = GetTempNamespaceBackendId(relform->relnamespace);
982 : Assert(backend != InvalidBackendId);
983 : }
984 0 : break;
985 0 : default:
986 0 : elog(ERROR, "invalid relpersistence: %c", relform->relpersistence);
987 : backend = InvalidBackendId; /* placate compiler */
988 : break;
989 : }
990 :
991 2276 : ReleaseSysCache(tuple);
992 :
993 2276 : path = relpathbackend(rnode, backend, MAIN_FORKNUM);
994 :
995 2276 : PG_RETURN_TEXT_P(cstring_to_text(path));
996 : }
|
