1999-04-10 18:48:05 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* vacuumlo.c
|
|
|
|
* This removes orphaned large objects from a database.
|
|
|
|
*
|
2018-01-03 05:30:12 +01:00
|
|
|
* Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1999-04-10 18:48:05 +02:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2010-09-20 22:08:53 +02:00
|
|
|
* contrib/vacuumlo/vacuumlo.c
|
1999-04-10 18:48:05 +02:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
2002-09-05 23:19:13 +02:00
|
|
|
#include "postgres_fe.h"
|
2002-04-24 04:45:51 +02:00
|
|
|
|
1999-04-10 18:48:05 +02:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
2002-09-05 23:19:13 +02:00
|
|
|
#ifdef HAVE_TERMIOS_H
|
|
|
|
#include <termios.h>
|
|
|
|
#endif
|
1999-04-10 18:48:05 +02:00
|
|
|
|
2018-04-08 19:59:52 +02:00
|
|
|
#include "catalog/pg_class_d.h"
|
2017-03-10 05:36:44 +01:00
|
|
|
|
Empty search_path in Autovacuum and non-psql/pgbench clients.
This makes the client programs behave as documented regardless of the
connect-time search_path and regardless of user-created objects. Today,
a malicious user with CREATE permission on a search_path schema can take
control of certain of these clients' queries and invoke arbitrary SQL
functions under the client identity, often a superuser. This is
exploitable in the default configuration, where all users have CREATE
privilege on schema "public".
This changes behavior of user-defined code stored in the database, like
pg_index.indexprs and pg_extension_config_dump(). If they reach code
bearing unqualified names, "does not exist" or "no schema has been
selected to create in" errors might appear. Users may fix such errors
by schema-qualifying affected names. After upgrading, consider watching
server logs for these errors.
The --table arguments of src/bin/scripts clients have been lax; for
example, "vacuumdb -Zt pg_am\;CHECKPOINT" performed a checkpoint. That
now fails, but for now, "vacuumdb -Zt 'pg_am(amname);CHECKPOINT'" still
performs a checkpoint.
Back-patch to 9.3 (all supported versions).
Reviewed by Tom Lane, though this fix strategy was not his first choice.
Reported by Arseniy Sharoglazov.
Security: CVE-2018-1058
2018-02-26 16:39:44 +01:00
|
|
|
#include "fe_utils/connect.h"
|
1999-04-10 18:48:05 +02:00
|
|
|
#include "libpq-fe.h"
|
2014-02-15 20:31:30 +01:00
|
|
|
#include "pg_getopt.h"
|
1999-04-10 18:48:05 +02:00
|
|
|
|
|
|
|
#define BUFSIZE 1024
|
|
|
|
|
2009-02-26 17:02:39 +01:00
|
|
|
enum trivalue
|
|
|
|
{
|
|
|
|
TRI_DEFAULT,
|
|
|
|
TRI_NO,
|
|
|
|
TRI_YES
|
|
|
|
};
|
|
|
|
|
2002-09-04 22:31:48 +02:00
|
|
|
struct _param
|
|
|
|
{
|
|
|
|
char *pg_user;
|
2009-02-26 17:02:39 +01:00
|
|
|
enum trivalue pg_prompt;
|
2002-09-04 22:31:48 +02:00
|
|
|
char *pg_port;
|
|
|
|
char *pg_host;
|
2012-07-04 21:39:33 +02:00
|
|
|
const char *progname;
|
2002-09-04 22:31:48 +02:00
|
|
|
int verbose;
|
|
|
|
int dry_run;
|
2011-08-08 15:12:16 +02:00
|
|
|
long transaction_limit;
|
2002-04-24 04:45:51 +02:00
|
|
|
};
|
|
|
|
|
2017-06-21 20:39:04 +02:00
|
|
|
static int vacuumlo(const char *database, const struct _param *param);
|
2012-03-21 00:05:08 +01:00
|
|
|
static void usage(const char *progname);
|
2002-04-24 04:45:51 +02:00
|
|
|
|
|
|
|
|
1999-04-10 18:48:05 +02:00
|
|
|
|
|
|
|
/*
|
2000-11-21 18:54:21 +01:00
|
|
|
* This vacuums LOs of one database. It returns 0 on success, -1 on failure.
|
1999-04-10 18:48:05 +02:00
|
|
|
*/
|
2012-03-21 00:05:08 +01:00
|
|
|
static int
|
2017-06-21 20:39:04 +02:00
|
|
|
vacuumlo(const char *database, const struct _param *param)
|
1999-04-10 18:48:05 +02:00
|
|
|
{
|
1999-05-25 18:15:34 +02:00
|
|
|
PGconn *conn;
|
|
|
|
PGresult *res,
|
2002-09-04 22:31:48 +02:00
|
|
|
*res2;
|
1999-05-25 18:15:34 +02:00
|
|
|
char buf[BUFSIZE];
|
2011-08-08 15:12:16 +02:00
|
|
|
long matched;
|
|
|
|
long deleted;
|
2002-09-04 22:31:48 +02:00
|
|
|
int i;
|
2007-12-11 03:08:59 +01:00
|
|
|
bool new_pass;
|
2012-06-10 21:20:04 +02:00
|
|
|
bool success = true;
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
static bool have_password = false;
|
|
|
|
static char password[100];
|
2002-09-04 22:31:48 +02:00
|
|
|
|
2012-03-21 00:05:08 +01:00
|
|
|
/* Note: password can be carried over from a previous call */
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
if (param->pg_prompt == TRI_YES && !have_password)
|
|
|
|
{
|
|
|
|
simple_prompt("Password: ", password, sizeof(password), false);
|
|
|
|
have_password = true;
|
|
|
|
}
|
2007-12-11 03:08:59 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Start the connection. Loop until we have a password if requested by
|
|
|
|
* backend.
|
|
|
|
*/
|
|
|
|
do
|
2002-09-04 22:31:48 +02:00
|
|
|
{
|
2013-05-29 22:58:43 +02:00
|
|
|
#define PARAMS_ARRAY_SIZE 7
|
2012-07-04 21:39:33 +02:00
|
|
|
|
|
|
|
const char *keywords[PARAMS_ARRAY_SIZE];
|
|
|
|
const char *values[PARAMS_ARRAY_SIZE];
|
|
|
|
|
|
|
|
keywords[0] = "host";
|
|
|
|
values[0] = param->pg_host;
|
|
|
|
keywords[1] = "port";
|
|
|
|
values[1] = param->pg_port;
|
|
|
|
keywords[2] = "user";
|
|
|
|
values[2] = param->pg_user;
|
|
|
|
keywords[3] = "password";
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
values[3] = have_password ? password : NULL;
|
2012-07-04 21:39:33 +02:00
|
|
|
keywords[4] = "dbname";
|
|
|
|
values[4] = database;
|
|
|
|
keywords[5] = "fallback_application_name";
|
|
|
|
values[5] = param->progname;
|
|
|
|
keywords[6] = NULL;
|
|
|
|
values[6] = NULL;
|
2007-12-11 03:08:59 +01:00
|
|
|
|
2012-07-04 21:39:33 +02:00
|
|
|
new_pass = false;
|
|
|
|
conn = PQconnectdbParams(keywords, values, true);
|
2007-12-11 03:08:59 +01:00
|
|
|
if (!conn)
|
2002-09-04 22:31:48 +02:00
|
|
|
{
|
2007-12-11 03:08:59 +01:00
|
|
|
fprintf(stderr, "Connection to database \"%s\" failed\n",
|
|
|
|
database);
|
|
|
|
return -1;
|
2002-04-24 04:45:51 +02:00
|
|
|
}
|
|
|
|
|
2007-12-11 03:08:59 +01:00
|
|
|
if (PQstatus(conn) == CONNECTION_BAD &&
|
|
|
|
PQconnectionNeedsPassword(conn) &&
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
!have_password &&
|
2009-02-26 17:02:39 +01:00
|
|
|
param->pg_prompt != TRI_NO)
|
2007-12-11 03:08:59 +01:00
|
|
|
{
|
|
|
|
PQfinish(conn);
|
Simplify correct use of simple_prompt().
The previous API for this function had it returning a malloc'd string.
That meant that callers had to check for NULL return, which few of them
were doing, and it also meant that callers had to remember to free()
the string later, which required extra logic in most cases.
Instead, make simple_prompt() write into a buffer supplied by the caller.
Anywhere that the maximum required input length is reasonably small,
which is almost all of the callers, we can just use a local or static
array as the buffer instead of dealing with malloc/free.
A fair number of callers used "pointer == NULL" as a proxy for "haven't
requested the password yet". Maintaining the same behavior requires
adding a separate boolean flag for that, which adds back some of the
complexity we save by removing free()s. Nonetheless, this nets out
at a small reduction in overall code size, and considerably less code
than we would have had if we'd added the missing NULL-return checks
everywhere they were needed.
In passing, clean up the API comment for simple_prompt() and get rid
of a very-unnecessary malloc/free in its Windows code path.
This is nominally a bug fix, but it does not seem worth back-patching,
because the actual risk of an OOM failure in any of these places seems
pretty tiny, and all of them are client-side not server-side anyway.
This patch is by me, but it owes a great deal to Michael Paquier
who identified the problem and drafted a patch for fixing it the
other way.
Discussion: <CAB7nPqRu07Ot6iht9i9KRfYLpDaF2ZuUv5y_+72uP23ZAGysRg@mail.gmail.com>
2016-08-30 23:02:02 +02:00
|
|
|
simple_prompt("Password: ", password, sizeof(password), false);
|
|
|
|
have_password = true;
|
2007-12-11 03:08:59 +01:00
|
|
|
new_pass = true;
|
|
|
|
}
|
|
|
|
} while (new_pass);
|
1999-05-25 18:15:34 +02:00
|
|
|
|
|
|
|
/* check to see that the backend connection was successfully made */
|
|
|
|
if (PQstatus(conn) == CONNECTION_BAD)
|
1999-04-10 18:48:05 +02:00
|
|
|
{
|
2007-12-11 03:08:59 +01:00
|
|
|
fprintf(stderr, "Connection to database \"%s\" failed:\n%s",
|
2021-01-26 20:42:13 +01:00
|
|
|
PQdb(conn) ? PQdb(conn) : "", PQerrorMessage(conn));
|
2000-11-21 18:54:21 +01:00
|
|
|
PQfinish(conn);
|
1999-05-25 18:15:34 +02:00
|
|
|
return -1;
|
1999-04-10 18:48:05 +02:00
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
|
2002-09-04 22:31:48 +02:00
|
|
|
if (param->verbose)
|
|
|
|
{
|
2012-03-21 00:05:08 +01:00
|
|
|
fprintf(stdout, "Connected to database \"%s\"\n", database);
|
2002-09-04 22:31:48 +02:00
|
|
|
if (param->dry_run)
|
|
|
|
fprintf(stdout, "Test run: no large objects will be removed!\n");
|
2002-04-24 04:45:51 +02:00
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
|
Empty search_path in Autovacuum and non-psql/pgbench clients.
This makes the client programs behave as documented regardless of the
connect-time search_path and regardless of user-created objects. Today,
a malicious user with CREATE permission on a search_path schema can take
control of certain of these clients' queries and invoke arbitrary SQL
functions under the client identity, often a superuser. This is
exploitable in the default configuration, where all users have CREATE
privilege on schema "public".
This changes behavior of user-defined code stored in the database, like
pg_index.indexprs and pg_extension_config_dump(). If they reach code
bearing unqualified names, "does not exist" or "no schema has been
selected to create in" errors might appear. Users may fix such errors
by schema-qualifying affected names. After upgrading, consider watching
server logs for these errors.
The --table arguments of src/bin/scripts clients have been lax; for
example, "vacuumdb -Zt pg_am\;CHECKPOINT" performed a checkpoint. That
now fails, but for now, "vacuumdb -Zt 'pg_am(amname);CHECKPOINT'" still
performs a checkpoint.
Back-patch to 9.3 (all supported versions).
Reviewed by Tom Lane, though this fix strategy was not his first choice.
Reported by Arseniy Sharoglazov.
Security: CVE-2018-1058
2018-02-26 16:39:44 +01:00
|
|
|
res = PQexec(conn, ALWAYS_SECURE_SEARCH_PATH_SQL);
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
2002-10-18 20:41:22 +02:00
|
|
|
{
|
2003-09-24 07:38:38 +02:00
|
|
|
fprintf(stderr, "Failed to set search_path:\n");
|
2002-10-18 20:41:22 +02:00
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
PQclear(res);
|
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
/*
|
2000-11-21 18:54:21 +01:00
|
|
|
* First we create and populate the LO temp table
|
1999-05-25 18:15:34 +02:00
|
|
|
*/
|
|
|
|
buf[0] = '\0';
|
2003-09-24 07:38:38 +02:00
|
|
|
strcat(buf, "CREATE TEMP TABLE vacuum_l AS ");
|
2010-02-17 05:19:41 +01:00
|
|
|
if (PQserverVersion(conn) >= 90000)
|
2009-12-14 01:39:11 +01:00
|
|
|
strcat(buf, "SELECT oid AS lo FROM pg_largeobject_metadata");
|
|
|
|
else
|
|
|
|
strcat(buf, "SELECT DISTINCT loid AS lo FROM pg_largeobject");
|
2000-11-21 18:54:21 +01:00
|
|
|
res = PQexec(conn, buf);
|
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Failed to create temp table:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
PQclear(res);
|
2001-03-22 05:01:46 +01:00
|
|
|
|
2000-11-21 18:54:21 +01:00
|
|
|
/*
|
2009-07-14 00:56:30 +02:00
|
|
|
* Analyze the temp table so that planner will generate decent plans for
|
2005-10-15 04:49:52 +02:00
|
|
|
* the DELETEs below.
|
2000-11-21 18:54:21 +01:00
|
|
|
*/
|
|
|
|
buf[0] = '\0';
|
2009-07-14 00:56:30 +02:00
|
|
|
strcat(buf, "ANALYZE vacuum_l");
|
2000-11-21 18:54:21 +01:00
|
|
|
res = PQexec(conn, buf);
|
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
1999-04-10 18:48:05 +02:00
|
|
|
{
|
2000-11-21 18:54:21 +01:00
|
|
|
fprintf(stderr, "Failed to vacuum temp table:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
1999-04-10 18:48:05 +02:00
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
1999-05-25 18:15:34 +02:00
|
|
|
}
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
/*
|
2003-09-24 07:38:38 +02:00
|
|
|
* Now find any candidate tables that have columns of type oid.
|
2000-11-21 18:54:21 +01:00
|
|
|
*
|
2003-08-05 00:03:39 +02:00
|
|
|
* NOTE: we ignore system tables and temp tables by the expedient of
|
|
|
|
* rejecting tables in schemas named 'pg_*'. In particular, the temp
|
2003-08-08 23:42:59 +02:00
|
|
|
* table formed above is ignored, and pg_largeobject will be too. If
|
|
|
|
* either of these were scanned, obviously we'd end up with nothing to
|
|
|
|
* delete...
|
2000-11-21 18:54:21 +01:00
|
|
|
*
|
2001-03-22 05:01:46 +01:00
|
|
|
* NOTE: the system oid column is ignored, as it has attnum < 1. This
|
|
|
|
* shouldn't matter for correctness, but it saves time.
|
1999-05-25 18:15:34 +02:00
|
|
|
*/
|
|
|
|
buf[0] = '\0';
|
2003-09-24 07:38:38 +02:00
|
|
|
strcat(buf, "SELECT s.nspname, c.relname, a.attname ");
|
2003-08-05 00:03:39 +02:00
|
|
|
strcat(buf, "FROM pg_class c, pg_attribute a, pg_namespace s, pg_type t ");
|
2003-09-24 07:38:38 +02:00
|
|
|
strcat(buf, "WHERE a.attnum > 0 AND NOT a.attisdropped ");
|
1999-05-25 18:15:34 +02:00
|
|
|
strcat(buf, " AND a.attrelid = c.oid ");
|
|
|
|
strcat(buf, " AND a.atttypid = t.oid ");
|
2003-08-05 00:03:39 +02:00
|
|
|
strcat(buf, " AND c.relnamespace = s.oid ");
|
2001-09-17 04:30:54 +02:00
|
|
|
strcat(buf, " AND t.typname in ('oid', 'lo') ");
|
2017-03-10 05:36:44 +01:00
|
|
|
strcat(buf, " AND c.relkind in (" CppAsString2(RELKIND_RELATION) ", " CppAsString2(RELKIND_MATVIEW) ")");
|
2006-02-23 23:33:59 +01:00
|
|
|
strcat(buf, " AND s.nspname !~ '^pg_'");
|
2000-11-21 18:54:21 +01:00
|
|
|
res = PQexec(conn, buf);
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
1999-05-25 18:15:34 +02:00
|
|
|
{
|
2000-11-21 18:54:21 +01:00
|
|
|
fprintf(stderr, "Failed to find OID columns:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
1999-04-10 18:48:05 +02:00
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
1999-05-25 18:15:34 +02:00
|
|
|
}
|
2000-11-21 18:54:21 +01:00
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
for (i = 0; i < PQntuples(res); i++)
|
|
|
|
{
|
2003-09-24 07:38:38 +02:00
|
|
|
char *schema,
|
|
|
|
*table,
|
1999-05-25 18:15:34 +02:00
|
|
|
*field;
|
|
|
|
|
2003-09-24 07:38:38 +02:00
|
|
|
schema = PQgetvalue(res, i, 0);
|
|
|
|
table = PQgetvalue(res, i, 1);
|
|
|
|
field = PQgetvalue(res, i, 2);
|
1999-05-25 18:15:34 +02:00
|
|
|
|
2002-04-24 04:45:51 +02:00
|
|
|
if (param->verbose)
|
2003-09-24 07:38:38 +02:00
|
|
|
fprintf(stdout, "Checking %s in %s.%s\n", field, schema, table);
|
2000-11-21 18:54:21 +01:00
|
|
|
|
2012-03-21 00:05:08 +01:00
|
|
|
schema = PQescapeIdentifier(conn, schema, strlen(schema));
|
|
|
|
table = PQescapeIdentifier(conn, table, strlen(table));
|
|
|
|
field = PQescapeIdentifier(conn, field, strlen(field));
|
|
|
|
|
|
|
|
if (!schema || !table || !field)
|
|
|
|
{
|
2016-08-31 00:22:43 +02:00
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
2012-03-21 00:05:08 +01:00
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
2015-01-14 21:14:20 +01:00
|
|
|
if (schema != NULL)
|
|
|
|
PQfreemem(schema);
|
2019-06-07 11:43:55 +02:00
|
|
|
if (table != NULL)
|
2015-01-14 21:14:20 +01:00
|
|
|
PQfreemem(table);
|
2019-06-07 11:43:55 +02:00
|
|
|
if (field != NULL)
|
2015-01-14 21:14:20 +01:00
|
|
|
PQfreemem(field);
|
2012-03-21 00:05:08 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-08-05 00:03:39 +02:00
|
|
|
snprintf(buf, BUFSIZE,
|
|
|
|
"DELETE FROM vacuum_l "
|
2012-03-21 00:05:08 +01:00
|
|
|
"WHERE lo IN (SELECT %s FROM %s.%s)",
|
2003-09-24 07:38:38 +02:00
|
|
|
field, schema, table);
|
2000-11-21 18:54:21 +01:00
|
|
|
res2 = PQexec(conn, buf);
|
1999-05-25 18:15:34 +02:00
|
|
|
if (PQresultStatus(res2) != PGRES_COMMAND_OK)
|
|
|
|
{
|
2003-09-24 07:38:38 +02:00
|
|
|
fprintf(stderr, "Failed to check %s in table %s.%s:\n",
|
|
|
|
field, schema, table);
|
2000-11-21 18:54:21 +01:00
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
1999-05-25 18:15:34 +02:00
|
|
|
PQclear(res2);
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
2015-01-14 21:14:20 +01:00
|
|
|
PQfreemem(schema);
|
|
|
|
PQfreemem(table);
|
|
|
|
PQfreemem(field);
|
1999-05-25 18:15:34 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
PQclear(res2);
|
2012-03-21 00:05:08 +01:00
|
|
|
|
|
|
|
PQfreemem(schema);
|
|
|
|
PQfreemem(table);
|
|
|
|
PQfreemem(field);
|
1999-04-10 18:48:05 +02:00
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
PQclear(res);
|
|
|
|
|
2000-11-21 18:54:21 +01:00
|
|
|
/*
|
2012-03-21 00:05:08 +01:00
|
|
|
* Now, those entries remaining in vacuum_l are orphans. Delete 'em.
|
|
|
|
*
|
|
|
|
* We don't want to run each delete as an individual transaction, because
|
|
|
|
* the commit overhead would be high. However, since 9.0 the backend will
|
|
|
|
* acquire a lock per deleted LO, so deleting too many LOs per transaction
|
2012-06-10 21:20:04 +02:00
|
|
|
* risks running out of room in the shared-memory lock table. Accordingly,
|
|
|
|
* we delete up to transaction_limit LOs per transaction.
|
2000-11-21 18:54:21 +01:00
|
|
|
*/
|
1999-05-25 18:15:34 +02:00
|
|
|
res = PQexec(conn, "begin");
|
2012-03-21 00:05:08 +01:00
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Failed to start transaction:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
buf[0] = '\0';
|
2013-07-15 16:48:44 +02:00
|
|
|
strcat(buf,
|
|
|
|
"DECLARE myportal CURSOR WITH HOLD FOR SELECT lo FROM vacuum_l");
|
2000-11-21 18:54:21 +01:00
|
|
|
res = PQexec(conn, buf);
|
2013-07-15 16:48:44 +02:00
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
1999-04-10 18:48:05 +02:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
fprintf(stderr, "DECLARE CURSOR failed: %s", PQerrorMessage(conn));
|
2000-11-21 18:54:21 +01:00
|
|
|
PQclear(res);
|
1999-05-25 18:15:34 +02:00
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
2013-07-15 16:48:44 +02:00
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
snprintf(buf, BUFSIZE, "FETCH FORWARD %ld IN myportal",
|
|
|
|
param->transaction_limit > 0 ? param->transaction_limit : 1000L);
|
2000-11-21 18:54:21 +01:00
|
|
|
|
|
|
|
deleted = 0;
|
2013-07-15 16:48:44 +02:00
|
|
|
|
2019-03-24 20:13:21 +01:00
|
|
|
do
|
1999-05-25 18:15:34 +02:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
res = PQexec(conn, buf);
|
|
|
|
if (PQresultStatus(res) != PGRES_TUPLES_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "FETCH FORWARD failed: %s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
|
2013-07-15 16:48:44 +02:00
|
|
|
matched = PQntuples(res);
|
|
|
|
if (matched <= 0)
|
1999-05-25 18:15:34 +02:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
/* at end of resultset */
|
|
|
|
PQclear(res);
|
|
|
|
break;
|
1999-05-25 18:15:34 +02:00
|
|
|
}
|
|
|
|
|
2013-07-15 16:48:44 +02:00
|
|
|
for (i = 0; i < matched; i++)
|
2002-09-04 22:31:48 +02:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
Oid lo = atooid(PQgetvalue(res, i, 0));
|
|
|
|
|
|
|
|
if (param->verbose)
|
|
|
|
{
|
|
|
|
fprintf(stdout, "\rRemoving lo %6u ", lo);
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (param->dry_run == 0)
|
2002-09-04 22:31:48 +02:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
if (lo_unlink(conn, lo) < 0)
|
2011-08-08 15:12:16 +02:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
fprintf(stderr, "\nFailed to remove lo %u: ", lo);
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
if (PQtransactionStatus(conn) == PQTRANS_INERROR)
|
|
|
|
{
|
|
|
|
success = false;
|
2019-03-24 20:13:21 +01:00
|
|
|
break; /* out of inner for-loop */
|
2013-07-15 16:48:44 +02:00
|
|
|
}
|
2011-08-08 15:12:16 +02:00
|
|
|
}
|
2013-07-15 16:48:44 +02:00
|
|
|
else
|
|
|
|
deleted++;
|
2002-09-04 22:31:48 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
deleted++;
|
2013-07-15 16:48:44 +02:00
|
|
|
|
|
|
|
if (param->transaction_limit > 0 &&
|
|
|
|
(deleted % param->transaction_limit) == 0)
|
2012-03-21 00:05:08 +01:00
|
|
|
{
|
2013-07-15 16:48:44 +02:00
|
|
|
res2 = PQexec(conn, "commit");
|
|
|
|
if (PQresultStatus(res2) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Failed to commit transaction:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res2);
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-03-21 00:05:08 +01:00
|
|
|
PQclear(res2);
|
2013-07-15 16:48:44 +02:00
|
|
|
res2 = PQexec(conn, "begin");
|
|
|
|
if (PQresultStatus(res2) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Failed to start transaction:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res2);
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
2012-03-21 00:05:08 +01:00
|
|
|
PQclear(res2);
|
|
|
|
}
|
|
|
|
}
|
2013-07-15 16:48:44 +02:00
|
|
|
|
|
|
|
PQclear(res);
|
2019-03-24 20:13:21 +01:00
|
|
|
} while (success);
|
1999-05-25 18:15:34 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* That's all folks!
|
|
|
|
*/
|
2012-03-21 00:05:08 +01:00
|
|
|
res = PQexec(conn, "commit");
|
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "Failed to commit transaction:\n");
|
|
|
|
fprintf(stderr, "%s", PQerrorMessage(conn));
|
|
|
|
PQclear(res);
|
|
|
|
PQfinish(conn);
|
|
|
|
return -1;
|
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
PQclear(res);
|
2000-11-21 18:54:21 +01:00
|
|
|
|
1999-05-25 18:15:34 +02:00
|
|
|
PQfinish(conn);
|
|
|
|
|
2002-04-24 04:45:51 +02:00
|
|
|
if (param->verbose)
|
2011-08-08 15:12:16 +02:00
|
|
|
{
|
|
|
|
if (param->dry_run)
|
2012-03-21 00:05:08 +01:00
|
|
|
fprintf(stdout, "\rWould remove %ld large objects from database \"%s\".\n",
|
2011-08-08 15:12:16 +02:00
|
|
|
deleted, database);
|
|
|
|
else if (success)
|
|
|
|
fprintf(stdout,
|
2012-03-21 00:05:08 +01:00
|
|
|
"\rSuccessfully removed %ld large objects from database \"%s\".\n",
|
2011-08-08 15:12:16 +02:00
|
|
|
deleted, database);
|
|
|
|
else
|
2012-03-21 00:05:08 +01:00
|
|
|
fprintf(stdout, "\rRemoval from database \"%s\" failed at object %ld of %ld.\n",
|
2011-08-08 15:12:16 +02:00
|
|
|
database, deleted, matched);
|
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
|
2011-08-08 15:12:16 +02:00
|
|
|
return ((param->dry_run || success) ? 0 : -1);
|
1999-04-10 18:48:05 +02:00
|
|
|
}
|
|
|
|
|
2012-03-21 00:05:08 +01:00
|
|
|
static void
|
2009-02-27 10:30:21 +01:00
|
|
|
usage(const char *progname)
|
2002-09-04 22:31:48 +02:00
|
|
|
{
|
2009-02-27 10:30:21 +01:00
|
|
|
printf("%s removes unreferenced large objects from databases.\n\n", progname);
|
|
|
|
printf("Usage:\n %s [OPTION]... DBNAME...\n\n", progname);
|
2009-02-25 14:34:32 +01:00
|
|
|
printf("Options:\n");
|
2012-06-18 01:44:00 +02:00
|
|
|
printf(" -l LIMIT commit after removing each LIMIT large objects\n");
|
|
|
|
printf(" -n don't remove large objects, just show what would be done\n");
|
|
|
|
printf(" -v write a lot of progress messages\n");
|
|
|
|
printf(" -V, --version output version information, then exit\n");
|
|
|
|
printf(" -?, --help show this help, then exit\n");
|
|
|
|
printf("\nConnection options:\n");
|
|
|
|
printf(" -h HOSTNAME database server host or socket directory\n");
|
|
|
|
printf(" -p PORT database server port\n");
|
|
|
|
printf(" -U USERNAME user name to connect as\n");
|
|
|
|
printf(" -w never prompt for password\n");
|
|
|
|
printf(" -W force password prompt\n");
|
2009-02-25 14:34:32 +01:00
|
|
|
printf("\n");
|
2009-02-27 10:30:21 +01:00
|
|
|
printf("Report bugs to <pgsql-bugs@postgresql.org>.\n");
|
2002-04-24 04:45:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-04-10 18:48:05 +02:00
|
|
|
int
|
|
|
|
main(int argc, char **argv)
|
|
|
|
{
|
1999-05-25 18:15:34 +02:00
|
|
|
int rc = 0;
|
2002-09-04 22:31:48 +02:00
|
|
|
struct _param param;
|
|
|
|
int c;
|
|
|
|
int port;
|
2009-02-27 10:30:21 +01:00
|
|
|
const char *progname;
|
|
|
|
|
|
|
|
progname = get_progname(argv[0]);
|
1999-05-25 18:15:34 +02:00
|
|
|
|
2012-03-21 00:05:08 +01:00
|
|
|
/* Set default parameter values */
|
2002-09-04 22:31:48 +02:00
|
|
|
param.pg_user = NULL;
|
2009-02-26 17:02:39 +01:00
|
|
|
param.pg_prompt = TRI_DEFAULT;
|
2002-04-24 04:45:51 +02:00
|
|
|
param.pg_host = NULL;
|
2004-11-09 07:09:40 +01:00
|
|
|
param.pg_port = NULL;
|
2012-07-04 21:39:33 +02:00
|
|
|
param.progname = progname;
|
2002-09-04 22:31:48 +02:00
|
|
|
param.verbose = 0;
|
2002-04-24 04:45:51 +02:00
|
|
|
param.dry_run = 0;
|
2012-03-21 00:05:08 +01:00
|
|
|
param.transaction_limit = 1000;
|
2002-04-24 04:45:51 +02:00
|
|
|
|
2012-03-21 00:05:08 +01:00
|
|
|
/* Process command-line arguments */
|
2009-02-27 10:30:21 +01:00
|
|
|
if (argc > 1)
|
|
|
|
{
|
|
|
|
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
|
|
|
|
{
|
|
|
|
usage(progname);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
|
|
|
|
{
|
|
|
|
puts("vacuumlo (PostgreSQL) " PG_VERSION);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-09-04 22:31:48 +02:00
|
|
|
while (1)
|
|
|
|
{
|
2011-08-08 15:12:16 +02:00
|
|
|
c = getopt(argc, argv, "h:l:U:p:vnwW");
|
2002-09-04 22:31:48 +02:00
|
|
|
if (c == -1)
|
|
|
|
break;
|
|
|
|
|
|
|
|
switch (c)
|
|
|
|
{
|
|
|
|
case '?':
|
2009-02-27 10:30:21 +01:00
|
|
|
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
|
2002-09-04 22:31:48 +02:00
|
|
|
exit(1);
|
|
|
|
case ':':
|
|
|
|
exit(1);
|
|
|
|
case 'v':
|
|
|
|
param.verbose = 1;
|
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
param.dry_run = 1;
|
|
|
|
param.verbose = 1;
|
|
|
|
break;
|
2012-03-21 00:05:08 +01:00
|
|
|
case 'l':
|
|
|
|
param.transaction_limit = strtol(optarg, NULL, 10);
|
|
|
|
if (param.transaction_limit < 0)
|
|
|
|
{
|
|
|
|
fprintf(stderr,
|
2012-06-10 21:20:04 +02:00
|
|
|
"%s: transaction limit must not be negative (0 disables)\n",
|
|
|
|
progname);
|
2012-03-21 00:05:08 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
break;
|
2002-09-04 22:31:48 +02:00
|
|
|
case 'U':
|
2016-08-31 00:22:43 +02:00
|
|
|
param.pg_user = pg_strdup(optarg);
|
2002-09-04 22:31:48 +02:00
|
|
|
break;
|
2009-02-26 17:02:39 +01:00
|
|
|
case 'w':
|
|
|
|
param.pg_prompt = TRI_NO;
|
|
|
|
break;
|
2002-09-04 22:31:48 +02:00
|
|
|
case 'W':
|
2009-02-26 17:02:39 +01:00
|
|
|
param.pg_prompt = TRI_YES;
|
2002-09-04 22:31:48 +02:00
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
port = strtol(optarg, NULL, 10);
|
|
|
|
if ((port < 1) || (port > 65535))
|
|
|
|
{
|
2009-02-27 10:30:21 +01:00
|
|
|
fprintf(stderr, "%s: invalid port number: %s\n", progname, optarg);
|
2002-09-04 22:31:48 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2016-08-31 00:22:43 +02:00
|
|
|
param.pg_port = pg_strdup(optarg);
|
2002-09-04 22:31:48 +02:00
|
|
|
break;
|
|
|
|
case 'h':
|
2016-08-31 00:22:43 +02:00
|
|
|
param.pg_host = pg_strdup(optarg);
|
2002-09-04 22:31:48 +02:00
|
|
|
break;
|
|
|
|
}
|
2002-04-24 04:45:51 +02:00
|
|
|
}
|
2002-09-04 22:31:48 +02:00
|
|
|
|
2002-04-24 04:45:51 +02:00
|
|
|
/* No database given? Show usage */
|
2002-12-03 08:12:18 +01:00
|
|
|
if (optind >= argc)
|
2002-09-04 22:31:48 +02:00
|
|
|
{
|
|
|
|
fprintf(stderr, "vacuumlo: missing required argument: database name\n");
|
2012-03-21 00:05:08 +01:00
|
|
|
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
|
2002-09-04 22:31:48 +02:00
|
|
|
exit(1);
|
1999-04-10 18:48:05 +02:00
|
|
|
}
|
1999-05-25 18:15:34 +02:00
|
|
|
|
2002-09-04 22:31:48 +02:00
|
|
|
for (c = optind; c < argc; c++)
|
|
|
|
{
|
|
|
|
/* Work on selected database */
|
|
|
|
rc += (vacuumlo(argv[c], ¶m) != 0);
|
1999-05-25 18:15:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
1999-04-10 18:48:05 +02:00
|
|
|
}
|