Comment faire pour obtenir l'actuel, de l'espace disque libre dans Postgres?

J'ai besoin d'être sûr que j'ai au moins 1 go d'espace libre sur le disque avant de commencer à faire des travaux dans ma base de données. Je suis à la recherche de quelque chose comme ceci:

select pg_get_free_disk_space();

Est-il possible? (Je n'ai rien trouvé à ce sujet dans les docs).

PG: 9.3 & OS: Linux/Windows

Pire des cas, vous pourriez probablement écrire un vous-même à l'aide d'un sans restriction de langue de la procédure comme pl/perlU. Vérifiez également pgxn.org si vous ne l'avez pas déjà.
voir cette réponse (question similaire): stackoverflow.com/questions/14346371/...

OriginalL'auteur Christian | 2015-04-22

11

PostgreSQL n'a pas actuellement les fonctionnalités d'exposer directement de l'espace disque.

Pour une chose, le disque? Une production instance PostgreSQL ressemble souvent à ceci:
- /pg/pg94/: un RAID6 de rapide et fiable de stockage sur une batterie de secours contrôleur RAID en mode de balance des blancs, pour les catalogues et les données les plus importantes
- /pg/pg94/pg_xlog: rapide fiable RAID1, pour les journaux de transactions
- /pg/tablespace-lowredundancy: Un RAID 10 de rapide pas cher de stockage pour des choses comme les index et les UNLOGGED tables que vous ne vous inquiétez pas à propos de la perte de sorte que vous pouvez utiliser moins de redondance de stockage
- /pg/tablespace-bulkdata: Un RAID6 ou similaires de la lenteur de près de la ligne magnétique de stockage utilisé pour les vieux journaux d'audit, des données historiques, écrivez-la plupart des données, et d'autres choses qui peuvent être plus lents à l'accès.
- PostgreSQL journaux sont généralement quelque part d'autre encore, mais si cela se remplit, le système peut encore arrêter. Où dépend d'un certain nombre de paramètres de configuration, que vous ne pouvez pas voir à partir de PostgreSQL à tous, comme syslog options.
Puis il y a le fait que l'espace "libre" ne veut pas forcément dire PostgreSQL peut l'utiliser (pense: les quotas de disque, réservée au système de l'espace disque), et le fait que la liberté d' blocs/octets n'est pas la seule contrainte, comme de nombreux systèmes de fichiers ont des limites sur le nombre de fichiers (inodes).

Comment unSELECT pg_get_free_disk_space() rapport à cela?

Sachant que l'espace disque libre pourrait être un problème de sécurité. Si la prise en charge, c'est quelque chose que j'avais seulement être exposé à des super-utilisateur, au moins.

Ce que vous peut faire est d'utiliser un non approuvés langage procédural comme plpythonu de faire des appels de système d'exploitation de s'interroger sur le système d'exploitation hôte pour l'espace disque de l'information, à l'aide de requêtes contre pg_catalog.pg_tablespace et à l'aide de la data_directory réglage de pg_settings à découvrir d'où PostgreSQL est de garder les choses sur le système d'exploitation hôte. Vous devez également vérifier pour les points de montage (unix/Mac) /points de jonction (Windows) pour découvrir si pg_xlog, etc, sont sur de stockage distinct. Ce ne sont pas vraiment vous aider avec de l'espace pour les journaux, mais les.

Que j'aimerais avoir un SELECT * FROM pg_get_free_diskspace qui a signalé le principal datadir de l'espace, et tout les points de montage du ou des points de jonction à l'intérieur comme pour pg_xlog ou pg_clog, et également signalés chaque tablespace et tout les points de montage à l'intérieur. Ce serait un retour de fonction. Quelqu'un qui se soucie assez aurait de la peine de la mettre en œuvre pour toutes les plateformes cibles bien, et maintenant, personne ne veut-il suffisant pour faire le travail.

Dans le temps de le dire, si vous êtes prêt pour simplifier vos besoins:
- Un système de fichiers
- Système d'exploitation UNIX/POSIX-compatible comme Linux
- Il n'y a pas de système de quotas de permis
- Il n'y a pas de racine réservés bloc pourcentage
- inode épuisement n'est pas une préoccupation
alors vous pouvez CREATE LANGUAGE plpython3u; et CREATE FUNCTION un LANGUAGE plpython3u fonction qui fait quelque chose comme:
```
import os
st = os.statvfs(datadir_path)
return st.f_bavail * st.f_frsize
```
dans une fonction qui returns bigint et prend soit datadir_path comme un argument, ou découvre-il en faisant un SPI requête comme SELECT setting FROM pg_settings WHERE name = 'data_directory' de l'intérieur de PL/Python.

Si vous voulez prendre en charge de Windows, voir Croix-plate-forme de l'espace restant sur le volume à l'aide de python . J'aimerais utiliser l'Interface de Gestion Windows (WMI) les requêtes plutôt que d'utiliser ctypes pour appeler l'API de Windows.

Ou vous pourriez utiliser cette fonction, quelqu'un a écrit en PL/Perlu faire à l'aide de df et mount de sortie de la commande de l'analyse, qui ne fonctionnera probablement sur Linux, mais bon, c'est prédéfinies.

Une autre option pourrait être une tâche cron qui crée un fichier texte par exemple, toutes les x minutes qui contient l'espace libre de l'information. Ce fichier texte peut ensuite être mis à disposition par le biais d'un FDW table (ou de la tâche cron insertions/mises à jour des lignes dans une table qui contient les informations)
C'est une excellente réponse! Il y a beaucoup de choses à penser. Merci Craig et "Cheval".

OriginalL'auteur Craig Ringer

Voici un plpython2u mise en œuvre, nous avons été à l'aide pendant un certain temps.

-- NOTE this function is a security definer, so it carries the superuser permissions
-- even when called by the plebs.
-- (required so we can access the data_directory setting.)
CREATE OR REPLACE FUNCTION get_tablespace_disk_usage()
    RETURNS TABLE (
        path VARCHAR,
        bytes_free BIGINT,
        total_bytes BIGINT
    )
AS $$
import os

data_directory = plpy.execute("select setting from pg_settings where name='data_directory';")[0]['setting']
records = []

for t in plpy.execute("select spcname, spcacl, pg_tablespace_location(oid) as path from pg_tablespace"):
    if t['spcacl']:
        # TODO handle ACLs. For now only show public tablespaces.
        continue

    name = t['spcname']
    if name == 'pg_default':
        path = os.path.join(data_directory, 'default')
    elif name == 'pg_global':
        path = os.path.join(data_directory, 'global')
    else:
        path = t['path']

    # not all tablespaces actually seem to exist(?) in particular, pg_default.
    if os.path.exists(path):
        s = os.statvfs(path)
        total_bytes = s.f_blocks * s.f_frsize
        bytes_free = s.f_bavail * s.f_frsize

        records.append((path, bytes_free, total_bytes))

return records

$$ LANGUAGE plpython2u STABLE SECURITY DEFINER;

Utilisation est quelque chose comme:

SELECT path, bytes_free, total_bytes FROM get_tablespace_disk_usage();

OriginalL'auteur craigds

C version pour ceux qui veulent encore un outil pour vérifier l'espace libre sur le serveur postgresql.
Seulement pour Linux et FreeBSD, besoin d'ajouter bon les en-têtes et définit pour les autres Systèmes d'exploitation.

#if defined __FreeBSD__
# include <sys/param.h>
# include <sys/mount.h>
#elif defined __linux__
# define _XOPEN_SOURCE
# define _BSD_SOURCE
# include <sys/vfs.h>
#else
# error Unsupported OS
#endif
#include <postgres.h>
#include <catalog/pg_type.h>
#include <funcapi.h>
#include <utils/builtins.h>
/* Registration:
CREATE FUNCTION disk_free(path TEXT) RETURNS TABLE (
size BIGINT, free BIGINT, available BIGINT, inodes INTEGER, ifree INTEGER, blksize INTEGER
) AS '$pglib/pg_df.so', 'df' LANGUAGE c STRICT;
*/
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif
PG_FUNCTION_INFO_V1(df);
Datum df(PG_FUNCTION_ARGS)
{
TupleDesc tupdesc;
AttInMetadata *attinmeta;
HeapTuple tuple;
Datum result;
char **values;
struct statfs sfs;
const char* path = text_to_cstring(PG_GETARG_TEXT_P(0));
if(get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("function returning record called in context that cannot accept type record")));
attinmeta = TupleDescGetAttInMetadata(tupdesc);
if(0 != statfs(path, &sfs))
ereport(ERROR, (errcode(ERRCODE_INTERNAL_ERROR), errmsg("statfs() system call failed: %m")));
values = (char **) palloc(6 * sizeof(char *));
values[0] = (char *) palloc(20 * sizeof(char));
values[1] = (char *) palloc(20 * sizeof(char));
values[2] = (char *) palloc(20 * sizeof(char));
values[3] = (char *) palloc(10 * sizeof(char));
values[4] = (char *) palloc(10 * sizeof(char));
values[5] = (char *) palloc(10 * sizeof(char));
int64 df_total_bytes = sfs.f_blocks * sfs.f_bsize;
int64 df_free_bytes  = sfs.f_bfree  * sfs.f_bsize;
int64 df_avail_bytes = sfs.f_bavail * sfs.f_bsize;
snprintf(values[0], 20, "%lld", df_total_bytes);
snprintf(values[1], 20, "%lld", df_free_bytes);
snprintf(values[2], 20, "%lld", df_avail_bytes);
snprintf(values[3], 10, "%d", sfs.f_files);
snprintf(values[4], 10, "%d", sfs.f_ffree);
snprintf(values[5], 10, "%d", sfs.f_bsize);
tuple = BuildTupleFromCStrings(attinmeta, values);
return HeapTupleGetDatum(tuple);
}

OriginalL'auteur Vasily Redkin

Vous devez vous connecter pour publier un commentaire.