TODO : Allow parallel cores to be used by vacuumdb [ WIP ]

diff --git a/src/bin/scripts/vac_parallel.c b/src/bin/scripts/vac_parallel.c
new file mode 100644
index 0000000..da56f86
--- /dev/null
+++ b/src/bin/scripts/vac_parallel.c
@@ -0,0 +1,1007 @@
+/*-------------------------------------------------------------------------
+ *
+ * vac_parallel.c
+ *
+ *	Parallel support for the vacuumdb
+ *
+ * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *	The author is not responsible for loss or damages that may
+ *	result from its use.
+ *
+ * IDENTIFICATION
+ *		src/bin/scripts/vac_parallel.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres_fe.h"
+#include "vac_parallel.h"
+
+#ifndef WIN32
+#include <sys/types.h>
+#include <sys/wait.h>
+#include "signal.h"
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+#include "common.h"
+
+#define PIPE_READ							0
+#define PIPE_WRITE							1
+
+/* file-scope variables */
+#ifdef WIN32
+static unsigned int tMasterThreadId = 0;
+static HANDLE termEvent = INVALID_HANDLE_VALUE;
+static int	pgpipe(int handles[2]);
+static int	piperead(int s, char *buf, int len);
+bool		parallel_init_done = false;
+DWORD		mainThreadId;
+
+/*
+ * Structure to hold info passed by _beginthreadex() to the function it calls
+ * via its single allowed argument.
+ */
+typedef struct
+{
+	VacuumOption *vopt;
+	int			worker;
+	int			pipeRead;
+	int			pipeWrite;
+} WorkerInfo;
+
+#define pipewrite(a,b,c)	send(a,b,c,0)
+#else
+/*
+ * aborting is only ever used in the master, the workers are fine with just
+ * wantAbort.
+ */
+static bool aborting = false;
+static volatile sig_atomic_t wantAbort = 0;
+
+#define pgpipe(a)			pipe(a)
+#define piperead(a,b,c)		read(a,b,c)
+#define pipewrite(a,b,c)	write(a,b,c)
+#endif
+
+static const char *modulename = gettext_noop("parallel vacuum");
+
+typedef struct ShutdownInformation
+{
+	ParallelState *pstate;
+	PGconn        *conn;
+} ShutdownInformation;
+
+static ShutdownInformation shutdown_info;
+
+static char *readMessageFromPipe(int fd);
+static void
+SetupWorker(PGconn *connection, int pipefd[2], int worker);
+static void
+WaitForCommands(PGconn * connection, int pipefd[2]);
+static char *
+getMessageFromMaster(int pipefd[2]);
+#define messageStartsWith(msg, prefix) \
+	(strncmp(msg, prefix, strlen(prefix)) == 0)
+#define messageEquals(msg, pattern) \
+	(strcmp(msg, pattern) == 0)
+static char *
+getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+
+static void
+sendMessageToMaster(int pipefd[2], const char *str);
+
+#ifndef WIN32
+static void sigTermHandler(int signum);
+#endif
+
+static ParallelSlot *
+GetMyPSlot(ParallelState *pstate);
+static int
+select_loop(int maxFd, fd_set *workerset);
+void
+exit_horribly(const char *modulename, const char *fmt,...);
+void
+init_parallel_vacuum_utils(void);
+
+static void  exit_nicely(int code);
+
+static bool
+HasEveryWorkerTerminated(ParallelState *pstate);
+
+static ParallelSlot *
+GetMyPSlot(ParallelState *pstate)
+{
+	int			i;
+
+	for (i = 0; i < pstate->numWorkers; i++)
+#ifdef WIN32
+		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+#else
+		if (pstate->parallelSlot[i].pid == getpid())
+#endif
+			return &(pstate->parallelSlot[i]);
+
+	return NULL;
+}
+
+/* Sends the error message from the worker to the master process */
+static void
+parallel_msg_master(ParallelSlot *slot, const char *modulename,
+					const char *fmt, va_list ap)
+{
+	char		buf[512];
+	int			pipefd[2];
+
+	pipefd[PIPE_READ] = slot->pipeRevRead;
+	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+
+	strcpy(buf, "ERROR ");
+	vsnprintf(buf + strlen("ERROR "),
+			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+
+	sendMessageToMaster(pipefd, buf);
+}
+
+/*
+ * Wait for the termination of the processes using the OS-specific method.
+ */
+static void
+WaitForTerminatingWorkers(ParallelState *pstate)
+{
+	while (!HasEveryWorkerTerminated(pstate))
+	{
+		ParallelSlot *slot = NULL;
+		int			j;
+
+#ifndef WIN32
+		int			status;
+		pid_t		pid = wait(&status);
+
+		for (j = 0; j < pstate->numWorkers; j++)
+			if (pstate->parallelSlot[j].pid == pid)
+				slot = &(pstate->parallelSlot[j]);
+#else
+		uintptr_t	hThread;
+		DWORD		ret;
+		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+		int			nrun = 0;
+
+		for (j = 0; j < pstate->numWorkers; j++)
+			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+			{
+				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+				nrun++;
+			}
+		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+		Assert(ret != WAIT_FAILED);
+		hThread = lpHandles[ret - WAIT_OBJECT_0];
+
+		for (j = 0; j < pstate->numWorkers; j++)
+			if (pstate->parallelSlot[j].hThread == hThread)
+				slot = &(pstate->parallelSlot[j]);
+
+		free(lpHandles);
+#endif
+		Assert(slot);
+
+		slot->workerStatus = WRKR_TERMINATED;
+	}
+	Assert(HasEveryWorkerTerminated(pstate));
+}
+
+
+#ifdef WIN32
+static unsigned __stdcall
+init_spawned_worker_win32(WorkerInfo *wi)
+{
+	PGconn *conn;
+	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+	int			worker = wi->worker;
+	VacuumOption *vopt = wi->vopt;
+
+    conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport, vopt->username, 1,
+		vopt->progname, false);
+
+	free(wi);
+	SetupWorker(conn, pipefd, worker);
+	_endthreadex(0);
+	return 0;
+}
+#endif
+
+
+
+ParallelState * ParallelVacuumStart(VacuumOption *vopt, int numWorkers)
+{
+	ParallelState *pstate;
+	int			i;
+	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+
+	Assert(numWorkers > 0);
+
+	/* Ensure stdio state is quiesced before forking */
+	fflush(NULL);
+
+	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+
+	pstate->numWorkers = numWorkers;
+	pstate->parallelSlot = NULL;
+
+	if (numWorkers == 1)
+		return pstate;
+
+	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+	memset((void *) pstate->parallelSlot, 0, slotSize);
+
+	/*
+	 * Set the pstate in the shutdown_info. The exit handler uses pstate if
+	 * set and falls back to AHX otherwise.
+	 */
+#ifdef WIN32
+	tMasterThreadId = GetCurrentThreadId();
+#endif
+
+	for (i = 0; i < pstate->numWorkers; i++)
+	{
+#ifdef WIN32
+		WorkerInfo *wi;
+		uintptr_t	handle;
+#else
+		pid_t		pid;
+#endif
+		int			pipeMW[2],
+					pipeWM[2];
+
+		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+			exit_horribly(modulename,
+						  "could not create communication channels: %s\n",
+						  strerror(errno));
+
+		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+#ifdef WIN32
+		/* Allocate a new structure for every worker */
+		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+		wi->worker = i;
+		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+        wi->vopt = vopt;
+		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+								wi, 0, &(pstate->parallelSlot[i].threadId));
+		pstate->parallelSlot[i].hThread = handle;
+#else
+		pid = fork();
+		if (pid == 0)
+		{
+			/* we are the worker */
+			int			j;
+			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+
+			/*
+			 * Store the fds for the reverse communication in pstate. Actually
+			 * we only use this in case of an error and don't use pstate
+			 * otherwise in the worker process. On Windows we write to the
+			 * global pstate, in Unix we write to our process-local copy but
+			 * that's also where we'd retrieve this information back from.
+			 */
+			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+			pstate->parallelSlot[i].pid = getpid();
+
+			pstate->parallelSlot[i].args->connection
+			        = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+			                          vopt->username, 1,
+			                          vopt->progname, false);
+
+			/* close read end of Worker -> Master */
+			closesocket(pipeWM[PIPE_READ]);
+			/* close write end of Master -> Worker */
+			closesocket(pipeMW[PIPE_WRITE]);
+
+			/*
+			 * Close all inherited fds for communication of the master with
+			 * the other workers.
+			 */
+			for (j = 0; j < i; j++)
+			{
+				closesocket(pstate->parallelSlot[j].pipeRead);
+				closesocket(pstate->parallelSlot[j].pipeWrite);
+			}
+
+			SetupWorker(pstate->parallelSlot[i].args->connection, pipefd, i);
+			exit(0);
+		}
+		else if (pid < 0)
+			/* fork failed */
+			exit_horribly(modulename,
+						  "could not create worker process: %s\n",
+						  strerror(errno));
+
+		/* we are the Master, pid > 0 here */
+		Assert(pid > 0);
+
+		/* close read end of Master -> Worker */
+		closesocket(pipeMW[PIPE_READ]);
+		/* close write end of Worker -> Master */
+		closesocket(pipeWM[PIPE_WRITE]);
+
+		pstate->parallelSlot[i].pid = pid;
+#endif
+
+		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+	}
+
+	return pstate;
+}
+
+/*
+ * Tell all of our workers to terminate.
+ *
+ * Pretty straightforward routine, first we tell everyone to terminate, then
+ * we listen to the workers' replies and finally close the sockets that we
+ * have used for communication.
+ */
+void
+ParallelVacuumEnd(ParallelState *pstate)
+{
+	int			i;
+
+	if (pstate->numWorkers == 1)
+		return;
+
+	Assert(IsEveryWorkerIdle(pstate));
+
+	/* close the sockets so that the workers know they can exit */
+	for (i = 0; i < pstate->numWorkers; i++)
+	{
+		closesocket(pstate->parallelSlot[i].pipeRead);
+		closesocket(pstate->parallelSlot[i].pipeWrite);
+	}
+
+	WaitForTerminatingWorkers(pstate);
+
+	/*
+	 * Remove the pstate again, so the exit handler in the parent will now
+	 * again fall back to closing AH->connection (if connected).
+	 */
+	shutdown_info.pstate = NULL;
+
+	free(pstate->parallelSlot);
+	free(pstate);
+}
+
+
+/*
+ * Find the first free parallel slot (if any).
+ */
+int
+GetIdleWorker(ParallelState *pstate)
+{
+	int			i;
+
+	for (i = 0; i < pstate->numWorkers; i++)
+		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+			return i;
+	return NO_SLOT;
+}
+
+/*
+ * Return true iff every worker process is in the WRKR_TERMINATED state.
+ */
+static bool
+HasEveryWorkerTerminated(ParallelState *pstate)
+{
+	int			i;
+
+	for (i = 0; i < pstate->numWorkers; i++)
+		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+			return false;
+	return true;
+}
+
+
+
+/*
+ * This function is called by both UNIX and Windows variants to set up a
+ * worker process.
+ */
+static void
+SetupWorker(PGconn *connection, int pipefd[2], int worker)
+{
+	/*
+	 * Call the setup worker function that's defined in the ArchiveHandle.
+	 *
+	 * We get the raw connection only for the reason that we can close it
+	 * properly when we shut down. This happens only that way when it is
+	 * brought down because of an error.
+	 */
+	WaitForCommands(connection, pipefd);
+	closesocket(pipefd[PIPE_READ]);
+	closesocket(pipefd[PIPE_WRITE]);
+}
+
+
+
+/*
+ * That's the main routine for the worker.
+ * When it starts up it enters this routine and waits for commands from the
+ * master process. After having processed a command it comes back to here to
+ * wait for the next command. Finally it will receive a TERMINATE command and
+ * exit.
+ */
+static void
+WaitForCommands(PGconn * connection, int pipefd[2])
+{
+	char	   *command;
+
+	for (;;)
+	{
+		if (!(command = getMessageFromMaster(pipefd)))
+		{
+			PQfinish(connection);
+			connection = NULL;
+			return;
+		}
+
+		/*
+		 * The message we return here has been pg_malloc()ed and we are
+		 * responsible for free()ing it.
+		 */
+		if (executeMaintenanceCommand(connection, command, false))
+            sendMessageToMaster(pipefd, "OK");
+        else
+            sendMessageToMaster(pipefd, "ERROR  : Execute failed");
+
+		/* command was pg_malloc'd and we are responsible for free()ing it. */
+		free(command);
+	}
+}
+
+/*
+ * ---------------------------------------------------------------------
+ * Note the status change:
+ *
+ * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+ * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+ * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+ * ---------------------------------------------------------------------
+ *
+ * Just calling ReapWorkerStatus() when all workers are working might or might
+ * not give you an idle worker because you need to call ListenToWorkers() in
+ * between and only thereafter ReapWorkerStatus(). This is necessary in order
+ * to get and deal with the status (=result) of the worker's execution.
+ */
+void
+ListenToWorkers(ParallelState *pstate, bool do_wait)
+{
+	int			worker;
+	char	   *msg;
+
+	msg = getMessageFromWorker(pstate, do_wait, &worker);
+
+	if (!msg)
+	{
+		if (do_wait)
+			exit_horribly(modulename, "a worker process died unexpectedly\n");
+		return;
+	}
+
+	if (messageStartsWith(msg, "OK"))
+	{
+		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+
+	}
+	else if (messageStartsWith(msg, "ERROR "))
+	{
+		pstate->parallelSlot[worker].workerStatus = WRKR_TERMINATED;
+		exit_horribly(modulename, "%s", msg + strlen("ERROR "));
+	}
+	else
+		exit_horribly(modulename, "invalid message received from worker: %s\n", msg);
+
+	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+	free(msg);
+}
+
+/*
+ * This function is executed in the master process.
+ *
+ * This function is used to get the return value of a terminated worker
+ * process. If a process has terminated, its status is stored in *status and
+ * the id of the worker is returned.
+ */
+int
+ReapWorkerStatus(ParallelState *pstate, int *status)
+{
+	int			i;
+
+	for (i = 0; i < pstate->numWorkers; i++)
+	{
+		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+		{
+			*status = pstate->parallelSlot[i].status;
+			pstate->parallelSlot[i].status = 0;
+			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+			return i;
+		}
+	}
+
+	return NO_SLOT;
+}
+
+/*
+ * This function is executed in the master process.
+ *
+ * It looks for an idle worker process and only returns if there is one.
+ */
+void
+EnsureIdleWorker(ParallelState *pstate)
+{
+	int			ret_worker;
+	int			work_status;
+
+	for (;;)
+	{
+		int			nTerm = 0;
+
+		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+		{
+			if (work_status != 0)
+				exit_horribly(modulename, "error processing a parallel work item\n");
+
+			nTerm++;
+		}
+
+		/*
+		 * We need to make sure that we have an idle worker before dispatching
+		 * the next item. If nTerm > 0 we already have that (quick check).
+		 */
+		if (nTerm > 0)
+			return;
+
+		/* explicit check for an idle worker */
+		if (GetIdleWorker(pstate) != NO_SLOT)
+			return;
+
+		/*
+		 * If we have no idle worker, read the result of one or more workers
+		 * and loop the loop to call ReapWorkerStatus() on them
+		 */
+		ListenToWorkers(pstate, true);
+	}
+}
+
+
+/*
+ * Return true iff every worker is in the WRKR_IDLE state.
+ */
+bool
+IsEveryWorkerIdle(ParallelState *pstate)
+{
+	int			i;
+
+	for (i = 0; i < pstate->numWorkers; i++)
+		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+			return false;
+	return true;
+}
+
+
+/*
+ * This function is executed in the master process.
+ *
+ * It waits for all workers to terminate.
+ */
+void
+EnsureWorkersFinished(ParallelState *pstate)
+{
+	int			work_status;
+
+	if (!pstate || pstate->numWorkers == 1)
+		return;
+
+	/* Waiting for the remaining worker processes to finish */
+	while (!IsEveryWorkerIdle(pstate))
+	{
+		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+			ListenToWorkers(pstate, true);
+		else if (work_status != 0)
+			exit_horribly(modulename,
+						  "error processing a parallel work item\n");
+	}
+}
+
+/*
+ * This function is executed in the worker process.
+ *
+ * It returns the next message on the communication channel, blocking until it
+ * becomes available.
+ */
+static char *
+getMessageFromMaster(int pipefd[2])
+{
+	return readMessageFromPipe(pipefd[PIPE_READ]);
+}
+
+/*
+ * This function is executed in the worker process.
+ *
+ * It sends a message to the master on the communication channel.
+ */
+static void
+sendMessageToMaster(int pipefd[2], const char *str)
+{
+	int			len = strlen(str) + 1;
+
+	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+		exit_horribly(modulename,
+					  "could not write to the communication channel: %s\n",
+					  strerror(errno));
+}
+
+/*
+ * This function is executed in the master process.
+ *
+ * It returns the next message from the worker on the communication channel,
+ * optionally blocking (do_wait) until it becomes available.
+ *
+ * The id of the worker is returned in *worker.
+ */
+static char *
+getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+{
+	int			i;
+	fd_set		workerset;
+	int			maxFd = -1;
+	struct timeval nowait = {0, 0};
+
+	FD_ZERO(&workerset);
+
+	for (i = 0; i < pstate->numWorkers; i++)
+	{
+		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+			continue;
+		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+		/* actually WIN32 ignores the first parameter to select()... */
+		if (pstate->parallelSlot[i].pipeRead > maxFd)
+			maxFd = pstate->parallelSlot[i].pipeRead;
+	}
+
+	if (do_wait)
+	{
+		i = select_loop(maxFd, &workerset);
+		Assert(i != 0);
+	}
+	else
+	{
+		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+			return NULL;
+	}
+
+	if (i < 0)
+		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+
+	for (i = 0; i < pstate->numWorkers; i++)
+	{
+		char	   *msg;
+
+		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+			continue;
+
+		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+		*worker = i;
+		return msg;
+	}
+
+	Assert(false);
+	return NULL;
+}
+
+/*
+ * This function is executed in the master process.
+ *
+ * It sends a message to a certain worker on the communication channel.
+ */
+static void
+sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+{
+	int			len = strlen(str) + 1;
+
+	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+	{
+		/*
+		 * If we're already aborting anyway, don't care if we succeed or not.
+		 * The child might have gone already.
+		 */
+#ifndef WIN32
+		if (!aborting)
+#endif
+			exit_horribly(modulename,
+						  "could not write to the communication channel: %s\n",
+						  strerror(errno));
+	}
+}
+
+/*
+ * The underlying function to read a message from the communication channel
+ * (fd) with optional blocking (do_wait).
+ */
+static char *
+readMessageFromPipe(int fd)
+{
+	char	   *msg;
+	int			msgsize,
+				bufsize;
+	int			ret;
+
+	/*
+	 * The problem here is that we need to deal with several possibilites: we
+	 * could receive only a partial message or several messages at once. The
+	 * caller expects us to return exactly one message however.
+	 *
+	 * We could either read in as much as we can and keep track of what we
+	 * delivered back to the caller or we just read byte by byte. Once we see
+	 * (char) 0, we know that it's the message's end. This would be quite
+	 * inefficient for more data but since we are reading only on the command
+	 * channel, the performance loss does not seem worth the trouble of
+	 * keeping internal states for different file descriptors.
+	 */
+	bufsize = 64;				/* could be any number */
+	msg = (char *) pg_malloc(bufsize);
+
+	msgsize = 0;
+	for (;;)
+	{
+		Assert(msgsize <= bufsize);
+		ret = piperead(fd, msg + msgsize, 1);
+
+		/* worker has closed the connection or another error happened */
+		if (ret <= 0)
+			return NULL;
+
+		Assert(ret == 1);
+
+		if (msg[msgsize] == '\0')
+			return msg;
+
+		msgsize++;
+		if (msgsize == bufsize)
+		{
+			/* could be any number */
+			bufsize += 16;
+			msg = (char *) realloc(msg, bufsize);
+		}
+	}
+}
+
+/*
+ * A select loop that repeats calling select until a descriptor in the read
+ * set becomes readable. On Windows we have to check for the termination event
+ * from time to time, on Unix we can just block forever.
+ */
+static int
+select_loop(int maxFd, fd_set *workerset)
+{
+	int			i;
+	fd_set		saveSet = *workerset;
+
+#ifdef WIN32
+	/* should always be the master */
+	Assert(tMasterThreadId == GetCurrentThreadId());
+
+	for (;;)
+	{
+		/*
+		 * sleep a quarter of a second before checking if we should terminate.
+		 */
+		struct timeval tv = {0, 250000};
+
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+
+		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+			continue;
+		if (i)
+			break;
+	}
+#else							/* UNIX */
+
+	for (;;)
+	{
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+
+		/*
+		 * If we Ctrl-C the master process , it's likely that we interrupt
+		 * select() here. The signal handler will set wantAbort == true and
+		 * the shutdown journey starts from here. Note that we'll come back
+		 * here later when we tell all workers to terminate and read their
+		 * responses. But then we have aborting set to true.
+		 */
+		if (wantAbort && !aborting)
+			exit_horribly(modulename, "terminated by user\n");
+
+		if (i < 0 && errno == EINTR)
+			continue;
+		break;
+	}
+#endif
+
+	return i;
+}
+
+void
+DispatchJob(ParallelState *pstate, char * command)
+{
+	int			worker;
+
+	/* our caller makes sure that at least one worker is idle */
+	Assert(GetIdleWorker(pstate) != NO_SLOT);
+	worker = GetIdleWorker(pstate);
+	Assert(worker != NO_SLOT);
+
+	sendMessageToWorker(pstate, worker, command);
+	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+}
+
+#ifdef WIN32
+/*
+ * This is a replacement version of pipe for Win32 which allows returned
+ * handles to be used in select(). Note that read/write calls must be replaced
+ * with recv/send.
+ */
+static int
+pgpipe(int handles[2])
+{
+	SOCKET		s;
+	struct sockaddr_in serv_addr;
+	int			len = sizeof(serv_addr);
+
+	handles[0] = handles[1] = INVALID_SOCKET;
+
+	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+	{
+		return -1;
+	}
+
+	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+	serv_addr.sin_family = AF_INET;
+	serv_addr.sin_port = htons(0);
+	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+	{
+		closesocket(s);
+		return -1;
+	}
+	if (listen(s, 1) == SOCKET_ERROR)
+	{
+		closesocket(s);
+		return -1;
+	}
+	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+	{
+		closesocket(s);
+		return -1;
+	}
+	if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+	{
+		closesocket(s);
+		return -1;
+	}
+
+	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+	{
+		closesocket(s);
+		return -1;
+	}
+	if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
+	{
+		closesocket(handles[1]);
+		handles[1] = INVALID_SOCKET;
+		closesocket(s);
+		return -1;
+	}
+	closesocket(s);
+	return 0;
+}
+
+static int
+piperead(int s, char *buf, int len)
+{
+	int			ret = recv(s, buf, len, 0);
+
+	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+		/* EOF on the pipe! (win32 socket based implementation) */
+		ret = 0;
+	return ret;
+}
+
+#endif
+
+static void
+shutdown_parallel_vacuum_utils()
+{
+#ifdef WIN32
+	/* Call the cleanup function only from the main thread */
+	if (mainThreadId == GetCurrentThreadId())
+		WSACleanup();
+#endif
+}
+
+void
+init_parallel_vacuum_utils(void)
+{
+#ifdef WIN32
+	if (!parallel_init_done)
+	{
+		WSADATA		wsaData;
+		int			err;
+
+		mainThreadId = GetCurrentThreadId();
+		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+		if (err != 0)
+		{
+			exit_nicely(1);
+		}
+		parallel_init_done = true;
+	}
+#endif
+}
+
+void
+on_exit_close_connection(PGconn *conn)
+{
+	shutdown_info.conn = conn;
+}
+
+/*
+ * Fail and die, with a message to stderr.	Parameters as for write_msg.
+ *
+ * This is defined in parallel.c, because in parallel mode, things are more
+ * complicated. If the worker process does exit_horribly(), we forward its
+ * last words to the master process. The master process then does
+ * exit_horribly() with this error message itself and prints it normally.
+ * After printing the message, exit_horribly() on the master will shut down
+ * the remaining worker processes.
+ */
+void
+exit_horribly(const char *modulename, const char *fmt,...)
+{
+    va_list     ap;
+    ParallelState *pstate = shutdown_info.pstate;
+    ParallelSlot *slot;
+
+    va_start(ap, fmt);
+
+    slot = GetMyPSlot(pstate);
+    if (!slot)
+    {
+        /* We're the parent, just write the message out */
+        vfprintf(stderr, _(fmt), ap);
+        ParallelVacuumEnd(pstate);
+        PQfinish(shutdown_info.conn);
+    }
+    else
+    {
+        /* If we're a worker process, send the msg to the master process */
+        parallel_msg_master(slot, modulename, fmt, ap);
+        PQfinish(slot->args->connection);
+    }
+
+    va_end(ap);
+    exit_nicely(1);
+}
+
+static void
+exit_nicely(int code)
+{
+    shutdown_parallel_vacuum_utils();
+	exit(code);
+}
+
+
diff --git a/src/bin/scripts/vac_parallel.h b/src/bin/scripts/vac_parallel.h
new file mode 100644
index 0000000..21100b1
--- /dev/null
+++ b/src/bin/scripts/vac_parallel.h
@@ -0,0 +1,102 @@
+/*-------------------------------------------------------------------------
+ *
+ * vac_parallel.h
+ *
+ *	Parallel support header file for the vacuumdb
+ *
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *	The author is not responsible for loss or damages that may
+ *	result from its use.
+ *
+ * IDENTIFICATION
+ *		src/bin/scripts/vac_parallel.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef VAC_PARALLEL_H
+#define VAC_PARALLEL_H
+
+#include "postgres_fe.h"
+#include <time.h>
+#include "libpq-fe.h"
+
+
+typedef enum
+{
+	WRKR_TERMINATED = 0,
+	WRKR_IDLE,
+	WRKR_WORKING,
+	WRKR_FINISHED
+} T_WorkerStatus;
+
+/* Arguments needed for a worker process */
+typedef struct ParallelArgs
+{
+	PGconn *connection;
+} ParallelArgs;
+
+/* State for each parallel activity slot */
+typedef struct ParallelSlot
+{
+	ParallelArgs *args; //can pass connection handle here
+	T_WorkerStatus workerStatus;
+	int			status;
+	int			pipeRead;
+	int			pipeWrite;
+	int			pipeRevRead;
+	int			pipeRevWrite;
+#ifdef WIN32
+	uintptr_t	hThread;
+	unsigned int threadId;
+#else
+	pid_t		pid;
+#endif
+} ParallelSlot;
+
+#define NO_SLOT (-1)
+
+typedef struct ParallelState
+{
+	int			numWorkers;
+	ParallelSlot *parallelSlot;
+} ParallelState;
+
+
+
+typedef struct VacuumOption
+{
+	char	   *dbname;
+	char	   *pgport;
+	char	   *pghost;
+	char	   *username;
+	char * progname;
+}VacuumOption;
+
+
+#ifdef WIN32
+extern bool parallel_init_done;
+extern DWORD mainThreadId;
+#endif
+
+extern ParallelState * ParallelVacuumStart(VacuumOption *vopt, int numWorkers);
+extern int	GetIdleWorker(ParallelState *pstate);
+extern bool IsEveryWorkerIdle(ParallelState *pstate);
+extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+extern void EnsureIdleWorker(ParallelState *pstate);
+extern void EnsureWorkersFinished(ParallelState *pstate);
+
+extern void DispatchJob(ParallelState *pstate, char * command);
+extern void
+exit_horribly(const char *modulename, const char *fmt,...)
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+
+extern void init_parallel_vacuum_utils(void);
+extern  void on_exit_close_connection(PGconn *conn);
+extern void ParallelVacuumEnd(ParallelState *pstate);
+
+
+#endif   /* VAC_PARALLEL_H */
diff --git a/src/bin/scripts/vacuumdb.c b/src/bin/scripts/vacuumdb.c
index e4dde1f..766ed0e 100644
--- a/src/bin/scripts/vacuumdb.c
+++ b/src/bin/scripts/vacuumdb.c
@@ -13,6 +13,7 @@
 #include "postgres_fe.h"
 #include "common.h"
 #include "dumputils.h"
+#include "vac_parallel.h"
 
 
 static void vacuum_one_database(const char *dbname, bool full, bool verbose,
@@ -29,6 +30,18 @@ static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
 
 static void help(const char *progname);
 
+void vacuum_parallel(const char *dbname, bool full, bool verbose,
+					bool and_analyze, bool analyze_only, bool freeze,
+					const char *table, const char *host, const char *port,
+					const char *username, enum trivalue prompt_password,
+					const char *progname, bool echo, int parallel,
+					SimpleStringList *tables);
+
+void run_command(ParallelState *pstate, char *command);
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                     bool analyze_only, bool freeze, PQExpBuffer sql);
+
 
 int
 main(int argc, char *argv[])
@@ -49,6 +62,7 @@ main(int argc, char *argv[])
 		{"table", required_argument, NULL, 't'},
 		{"full", no_argument, NULL, 'f'},
 		{"verbose", no_argument, NULL, 'v'},
+		{"parallel", required_argument, NULL, 'j'},
 		{"maintenance-db", required_argument, NULL, 2},
 		{NULL, 0, NULL, 0}
 	};
@@ -72,13 +86,14 @@ main(int argc, char *argv[])
 	bool		full = false;
 	bool		verbose = false;
 	SimpleStringList tables = {NULL, NULL};
+    int parallel = 0;
 
 	progname = get_progname(argv[0]);
 	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
 
 	handle_help_version_opts(argc, argv, "vacuumdb", help);
 
-	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
+	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
 	{
 		switch (c)
 		{
@@ -127,6 +142,9 @@ main(int argc, char *argv[])
 			case 'v':
 				verbose = true;
 				break;
+            case 'j':
+                parallel = atoi(optarg);
+                break;
 			case 2:
 				maintenance_db = pg_strdup(optarg);
 				break;
@@ -136,6 +154,7 @@ main(int argc, char *argv[])
 		}
 	}
 
+    optind++;
 
 	/*
 	 * Non-option argument specifies database name as long as it wasn't
@@ -209,21 +228,49 @@ main(int argc, char *argv[])
 		{
 			SimpleStringListCell *cell;
 
-			for (cell = tables.head; cell; cell = cell->next)
-			{
-				vacuum_one_database(dbname, full, verbose, and_analyze,
-									analyze_only,
-									freeze, cell->val,
-									host, port, username, prompt_password,
-									progname, echo);
-			}
+            if (parallel < 2)
+            {
+    			for (cell = tables.head; cell; cell = cell->next)
+    			{
+    				vacuum_one_database(dbname, full, verbose, and_analyze,
+    									analyze_only,
+    									freeze, cell->val,
+    									host, port, username, prompt_password,
+    									progname, echo);
+    			}
+            }
+            else
+            {
+                vacuum_parallel(dbname, full, verbose, and_analyze,
+    								analyze_only,
+    								freeze, NULL,
+    								host, port, username, prompt_password,
+    								progname, echo, parallel, &tables);
+
+            }
 		}
 		else
-			vacuum_one_database(dbname, full, verbose, and_analyze,
-								analyze_only,
-								freeze, NULL,
-								host, port, username, prompt_password,
-								progname, echo);
+		{
+
+            if (parallel < 2)
+            {
+    			vacuum_one_database(dbname, full, verbose, and_analyze,
+    								analyze_only,
+    								freeze, NULL,
+    								host, port, username, prompt_password,
+    								progname, echo);
+            }
+            else
+            {
+
+                vacuum_parallel(dbname, full, verbose, and_analyze,
+    								analyze_only,
+    								freeze, NULL,
+    								host, port, username, prompt_password,
+    								progname, echo, parallel, NULL);
+            }
+	    }
+
 	}
 
 	exit(0);
@@ -351,6 +398,174 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 }
 
 
+void
+vacuum_parallel(const char *dbname, bool full, bool verbose,
+					bool and_analyze, bool analyze_only, bool freeze,
+					const char *table, const char *host, const char *port,
+					const char *username, enum trivalue prompt_password,
+					const char *progname, bool echo, int parallel,
+					SimpleStringList *tables)
+{
+	PQExpBufferData sql;
+
+	PGconn	   *conn;
+    PGresult *res;
+    int ntuple;
+    int i;
+    char *relName;
+    char *nspace;
+    VacuumOption vopt;
+    ParallelState *pstate;
+
+    init_parallel_vacuum_utils();
+
+	initPQExpBuffer(&sql);
+
+	conn = connectDatabase(dbname, host, port, username, prompt_password,
+						   progname, false);
+
+    vopt.dbname = dbname;
+    vopt.pghost = host;
+    vopt.pgport = port;
+    vopt.username = username;
+    vopt.progname = progname;
+
+    on_exit_close_connection(conn);
+
+    pstate = ParallelVacuumStart(&vopt, parallel);
+
+    if (tables == NULL)
+    {
+        res = executeQuery(conn,
+            "select relname, nspname from pg_class c, pg_namespace ns"
+            " where relkind= \'r\' and c.relnamespace = ns.oid"
+            " order by relpages desc",
+            progname, echo);
+
+        ntuple = PQntuples(res);
+        for (i = 0; i < ntuple; i++)
+        {
+            relName = PQgetvalue(res, i, 0);
+            nspace = PQgetvalue(res, i, 1);
+            prepare_command(conn, full, verbose, and_analyze,
+                            analyze_only, freeze, &sql);
+
+            appendPQExpBuffer(&sql, " %s.%s", nspace, relName);
+            run_command(pstate, sql.data);
+            termPQExpBuffer(&sql);
+        }
+    }
+    else
+    {
+        SimpleStringListCell *cell;
+
+        for (cell = tables->head; cell; cell = cell->next)
+        {
+            prepare_command(conn, full, verbose, and_analyze,
+                            analyze_only, freeze, &sql);
+            appendPQExpBuffer(&sql, " %s", cell->val);
+            run_command(pstate, sql.data);
+            termPQExpBuffer(&sql);
+        }
+    }
+
+    EnsureWorkersFinished(pstate);
+    ParallelVacuumEnd(pstate);
+
+	PQfinish(conn);
+	termPQExpBuffer(&sql);
+}
+
+void run_command(ParallelState *pstate, char *command)
+{
+    int work_status;
+    int ret_child;
+
+	DispatchJob(pstate, command);
+
+    /*Listen for worker and get message*/
+    for (;;)
+    {
+        int         nTerm = 0;
+
+        ListenToWorkers(pstate, false);
+        while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+        {
+            nTerm++;
+        }
+
+        /*
+         * We need to make sure that we have an idle worker before
+         * re-running the loop. If nTerm > 0 we already have that (quick
+         * check).
+         */
+        if (nTerm > 0)
+            break;
+
+        /* if nobody terminated, explicitly check for an idle worker */
+        if (GetIdleWorker(pstate) != NO_SLOT)
+            break;
+    }
+}
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                     bool analyze_only, bool freeze, PQExpBuffer sql)
+{
+	initPQExpBuffer(sql);
+
+	if (analyze_only)
+	{
+		appendPQExpBuffer(sql, "ANALYZE");
+		if (verbose)
+			appendPQExpBuffer(sql, " VERBOSE");
+	}
+	else
+	{
+		appendPQExpBuffer(sql, "VACUUM");
+		if (PQserverVersion(conn) >= 90000)
+		{
+			const char *paren = " (";
+			const char *comma = ", ";
+			const char *sep = paren;
+
+			if (full)
+			{
+				appendPQExpBuffer(sql, "%sFULL", sep);
+				sep = comma;
+			}
+			if (freeze)
+			{
+				appendPQExpBuffer(sql, "%sFREEZE", sep);
+				sep = comma;
+			}
+			if (verbose)
+			{
+				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+				sep = comma;
+			}
+			if (and_analyze)
+			{
+				appendPQExpBuffer(sql, "%sANALYZE", sep);
+				sep = comma;
+			}
+			if (sep != paren)
+				appendPQExpBuffer(sql, ")");
+		}
+		else
+		{
+			if (full)
+				appendPQExpBuffer(sql, " FULL");
+			if (freeze)
+				appendPQExpBuffer(sql, " FREEZE");
+			if (verbose)
+				appendPQExpBuffer(sql, " VERBOSE");
+			if (and_analyze)
+				appendPQExpBuffer(sql, " ANALYZE");
+		}
+	}
+}
+
+
 static void
 help(const char *progname)
 {

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,219 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-j <replaceable class="parameter">parallel_threads</replaceable></></term>
+       <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+       <listitem>
+        <para>
+         No of parallel jobs to perform the operation.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 66,70 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
--- 66,70 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,1112 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ 
+ #include "common.h"
+ 
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ static HANDLE termEvent = INVALID_HANDLE_VALUE;
+ static int	pgpipe(int handles[2]);
+ static int	piperead(int s, char *buf, int len);
+ bool		parallel_init_done = false;
+ DWORD		mainThreadId;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ 
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #else
+ /*
+  * aborting is only ever used in the master, the workers are fine with just
+  * wantAbort.
+  */
+ static bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	PGconn        *conn;
+ } ShutdownInformation;
+ 
+ static ShutdownInformation shutdown_info;
+ 
+ static char *readMessageFromPipe(int fd);
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker);
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ static char *
+ getMessageFromMaster(int pipefd[2]);
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+ 
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str);
+ 
+ #ifndef WIN32
+ static void sigTermHandler(int signum);
+ #endif
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ void
+ exit_horribly(const char *modulename, const char *fmt,...);
+ void
+ init_parallel_vacuum_utils(void);
+ 
+ static void  exit_nicely(int code);
+ 
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ static void checkAborting();
+ 
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ static void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		int			nrun = 0;
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt      *vopt = wi->vopt;
+ 
+     conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			exit_horribly(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+         wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			pstate->parallelSlot[i].args->connection
+ 			        = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 			                          vopt->username, vopt->promptPassword,
+ 			                          vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(pstate->parallelSlot[i].args->connection, pipefd, i);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			exit_horribly(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ static void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		exit_horribly(modulename, "worker is terminating\n");
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ static void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ #ifndef WIN32
+ 	int			i;
+ 
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ static void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ 
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker)
+ {
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+             sendMessageToMaster(pipefd, "OK");
+         else
+             sendMessageToMaster(pipefd, "ERROR  : Execute failed");
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			exit_horribly(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_TERMINATED;
+ 		exit_horribly(modulename, "%s", msg + strlen("ERROR "));
+ 	}
+ 	else
+ 		exit_horribly(modulename, "invalid message received from worker: %s\n", msg);
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				exit_horribly(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			exit_horribly(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ static char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		exit_horribly(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ static void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			exit_horribly(modulename,
+ 						  "could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * The underlying function to read a message from the communication channel
+  * (fd) with optional blocking (do_wait).
+  */
+ static char *
+ readMessageFromPipe(int fd)
+ {
+ 	char	   *msg;
+ 	int			msgsize,
+ 				bufsize;
+ 	int			ret;
+ 
+ 	/*
+ 	 * The problem here is that we need to deal with several possibilites: we
+ 	 * could receive only a partial message or several messages at once. The
+ 	 * caller expects us to return exactly one message however.
+ 	 *
+ 	 * We could either read in as much as we can and keep track of what we
+ 	 * delivered back to the caller or we just read byte by byte. Once we see
+ 	 * (char) 0, we know that it's the message's end. This would be quite
+ 	 * inefficient for more data but since we are reading only on the command
+ 	 * channel, the performance loss does not seem worth the trouble of
+ 	 * keeping internal states for different file descriptors.
+ 	 */
+ 	bufsize = 64;				/* could be any number */
+ 	msg = (char *) pg_malloc(bufsize);
+ 
+ 	msgsize = 0;
+ 	for (;;)
+ 	{
+ 		Assert(msgsize <= bufsize);
+ 		ret = piperead(fd, msg + msgsize, 1);
+ 
+ 		/* worker has closed the connection or another error happened */
+ 		if (ret <= 0)
+ 			return NULL;
+ 
+ 		Assert(ret == 1);
+ 
+ 		if (msg[msgsize] == '\0')
+ 			return msg;
+ 
+ 		msgsize++;
+ 		if (msgsize == bufsize)
+ 		{
+ 			/* could be any number */
+ 			bufsize += 16;
+ 			msg = (char *) realloc(msg, bufsize);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			exit_horribly(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.
+  */
+ static int
+ pgpipe(int handles[2])
+ {
+ 	SOCKET		s;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	handles[0] = handles[1] = INVALID_SOCKET;
+ 
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(handles[1]);
+ 		handles[1] = INVALID_SOCKET;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ static int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ static void
+ shutdown_parallel_vacuum_utils()
+ {
+ #ifdef WIN32
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ #endif
+ }
+ 
+ void
+ init_parallel_vacuum_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			exit_nicely(1);
+ 		}
+ 
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ void
+ on_exit_close_connection(PGconn *conn)
+ {
+ 	shutdown_info.conn = conn;
+ }
+ 
+ /*
+  * Fail and die, with a message to stderr.	Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does exit_horribly(), we forward its
+  * last words to the master process. The master process then does
+  * exit_horribly() with this error message itself and prints it normally.
+  * After printing the message, exit_horribly() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ {
+     va_list     ap;
+     ParallelState *pstate = shutdown_info.pstate;
+     ParallelSlot *slot;
+ 
+     va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+         /* We're the parent, just write the message out */
+         vfprintf(stderr, _(fmt), ap);
+ 	}
+ 	else
+ 	{
+ 	    slot = GetMyPSlot(pstate);
+ 	    if (!slot)
+ 	    {
+ 	        /* We're the parent, just write the message out */
+ 	        vfprintf(stderr, _(fmt), ap);
+ 
+ 	    }
+ 	    else
+ 	    {
+ 	        /* If we're a worker process, send the msg to the master process */
+ 	        parallel_msg_master(slot, modulename, fmt, ap);
+ 	    }
+ 	}
+ 
+     va_end(ap);
+ 
+     exit_nicely(1);
+ }
+ 
+ static void
+ exit_nicely(int code)
+ {
+ 	if (shutdown_info.pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(shutdown_info.pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			/*
+ 			 * We're the master: We have already printed out the message
+ 			 * passed to exit_horribly() either from the master itself or from
+ 			 * a worker process. Now we need to close our own database
+ 			 * connection (only open during parallel dump but not restore) and
+ 			 * shut down the remaining workers.
+ 			 */
+ 			PQfinish(shutdown_info.conn);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(shutdown_info.pstate);
+ 		}
+ 		else if (slot->args->connection)
+ 			PQfinish(slot->args->connection);
+ 
+ 	}
+ 	else if (shutdown_info.conn)
+ 		PQfinish(shutdown_info.conn);
+ 
+ 	shutdown_parallel_vacuum_utils();
+ 	exit(code);
+ }
+ 
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,103 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ } ParallelArgs;
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	ParallelArgs *args; //can pass connection handle here
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ #define NO_SLOT (-1)
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ }VacOpt;
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD mainThreadId;
+ #endif
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern int	GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ extern void init_parallel_vacuum_utils(void);
+ extern  void on_exit_close_connection(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,18 ****
   */
  
  #include "postgres_fe.h"
- #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
--- 11,18 ----
   */
  
  #include "postgres_fe.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 25,46 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool freeze,
+ 					const char *table, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int parallel,
+ 					SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 61,67 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"parallel", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{NULL, 0, NULL, 0}
  	};
***************
*** 72,84 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 85,98 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 127,132 **** main(int argc, char *argv[])
--- 141,149 ----
  			case 'v':
  				verbose = true;
  				break;
+             case 'j':
+                 parallel = atoi(optarg);
+                 break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 136,141 **** main(int argc, char *argv[])
--- 153,159 ----
  		}
  	}
  
+     optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 191,197 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 209,215 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 205,229 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 223,262 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only,
! 								freeze, NULL,
! 								host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
! 			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 321,327 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  					 bool freeze, const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 354,360 ----
  					 bool freeze, const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 342,356 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 						 freeze, NULL, host, port, username, prompt_password,
! 							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
  {
--- 375,581 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only,
! 								freeze, NULL,
! 								host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 								analyze_only, freeze, NULL, host, port,
! 								username, prompt_password, progname, echo);
! 		}
  	}
  
  	PQclear(result);
  }
  
  
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool freeze,
+ 					const char *table, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int parallel,
+ 					SimpleStringList *tables)
+ {
+ 	PQExpBufferData sql;
+ 
+ 	PGconn	   *conn;
+     PGresult *res;
+     int ntuple;
+     int i;
+     char *relName;
+     char *nspace;
+     VacOpt vopt = {0};
+     ParallelState *pstate;
+ 
+     init_parallel_vacuum_utils();
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_connection(conn);
+ 
+     pstate = ParallelVacuumStart(&vopt, parallel);
+ 
+     if (tables && tables->head)
+     {
+         SimpleStringListCell *cell;
+ 
+         for (cell = tables->head; cell; cell = cell->next)
+         {
+             prepare_command(conn, full, verbose, and_analyze,
+                             analyze_only, freeze, &sql);
+             appendPQExpBuffer(&sql, " %s", cell->val);
+             run_command(pstate, sql.data);
+             termPQExpBuffer(&sql);
+         }
+     }
+     else
+     {
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+             prepare_command(conn, full, verbose, and_analyze,
+                             analyze_only, freeze, &sql);
+ 
+             appendPQExpBuffer(&sql, " %s.%s", nspace, relName);
+             run_command(pstate, sql.data);
+             termPQExpBuffer(&sql);
+         }
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 
+ 	PQfinish(conn);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
+ 
  static void
  help(const char *progname)
  {
***************
*** 369,374 **** help(const char *progname)
--- 594,600 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM               	use this many parallel jobs to vacuum\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));
  	printf(_("\nConnection options:\n"));
  	printf(_("  -h, --host=HOSTNAME       database server host or socket directory\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,1112 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ 
+ #include "common.h"
+ 
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ static HANDLE termEvent = INVALID_HANDLE_VALUE;
+ static int	pgpipe(int handles[2]);
+ static int	piperead(int s, char *buf, int len);
+ bool		parallel_init_done = false;
+ DWORD		mainThreadId;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ 
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #else
+ /*
+  * aborting is only ever used in the master, the workers are fine with just
+  * wantAbort.
+  */
+ static bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	PGconn        *conn;
+ } ShutdownInformation;
+ 
+ static ShutdownInformation shutdown_info;
+ 
+ static char *readMessageFromPipe(int fd);
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker);
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ static char *
+ getMessageFromMaster(int pipefd[2]);
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+ 
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str);
+ 
+ #ifndef WIN32
+ static void sigTermHandler(int signum);
+ #endif
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ void
+ exit_horribly(const char *modulename, const char *fmt,...);
+ void
+ init_parallel_vacuum_utils(void);
+ 
+ static void  exit_nicely(int code);
+ 
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ static void checkAborting();
+ 
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ static void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		int			nrun = 0;
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt      *vopt = wi->vopt;
+ 
+     conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			exit_horribly(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+         wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			pstate->parallelSlot[i].args->connection
+ 			        = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 			                          vopt->username, vopt->promptPassword,
+ 			                          vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(pstate->parallelSlot[i].args->connection, pipefd, i);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			exit_horribly(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ static void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		exit_horribly(modulename, "worker is terminating\n");
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ static void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ #ifndef WIN32
+ 	int			i;
+ 
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ static void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ 
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker)
+ {
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+             sendMessageToMaster(pipefd, "OK");
+         else
+             sendMessageToMaster(pipefd, "ERROR  : Execute failed");
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			exit_horribly(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_TERMINATED;
+ 		exit_horribly(modulename, "%s", msg + strlen("ERROR "));
+ 	}
+ 	else
+ 		exit_horribly(modulename, "invalid message received from worker: %s\n", msg);
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				exit_horribly(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			exit_horribly(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ static char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		exit_horribly(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ static void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			exit_horribly(modulename,
+ 						  "could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * The underlying function to read a message from the communication channel
+  * (fd) with optional blocking (do_wait).
+  */
+ static char *
+ readMessageFromPipe(int fd)
+ {
+ 	char	   *msg;
+ 	int			msgsize,
+ 				bufsize;
+ 	int			ret;
+ 
+ 	/*
+ 	 * The problem here is that we need to deal with several possibilites: we
+ 	 * could receive only a partial message or several messages at once. The
+ 	 * caller expects us to return exactly one message however.
+ 	 *
+ 	 * We could either read in as much as we can and keep track of what we
+ 	 * delivered back to the caller or we just read byte by byte. Once we see
+ 	 * (char) 0, we know that it's the message's end. This would be quite
+ 	 * inefficient for more data but since we are reading only on the command
+ 	 * channel, the performance loss does not seem worth the trouble of
+ 	 * keeping internal states for different file descriptors.
+ 	 */
+ 	bufsize = 64;				/* could be any number */
+ 	msg = (char *) pg_malloc(bufsize);
+ 
+ 	msgsize = 0;
+ 	for (;;)
+ 	{
+ 		Assert(msgsize <= bufsize);
+ 		ret = piperead(fd, msg + msgsize, 1);
+ 
+ 		/* worker has closed the connection or another error happened */
+ 		if (ret <= 0)
+ 			return NULL;
+ 
+ 		Assert(ret == 1);
+ 
+ 		if (msg[msgsize] == '\0')
+ 			return msg;
+ 
+ 		msgsize++;
+ 		if (msgsize == bufsize)
+ 		{
+ 			/* could be any number */
+ 			bufsize += 16;
+ 			msg = (char *) realloc(msg, bufsize);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			exit_horribly(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.
+  */
+ static int
+ pgpipe(int handles[2])
+ {
+ 	SOCKET		s;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	handles[0] = handles[1] = INVALID_SOCKET;
+ 
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(handles[1]);
+ 		handles[1] = INVALID_SOCKET;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ static int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ static void
+ shutdown_parallel_vacuum_utils()
+ {
+ #ifdef WIN32
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ #endif
+ }
+ 
+ void
+ init_parallel_vacuum_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			exit_nicely(1);
+ 		}
+ 
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ void
+ on_exit_close_connection(PGconn *conn)
+ {
+ 	shutdown_info.conn = conn;
+ }
+ 
+ /*
+  * Fail and die, with a message to stderr.	Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does exit_horribly(), we forward its
+  * last words to the master process. The master process then does
+  * exit_horribly() with this error message itself and prints it normally.
+  * After printing the message, exit_horribly() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ {
+     va_list     ap;
+     ParallelState *pstate = shutdown_info.pstate;
+     ParallelSlot *slot;
+ 
+     va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+         /* We're the parent, just write the message out */
+         vfprintf(stderr, _(fmt), ap);
+ 	}
+ 	else
+ 	{
+ 	    slot = GetMyPSlot(pstate);
+ 	    if (!slot)
+ 	    {
+ 	        /* We're the parent, just write the message out */
+ 	        vfprintf(stderr, _(fmt), ap);
+ 
+ 	    }
+ 	    else
+ 	    {
+ 	        /* If we're a worker process, send the msg to the master process */
+ 	        parallel_msg_master(slot, modulename, fmt, ap);
+ 	    }
+ 	}
+ 
+     va_end(ap);
+ 
+     exit_nicely(1);
+ }
+ 
+ static void
+ exit_nicely(int code)
+ {
+ 	if (shutdown_info.pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(shutdown_info.pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			/*
+ 			 * We're the master: We have already printed out the message
+ 			 * passed to exit_horribly() either from the master itself or from
+ 			 * a worker process. Now we need to close our own database
+ 			 * connection (only open during parallel dump but not restore) and
+ 			 * shut down the remaining workers.
+ 			 */
+ 			PQfinish(shutdown_info.conn);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(shutdown_info.pstate);
+ 		}
+ 		else if (slot->args->connection)
+ 			PQfinish(slot->args->connection);
+ 
+ 	}
+ 	else if (shutdown_info.conn)
+ 		PQfinish(shutdown_info.conn);
+ 
+ 	shutdown_parallel_vacuum_utils();
+ 	exit(code);
+ }
+ 
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,103 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ } ParallelArgs;
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	ParallelArgs *args; //can pass connection handle here
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ #define NO_SLOT (-1)
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ }VacOpt;
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD mainThreadId;
+ #endif
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern int	GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ extern void init_parallel_vacuum_utils(void);
+ extern  void on_exit_close_connection(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,34 ****
   */
  
  #include "postgres_fe.h"
- #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 11,54 ----
   */
  
  #include "postgres_fe.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname);
+ 
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 69,75 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"parallel", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 95,108 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 151,159 ----
  			case 'v':
  				verbose = true;
  				break;
+             case 'j':
+                 parallel = atoi(optarg);
+                 break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 166,172 ----
  		}
  	}
  
+     optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 222,228 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 236,274 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
  			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 293,304 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 393,404 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 419,668 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int parallel, 
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_vacuum_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_connection(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " %s.%s", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"
+ 		};
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 		};
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			puts(gettext(stage_messages[i]));
+ 			executeCommand(conn, stage_commands[i], progname, echo);
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt,
+ 						progname);
+ 		}
+ 	}
+ 	else
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt,
+ 					progname);
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 682,688 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM               	use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,1144 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ 
+ #include "common.h"
+ 
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ static HANDLE termEvent = INVALID_HANDLE_VALUE;
+ static int	pgpipe(int handles[2]);
+ static int	piperead(int s, char *buf, int len);
+ bool		parallel_init_done = false;
+ DWORD		mainThreadId;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ 
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #else
+ /*
+  * aborting is only ever used in the master, the workers are fine with just
+  * wantAbort.
+  */
+ static bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	PGconn        *conn;
+ } ShutdownInformation;
+ 
+ static ShutdownInformation shutdown_info;
+ 
+ static char *readMessageFromPipe(int fd);
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage);
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ static char *
+ getMessageFromMaster(int pipefd[2]);
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+ 
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str);
+ 
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename, const char *fmt,
+ 		va_list ap)__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
+ 
+ 
+ #ifndef WIN32
+ static void sigTermHandler(int signum);
+ #endif
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ void horribly_exit(const char *modulename, const char *fmt,...)
+ 	__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+ 
+ void
+ init_parallel_vacuum_utils(void);
+ 
+ static void  exit_nicely(int code);
+ 
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ static void checkAborting();
+ 
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ static void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		int			nrun = 0;
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt      *vopt = wi->vopt;
+ 	ParallelSlot *mySlot = &shutdown_info.pstate->parallelSlot[worker];
+ 
+     conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	mySlot->args->connection = conn;
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker, vopt->analyze_stage);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			horribly_exit(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ 		pstate->parallelSlot[i].args->vopt = vopt;
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+         wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			pstate->parallelSlot[i].args->connection
+ 			        = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 			                          vopt->username, vopt->promptPassword,
+ 			                          vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(pstate->parallelSlot[i].args->connection,
+ 						pipefd, i, vopt->analyze_stage);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			horribly_exit(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ static void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		horribly_exit(modulename, "worker is terminating\n");
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ static void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ #ifndef WIN32
+ 	int			i;
+ 
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ static void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ 
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage)
+ {
+ 
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	executeMaintenanceCommand(connection, stage_commands[vacStage], false);
+ 
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 	PQExpBufferData sql;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+             sendMessageToMaster(pipefd, "OK");
+         else
+         {
+ 			initPQExpBuffer(&sql);
+         	appendPQExpBuffer(&sql, "ERROR : %s",
+ 						PQerrorMessage(connection));
+             sendMessageToMaster(pipefd, sql.data);
+ 			termPQExpBuffer(&sql);
+         }
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			horribly_exit(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 
+ 		ParallelSlot *mySlot = &pstate->parallelSlot[worker];
+ 
+ 		mySlot->workerStatus = WRKR_TERMINATED;
+ 
+ 		horribly_exit(modulename,
+ 			"%s: vacuuming of database \"%s\" failed %s",
+ 			mySlot->args->vopt->progname,
+ 			mySlot->args->vopt->dbname, msg + strlen("ERROR "));
+ 	}
+ 	else
+ 		horribly_exit(modulename, "invalid message received from worker: %s\n", msg);
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				horribly_exit(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			horribly_exit(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ static char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		horribly_exit(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		horribly_exit(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ static void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			horribly_exit(modulename,
+ 						  "could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * The underlying function to read a message from the communication channel
+  * (fd) with optional blocking (do_wait).
+  */
+ static char *
+ readMessageFromPipe(int fd)
+ {
+ 	char	   *msg;
+ 	int			msgsize,
+ 				bufsize;
+ 	int			ret;
+ 
+ 	/*
+ 	 * The problem here is that we need to deal with several possibilites: we
+ 	 * could receive only a partial message or several messages at once. The
+ 	 * caller expects us to return exactly one message however.
+ 	 *
+ 	 * We could either read in as much as we can and keep track of what we
+ 	 * delivered back to the caller or we just read byte by byte. Once we see
+ 	 * (char) 0, we know that it's the message's end. This would be quite
+ 	 * inefficient for more data but since we are reading only on the command
+ 	 * channel, the performance loss does not seem worth the trouble of
+ 	 * keeping internal states for different file descriptors.
+ 	 */
+ 	bufsize = 64;				/* could be any number */
+ 	msg = (char *) pg_malloc(bufsize);
+ 
+ 	msgsize = 0;
+ 	for (;;)
+ 	{
+ 		Assert(msgsize <= bufsize);
+ 		ret = piperead(fd, msg + msgsize, 1);
+ 
+ 		/* worker has closed the connection or another error happened */
+ 		if (ret <= 0)
+ 			return NULL;
+ 
+ 		Assert(ret == 1);
+ 
+ 		if (msg[msgsize] == '\0')
+ 			return msg;
+ 
+ 		msgsize++;
+ 		if (msgsize == bufsize)
+ 		{
+ 			/* could be any number */
+ 			bufsize += 16;
+ 			msg = (char *) realloc(msg, bufsize);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			horribly_exit(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.
+  */
+ static int
+ pgpipe(int handles[2])
+ {
+ 	SOCKET		s;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	handles[0] = handles[1] = INVALID_SOCKET;
+ 
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(handles[1]);
+ 		handles[1] = INVALID_SOCKET;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ static int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ static void
+ shutdown_parallel_vacuum_utils()
+ {
+ #ifdef WIN32
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ #endif
+ }
+ 
+ void
+ init_parallel_vacuum_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			exit_nicely(1);
+ 		}
+ 
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ void
+ on_exit_close_connection(PGconn *conn)
+ {
+ 	shutdown_info.conn = conn;
+ }
+ 
+ /*
+  * Fail and die, with a message to stderr.	Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does horribly_exit(), we forward its
+  * last words to the master process. The master process then does
+  * horribly_exit() with this error message itself and prints it normally.
+  * After printing the message, horribly_exit() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ horribly_exit(const char *modulename, const char *fmt,...)
+ {
+ 	va_list 	ap;
+     ParallelState *pstate = shutdown_info.pstate;
+     ParallelSlot *slot;
+     va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+         /* We're the parent, just write the message out */
+         vfprintf(stderr, _(fmt), ap);
+ 	}
+ 	else
+ 	{
+ 	    slot = GetMyPSlot(pstate);
+ 	    if (!slot)
+ 	    {
+ 	        /* We're the parent, just write the message out */
+ 	        vfprintf(stderr, _(fmt), ap);
+ 
+ 	    }
+ 	    else
+ 	    {
+ 	        /* If we're a worker process, send the msg to the master process */
+ 	        parallel_msg_master(slot, modulename, fmt, ap);
+ 	    }
+ 	}
+ 
+     va_end(ap);
+ 
+     exit_nicely(1);
+ }
+ 
+ static void
+ exit_nicely(int code)
+ {
+ 	if (shutdown_info.pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(shutdown_info.pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			/*
+ 			 * We're the master: We have already printed out the message
+ 			 * passed to horribly_exit() either from the master itself or from
+ 			 * a worker process. Now we need to close our own database
+ 			 * connection (only open during parallel dump but not restore) and
+ 			 * shut down the remaining workers.
+ 			 */
+ 			PQfinish(shutdown_info.conn);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(shutdown_info.pstate);
+ 		}
+ 		else if (slot->args->connection)
+ 			PQfinish(slot->args->connection);
+ 
+ 	}
+ 	else if (shutdown_info.conn)
+ 		PQfinish(shutdown_info.conn);
+ 
+ 	shutdown_parallel_vacuum_utils();
+ 	exit(code);
+ }
+ 
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,105 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ 	int		   analyze_stage;
+ }VacOpt;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ 	VacOpt *vopt;
+ } ParallelArgs;
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	ParallelArgs *args; //can pass connection handle here
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ #define NO_SLOT (-1)
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD mainThreadId;
+ #endif
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern int	GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ extern void init_parallel_vacuum_utils(void);
+ extern  void on_exit_close_connection(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,34 ****
   */
  
  #include "postgres_fe.h"
- #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 11,54 ----
   */
  
  #include "postgres_fe.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname);
+ 
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 69,75 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"parallel", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 95,108 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 151,159 ----
  			case 'v':
  				verbose = true;
  				break;
+             case 'j':
+                 parallel = atoi(optarg);
+                 break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 166,172 ----
  		}
  	}
  
+     optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 222,228 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 236,274 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
  			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 293,304 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 393,404 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 419,666 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int parallel,
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_vacuum_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_connection(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " %s.\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 			vopt.analyze_stage = i;
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt,
+ 						progname);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		vopt.analyze_stage = -1;
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt,
+ 					progname);
+ 	}
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 680,686 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,1144 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ 
+ #include "common.h"
+ 
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ static HANDLE termEvent = INVALID_HANDLE_VALUE;
+ static int	pgpipe(int handles[2]);
+ static int	piperead(int s, char *buf, int len);
+ bool		parallel_init_done = false;
+ DWORD		mainThreadId;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ 
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #else
+ /*
+  * aborting is only ever used in the master, the workers are fine with just
+  * wantAbort.
+  */
+ static bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	PGconn		  *conn;
+ } ShutdownInformation;
+ 
+ static ShutdownInformation shutdown_info;
+ 
+ static char *readMessageFromPipe(int fd);
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage);
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ static char *
+ getMessageFromMaster(int pipefd[2]);
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+ 
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str);
+ 
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename, const char *fmt,
+ 		va_list ap)__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
+ 
+ 
+ #ifndef WIN32
+ static void sigTermHandler(int signum);
+ #endif
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ void horribly_exit(const char *modulename, const char *fmt,...)
+ 	__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+ 
+ void
+ init_parallel_vacuum_utils(void);
+ 
+ static void  exit_nicely(int code);
+ 
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ static void checkAborting();
+ 
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ static void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		int			nrun = 0;
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt		*vopt = wi->vopt;
+ 	ParallelSlot *mySlot = &shutdown_info.pstate->parallelSlot[worker];
+ 
+ 	conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	mySlot->args->connection = conn;
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker, vopt->analyze_stage);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			horribly_exit(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ 		pstate->parallelSlot[i].args->vopt = vopt;
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+ 		wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			pstate->parallelSlot[i].args->connection
+ 					= connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 									  vopt->username, vopt->promptPassword,
+ 									  vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(pstate->parallelSlot[i].args->connection,
+ 						pipefd, i, vopt->analyze_stage);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			horribly_exit(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ static void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		horribly_exit(modulename, "worker is terminating\n");
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ static void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ #ifndef WIN32
+ 	int			i;
+ 
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ static void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ 
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage)
+ {
+ 
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	executeMaintenanceCommand(connection, stage_commands[vacStage], false);
+ 
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 	PQExpBufferData sql;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+ 			sendMessageToMaster(pipefd, "OK");
+ 		else
+ 		{
+ 			initPQExpBuffer(&sql);
+ 			appendPQExpBuffer(&sql, "ERROR : %s",
+ 						PQerrorMessage(connection));
+ 			sendMessageToMaster(pipefd, sql.data);
+ 			termPQExpBuffer(&sql);
+ 		}
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			horribly_exit(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 
+ 		ParallelSlot *mySlot = &pstate->parallelSlot[worker];
+ 
+ 		mySlot->workerStatus = WRKR_TERMINATED;
+ 
+ 		horribly_exit(modulename,
+ 			"%s: vacuuming of database \"%s\" failed %s",
+ 			mySlot->args->vopt->progname,
+ 			mySlot->args->vopt->dbname, msg + strlen("ERROR "));
+ 	}
+ 	else
+ 		horribly_exit(modulename, "invalid message received from worker: %s\n", msg);
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				horribly_exit(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			horribly_exit(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ static char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		horribly_exit(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		horribly_exit(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ static void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			horribly_exit(modulename,
+ 						  "could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * The underlying function to read a message from the communication channel
+  * (fd) with optional blocking (do_wait).
+  */
+ static char *
+ readMessageFromPipe(int fd)
+ {
+ 	char	   *msg;
+ 	int			msgsize,
+ 				bufsize;
+ 	int			ret;
+ 
+ 	/*
+ 	 * The problem here is that we need to deal with several possibilites: we
+ 	 * could receive only a partial message or several messages at once. The
+ 	 * caller expects us to return exactly one message however.
+ 	 *
+ 	 * We could either read in as much as we can and keep track of what we
+ 	 * delivered back to the caller or we just read byte by byte. Once we see
+ 	 * (char) 0, we know that it's the message's end. This would be quite
+ 	 * inefficient for more data but since we are reading only on the command
+ 	 * channel, the performance loss does not seem worth the trouble of
+ 	 * keeping internal states for different file descriptors.
+ 	 */
+ 	bufsize = 64;				/* could be any number */
+ 	msg = (char *) pg_malloc(bufsize);
+ 
+ 	msgsize = 0;
+ 	for (;;)
+ 	{
+ 		Assert(msgsize <= bufsize);
+ 		ret = piperead(fd, msg + msgsize, 1);
+ 
+ 		/* worker has closed the connection or another error happened */
+ 		if (ret <= 0)
+ 			return NULL;
+ 
+ 		Assert(ret == 1);
+ 
+ 		if (msg[msgsize] == '\0')
+ 			return msg;
+ 
+ 		msgsize++;
+ 		if (msgsize == bufsize)
+ 		{
+ 			/* could be any number */
+ 			bufsize += 16;
+ 			msg = (char *) realloc(msg, bufsize);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			horribly_exit(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.
+  */
+ static int
+ pgpipe(int handles[2])
+ {
+ 	SOCKET		s;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	handles[0] = handles[1] = INVALID_SOCKET;
+ 
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(handles[1]);
+ 		handles[1] = INVALID_SOCKET;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ static int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ static void
+ shutdown_parallel_vacuum_utils()
+ {
+ #ifdef WIN32
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ #endif
+ }
+ 
+ void
+ init_parallel_vacuum_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			exit_nicely(1);
+ 		}
+ 
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ void
+ on_exit_close_connection(PGconn *conn)
+ {
+ 	shutdown_info.conn = conn;
+ }
+ 
+ /*
+  * Fail and die, with a message to stderr.	Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does horribly_exit(), we forward its
+  * last words to the master process. The master process then does
+  * horribly_exit() with this error message itself and prints it normally.
+  * After printing the message, horribly_exit() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ horribly_exit(const char *modulename, const char *fmt,...)
+ {
+ 	va_list 	ap;
+ 	ParallelState *pstate = shutdown_info.pstate;
+ 	ParallelSlot *slot;
+ 	va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+ 		/* We're the parent, just write the message out */
+ 		vfprintf(stderr, _(fmt), ap);
+ 	}
+ 	else
+ 	{
+ 		slot = GetMyPSlot(pstate);
+ 		if (!slot)
+ 		{
+ 			/* We're the parent, just write the message out */
+ 			vfprintf(stderr, _(fmt), ap);
+ 
+ 		}
+ 		else
+ 		{
+ 			/* If we're a worker process, send the msg to the master process */
+ 			parallel_msg_master(slot, modulename, fmt, ap);
+ 		}
+ 	}
+ 
+ 	va_end(ap);
+ 
+ 	exit_nicely(1);
+ }
+ 
+ static void
+ exit_nicely(int code)
+ {
+ 	if (shutdown_info.pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(shutdown_info.pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			/*
+ 			 * We're the master: We have already printed out the message
+ 			 * passed to horribly_exit() either from the master itself or from
+ 			 * a worker process. Now we need to close our own database
+ 			 * connection (only open during parallel dump but not restore) and
+ 			 * shut down the remaining workers.
+ 			 */
+ 			PQfinish(shutdown_info.conn);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(shutdown_info.pstate);
+ 		}
+ 		else if (slot->args->connection)
+ 			PQfinish(slot->args->connection);
+ 
+ 	}
+ 	else if (shutdown_info.conn)
+ 		PQfinish(shutdown_info.conn);
+ 
+ 	shutdown_parallel_vacuum_utils();
+ 	exit(code);
+ }
+ 
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,105 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ 	int		   analyze_stage;
+ }VacOpt;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ 	VacOpt *vopt;
+ } ParallelArgs;
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	ParallelArgs *args; //can pass connection handle here
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ #define NO_SLOT (-1)
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD mainThreadId;
+ #endif
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern int	GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ extern void init_parallel_vacuum_utils(void);
+ extern  void on_exit_close_connection(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,34 ****
   */
  
  #include "postgres_fe.h"
- #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 11,54 ----
   */
  
  #include "postgres_fe.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname);
+ 
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 69,75 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 95,108 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 151,159 ----
  			case 'v':
  				verbose = true;
  				break;
+             case 'j':
+                 parallel = atoi(optarg);
+                 break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 166,172 ----
  		}
  	}
  
+     optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 222,228 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 236,274 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
  			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 293,304 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 393,404 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 419,666 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int parallel,
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_vacuum_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_connection(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " %s.\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 			vopt.analyze_stage = i;
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt,
+ 						progname);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		vopt.analyze_stage = -1;
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt,
+ 					progname);
+ 	}
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 680,686 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,1144 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ 
+ #include "common.h"
+ 
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ static HANDLE termEvent = INVALID_HANDLE_VALUE;
+ static int	pgpipe(int handles[2]);
+ static int	piperead(int s, char *buf, int len);
+ bool		parallel_init_done = false;
+ DWORD		mainThreadId;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ 
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #else
+ /*
+  * aborting is only ever used in the master, the workers are fine with just
+  * wantAbort.
+  */
+ static bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	PGconn		  *conn;
+ } ShutdownInformation;
+ 
+ static ShutdownInformation shutdown_info;
+ 
+ static char *readMessageFromPipe(int fd);
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage);
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ static char *
+ getMessageFromMaster(int pipefd[2]);
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+ 
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str);
+ 
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename, const char *fmt,
+ 		va_list ap)__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
+ 
+ 
+ #ifndef WIN32
+ static void sigTermHandler(int signum);
+ #endif
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ void horribly_exit(const char *modulename, const char *fmt,...)
+ 	__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+ 
+ void
+ init_parallel_vacuum_utils(void);
+ 
+ static void  exit_nicely(int code);
+ 
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ static void checkAborting();
+ 
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ static void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		int			nrun = 0;
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt		*vopt = wi->vopt;
+ 	ParallelSlot *mySlot = &shutdown_info.pstate->parallelSlot[worker];
+ 
+ 	conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	mySlot->args->connection = conn;
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker, vopt->analyze_stage);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			horribly_exit(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ 		pstate->parallelSlot[i].args->vopt = vopt;
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+ 		wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			pstate->parallelSlot[i].args->connection
+ 					= connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 									  vopt->username, vopt->promptPassword,
+ 									  vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(pstate->parallelSlot[i].args->connection,
+ 						pipefd, i, vopt->analyze_stage);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			horribly_exit(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ static void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		horribly_exit(modulename, "worker is terminating\n");
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ static void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ #ifndef WIN32
+ 	int			i;
+ 
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ static void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ 
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage)
+ {
+ 
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	executeMaintenanceCommand(connection, stage_commands[vacStage], false);
+ 
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 	PQExpBufferData sql;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+ 			sendMessageToMaster(pipefd, "OK");
+ 		else
+ 		{
+ 			initPQExpBuffer(&sql);
+ 			appendPQExpBuffer(&sql, "ERROR : %s",
+ 						PQerrorMessage(connection));
+ 			sendMessageToMaster(pipefd, sql.data);
+ 			termPQExpBuffer(&sql);
+ 		}
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			horribly_exit(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 
+ 		ParallelSlot *mySlot = &pstate->parallelSlot[worker];
+ 
+ 		mySlot->workerStatus = WRKR_TERMINATED;
+ 
+ 		horribly_exit(modulename,
+ 			"%s: vacuuming of database \"%s\" failed %s",
+ 			mySlot->args->vopt->progname,
+ 			mySlot->args->vopt->dbname, msg + strlen("ERROR "));
+ 	}
+ 	else
+ 		horribly_exit(modulename, "invalid message received from worker: %s\n", msg);
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				horribly_exit(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			horribly_exit(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ static char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		horribly_exit(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		horribly_exit(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ static void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			horribly_exit(modulename,
+ 						  "could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * The underlying function to read a message from the communication channel
+  * (fd) with optional blocking (do_wait).
+  */
+ static char *
+ readMessageFromPipe(int fd)
+ {
+ 	char	   *msg;
+ 	int			msgsize,
+ 				bufsize;
+ 	int			ret;
+ 
+ 	/*
+ 	 * The problem here is that we need to deal with several possibilites: we
+ 	 * could receive only a partial message or several messages at once. The
+ 	 * caller expects us to return exactly one message however.
+ 	 *
+ 	 * We could either read in as much as we can and keep track of what we
+ 	 * delivered back to the caller or we just read byte by byte. Once we see
+ 	 * (char) 0, we know that it's the message's end. This would be quite
+ 	 * inefficient for more data but since we are reading only on the command
+ 	 * channel, the performance loss does not seem worth the trouble of
+ 	 * keeping internal states for different file descriptors.
+ 	 */
+ 	bufsize = 64;				/* could be any number */
+ 	msg = (char *) pg_malloc(bufsize);
+ 
+ 	msgsize = 0;
+ 	for (;;)
+ 	{
+ 		Assert(msgsize <= bufsize);
+ 		ret = piperead(fd, msg + msgsize, 1);
+ 
+ 		/* worker has closed the connection or another error happened */
+ 		if (ret <= 0)
+ 			return NULL;
+ 
+ 		Assert(ret == 1);
+ 
+ 		if (msg[msgsize] == '\0')
+ 			return msg;
+ 
+ 		msgsize++;
+ 		if (msgsize == bufsize)
+ 		{
+ 			/* could be any number */
+ 			bufsize += 16;
+ 			msg = (char *) realloc(msg, bufsize);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			horribly_exit(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.
+  */
+ static int
+ pgpipe(int handles[2])
+ {
+ 	SOCKET		s;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	handles[0] = handles[1] = INVALID_SOCKET;
+ 
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
+ 	{
+ 		closesocket(handles[1]);
+ 		handles[1] = INVALID_SOCKET;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ static int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ static void
+ shutdown_parallel_vacuum_utils()
+ {
+ #ifdef WIN32
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ #endif
+ }
+ 
+ void
+ init_parallel_vacuum_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			exit_nicely(1);
+ 		}
+ 
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ void
+ on_exit_close_connection(PGconn *conn)
+ {
+ 	shutdown_info.conn = conn;
+ }
+ 
+ /*
+  * Fail and die, with a message to stderr.	Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does horribly_exit(), we forward its
+  * last words to the master process. The master process then does
+  * horribly_exit() with this error message itself and prints it normally.
+  * After printing the message, horribly_exit() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ horribly_exit(const char *modulename, const char *fmt,...)
+ {
+ 	va_list 	ap;
+ 	ParallelState *pstate = shutdown_info.pstate;
+ 	ParallelSlot *slot;
+ 	va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+ 		/* We're the parent, just write the message out */
+ 		vfprintf(stderr, _(fmt), ap);
+ 	}
+ 	else
+ 	{
+ 		slot = GetMyPSlot(pstate);
+ 		if (!slot)
+ 		{
+ 			/* We're the parent, just write the message out */
+ 			vfprintf(stderr, _(fmt), ap);
+ 
+ 		}
+ 		else
+ 		{
+ 			/* If we're a worker process, send the msg to the master process */
+ 			parallel_msg_master(slot, modulename, fmt, ap);
+ 		}
+ 	}
+ 
+ 	va_end(ap);
+ 
+ 	exit_nicely(1);
+ }
+ 
+ static void
+ exit_nicely(int code)
+ {
+ 	if (shutdown_info.pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(shutdown_info.pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			/*
+ 			 * We're the master: We have already printed out the message
+ 			 * passed to horribly_exit() either from the master itself or from
+ 			 * a worker process. Now we need to close our own database
+ 			 * connection (only open during parallel dump but not restore) and
+ 			 * shut down the remaining workers.
+ 			 */
+ 			PQfinish(shutdown_info.conn);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(shutdown_info.pstate);
+ 		}
+ 		else if (slot->args->connection)
+ 			PQfinish(slot->args->connection);
+ 
+ 	}
+ 	else if (shutdown_info.conn)
+ 		PQfinish(shutdown_info.conn);
+ 
+ 	shutdown_parallel_vacuum_utils();
+ 	exit(code);
+ }
+ 
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,105 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ 	int		   analyze_stage;
+ }VacOpt;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ 	VacOpt *vopt;
+ } ParallelArgs;
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	ParallelArgs *args; //can pass connection handle here
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ #define NO_SLOT (-1)
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD mainThreadId;
+ #endif
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern int	GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ extern void init_parallel_vacuum_utils(void);
+ extern  void on_exit_close_connection(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,34 ****
   */
  
  #include "postgres_fe.h"
- #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 11,54 ----
   */
  
  #include "postgres_fe.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname);
+ 
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 69,75 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 95,108 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 151,166 ----
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				parallel = atoi(optarg);
+ 				if (parallel <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 					progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 173,179 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 229,235 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 243,281 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
! 			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 300,311 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 400,411 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 426,673 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt, const char *progname)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int parallel,
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_vacuum_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_connection(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " %s.\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 			vopt.analyze_stage = i;
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt,
+ 						progname);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		vopt.analyze_stage = -1;
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt,
+ 					progname);
+ 	}
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 687,693 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/pg_dump/parallel.c
--- b/src/bin/pg_dump/parallel.c
***************
*** 36,43 ****
  #ifdef WIN32
  static unsigned int tMasterThreadId = 0;
  static HANDLE termEvent = INVALID_HANDLE_VALUE;
- static int	pgpipe(int handles[2]);
- static int	piperead(int s, char *buf, int len);
  
  /*
   * Structure to hold info passed by _beginthreadex() to the function it calls
--- 36,41 ----
***************
*** 61,69 **** typedef struct
  static bool aborting = false;
  static volatile sig_atomic_t wantAbort = 0;
  
- #define pgpipe(a)			pipe(a)
- #define piperead(a,b,c)		read(a,b,c)
- #define pipewrite(a,b,c)	write(a,b,c)
  #endif
  
  typedef struct ShutdownInformation
--- 59,64 ----
***************
*** 1315,1417 **** readMessageFromPipe(int fd)
  
  	return NULL;
  }
- 
- #ifdef WIN32
- /*
-  * This is a replacement version of pipe for Win32 which allows returned
-  * handles to be used in select(). Note that read/write calls must be replaced
-  * with recv/send.  "handles" have to be integers so we check for errors then
-  * cast to integers.
-  */
- static int
- pgpipe(int handles[2])
- {
- 	pgsocket		s, tmp_sock;
- 	struct sockaddr_in serv_addr;
- 	int			len = sizeof(serv_addr);
- 
- 	/* We have to use the Unix socket invalid file descriptor value here. */
- 	handles[0] = handles[1] = -1;
- 
- 	/*
- 	 * setup listen socket
- 	 */
- 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not create socket: error code %d\n",
- 				  WSAGetLastError());
- 		return -1;
- 	}
- 
- 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
- 	serv_addr.sin_family = AF_INET;
- 	serv_addr.sin_port = htons(0);
- 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not bind: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if (listen(s, 1) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not listen: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: getsockname() failed: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 
- 	/*
- 	 * setup pipe handles
- 	 */
- 	if ((tmp_sock = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not create second socket: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	handles[1] = (int) tmp_sock;
- 
- 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not connect socket: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if ((tmp_sock = accept(s, (SOCKADDR *) &serv_addr, &len)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not accept connection: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(handles[1]);
- 		handles[1] = -1;
- 		closesocket(s);
- 		return -1;
- 	}
- 	handles[0] = (int) tmp_sock;
- 
- 	closesocket(s);
- 	return 0;
- }
- 
- static int
- piperead(int s, char *buf, int len)
- {
- 	int			ret = recv(s, buf, len, 0);
- 
- 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
- 		/* EOF on the pipe! (win32 socket based implementation) */
- 		ret = 0;
- 	return ret;
- }
- 
- #endif
--- 1310,1312 ----
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,1070 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ 
+ #include "common.h"
+ 
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ static HANDLE termEvent = INVALID_HANDLE_VALUE;
+ bool		parallel_init_done = false;
+ DWORD		mainThreadId;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ 
+ #else
+ /*
+  * aborting is only ever used in the master, the workers are fine with just
+  * wantAbort.
+  */
+ static bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	PGconn		  *conn;
+ } ShutdownInformation;
+ 
+ static ShutdownInformation shutdown_info;
+ 
+ static char *readMessageFromPipe(int fd);
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage);
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ static char *
+ getMessageFromMaster(int pipefd[2]);
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker);
+ 
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str);
+ 
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename, const char *fmt,
+ 		va_list ap)__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
+ 
+ 
+ #ifndef WIN32
+ static void sigTermHandler(int signum);
+ #endif
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ void horribly_exit(const char *modulename, const char *fmt,...)
+ 	__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+ 
+ void
+ init_parallel_vacuum_utils(void);
+ 
+ static void  exit_nicely(int code);
+ 
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ static void checkAborting();
+ 
+ 
+ static ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ static void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ static void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		int			nrun = 0;
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt		*vopt = wi->vopt;
+ 	ParallelSlot *mySlot = &shutdown_info.pstate->parallelSlot[worker];
+ 
+ 	conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	mySlot->args->connection = conn;
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker, vopt->analyze_stage);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			horribly_exit(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ 		pstate->parallelSlot[i].args->vopt = vopt;
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+ 		wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			pstate->parallelSlot[i].args->connection
+ 					= connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 									  vopt->username, vopt->promptPassword,
+ 									  vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(pstate->parallelSlot[i].args->connection,
+ 						pipefd, i, vopt->analyze_stage);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			horribly_exit(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ static bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ static void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		horribly_exit(modulename, "worker is terminating\n");
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ static void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ #ifndef WIN32
+ 	int			i;
+ 
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ static void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ 
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage)
+ {
+ 
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	executeMaintenanceCommand(connection, stage_commands[vacStage], false);
+ 
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 	PQExpBufferData sql;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+ 			sendMessageToMaster(pipefd, "OK");
+ 		else
+ 		{
+ 			initPQExpBuffer(&sql);
+ 			appendPQExpBuffer(&sql, "ERROR : %s",
+ 						PQerrorMessage(connection));
+ 			sendMessageToMaster(pipefd, sql.data);
+ 			termPQExpBuffer(&sql);
+ 		}
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			horribly_exit(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 		ParallelSlot *mySlot = &pstate->parallelSlot[worker];
+ 
+ 		mySlot->workerStatus = WRKR_TERMINATED;
+ 		horribly_exit(modulename,
+ 			"vacuuming of database \"%s\" failed %s",
+ 			mySlot->args->vopt->dbname, msg + strlen("ERROR "));
+ 	}
+ 	else
+ 	{
+ 		horribly_exit(modulename,
+ 				"invalid message received from worker: %s\n", msg);
+ 	}
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				horribly_exit(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			horribly_exit(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ static char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ static void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		horribly_exit(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ static char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		horribly_exit(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ static void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			horribly_exit(modulename,
+ 						  "could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * The underlying function to read a message from the communication channel
+  * (fd) with optional blocking (do_wait).
+  */
+ static char *
+ readMessageFromPipe(int fd)
+ {
+ 	char	   *msg;
+ 	int			msgsize,
+ 				bufsize;
+ 	int			ret;
+ 
+ 	/*
+ 	 * The problem here is that we need to deal with several possibilites: we
+ 	 * could receive only a partial message or several messages at once. The
+ 	 * caller expects us to return exactly one message however.
+ 	 *
+ 	 * We could either read in as much as we can and keep track of what we
+ 	 * delivered back to the caller or we just read byte by byte. Once we see
+ 	 * (char) 0, we know that it's the message's end. This would be quite
+ 	 * inefficient for more data but since we are reading only on the command
+ 	 * channel, the performance loss does not seem worth the trouble of
+ 	 * keeping internal states for different file descriptors.
+ 	 */
+ 	bufsize = 64;				/* could be any number */
+ 	msg = (char *) pg_malloc(bufsize);
+ 
+ 	msgsize = 0;
+ 	for (;;)
+ 	{
+ 		Assert(msgsize <= bufsize);
+ 		ret = piperead(fd, msg + msgsize, 1);
+ 
+ 		/* worker has closed the connection or another error happened */
+ 		if (ret <= 0)
+ 			return NULL;
+ 
+ 		Assert(ret == 1);
+ 
+ 		if (msg[msgsize] == '\0')
+ 			return msg;
+ 
+ 		msgsize++;
+ 		if (msgsize == bufsize)
+ 		{
+ 			/* could be any number */
+ 			bufsize += 16;
+ 			msg = (char *) realloc(msg, bufsize);
+ 		}
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			horribly_exit(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ static void
+ shutdown_parallel_vacuum_utils()
+ {
+ #ifdef WIN32
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ #endif
+ }
+ 
+ void
+ init_parallel_vacuum_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			exit_nicely(1);
+ 		}
+ 
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ void
+ on_exit_close_connection(PGconn *conn)
+ {
+ 	shutdown_info.conn = conn;
+ }
+ 
+ /*
+  * Fail and die, with a message to stderr.	Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does horribly_exit(), we forward its
+  * last words to the master process. The master process then does
+  * horribly_exit() with this error message itself and prints it normally.
+  * After printing the message, horribly_exit() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ horribly_exit(const char *modulename, const char *fmt,...)
+ {
+ 	va_list 	ap;
+ 	ParallelState *pstate = shutdown_info.pstate;
+ 	ParallelSlot *slot;
+ 	va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+ 		/* We're the parent, just write the message out */
+ 		vfprintf(stderr, _(fmt), ap);
+ 	}
+ 	else
+ 	{
+ 		slot = GetMyPSlot(pstate);
+ 		if (!slot)
+ 		{
+ 			if (progname)
+ 			{
+ 				if (modulename)
+ 					fprintf(stderr, "%s: [%s] ", progname, _(modulename));
+ 				else
+ 					fprintf(stderr, "%s: ", progname);
+ 			}
+ 
+ 			/* We're the parent, just write the message out */
+ 			vfprintf(stderr, _(fmt), ap);
+ 		}
+ 		else
+ 		{
+ 			/* If we're a worker process, send the msg to the master process */
+ 			parallel_msg_master(slot, modulename, fmt, ap);
+ 		}
+ 	}
+ 
+ 	va_end(ap);
+ 
+ 	exit_nicely(1);
+ }
+ 
+ static void
+ exit_nicely(int code)
+ {
+ 	if (shutdown_info.pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(shutdown_info.pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			/*
+ 			 * We're the master: We have already printed out the message
+ 			 * passed to horribly_exit() either from the master itself or from
+ 			 * a worker process. Now we need to close our own database
+ 			 * connection (only open during parallel dump but not restore) and
+ 			 * shut down the remaining workers.
+ 			 */
+ 			PQfinish(shutdown_info.conn);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(shutdown_info.pstate);
+ 		}
+ 		else if (slot->args->connection)
+ 			PQfinish(slot->args->connection);
+ 
+ 	}
+ 	else if (shutdown_info.conn)
+ 		PQfinish(shutdown_info.conn);
+ 
+ 	shutdown_parallel_vacuum_utils();
+ 	exit(code);
+ }
+ 
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,107 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ 	int		   analyze_stage;
+ }VacOpt;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ 	VacOpt *vopt;
+ } ParallelArgs;
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	ParallelArgs *args; //can pass connection handle here
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ #define NO_SLOT (-1)
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD mainThreadId;
+ #endif
+ 
+ extern const char *progname;
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern int	GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ extern void init_parallel_vacuum_utils(void);
+ extern  void on_exit_close_connection(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,34 ****
   */
  
  #include "postgres_fe.h"
- #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 11,53 ----
   */
  
  #include "postgres_fe.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt);
+ 
+ const char *progname = NULL;
  
  int
  main(int argc, char *argv[])
***************
*** 49,60 **** main(int argc, char *argv[])
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
- 	const char *progname;
  	int			optindex;
  	int			c;
  
--- 68,79 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
  	int			optindex;
  	int			c;
  
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 93,106 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 149,164 ----
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				parallel = atoi(optarg);
+ 				if (parallel <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 					progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 171,177 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 227,233 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 241,279 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										echo);
! 				}
! 			}
! 			else
! 			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 298,308 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 397,408 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
! 							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 423,667 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
! 							echo);
! 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			bool echo, int parallel, SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_vacuum_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_connection(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " %s.\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 			vopt.analyze_stage = i;
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		vopt.analyze_stage = -1;
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt);
+ 	}
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 681,687 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));
*** a/src/include/port.h
--- b/src/include/port.h
***************
*** 216,221 **** extern char *pgwin32_setlocale(int category, const char *locale);
--- 216,241 ----
  /* Portable prompt handling */
  extern char *simple_prompt(const char *prompt, int maxlen, bool echo);
  
+ /*
+  *	WIN32 doesn't allow descriptors returned by pipe() to be used in select(),
+  *	so for that platform we use socket() instead of pipe().
+  *	There is some inconsistency here because sometimes we require pg*, like
+  *	pgpipe, but in other cases we define rename to pgrename just on Win32.
+  */
+ #ifndef WIN32
+ /*
+  *	The function prototypes are not supplied because every C file
+  *	includes this file.
+  */
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #else
+ extern int	pgpipe(int handles[2]);
+ extern int	piperead(int s, char *buf, int len);
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #endif
+ 
  #ifdef WIN32
  #define PG_SIGNAL_COUNT 32
  #define kill(pid,sig)	pgkill(pid,sig)
*** /dev/null
--- b/src/port/pipe.c
***************
*** 0 ****
--- 1,122 ----
+ /*-------------------------------------------------------------------------
+  *
+  * pipe.c
+  *	  pipe()
+  *
+  * Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  *
+  *	This is a replacement version of pipe for Win32 which allows
+  *	returned handles to be used in select(). Note that read/write calls
+  *	must be replaced with recv/send.
+  *
+  * IDENTIFICATION
+  *	  src/backend/port/pipe.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "postgres.h"
+ #include "port.h"
+ #include "common/fe_memutils.h"
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.  "handles" have to be integers so we check for errors then
+  * cast to integers.
+  */
+ int
+ pgpipe(int handles[2])
+ {
+ 	pgsocket		s, tmp_sock;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	/* We have to use the Unix socket invalid file descriptor value here. */
+ 	handles[0] = handles[1] = -1;
+ 
+ 	/*
+ 	 * setup listen socket
+ 	 */
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not create socket: error code %d\n"),
+ 						WSAGetLastError());
+ 
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not bind: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not listen: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: getsockname() failed: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	/*
+ 	 * setup pipe handles
+ 	 */
+ 	if ((tmp_sock = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not create second socket: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	handles[1] = (int) tmp_sock;
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not connect socket: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((tmp_sock = accept(s, (SOCKADDR *) &serv_addr, &len)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not accept connection: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(handles[1]);
+ 		handles[1] = -1;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	handles[0] = (int) tmp_sock;
+ 
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
*** a/src/tools/msvc/Mkvcbuild.pm
--- b/src/tools/msvc/Mkvcbuild.pm
***************
*** 71,77 **** sub mkvcbuild
  	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
  	  mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
  	  sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c
! 	  win32env.c win32error.c win32setlocale.c);
  
  	push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
  
--- 71,77 ----
  	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
  	  mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
  	  sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c
! 	  win32env.c win32error.c win32setlocale.c pipe.c);
  
  	push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
  

*** a/src/bin/pg_dump/common.c
--- b/src/bin/pg_dump/common.c
***************
*** 15,21 ****
   */
  #include "pg_backup_archiver.h"
  #include "pg_backup_utils.h"
! 
  #include <ctype.h>
  
  #include "catalog/pg_class.h"
--- 15,21 ----
   */
  #include "pg_backup_archiver.h"
  #include "pg_backup_utils.h"
! #include "parallel_utils.h"
  #include <ctype.h>
  
  #include "catalog/pg_class.h"
*** a/src/bin/pg_dump/compress_io.c
--- b/src/bin/pg_dump/compress_io.c
***************
*** 184,190 **** WriteDataToArchive(ArchiveHandle *AH, CompressorState *cs,
  				   const void *data, size_t dLen)
  {
  	/* Are we aborting? */
! 	checkAborting(AH);
  
  	switch (cs->comprAlg)
  	{
--- 184,190 ----
  				   const void *data, size_t dLen)
  {
  	/* Are we aborting? */
! 	checkAborting();
  
  	switch (cs->comprAlg)
  	{
***************
*** 351,357 **** ReadDataFromArchiveZlib(ArchiveHandle *AH, ReadFunc readF)
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting(AH);
  
  		zp->next_in = (void *) buf;
  		zp->avail_in = cnt;
--- 351,357 ----
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting();
  
  		zp->next_in = (void *) buf;
  		zp->avail_in = cnt;
***************
*** 414,420 **** ReadDataFromArchiveNone(ArchiveHandle *AH, ReadFunc readF)
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting(AH);
  
  		ahwrite(buf, 1, cnt, AH);
  	}
--- 414,420 ----
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting();
  
  		ahwrite(buf, 1, cnt, AH);
  	}
*** a/src/bin/pg_dump/parallel.c
--- b/src/bin/pg_dump/parallel.c
***************
*** 20,25 ****
--- 20,26 ----
  
  #include "pg_backup_utils.h"
  #include "parallel.h"
+ #include "parallel_utils.h"
  
  #ifndef WIN32
  #include <sys/types.h>
***************
*** 35,43 ****
  /* file-scope variables */
  #ifdef WIN32
  static unsigned int tMasterThreadId = 0;
- static HANDLE termEvent = INVALID_HANDLE_VALUE;
- static int	pgpipe(int handles[2]);
- static int	piperead(int s, char *buf, int len);
  
  /*
   * Structure to hold info passed by _beginthreadex() to the function it calls
--- 36,41 ----
***************
*** 53,228 **** typedef struct
  } WorkerInfo;
  
  #define pipewrite(a,b,c)	send(a,b,c,0)
- #else
- /*
-  * aborting is only ever used in the master, the workers are fine with just
-  * wantAbort.
-  */
- static bool aborting = false;
- static volatile sig_atomic_t wantAbort = 0;
  
- #define pgpipe(a)			pipe(a)
- #define piperead(a,b,c)		read(a,b,c)
- #define pipewrite(a,b,c)	write(a,b,c)
  #endif
  
- typedef struct ShutdownInformation
- {
- 	ParallelState *pstate;
- 	Archive    *AHX;
- } ShutdownInformation;
- 
- static ShutdownInformation shutdown_info;
- 
  static const char *modulename = gettext_noop("parallel archiver");
  
- static ParallelSlot *GetMyPSlot(ParallelState *pstate);
- static void
- parallel_msg_master(ParallelSlot *slot, const char *modulename,
- 					const char *fmt, va_list ap)
  __attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
  static void archive_close_connection(int code, void *arg);
- static void ShutdownWorkersHard(ParallelState *pstate);
- static void WaitForTerminatingWorkers(ParallelState *pstate);
  
- #ifndef WIN32
- static void sigTermHandler(int signum);
- #endif
  static void SetupWorker(ArchiveHandle *AH, int pipefd[2], int worker,
  			RestoreOptions *ropt);
- static bool HasEveryWorkerTerminated(ParallelState *pstate);
  
  static void lockTableNoWait(ArchiveHandle *AH, TocEntry *te);
  static void WaitForCommands(ArchiveHandle *AH, int pipefd[2]);
- static char *getMessageFromMaster(int pipefd[2]);
- static void sendMessageToMaster(int pipefd[2], const char *str);
- static int	select_loop(int maxFd, fd_set *workerset);
- static char *getMessageFromWorker(ParallelState *pstate,
- 					 bool do_wait, int *worker);
- static void sendMessageToWorker(ParallelState *pstate,
- 					int worker, const char *str);
- static char *readMessageFromPipe(int fd);
  
  #define messageStartsWith(msg, prefix) \
  	(strncmp(msg, prefix, strlen(prefix)) == 0)
  #define messageEquals(msg, pattern) \
  	(strcmp(msg, pattern) == 0)
  
- #ifdef WIN32
- static void shutdown_parallel_dump_utils(int code, void *unused);
- bool		parallel_init_done = false;
- static DWORD tls_index;
- DWORD		mainThreadId;
- #endif
- 
- 
- #ifdef WIN32
- static void
- shutdown_parallel_dump_utils(int code, void *unused)
- {
- 	/* Call the cleanup function only from the main thread */
- 	if (mainThreadId == GetCurrentThreadId())
- 		WSACleanup();
- }
- #endif
- 
- void
- init_parallel_dump_utils(void)
- {
- #ifdef WIN32
- 	if (!parallel_init_done)
- 	{
- 		WSADATA		wsaData;
- 		int			err;
- 
- 		tls_index = TlsAlloc();
- 		mainThreadId = GetCurrentThreadId();
- 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
- 		if (err != 0)
- 		{
- 			fprintf(stderr, _("%s: WSAStartup failed: %d\n"), progname, err);
- 			exit_nicely(1);
- 		}
- 		on_exit_nicely(shutdown_parallel_dump_utils, NULL);
- 		parallel_init_done = true;
- 	}
- #endif
- }
- 
- static ParallelSlot *
- GetMyPSlot(ParallelState *pstate)
- {
- 	int			i;
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- #ifdef WIN32
- 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
- #else
- 		if (pstate->parallelSlot[i].pid == getpid())
- #endif
- 			return &(pstate->parallelSlot[i]);
- 
- 	return NULL;
- }
- 
- /*
-  * Fail and die, with a message to stderr.  Parameters as for write_msg.
-  *
-  * This is defined in parallel.c, because in parallel mode, things are more
-  * complicated. If the worker process does exit_horribly(), we forward its
-  * last words to the master process. The master process then does
-  * exit_horribly() with this error message itself and prints it normally.
-  * After printing the message, exit_horribly() on the master will shut down
-  * the remaining worker processes.
-  */
- void
- exit_horribly(const char *modulename, const char *fmt,...)
- {
- 	va_list		ap;
- 	ParallelState *pstate = shutdown_info.pstate;
- 	ParallelSlot *slot;
- 
- 	va_start(ap, fmt);
- 
- 	if (pstate == NULL)
- 	{
- 		/* Not in parallel mode, just write to stderr */
- 		vwrite_msg(modulename, fmt, ap);
- 	}
- 	else
- 	{
- 		slot = GetMyPSlot(pstate);
- 
- 		if (!slot)
- 			/* We're the parent, just write the message out */
- 			vwrite_msg(modulename, fmt, ap);
- 		else
- 			/* If we're a worker process, send the msg to the master process */
- 			parallel_msg_master(slot, modulename, fmt, ap);
- 	}
- 
- 	va_end(ap);
- 
- 	exit_nicely(1);
- }
- 
- /* Sends the error message from the worker to the master process */
- static void
- parallel_msg_master(ParallelSlot *slot, const char *modulename,
- 					const char *fmt, va_list ap)
- {
- 	char		buf[512];
- 	int			pipefd[2];
- 
- 	pipefd[PIPE_READ] = slot->pipeRevRead;
- 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
- 
- 	strcpy(buf, "ERROR ");
- 	vsnprintf(buf + strlen("ERROR "),
- 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
- 
- 	sendMessageToMaster(pipefd, buf);
- }
  
  /*
   * A thread-local version of getLocalPQExpBuffer().
--- 51,75 ----
***************
*** 280,286 **** getThreadLocalPQExpBuffer(void)
  void
  on_exit_close_archive(Archive *AHX)
  {
! 	shutdown_info.AHX = AHX;
  	on_exit_nicely(archive_close_connection, &shutdown_info);
  }
  
--- 127,133 ----
  void
  on_exit_close_archive(Archive *AHX)
  {
! 	shutdown_info.handle = (void*)AHX;
  	on_exit_nicely(archive_close_connection, &shutdown_info);
  }
  
***************
*** 306,312 **** archive_close_connection(int code, void *arg)
  			 * connection (only open during parallel dump but not restore) and
  			 * shut down the remaining workers.
  			 */
! 			DisconnectDatabase(si->AHX);
  #ifndef WIN32
  
  			/*
--- 153,159 ----
  			 * connection (only open during parallel dump but not restore) and
  			 * shut down the remaining workers.
  			 */
! 			DisconnectDatabase((Archive*)si->handle);
  #ifndef WIN32
  
  			/*
***************
*** 318,436 **** archive_close_connection(int code, void *arg)
  #endif
  			ShutdownWorkersHard(si->pstate);
  		}
! 		else if (slot->args->AH)
! 			DisconnectDatabase(&(slot->args->AH->public));
  	}
! 	else if (si->AHX)
! 		DisconnectDatabase(si->AHX);
  }
  
  /*
-  * If we have one worker that terminates for some reason, we'd like the other
-  * threads to terminate as well (and not finish with their 70 GB table dump
-  * first...). Now in UNIX we can just kill these processes, and let the signal
-  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
-  * as the signal for everyone to terminate.
-  */
- void
- checkAborting(ArchiveHandle *AH)
- {
- #ifdef WIN32
- 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
- #else
- 	if (wantAbort)
- #endif
- 		exit_horribly(modulename, "worker is terminating\n");
- }
- 
- /*
-  * Shut down any remaining workers, this has an implicit do_wait == true.
-  *
-  * The fastest way we can make the workers terminate gracefully is when
-  * they are listening for new commands and we just tell them to terminate.
-  */
- static void
- ShutdownWorkersHard(ParallelState *pstate)
- {
- #ifndef WIN32
- 	int			i;
- 
- 	signal(SIGPIPE, SIG_IGN);
- 
- 	/*
- 	 * Close our write end of the sockets so that the workers know they can
- 	 * exit.
- 	 */
- 	for (i = 0; i < pstate->numWorkers; i++)
- 		closesocket(pstate->parallelSlot[i].pipeWrite);
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 		kill(pstate->parallelSlot[i].pid, SIGTERM);
- #else
- 	/* The workers monitor this event via checkAborting(). */
- 	SetEvent(termEvent);
- #endif
- 
- 	WaitForTerminatingWorkers(pstate);
- }
- 
- /*
-  * Wait for the termination of the processes using the OS-specific method.
-  */
- static void
- WaitForTerminatingWorkers(ParallelState *pstate)
- {
- 	while (!HasEveryWorkerTerminated(pstate))
- 	{
- 		ParallelSlot *slot = NULL;
- 		int			j;
- 
- #ifndef WIN32
- 		int			status;
- 		pid_t		pid = wait(&status);
- 
- 		for (j = 0; j < pstate->numWorkers; j++)
- 			if (pstate->parallelSlot[j].pid == pid)
- 				slot = &(pstate->parallelSlot[j]);
- #else
- 		uintptr_t	hThread;
- 		DWORD		ret;
- 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
- 		int			nrun = 0;
- 
- 		for (j = 0; j < pstate->numWorkers; j++)
- 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
- 			{
- 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
- 				nrun++;
- 			}
- 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
- 		Assert(ret != WAIT_FAILED);
- 		hThread = lpHandles[ret - WAIT_OBJECT_0];
- 
- 		for (j = 0; j < pstate->numWorkers; j++)
- 			if (pstate->parallelSlot[j].hThread == hThread)
- 				slot = &(pstate->parallelSlot[j]);
- 
- 		free(lpHandles);
- #endif
- 		Assert(slot);
- 
- 		slot->workerStatus = WRKR_TERMINATED;
- 	}
- 	Assert(HasEveryWorkerTerminated(pstate));
- }
- 
- #ifndef WIN32
- /* Signal handling (UNIX only) */
- static void
- sigTermHandler(int signum)
- {
- 	wantAbort = 1;
- }
- #endif
- 
- /*
   * This function is called by both UNIX and Windows variants to set up a
   * worker process.
   */
--- 165,178 ----
  #endif
  			ShutdownWorkersHard(si->pstate);
  		}
! 		else if (((ParallelArgs*)slot->args)->AH)
! 			DisconnectDatabase(&(((ParallelArgs*)slot->args)->AH->public));
  	}
! 	else if ((ArchiveHandle*)si->handle)
! 		DisconnectDatabase((Archive*)si->handle);
  }
  
  /*
   * This function is called by both UNIX and Windows variants to set up a
   * worker process.
   */
***************
*** 537,544 **** ParallelBackupStart(ArchiveHandle *AH, RestoreOptions *ropt)
  
  		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
  		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
! 		pstate->parallelSlot[i].args->AH = NULL;
! 		pstate->parallelSlot[i].args->te = NULL;
  #ifdef WIN32
  		/* Allocate a new structure for every worker */
  		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
--- 279,286 ----
  
  		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
  		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
! 		((ParallelArgs*)pstate->parallelSlot[i].args)->AH = NULL;
! 		((ParallelArgs*)pstate->parallelSlot[i].args)->te = NULL;
  #ifdef WIN32
  		/* Allocate a new structure for every worker */
  		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
***************
*** 581,587 **** ParallelBackupStart(ArchiveHandle *AH, RestoreOptions *ropt)
  			 * and also clones the database connection (for parallel dump)
  			 * which both seem kinda helpful.
  			 */
! 			pstate->parallelSlot[i].args->AH = CloneArchive(AH);
  
  			/* close read end of Worker -> Master */
  			closesocket(pipeWM[PIPE_READ]);
--- 323,329 ----
  			 * and also clones the database connection (for parallel dump)
  			 * which both seem kinda helpful.
  			 */
! 			((ParallelArgs*)pstate->parallelSlot[i].args)->AH = CloneArchive(AH);
  
  			/* close read end of Worker -> Master */
  			closesocket(pipeWM[PIPE_READ]);
***************
*** 598,604 **** ParallelBackupStart(ArchiveHandle *AH, RestoreOptions *ropt)
  				closesocket(pstate->parallelSlot[j].pipeWrite);
  			}
  
! 			SetupWorker(pstate->parallelSlot[i].args->AH, pipefd, i, ropt);
  
  			exit(0);
  		}
--- 340,346 ----
  				closesocket(pstate->parallelSlot[j].pipeWrite);
  			}
  
! 			SetupWorker(((ParallelArgs*)pstate->parallelSlot[i].args)->AH, pipefd, i, ropt);
  
  			exit(0);
  		}
***************
*** 738,786 **** DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te,
  	sendMessageToWorker(pstate, worker, arg);
  
  	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
! 	pstate->parallelSlot[worker].args->te = te;
! }
! 
! /*
!  * Find the first free parallel slot (if any).
!  */
! int
! GetIdleWorker(ParallelState *pstate)
! {
! 	int			i;
! 
! 	for (i = 0; i < pstate->numWorkers; i++)
! 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
! 			return i;
! 	return NO_SLOT;
! }
! 
! /*
!  * Return true iff every worker process is in the WRKR_TERMINATED state.
!  */
! static bool
! HasEveryWorkerTerminated(ParallelState *pstate)
! {
! 	int			i;
! 
! 	for (i = 0; i < pstate->numWorkers; i++)
! 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
! 			return false;
! 	return true;
! }
! 
! /*
!  * Return true iff every worker is in the WRKR_IDLE state.
!  */
! bool
! IsEveryWorkerIdle(ParallelState *pstate)
! {
! 	int			i;
! 
! 	for (i = 0; i < pstate->numWorkers; i++)
! 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
! 			return false;
! 	return true;
  }
  
  /*
--- 480,486 ----
  	sendMessageToWorker(pstate, worker, arg);
  
  	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
! 	((ParallelArgs*)pstate->parallelSlot[worker].args)->te = te;
  }
  
  /*
***************
*** 966,972 **** ListenToWorkers(ArchiveHandle *AH, ParallelState *pstate, bool do_wait)
  		TocEntry   *te;
  
  		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
! 		te = pstate->parallelSlot[worker].args->te;
  		if (messageStartsWith(msg, "OK RESTORE "))
  		{
  			statusString = msg + strlen("OK RESTORE ");
--- 666,672 ----
  		TocEntry   *te;
  
  		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
! 		te = ((ParallelArgs*)pstate->parallelSlot[worker].args)->te;
  		if (messageStartsWith(msg, "OK RESTORE "))
  		{
  			statusString = msg + strlen("OK RESTORE ");
***************
*** 1001,1031 **** ListenToWorkers(ArchiveHandle *AH, ParallelState *pstate, bool do_wait)
  /*
   * This function is executed in the master process.
   *
-  * This function is used to get the return value of a terminated worker
-  * process. If a process has terminated, its status is stored in *status and
-  * the id of the worker is returned.
-  */
- int
- ReapWorkerStatus(ParallelState *pstate, int *status)
- {
- 	int			i;
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 	{
- 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
- 		{
- 			*status = pstate->parallelSlot[i].status;
- 			pstate->parallelSlot[i].status = 0;
- 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
- 			return i;
- 		}
- 	}
- 	return NO_SLOT;
- }
- 
- /*
-  * This function is executed in the master process.
-  *
   * It looks for an idle worker process and only returns if there is one.
   */
  void
--- 701,706 ----
***************
*** 1089,1417 **** EnsureWorkersFinished(ArchiveHandle *AH, ParallelState *pstate)
  	}
  }
  
- /*
-  * This function is executed in the worker process.
-  *
-  * It returns the next message on the communication channel, blocking until it
-  * becomes available.
-  */
- static char *
- getMessageFromMaster(int pipefd[2])
- {
- 	return readMessageFromPipe(pipefd[PIPE_READ]);
- }
- 
- /*
-  * This function is executed in the worker process.
-  *
-  * It sends a message to the master on the communication channel.
-  */
- static void
- sendMessageToMaster(int pipefd[2], const char *str)
- {
- 	int			len = strlen(str) + 1;
- 
- 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
- 		exit_horribly(modulename,
- 					  "could not write to the communication channel: %s\n",
- 					  strerror(errno));
- }
- 
- /*
-  * A select loop that repeats calling select until a descriptor in the read
-  * set becomes readable. On Windows we have to check for the termination event
-  * from time to time, on Unix we can just block forever.
-  */
- static int
- select_loop(int maxFd, fd_set *workerset)
- {
- 	int			i;
- 	fd_set		saveSet = *workerset;
- 
- #ifdef WIN32
- 	/* should always be the master */
- 	Assert(tMasterThreadId == GetCurrentThreadId());
- 
- 	for (;;)
- 	{
- 		/*
- 		 * sleep a quarter of a second before checking if we should terminate.
- 		 */
- 		struct timeval tv = {0, 250000};
- 
- 		*workerset = saveSet;
- 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
- 
- 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
- 			continue;
- 		if (i)
- 			break;
- 	}
- #else							/* UNIX */
- 
- 	for (;;)
- 	{
- 		*workerset = saveSet;
- 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
- 
- 		/*
- 		 * If we Ctrl-C the master process , it's likely that we interrupt
- 		 * select() here. The signal handler will set wantAbort == true and
- 		 * the shutdown journey starts from here. Note that we'll come back
- 		 * here later when we tell all workers to terminate and read their
- 		 * responses. But then we have aborting set to true.
- 		 */
- 		if (wantAbort && !aborting)
- 			exit_horribly(modulename, "terminated by user\n");
- 
- 		if (i < 0 && errno == EINTR)
- 			continue;
- 		break;
- 	}
- #endif
- 
- 	return i;
- }
- 
- 
- /*
-  * This function is executed in the master process.
-  *
-  * It returns the next message from the worker on the communication channel,
-  * optionally blocking (do_wait) until it becomes available.
-  *
-  * The id of the worker is returned in *worker.
-  */
- static char *
- getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
- {
- 	int			i;
- 	fd_set		workerset;
- 	int			maxFd = -1;
- 	struct timeval nowait = {0, 0};
- 
- 	FD_ZERO(&workerset);
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 	{
- 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
- 			continue;
- 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
- 		/* actually WIN32 ignores the first parameter to select()... */
- 		if (pstate->parallelSlot[i].pipeRead > maxFd)
- 			maxFd = pstate->parallelSlot[i].pipeRead;
- 	}
- 
- 	if (do_wait)
- 	{
- 		i = select_loop(maxFd, &workerset);
- 		Assert(i != 0);
- 	}
- 	else
- 	{
- 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
- 			return NULL;
- 	}
- 
- 	if (i < 0)
- 		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 	{
- 		char	   *msg;
- 
- 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
- 			continue;
- 
- 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
- 		*worker = i;
- 		return msg;
- 	}
- 	Assert(false);
- 	return NULL;
- }
- 
- /*
-  * This function is executed in the master process.
-  *
-  * It sends a message to a certain worker on the communication channel.
-  */
- static void
- sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
- {
- 	int			len = strlen(str) + 1;
- 
- 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
- 	{
- 		/*
- 		 * If we're already aborting anyway, don't care if we succeed or not.
- 		 * The child might have gone already.
- 		 */
- #ifndef WIN32
- 		if (!aborting)
- #endif
- 			exit_horribly(modulename,
- 						"could not write to the communication channel: %s\n",
- 						  strerror(errno));
- 	}
- }
- 
- /*
-  * The underlying function to read a message from the communication channel
-  * (fd) with optional blocking (do_wait).
-  */
- static char *
- readMessageFromPipe(int fd)
- {
- 	char	   *msg;
- 	int			msgsize,
- 				bufsize;
- 	int			ret;
- 
- 	/*
- 	 * The problem here is that we need to deal with several possibilites: we
- 	 * could receive only a partial message or several messages at once. The
- 	 * caller expects us to return exactly one message however.
- 	 *
- 	 * We could either read in as much as we can and keep track of what we
- 	 * delivered back to the caller or we just read byte by byte. Once we see
- 	 * (char) 0, we know that it's the message's end. This would be quite
- 	 * inefficient for more data but since we are reading only on the command
- 	 * channel, the performance loss does not seem worth the trouble of
- 	 * keeping internal states for different file descriptors.
- 	 */
- 	bufsize = 64;				/* could be any number */
- 	msg = (char *) pg_malloc(bufsize);
- 
- 	msgsize = 0;
- 	for (;;)
- 	{
- 		Assert(msgsize <= bufsize);
- 		ret = piperead(fd, msg + msgsize, 1);
- 
- 		/* worker has closed the connection or another error happened */
- 		if (ret <= 0)
- 			break;
- 
- 		Assert(ret == 1);
- 
- 		if (msg[msgsize] == '\0')
- 			return msg;
- 
- 		msgsize++;
- 		if (msgsize == bufsize)
- 		{
- 			/* could be any number */
- 			bufsize += 16;
- 			msg = (char *) realloc(msg, bufsize);
- 		}
- 	}
- 
- 	/*
- 	 * Worker has closed the connection, make sure to clean up before return
- 	 * since we are not returning msg (but did allocate it).
- 	 */
- 	free(msg);
- 
- 	return NULL;
- }
- 
- #ifdef WIN32
- /*
-  * This is a replacement version of pipe for Win32 which allows returned
-  * handles to be used in select(). Note that read/write calls must be replaced
-  * with recv/send.  "handles" have to be integers so we check for errors then
-  * cast to integers.
-  */
- static int
- pgpipe(int handles[2])
- {
- 	pgsocket		s, tmp_sock;
- 	struct sockaddr_in serv_addr;
- 	int			len = sizeof(serv_addr);
- 
- 	/* We have to use the Unix socket invalid file descriptor value here. */
- 	handles[0] = handles[1] = -1;
- 
- 	/*
- 	 * setup listen socket
- 	 */
- 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not create socket: error code %d\n",
- 				  WSAGetLastError());
- 		return -1;
- 	}
- 
- 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
- 	serv_addr.sin_family = AF_INET;
- 	serv_addr.sin_port = htons(0);
- 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not bind: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if (listen(s, 1) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not listen: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: getsockname() failed: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 
- 	/*
- 	 * setup pipe handles
- 	 */
- 	if ((tmp_sock = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not create second socket: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	handles[1] = (int) tmp_sock;
- 
- 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not connect socket: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if ((tmp_sock = accept(s, (SOCKADDR *) &serv_addr, &len)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not accept connection: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(handles[1]);
- 		handles[1] = -1;
- 		closesocket(s);
- 		return -1;
- 	}
- 	handles[0] = (int) tmp_sock;
- 
- 	closesocket(s);
- 	return 0;
- }
- 
- static int
- piperead(int s, char *buf, int len)
- {
- 	int			ret = recv(s, buf, len, 0);
- 
- 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
- 		/* EOF on the pipe! (win32 socket based implementation) */
- 		ret = 0;
- 	return ret;
- }
- 
- #endif
--- 764,766 ----
*** a/src/bin/pg_dump/parallel.h
--- b/src/bin/pg_dump/parallel.h
***************
*** 20,37 ****
  #define PG_DUMP_PARALLEL_H
  
  #include "pg_backup_db.h"
  
  struct _archiveHandle;
  struct _tocEntry;
  
- typedef enum
- {
- 	WRKR_TERMINATED = 0,
- 	WRKR_IDLE,
- 	WRKR_WORKING,
- 	WRKR_FINISHED
- } T_WorkerStatus;
- 
  /* Arguments needed for a worker process */
  typedef struct ParallelArgs
  {
--- 20,30 ----
  #define PG_DUMP_PARALLEL_H
  
  #include "pg_backup_db.h"
+ #include "parallel_utils.h"
  
  struct _archiveHandle;
  struct _tocEntry;
  
  /* Arguments needed for a worker process */
  typedef struct ParallelArgs
  {
***************
*** 39,81 **** typedef struct ParallelArgs
  	struct _tocEntry *te;
  } ParallelArgs;
  
- /* State for each parallel activity slot */
- typedef struct ParallelSlot
- {
- 	ParallelArgs *args;
- 	T_WorkerStatus workerStatus;
- 	int			status;
- 	int			pipeRead;
- 	int			pipeWrite;
- 	int			pipeRevRead;
- 	int			pipeRevWrite;
- #ifdef WIN32
- 	uintptr_t	hThread;
- 	unsigned int threadId;
- #else
- 	pid_t		pid;
- #endif
- } ParallelSlot;
- 
- #define NO_SLOT (-1)
- 
- typedef struct ParallelState
- {
- 	int			numWorkers;
- 	ParallelSlot *parallelSlot;
- } ParallelState;
- 
- #ifdef WIN32
- extern bool parallel_init_done;
- extern DWORD mainThreadId;
- #endif
- 
- extern void init_parallel_dump_utils(void);
- 
- extern int	GetIdleWorker(ParallelState *pstate);
- extern bool IsEveryWorkerIdle(ParallelState *pstate);
  extern void ListenToWorkers(struct _archiveHandle * AH, ParallelState *pstate, bool do_wait);
- extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
  extern void EnsureIdleWorker(struct _archiveHandle * AH, ParallelState *pstate);
  extern void EnsureWorkersFinished(struct _archiveHandle * AH, ParallelState *pstate);
  
--- 32,38 ----
***************
*** 86,95 **** extern void DispatchJobForTocEntry(struct _archiveHandle * AH,
  					   struct _tocEntry * te, T_Action act);
  extern void ParallelBackupEnd(struct _archiveHandle * AH, ParallelState *pstate);
  
- extern void checkAborting(struct _archiveHandle * AH);
- 
- extern void
- exit_horribly(const char *modulename, const char *fmt,...)
- __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
- 
  #endif   /* PG_DUMP_PARALLEL_H */
--- 43,46 ----
*** a/src/bin/pg_dump/pg_backup_archiver.c
--- b/src/bin/pg_dump/pg_backup_archiver.c
***************
*** 3825,3834 **** get_next_work_item(ArchiveHandle *AH, TocEntry *ready_list,
  	if (pref_non_data)
  	{
  		int			count = 0;
! 
  		for (k = 0; k < pstate->numWorkers; k++)
! 			if (pstate->parallelSlot[k].args->te != NULL &&
! 				pstate->parallelSlot[k].args->te->section == SECTION_DATA)
  				count++;
  		if (pstate->numWorkers == 0 || count * 4 < pstate->numWorkers)
  			pref_non_data = false;
--- 3825,3834 ----
  	if (pref_non_data)
  	{
  		int			count = 0;
! 		
  		for (k = 0; k < pstate->numWorkers; k++)
! 			if (((ParallelArgs*)pstate->parallelSlot[k].args)->te != NULL &&
! 				((ParallelArgs*)pstate->parallelSlot[k].args)->te->section == SECTION_DATA)
  				count++;
  		if (pstate->numWorkers == 0 || count * 4 < pstate->numWorkers)
  			pref_non_data = false;
***************
*** 3852,3858 **** get_next_work_item(ArchiveHandle *AH, TocEntry *ready_list,
  
  			if (pstate->parallelSlot[i].workerStatus != WRKR_WORKING)
  				continue;
! 			running_te = pstate->parallelSlot[i].args->te;
  
  			if (has_lock_conflicts(te, running_te) ||
  				has_lock_conflicts(running_te, te))
--- 3852,3858 ----
  
  			if (pstate->parallelSlot[i].workerStatus != WRKR_WORKING)
  				continue;
! 			running_te = ((ParallelArgs*)pstate->parallelSlot[i].args)->te;
  
  			if (has_lock_conflicts(te, running_te) ||
  				has_lock_conflicts(running_te, te))
***************
*** 3926,3932 **** mark_work_done(ArchiveHandle *AH, TocEntry *ready_list,
  {
  	TocEntry   *te = NULL;
  
! 	te = pstate->parallelSlot[worker].args->te;
  
  	if (te == NULL)
  		exit_horribly(modulename, "could not find slot of finished worker\n");
--- 3926,3932 ----
  {
  	TocEntry   *te = NULL;
  
! 	te = ((ParallelArgs*)pstate->parallelSlot[worker].args)->te;
  
  	if (te == NULL)
  		exit_horribly(modulename, "could not find slot of finished worker\n");
*** a/src/bin/pg_dump/pg_backup_directory.c
--- b/src/bin/pg_dump/pg_backup_directory.c
***************
*** 35,42 ****
  
  #include "compress_io.h"
  #include "pg_backup_utils.h"
  #include "parallel.h"
- 
  #include <dirent.h>
  #include <sys/stat.h>
  
--- 35,42 ----
  
  #include "compress_io.h"
  #include "pg_backup_utils.h"
+ #include "parallel_utils.h"
  #include "parallel.h"
  #include <dirent.h>
  #include <sys/stat.h>
  
***************
*** 356,362 **** _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting(AH);
  
  	if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen)
  		WRITE_ERROR_EXIT;
--- 356,362 ----
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting();
  
  	if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen)
  		WRITE_ERROR_EXIT;
***************
*** 524,530 **** _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting(AH);
  
  	if (cfwrite(buf, len, ctx->dataFH) != len)
  		WRITE_ERROR_EXIT;
--- 524,530 ----
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting();
  
  	if (cfwrite(buf, len, ctx->dataFH) != len)
  		WRITE_ERROR_EXIT;
*** a/src/bin/pg_dump/pg_backup_utils.c
--- b/src/bin/pg_dump/pg_backup_utils.c
***************
*** 15,33 ****
  
  #include "pg_backup_utils.h"
  #include "parallel.h"
! 
  /* Globals exported by this file */
  const char *progname = NULL;
  
- #define MAX_ON_EXIT_NICELY				20
- 
- static struct
- {
- 	on_exit_nicely_callback function;
- 	void	   *arg;
- }	on_exit_nicely_list[MAX_ON_EXIT_NICELY];
- 
- static int	on_exit_nicely_index;
  
  /*
   * Parse a --section=foo command line argument.
--- 15,24 ----
  
  #include "pg_backup_utils.h"
  #include "parallel.h"
! #include "parallel_utils.h"
  /* Globals exported by this file */
  const char *progname = NULL;
  
  
  /*
   * Parse a --section=foo command line argument.
***************
*** 60,126 **** set_dump_section(const char *arg, int *dumpSections)
  }
  
  
- /*
-  * Write a printf-style message to stderr.
-  *
-  * The program name is prepended, if "progname" has been set.
-  * Also, if modulename isn't NULL, that's included too.
-  * Note that we'll try to translate the modulename and the fmt string.
-  */
- void
- write_msg(const char *modulename, const char *fmt,...)
- {
- 	va_list		ap;
- 
- 	va_start(ap, fmt);
- 	vwrite_msg(modulename, fmt, ap);
- 	va_end(ap);
- }
- 
- /*
-  * As write_msg, but pass a va_list not variable arguments.
-  */
- void
- vwrite_msg(const char *modulename, const char *fmt, va_list ap)
- {
- 	if (progname)
- 	{
- 		if (modulename)
- 			fprintf(stderr, "%s: [%s] ", progname, _(modulename));
- 		else
- 			fprintf(stderr, "%s: ", progname);
- 	}
- 	vfprintf(stderr, _(fmt), ap);
- }
- 
- /* Register a callback to be run when exit_nicely is invoked. */
- void
- on_exit_nicely(on_exit_nicely_callback function, void *arg)
- {
- 	if (on_exit_nicely_index >= MAX_ON_EXIT_NICELY)
- 		exit_horribly(NULL, "out of on_exit_nicely slots\n");
- 	on_exit_nicely_list[on_exit_nicely_index].function = function;
- 	on_exit_nicely_list[on_exit_nicely_index].arg = arg;
- 	on_exit_nicely_index++;
- }
- 
- /*
-  * Run accumulated on_exit_nicely callbacks in reverse order and then exit
-  * quietly.  This needs to be thread-safe.
-  */
- void
- exit_nicely(int code)
- {
- 	int			i;
- 
- 	for (i = on_exit_nicely_index - 1; i >= 0; i--)
- 		(*on_exit_nicely_list[i].function) (code,
- 											on_exit_nicely_list[i].arg);
- 
- #ifdef WIN32
- 	if (parallel_init_done && GetCurrentThreadId() != mainThreadId)
- 		ExitThread(code);
- #endif
- 
- 	exit(code);
- }
--- 51,53 ----
*** a/src/bin/pg_dump/pg_backup_utils.h
--- b/src/bin/pg_dump/pg_backup_utils.h
***************
*** 23,40 **** typedef enum					/* bits returned by set_dump_section */
  	DUMP_UNSECTIONED = 0xff
  } DumpSections;
  
- typedef void (*on_exit_nicely_callback) (int code, void *arg);
- 
- extern const char *progname;
- 
  extern void set_dump_section(const char *arg, int *dumpSections);
- extern void
- write_msg(const char *modulename, const char *fmt,...)
- __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
- extern void
- vwrite_msg(const char *modulename, const char *fmt, va_list ap)
- __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 0)));
- extern void on_exit_nicely(on_exit_nicely_callback function, void *arg);
- extern void exit_nicely(int code) __attribute__((noreturn));
- 
  #endif   /* PG_BACKUP_UTILS_H */
--- 23,27 ----
*** /dev/null
--- b/src/include/parallel_utils.h
***************
*** 0 ****
--- 1,176 ----
+ /*-------------------------------------------------------------------------
+  *
+  * parallel_utils.h
+  *	  Header for src/port/ parallel execution functions.
+  *
+  * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * src/include/port.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ #ifndef PARALLEL_UTILS_H
+ #define PARALLEL_UTILS_H
+ 
+ #include <ctype.h>
+ #include <netdb.h>
+ #include <pwd.h>
+ 
+ /*
+  *	WIN32 doesn't allow descriptors returned by pipe() to be used in select(),
+  *	so for that platform we use socket() instead of pipe().
+  *	There is some inconsistency here because sometimes we require pg*, like
+  *	pgpipe, but in other cases we define rename to pgrename just on Win32.
+  */
+ #ifndef WIN32
+ /*
+  *	The function prototypes are not supplied because every C file
+  *	includes this file.
+  */
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #else
+ extern int	pgpipe(int handles[2]);
+ extern int	piperead(int s, char *buf, int len);
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #endif
+ 
+ #ifdef WIN32
+ #define PG_SIGNAL_COUNT 32
+ #define kill(pid,sig)	pgkill(pid,sig)
+ extern int	pgkill(int pid, int sig);
+ #endif
+ 
+ #ifdef WIN32
+ extern DWORD mainThreadId;
+ extern bool parallel_init_done;
+ extern HANDLE termEvent;
+ 
+ #endif
+ 
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ #define NO_SLOT (-1)
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	void *args;
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	void     *handle;
+ } ShutdownInformation;
+ 
+ extern ShutdownInformation shutdown_info;
+ 
+ #define MAX_ON_EXIT_NICELY				20
+ 
+ typedef void (*on_exit_nicely_callback) (int code, void *arg);
+ 
+ typedef struct on_exit_nicely_stru
+ {
+ 	on_exit_nicely_callback function;
+ 	void	   *arg;
+ }on_exit_nicely_stru;
+ 
+ extern on_exit_nicely_stru on_exit_nicely_list[MAX_ON_EXIT_NICELY];
+ 
+ extern int	on_exit_nicely_index;
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD tls_index;
+ 
+ #else
+ extern bool aborting;
+ 
+ #endif
+ 
+ extern const char *progname;
+ 
+ extern char *
+ readMessageFromPipe(int fd);
+ 
+ void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
+ 
+ extern void ShutdownWorkersHard(ParallelState *pstate);
+ extern void WaitForTerminatingWorkers(ParallelState *pstate);
+ 
+ extern bool HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ extern char *getMessageFromMaster(int pipefd[2]);
+ extern void sendMessageToMaster(int pipefd[2], const char *str);
+ extern int	select_loop(int maxFd, fd_set *workerset);
+ extern char *getMessageFromWorker(ParallelState *pstate,
+ 					 bool do_wait, int *worker);
+ extern void sendMessageToWorker(ParallelState *pstate,
+ 					int worker, const char *str);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ 
+ extern ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ 
+ extern void init_parallel_dump_utils(void);
+ extern int GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void checkAborting();
+ 
+ extern void
+ write_msg(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+ extern void
+ vwrite_msg(const char *modulename, const char *fmt, va_list ap)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 0)));
+ extern void on_exit_nicely(on_exit_nicely_callback function, void *arg);
+ extern void exit_nicely(int code) __attribute__((noreturn));
+ 
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ #ifndef WIN32
+ extern void sigTermHandler(int signum);
+ #endif
+ 
+ #ifdef WIN32
+ extern void shutdown_parallel_dump_utils(int code, void *unused);
+ #endif
+ 
+ #endif   /* PARALLEL_UTILS_H */
*** a/src/port/Makefile
--- b/src/port/Makefile
***************
*** 33,39 **** LIBS += $(PTHREAD_LIBS)
  OBJS = $(LIBOBJS) chklocale.o dirmod.o erand48.o fls.o inet_net_ntop.o \
  	noblock.o path.o pgcheckdir.o pg_crc.o pgmkdirp.o pgsleep.o \
  	pgstrcasecmp.o pqsignal.o \
! 	qsort.o qsort_arg.o quotes.o sprompt.o tar.o thread.o
  
  # foo_srv.o and foo.o are both built from foo.c, but only foo.o has -DFRONTEND
  OBJS_SRV = $(OBJS:%.o=%_srv.o)
--- 33,39 ----
  OBJS = $(LIBOBJS) chklocale.o dirmod.o erand48.o fls.o inet_net_ntop.o \
  	noblock.o path.o pgcheckdir.o pg_crc.o pgmkdirp.o pgsleep.o \
  	pgstrcasecmp.o pqsignal.o \
! 	qsort.o qsort_arg.o quotes.o sprompt.o tar.o thread.o parallel_utils.o
  
  # foo_srv.o and foo.o are both built from foo.c, but only foo.o has -DFRONTEND
  OBJS_SRV = $(OBJS:%.o=%_srv.o)
*** /dev/null
--- b/src/port/parallel_utils.c
***************
*** 0 ****
--- 1,737 ----
+ /*-------------------------------------------------------------------------
+  *
+  * parallel_utils.c
+  *	  kill()
+  *
+  * Copyright (c) 1996-2014, PostgreSQL Global Development Group
+  *
+  *	Utility function for supporing parallel execution in client tools
+  *
+  * IDENTIFICATION
+  *	  src/port/parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "postgres.h"
+ #include "parallel_utils.h"
+ #include "common/fe_memutils.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ 
+ #endif
+ 
+ 
+ #ifdef WIN32
+ DWORD		 mainThreadId;
+ bool parallel_init_done = false;
+ HANDLE termEvent = INVALID_HANDLE_VALUE;
+ DWORD tls_index;
+ #else
+ bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel utils");
+ 
+ ShutdownInformation shutdown_info;
+ int  on_exit_nicely_index;
+ on_exit_nicely_stru on_exit_nicely_list[MAX_ON_EXIT_NICELY];
+ 
+ 
+ 
+  /*
+   * The underlying function to read a message from the communication channel
+   * (fd) with optional blocking (do_wait).
+   */
+ char *
+ readMessageFromPipe(int fd)
+ {
+  char		*msg;
+  int		 msgsize,
+ 			 bufsize;
+  int		 ret;
+ 
+  /*
+   * The problem here is that we need to deal with several possibilites: we
+   * could receive only a partial message or several messages at once. The
+   * caller expects us to return exactly one message however.
+   *
+   * We could either read in as much as we can and keep track of what we
+   * delivered back to the caller or we just read byte by byte. Once we see
+   * (char) 0, we know that it's the message's end. This would be quite
+   * inefficient for more data but since we are reading only on the command
+   * channel, the performance loss does not seem worth the trouble of
+   * keeping internal states for different file descriptors.
+   */
+  bufsize = 64;				 /* could be any number */
+  msg = (char *)malloc(bufsize);
+  if (!msg)
+  {
+ 	 fprintf(stderr, _("out of memory\n"));
+ 	 exit(1);
+  }
+ 
+ 
+  msgsize = 0;
+  for (;;)
+  {
+ 	 Assert(msgsize <= bufsize);
+ 	 ret = piperead(fd, msg + msgsize, 1);
+ 
+ 	 /* worker has closed the connection or another error happened */
+ 	 if (ret <= 0)
+ 		 return NULL;
+ 
+ 	 Assert(ret == 1);
+ 
+ 	 if (msg[msgsize] == '\0')
+ 		 return msg;
+ 
+ 	 msgsize++;
+ 	 if (msgsize == bufsize)
+ 	 {
+ 		 /* could be any number */
+ 		 bufsize += 16;
+ 		 msg = (char *) realloc(msg, bufsize);
+ 	 }
+  }
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.  "handles" have to be integers so we check for errors then
+  * cast to integers.
+  */
+ int
+ pgpipe(int handles[2])
+ {
+ 	pgsocket		s, tmp_sock;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	/* We have to use the Unix socket invalid file descriptor value here. */
+ 	handles[0] = handles[1] = -1;
+ 
+ 	/*
+ 	 * setup listen socket
+ 	 */
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not create socket: error code %d\n"),
+ 						WSAGetLastError());
+ 
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not bind: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not listen: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: getsockname() failed: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	/*
+ 	 * setup pipe handles
+ 	 */
+ 	if ((tmp_sock = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not create second socket: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	handles[1] = (int) tmp_sock;
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not connect socket: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((tmp_sock = accept(s, (SOCKADDR *) &serv_addr, &len)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not accept connection: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(handles[1]);
+ 		handles[1] = -1;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	handles[0] = (int) tmp_sock;
+ 
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ 
+ #ifdef WIN32
+ void
+ shutdown_parallel_dump_utils(int code, void *unused)
+ {
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ }
+ #endif
+ 
+ void
+ init_parallel_dump_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		tls_index = TlsAlloc();
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			fprintf(stderr, _("%s: WSAStartup failed: %d\n"), progname, err);
+ 			exit_nicely(1);
+ 		}
+ 		on_exit_nicely(shutdown_parallel_dump_utils, NULL);
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ 
+ /*
+  * Fail and die, with a message to stderr.  Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does exit_horribly(), we forward its
+  * last words to the master process. The master process then does
+  * exit_horribly() with this error message itself and prints it normally.
+  * After printing the message, exit_horribly() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ {
+ 	va_list		ap;
+ 	ParallelState *pstate = shutdown_info.pstate;
+ 	ParallelSlot *slot;
+ 
+ 	va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+ 		/* Not in parallel mode, just write to stderr */
+ 		vwrite_msg(modulename, fmt, ap);
+ 	}
+ 	else
+ 	{
+ 		slot = GetMyPSlot(pstate);
+ 
+ 		if (!slot)
+ 			/* We're the parent, just write the message out */
+ 			vwrite_msg(modulename, fmt, ap);
+ 		else
+ 			/* If we're a worker process, send the msg to the master process */
+ 			parallel_msg_master(slot, modulename, fmt, ap);
+ 	}
+ 
+ 	va_end(ap);
+ 
+ 	exit_nicely(1);
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ 	int 		i;
+ 
+ #ifndef WIN32
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles;
+ 		int			nrun = 0;
+ 
+ 		lpHandles = malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		if (!lpHandles)
+  		{
+ 	 		fprintf(stderr, _("out of memory\n"));
+ 	 		exit(1);
+  		}
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		exit_horribly(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			exit_horribly(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			exit_horribly(modulename,
+ 						"could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		exit_horribly(modulename, "worker is terminating\n");
+ }
+ 
+ 
+ /*
+  * Write a printf-style message to stderr.
+  *
+  * The program name is prepended, if "progname" has been set.
+  * Also, if modulename isn't NULL, that's included too.
+  * Note that we'll try to translate the modulename and the fmt string.
+  */
+ void
+ write_msg(const char *modulename, const char *fmt,...)
+ {
+ 	va_list		ap;
+ 
+ 	va_start(ap, fmt);
+ 	vwrite_msg(modulename, fmt, ap);
+ 	va_end(ap);
+ }
+ 
+ /*
+  * As write_msg, but pass a va_list not variable arguments.
+  */
+ void
+ vwrite_msg(const char *modulename, const char *fmt, va_list ap)
+ {
+ 	if (progname)
+ 	{
+ 		if (modulename)
+ 			fprintf(stderr, "%s: [%s] ", progname, _(modulename));
+ 		else
+ 			fprintf(stderr, "%s: ", progname);
+ 	}
+ 	vfprintf(stderr, _(fmt), ap);
+ }
+ 
+ /* Register a callback to be run when exit_nicely is invoked. */
+ void
+ on_exit_nicely(on_exit_nicely_callback function, void *arg)
+ {
+ 	if (on_exit_nicely_index >= MAX_ON_EXIT_NICELY)
+ 		exit_horribly(NULL, "out of on_exit_nicely slots\n");
+ 	on_exit_nicely_list[on_exit_nicely_index].function = function;
+ 	on_exit_nicely_list[on_exit_nicely_index].arg = arg;
+ 	on_exit_nicely_index++;
+ }
+ 
+ /*
+  * Run accumulated on_exit_nicely callbacks in reverse order and then exit
+  * quietly.  This needs to be thread-safe.
+  */
+ void
+ exit_nicely(int code)
+ {
+ 	int			i;
+ 
+ 	for (i = on_exit_nicely_index - 1; i >= 0; i--)
+ 		(*on_exit_nicely_list[i].function) (code,
+ 											on_exit_nicely_list[i].arg);
+ 
+ #ifdef WIN32
+ 	if (parallel_init_done && GetCurrentThreadId() != mainThreadId)
+ 		ExitThread(code);
+ #endif
+ 
+ 	exit(code);
+ }
+ 
*** a/src/tools/msvc/Mkvcbuild.pm
--- b/src/tools/msvc/Mkvcbuild.pm
***************
*** 71,77 **** sub mkvcbuild
  	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
  	  mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
  	  sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c
! 	  win32env.c win32error.c win32setlocale.c);
  
  	push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
  
--- 71,77 ----
  	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
  	  mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
  	  sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c
! 	  win32env.c win32error.c win32setlocale.c parallel_utils.c);
  
  	push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
  

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,498 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ #include "common.h"
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage);
+ 
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ 
+ static void
+ vacuum_close_connection(int code, void *arg);
+ 
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt		*vopt = wi->vopt;
+ 	ParallelSlot *mySlot = &shutdown_info.pstate->parallelSlot[worker];
+ 
+ 	conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	((ParallelArgs*)mySlot->args)->connection = conn;
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker, vopt->analyze_stage);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			exit_horribly(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ 		((ParallelArgs*)pstate->parallelSlot[i].args)->vopt = vopt;
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+ 		wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			((ParallelArgs*)pstate->parallelSlot[i].args)->connection
+ 					= connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 									  vopt->username, vopt->promptPassword,
+ 									  vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(((ParallelArgs*)pstate->parallelSlot[i].args)->connection,
+ 						pipefd, i, vopt->analyze_stage);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			exit_horribly(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage)
+ {
+ 
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	if (vacStage >= 0)
+ 		executeMaintenanceCommand(connection, stage_commands[vacStage], false);
+ 
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 	PQExpBufferData sql;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+ 			sendMessageToMaster(pipefd, "OK");
+ 		else
+ 		{
+ 			initPQExpBuffer(&sql);
+ 			appendPQExpBuffer(&sql, "ERROR : %s",
+ 						PQerrorMessage(connection));
+ 			sendMessageToMaster(pipefd, sql.data);
+ 			termPQExpBuffer(&sql);
+ 		}
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			exit_horribly(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 		ParallelSlot *mySlot = &pstate->parallelSlot[worker];
+ 
+ 		mySlot->workerStatus = WRKR_TERMINATED;
+ 		exit_horribly(modulename,
+ 			"vacuuming of database \"%s\" failed %s",
+ 			((ParallelArgs*)mySlot->args)->vopt->dbname, msg + strlen("ERROR "));
+ 	}
+ 	else
+ 	{
+ 		exit_horribly(modulename,
+ 				"invalid message received from worker: %s\n", msg);
+ 	}
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				exit_horribly(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			exit_horribly(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ void
+ on_exit_close_vacuum(PGconn *conn)
+ {
+ 	shutdown_info.handle = (void*)conn;
+ 	on_exit_nicely(vacuum_close_connection, &shutdown_info);
+ }
+ 
+ /*
+  * This function can close archives in both the parallel and non-parallel
+  * case.
+  */
+ static void
+ vacuum_close_connection(int code, void *arg)
+ {
+ 	ShutdownInformation *si = (ShutdownInformation *) arg;
+ 
+ 	if (si->pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(si->pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			PQfinish((PGconn*)si->handle);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(si->pstate);
+ 		}
+ 		else if (((ParallelArgs*)slot->args)->connection)
+ 			PQfinish((((ParallelArgs*)slot->args)->connection));
+ 	}
+ 	else if ((PGconn*)si->handle)
+ 		PQfinish((PGconn*)si->handle);
+ }
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,58 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ #include "parallel_utils.h"
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ 	int		   analyze_stage;
+ }VacOpt;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ 	VacOpt *vopt;
+ } ParallelArgs;
+ 
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void on_exit_close_vacuum(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 13,34 ****
  #include "postgres_fe.h"
  #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 13,54 ----
  #include "postgres_fe.h"
  #include "common.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt);
+ 
+ const char *progname = NULL;
  
  int
  main(int argc, char *argv[])
***************
*** 49,60 **** main(int argc, char *argv[])
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
- 	const char *progname;
  	int			optindex;
  	int			c;
  
--- 69,80 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
  	int			optindex;
  	int			c;
  
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 94,107 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 150,165 ----
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				parallel = atoi(optarg);
+ 				if (parallel <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 					progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 172,178 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 228,234 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 242,280 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										echo);
! 				}
! 			}
! 			else
! 			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 299,309 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 398,409 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
! 							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 424,668 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
! 							echo);
! 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			bool echo, int parallel, SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_dump_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_vacuum(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " %s.\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 			vopt.analyze_stage = i;
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		vopt.analyze_stage = -1;
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt);
+ 	}
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 682,688 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/src/bin/pg_dump/common.c
--- b/src/bin/pg_dump/common.c
***************
*** 15,21 ****
   */
  #include "pg_backup_archiver.h"
  #include "pg_backup_utils.h"
! 
  #include <ctype.h>
  
  #include "catalog/pg_class.h"
--- 15,21 ----
   */
  #include "pg_backup_archiver.h"
  #include "pg_backup_utils.h"
! #include "parallel_utils.h"
  #include <ctype.h>
  
  #include "catalog/pg_class.h"
*** a/src/bin/pg_dump/compress_io.c
--- b/src/bin/pg_dump/compress_io.c
***************
*** 184,190 **** WriteDataToArchive(ArchiveHandle *AH, CompressorState *cs,
  				   const void *data, size_t dLen)
  {
  	/* Are we aborting? */
! 	checkAborting(AH);
  
  	switch (cs->comprAlg)
  	{
--- 184,190 ----
  				   const void *data, size_t dLen)
  {
  	/* Are we aborting? */
! 	checkAborting();
  
  	switch (cs->comprAlg)
  	{
***************
*** 351,357 **** ReadDataFromArchiveZlib(ArchiveHandle *AH, ReadFunc readF)
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting(AH);
  
  		zp->next_in = (void *) buf;
  		zp->avail_in = cnt;
--- 351,357 ----
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting();
  
  		zp->next_in = (void *) buf;
  		zp->avail_in = cnt;
***************
*** 414,420 **** ReadDataFromArchiveNone(ArchiveHandle *AH, ReadFunc readF)
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting(AH);
  
  		ahwrite(buf, 1, cnt, AH);
  	}
--- 414,420 ----
  	while ((cnt = readF(AH, &buf, &buflen)))
  	{
  		/* Are we aborting? */
! 		checkAborting();
  
  		ahwrite(buf, 1, cnt, AH);
  	}
*** a/src/bin/pg_dump/parallel.c
--- b/src/bin/pg_dump/parallel.c
***************
*** 20,25 ****
--- 20,26 ----
  
  #include "pg_backup_utils.h"
  #include "parallel.h"
+ #include "parallel_utils.h"
  
  #ifndef WIN32
  #include <sys/types.h>
***************
*** 35,43 ****
  /* file-scope variables */
  #ifdef WIN32
  static unsigned int tMasterThreadId = 0;
- static HANDLE termEvent = INVALID_HANDLE_VALUE;
- static int	pgpipe(int handles[2]);
- static int	piperead(int s, char *buf, int len);
  
  /*
   * Structure to hold info passed by _beginthreadex() to the function it calls
--- 36,41 ----
***************
*** 53,228 **** typedef struct
  } WorkerInfo;
  
  #define pipewrite(a,b,c)	send(a,b,c,0)
- #else
- /*
-  * aborting is only ever used in the master, the workers are fine with just
-  * wantAbort.
-  */
- static bool aborting = false;
- static volatile sig_atomic_t wantAbort = 0;
  
- #define pgpipe(a)			pipe(a)
- #define piperead(a,b,c)		read(a,b,c)
- #define pipewrite(a,b,c)	write(a,b,c)
  #endif
  
- typedef struct ShutdownInformation
- {
- 	ParallelState *pstate;
- 	Archive    *AHX;
- } ShutdownInformation;
- 
- static ShutdownInformation shutdown_info;
- 
  static const char *modulename = gettext_noop("parallel archiver");
  
- static ParallelSlot *GetMyPSlot(ParallelState *pstate);
- static void
- parallel_msg_master(ParallelSlot *slot, const char *modulename,
- 					const char *fmt, va_list ap)
  __attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
  static void archive_close_connection(int code, void *arg);
- static void ShutdownWorkersHard(ParallelState *pstate);
- static void WaitForTerminatingWorkers(ParallelState *pstate);
  
- #ifndef WIN32
- static void sigTermHandler(int signum);
- #endif
  static void SetupWorker(ArchiveHandle *AH, int pipefd[2], int worker,
  			RestoreOptions *ropt);
- static bool HasEveryWorkerTerminated(ParallelState *pstate);
  
  static void lockTableNoWait(ArchiveHandle *AH, TocEntry *te);
  static void WaitForCommands(ArchiveHandle *AH, int pipefd[2]);
- static char *getMessageFromMaster(int pipefd[2]);
- static void sendMessageToMaster(int pipefd[2], const char *str);
- static int	select_loop(int maxFd, fd_set *workerset);
- static char *getMessageFromWorker(ParallelState *pstate,
- 					 bool do_wait, int *worker);
- static void sendMessageToWorker(ParallelState *pstate,
- 					int worker, const char *str);
- static char *readMessageFromPipe(int fd);
  
  #define messageStartsWith(msg, prefix) \
  	(strncmp(msg, prefix, strlen(prefix)) == 0)
  #define messageEquals(msg, pattern) \
  	(strcmp(msg, pattern) == 0)
  
- #ifdef WIN32
- static void shutdown_parallel_dump_utils(int code, void *unused);
- bool		parallel_init_done = false;
- static DWORD tls_index;
- DWORD		mainThreadId;
- #endif
- 
- 
- #ifdef WIN32
- static void
- shutdown_parallel_dump_utils(int code, void *unused)
- {
- 	/* Call the cleanup function only from the main thread */
- 	if (mainThreadId == GetCurrentThreadId())
- 		WSACleanup();
- }
- #endif
- 
- void
- init_parallel_dump_utils(void)
- {
- #ifdef WIN32
- 	if (!parallel_init_done)
- 	{
- 		WSADATA		wsaData;
- 		int			err;
- 
- 		tls_index = TlsAlloc();
- 		mainThreadId = GetCurrentThreadId();
- 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
- 		if (err != 0)
- 		{
- 			fprintf(stderr, _("%s: WSAStartup failed: %d\n"), progname, err);
- 			exit_nicely(1);
- 		}
- 		on_exit_nicely(shutdown_parallel_dump_utils, NULL);
- 		parallel_init_done = true;
- 	}
- #endif
- }
- 
- static ParallelSlot *
- GetMyPSlot(ParallelState *pstate)
- {
- 	int			i;
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- #ifdef WIN32
- 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
- #else
- 		if (pstate->parallelSlot[i].pid == getpid())
- #endif
- 			return &(pstate->parallelSlot[i]);
- 
- 	return NULL;
- }
- 
- /*
-  * Fail and die, with a message to stderr.  Parameters as for write_msg.
-  *
-  * This is defined in parallel.c, because in parallel mode, things are more
-  * complicated. If the worker process does exit_horribly(), we forward its
-  * last words to the master process. The master process then does
-  * exit_horribly() with this error message itself and prints it normally.
-  * After printing the message, exit_horribly() on the master will shut down
-  * the remaining worker processes.
-  */
- void
- exit_horribly(const char *modulename, const char *fmt,...)
- {
- 	va_list		ap;
- 	ParallelState *pstate = shutdown_info.pstate;
- 	ParallelSlot *slot;
- 
- 	va_start(ap, fmt);
- 
- 	if (pstate == NULL)
- 	{
- 		/* Not in parallel mode, just write to stderr */
- 		vwrite_msg(modulename, fmt, ap);
- 	}
- 	else
- 	{
- 		slot = GetMyPSlot(pstate);
- 
- 		if (!slot)
- 			/* We're the parent, just write the message out */
- 			vwrite_msg(modulename, fmt, ap);
- 		else
- 			/* If we're a worker process, send the msg to the master process */
- 			parallel_msg_master(slot, modulename, fmt, ap);
- 	}
- 
- 	va_end(ap);
- 
- 	exit_nicely(1);
- }
- 
- /* Sends the error message from the worker to the master process */
- static void
- parallel_msg_master(ParallelSlot *slot, const char *modulename,
- 					const char *fmt, va_list ap)
- {
- 	char		buf[512];
- 	int			pipefd[2];
- 
- 	pipefd[PIPE_READ] = slot->pipeRevRead;
- 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
- 
- 	strcpy(buf, "ERROR ");
- 	vsnprintf(buf + strlen("ERROR "),
- 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
- 
- 	sendMessageToMaster(pipefd, buf);
- }
  
  /*
   * A thread-local version of getLocalPQExpBuffer().
--- 51,75 ----
***************
*** 280,286 **** getThreadLocalPQExpBuffer(void)
  void
  on_exit_close_archive(Archive *AHX)
  {
! 	shutdown_info.AHX = AHX;
  	on_exit_nicely(archive_close_connection, &shutdown_info);
  }
  
--- 127,133 ----
  void
  on_exit_close_archive(Archive *AHX)
  {
! 	shutdown_info.handle = (void*)AHX;
  	on_exit_nicely(archive_close_connection, &shutdown_info);
  }
  
***************
*** 306,312 **** archive_close_connection(int code, void *arg)
  			 * connection (only open during parallel dump but not restore) and
  			 * shut down the remaining workers.
  			 */
! 			DisconnectDatabase(si->AHX);
  #ifndef WIN32
  
  			/*
--- 153,159 ----
  			 * connection (only open during parallel dump but not restore) and
  			 * shut down the remaining workers.
  			 */
! 			DisconnectDatabase((Archive*)si->handle);
  #ifndef WIN32
  
  			/*
***************
*** 318,436 **** archive_close_connection(int code, void *arg)
  #endif
  			ShutdownWorkersHard(si->pstate);
  		}
! 		else if (slot->args->AH)
! 			DisconnectDatabase(&(slot->args->AH->public));
  	}
! 	else if (si->AHX)
! 		DisconnectDatabase(si->AHX);
  }
  
  /*
-  * If we have one worker that terminates for some reason, we'd like the other
-  * threads to terminate as well (and not finish with their 70 GB table dump
-  * first...). Now in UNIX we can just kill these processes, and let the signal
-  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
-  * as the signal for everyone to terminate.
-  */
- void
- checkAborting(ArchiveHandle *AH)
- {
- #ifdef WIN32
- 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
- #else
- 	if (wantAbort)
- #endif
- 		exit_horribly(modulename, "worker is terminating\n");
- }
- 
- /*
-  * Shut down any remaining workers, this has an implicit do_wait == true.
-  *
-  * The fastest way we can make the workers terminate gracefully is when
-  * they are listening for new commands and we just tell them to terminate.
-  */
- static void
- ShutdownWorkersHard(ParallelState *pstate)
- {
- #ifndef WIN32
- 	int			i;
- 
- 	signal(SIGPIPE, SIG_IGN);
- 
- 	/*
- 	 * Close our write end of the sockets so that the workers know they can
- 	 * exit.
- 	 */
- 	for (i = 0; i < pstate->numWorkers; i++)
- 		closesocket(pstate->parallelSlot[i].pipeWrite);
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 		kill(pstate->parallelSlot[i].pid, SIGTERM);
- #else
- 	/* The workers monitor this event via checkAborting(). */
- 	SetEvent(termEvent);
- #endif
- 
- 	WaitForTerminatingWorkers(pstate);
- }
- 
- /*
-  * Wait for the termination of the processes using the OS-specific method.
-  */
- static void
- WaitForTerminatingWorkers(ParallelState *pstate)
- {
- 	while (!HasEveryWorkerTerminated(pstate))
- 	{
- 		ParallelSlot *slot = NULL;
- 		int			j;
- 
- #ifndef WIN32
- 		int			status;
- 		pid_t		pid = wait(&status);
- 
- 		for (j = 0; j < pstate->numWorkers; j++)
- 			if (pstate->parallelSlot[j].pid == pid)
- 				slot = &(pstate->parallelSlot[j]);
- #else
- 		uintptr_t	hThread;
- 		DWORD		ret;
- 		uintptr_t  *lpHandles = pg_malloc(sizeof(HANDLE) * pstate->numWorkers);
- 		int			nrun = 0;
- 
- 		for (j = 0; j < pstate->numWorkers; j++)
- 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
- 			{
- 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
- 				nrun++;
- 			}
- 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
- 		Assert(ret != WAIT_FAILED);
- 		hThread = lpHandles[ret - WAIT_OBJECT_0];
- 
- 		for (j = 0; j < pstate->numWorkers; j++)
- 			if (pstate->parallelSlot[j].hThread == hThread)
- 				slot = &(pstate->parallelSlot[j]);
- 
- 		free(lpHandles);
- #endif
- 		Assert(slot);
- 
- 		slot->workerStatus = WRKR_TERMINATED;
- 	}
- 	Assert(HasEveryWorkerTerminated(pstate));
- }
- 
- #ifndef WIN32
- /* Signal handling (UNIX only) */
- static void
- sigTermHandler(int signum)
- {
- 	wantAbort = 1;
- }
- #endif
- 
- /*
   * This function is called by both UNIX and Windows variants to set up a
   * worker process.
   */
--- 165,178 ----
  #endif
  			ShutdownWorkersHard(si->pstate);
  		}
! 		else if (((ParallelArgs*)slot->args)->AH)
! 			DisconnectDatabase(&(((ParallelArgs*)slot->args)->AH->public));
  	}
! 	else if ((ArchiveHandle*)si->handle)
! 		DisconnectDatabase((Archive*)si->handle);
  }
  
  /*
   * This function is called by both UNIX and Windows variants to set up a
   * worker process.
   */
***************
*** 537,544 **** ParallelBackupStart(ArchiveHandle *AH, RestoreOptions *ropt)
  
  		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
  		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
! 		pstate->parallelSlot[i].args->AH = NULL;
! 		pstate->parallelSlot[i].args->te = NULL;
  #ifdef WIN32
  		/* Allocate a new structure for every worker */
  		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
--- 279,286 ----
  
  		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
  		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
! 		((ParallelArgs*)pstate->parallelSlot[i].args)->AH = NULL;
! 		((ParallelArgs*)pstate->parallelSlot[i].args)->te = NULL;
  #ifdef WIN32
  		/* Allocate a new structure for every worker */
  		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
***************
*** 581,587 **** ParallelBackupStart(ArchiveHandle *AH, RestoreOptions *ropt)
  			 * and also clones the database connection (for parallel dump)
  			 * which both seem kinda helpful.
  			 */
! 			pstate->parallelSlot[i].args->AH = CloneArchive(AH);
  
  			/* close read end of Worker -> Master */
  			closesocket(pipeWM[PIPE_READ]);
--- 323,329 ----
  			 * and also clones the database connection (for parallel dump)
  			 * which both seem kinda helpful.
  			 */
! 			((ParallelArgs*)pstate->parallelSlot[i].args)->AH = CloneArchive(AH);
  
  			/* close read end of Worker -> Master */
  			closesocket(pipeWM[PIPE_READ]);
***************
*** 598,604 **** ParallelBackupStart(ArchiveHandle *AH, RestoreOptions *ropt)
  				closesocket(pstate->parallelSlot[j].pipeWrite);
  			}
  
! 			SetupWorker(pstate->parallelSlot[i].args->AH, pipefd, i, ropt);
  
  			exit(0);
  		}
--- 340,346 ----
  				closesocket(pstate->parallelSlot[j].pipeWrite);
  			}
  
! 			SetupWorker(((ParallelArgs*)pstate->parallelSlot[i].args)->AH, pipefd, i, ropt);
  
  			exit(0);
  		}
***************
*** 738,786 **** DispatchJobForTocEntry(ArchiveHandle *AH, ParallelState *pstate, TocEntry *te,
  	sendMessageToWorker(pstate, worker, arg);
  
  	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
! 	pstate->parallelSlot[worker].args->te = te;
! }
! 
! /*
!  * Find the first free parallel slot (if any).
!  */
! int
! GetIdleWorker(ParallelState *pstate)
! {
! 	int			i;
! 
! 	for (i = 0; i < pstate->numWorkers; i++)
! 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
! 			return i;
! 	return NO_SLOT;
! }
! 
! /*
!  * Return true iff every worker process is in the WRKR_TERMINATED state.
!  */
! static bool
! HasEveryWorkerTerminated(ParallelState *pstate)
! {
! 	int			i;
! 
! 	for (i = 0; i < pstate->numWorkers; i++)
! 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
! 			return false;
! 	return true;
! }
! 
! /*
!  * Return true iff every worker is in the WRKR_IDLE state.
!  */
! bool
! IsEveryWorkerIdle(ParallelState *pstate)
! {
! 	int			i;
! 
! 	for (i = 0; i < pstate->numWorkers; i++)
! 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
! 			return false;
! 	return true;
  }
  
  /*
--- 480,486 ----
  	sendMessageToWorker(pstate, worker, arg);
  
  	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
! 	((ParallelArgs*)pstate->parallelSlot[worker].args)->te = te;
  }
  
  /*
***************
*** 966,972 **** ListenToWorkers(ArchiveHandle *AH, ParallelState *pstate, bool do_wait)
  		TocEntry   *te;
  
  		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
! 		te = pstate->parallelSlot[worker].args->te;
  		if (messageStartsWith(msg, "OK RESTORE "))
  		{
  			statusString = msg + strlen("OK RESTORE ");
--- 666,672 ----
  		TocEntry   *te;
  
  		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
! 		te = ((ParallelArgs*)pstate->parallelSlot[worker].args)->te;
  		if (messageStartsWith(msg, "OK RESTORE "))
  		{
  			statusString = msg + strlen("OK RESTORE ");
***************
*** 1001,1031 **** ListenToWorkers(ArchiveHandle *AH, ParallelState *pstate, bool do_wait)
  /*
   * This function is executed in the master process.
   *
-  * This function is used to get the return value of a terminated worker
-  * process. If a process has terminated, its status is stored in *status and
-  * the id of the worker is returned.
-  */
- int
- ReapWorkerStatus(ParallelState *pstate, int *status)
- {
- 	int			i;
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 	{
- 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
- 		{
- 			*status = pstate->parallelSlot[i].status;
- 			pstate->parallelSlot[i].status = 0;
- 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
- 			return i;
- 		}
- 	}
- 	return NO_SLOT;
- }
- 
- /*
-  * This function is executed in the master process.
-  *
   * It looks for an idle worker process and only returns if there is one.
   */
  void
--- 701,706 ----
***************
*** 1089,1417 **** EnsureWorkersFinished(ArchiveHandle *AH, ParallelState *pstate)
  	}
  }
  
- /*
-  * This function is executed in the worker process.
-  *
-  * It returns the next message on the communication channel, blocking until it
-  * becomes available.
-  */
- static char *
- getMessageFromMaster(int pipefd[2])
- {
- 	return readMessageFromPipe(pipefd[PIPE_READ]);
- }
- 
- /*
-  * This function is executed in the worker process.
-  *
-  * It sends a message to the master on the communication channel.
-  */
- static void
- sendMessageToMaster(int pipefd[2], const char *str)
- {
- 	int			len = strlen(str) + 1;
- 
- 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
- 		exit_horribly(modulename,
- 					  "could not write to the communication channel: %s\n",
- 					  strerror(errno));
- }
- 
- /*
-  * A select loop that repeats calling select until a descriptor in the read
-  * set becomes readable. On Windows we have to check for the termination event
-  * from time to time, on Unix we can just block forever.
-  */
- static int
- select_loop(int maxFd, fd_set *workerset)
- {
- 	int			i;
- 	fd_set		saveSet = *workerset;
- 
- #ifdef WIN32
- 	/* should always be the master */
- 	Assert(tMasterThreadId == GetCurrentThreadId());
- 
- 	for (;;)
- 	{
- 		/*
- 		 * sleep a quarter of a second before checking if we should terminate.
- 		 */
- 		struct timeval tv = {0, 250000};
- 
- 		*workerset = saveSet;
- 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
- 
- 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
- 			continue;
- 		if (i)
- 			break;
- 	}
- #else							/* UNIX */
- 
- 	for (;;)
- 	{
- 		*workerset = saveSet;
- 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
- 
- 		/*
- 		 * If we Ctrl-C the master process , it's likely that we interrupt
- 		 * select() here. The signal handler will set wantAbort == true and
- 		 * the shutdown journey starts from here. Note that we'll come back
- 		 * here later when we tell all workers to terminate and read their
- 		 * responses. But then we have aborting set to true.
- 		 */
- 		if (wantAbort && !aborting)
- 			exit_horribly(modulename, "terminated by user\n");
- 
- 		if (i < 0 && errno == EINTR)
- 			continue;
- 		break;
- 	}
- #endif
- 
- 	return i;
- }
- 
- 
- /*
-  * This function is executed in the master process.
-  *
-  * It returns the next message from the worker on the communication channel,
-  * optionally blocking (do_wait) until it becomes available.
-  *
-  * The id of the worker is returned in *worker.
-  */
- static char *
- getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
- {
- 	int			i;
- 	fd_set		workerset;
- 	int			maxFd = -1;
- 	struct timeval nowait = {0, 0};
- 
- 	FD_ZERO(&workerset);
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 	{
- 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
- 			continue;
- 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
- 		/* actually WIN32 ignores the first parameter to select()... */
- 		if (pstate->parallelSlot[i].pipeRead > maxFd)
- 			maxFd = pstate->parallelSlot[i].pipeRead;
- 	}
- 
- 	if (do_wait)
- 	{
- 		i = select_loop(maxFd, &workerset);
- 		Assert(i != 0);
- 	}
- 	else
- 	{
- 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
- 			return NULL;
- 	}
- 
- 	if (i < 0)
- 		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
- 
- 	for (i = 0; i < pstate->numWorkers; i++)
- 	{
- 		char	   *msg;
- 
- 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
- 			continue;
- 
- 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
- 		*worker = i;
- 		return msg;
- 	}
- 	Assert(false);
- 	return NULL;
- }
- 
- /*
-  * This function is executed in the master process.
-  *
-  * It sends a message to a certain worker on the communication channel.
-  */
- static void
- sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
- {
- 	int			len = strlen(str) + 1;
- 
- 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
- 	{
- 		/*
- 		 * If we're already aborting anyway, don't care if we succeed or not.
- 		 * The child might have gone already.
- 		 */
- #ifndef WIN32
- 		if (!aborting)
- #endif
- 			exit_horribly(modulename,
- 						"could not write to the communication channel: %s\n",
- 						  strerror(errno));
- 	}
- }
- 
- /*
-  * The underlying function to read a message from the communication channel
-  * (fd) with optional blocking (do_wait).
-  */
- static char *
- readMessageFromPipe(int fd)
- {
- 	char	   *msg;
- 	int			msgsize,
- 				bufsize;
- 	int			ret;
- 
- 	/*
- 	 * The problem here is that we need to deal with several possibilites: we
- 	 * could receive only a partial message or several messages at once. The
- 	 * caller expects us to return exactly one message however.
- 	 *
- 	 * We could either read in as much as we can and keep track of what we
- 	 * delivered back to the caller or we just read byte by byte. Once we see
- 	 * (char) 0, we know that it's the message's end. This would be quite
- 	 * inefficient for more data but since we are reading only on the command
- 	 * channel, the performance loss does not seem worth the trouble of
- 	 * keeping internal states for different file descriptors.
- 	 */
- 	bufsize = 64;				/* could be any number */
- 	msg = (char *) pg_malloc(bufsize);
- 
- 	msgsize = 0;
- 	for (;;)
- 	{
- 		Assert(msgsize <= bufsize);
- 		ret = piperead(fd, msg + msgsize, 1);
- 
- 		/* worker has closed the connection or another error happened */
- 		if (ret <= 0)
- 			break;
- 
- 		Assert(ret == 1);
- 
- 		if (msg[msgsize] == '\0')
- 			return msg;
- 
- 		msgsize++;
- 		if (msgsize == bufsize)
- 		{
- 			/* could be any number */
- 			bufsize += 16;
- 			msg = (char *) realloc(msg, bufsize);
- 		}
- 	}
- 
- 	/*
- 	 * Worker has closed the connection, make sure to clean up before return
- 	 * since we are not returning msg (but did allocate it).
- 	 */
- 	free(msg);
- 
- 	return NULL;
- }
- 
- #ifdef WIN32
- /*
-  * This is a replacement version of pipe for Win32 which allows returned
-  * handles to be used in select(). Note that read/write calls must be replaced
-  * with recv/send.  "handles" have to be integers so we check for errors then
-  * cast to integers.
-  */
- static int
- pgpipe(int handles[2])
- {
- 	pgsocket		s, tmp_sock;
- 	struct sockaddr_in serv_addr;
- 	int			len = sizeof(serv_addr);
- 
- 	/* We have to use the Unix socket invalid file descriptor value here. */
- 	handles[0] = handles[1] = -1;
- 
- 	/*
- 	 * setup listen socket
- 	 */
- 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not create socket: error code %d\n",
- 				  WSAGetLastError());
- 		return -1;
- 	}
- 
- 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
- 	serv_addr.sin_family = AF_INET;
- 	serv_addr.sin_port = htons(0);
- 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not bind: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if (listen(s, 1) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not listen: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: getsockname() failed: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 
- 	/*
- 	 * setup pipe handles
- 	 */
- 	if ((tmp_sock = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not create second socket: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	handles[1] = (int) tmp_sock;
- 
- 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
- 	{
- 		write_msg(modulename, "pgpipe: could not connect socket: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(s);
- 		return -1;
- 	}
- 	if ((tmp_sock = accept(s, (SOCKADDR *) &serv_addr, &len)) == PGINVALID_SOCKET)
- 	{
- 		write_msg(modulename, "pgpipe: could not accept connection: error code %d\n",
- 				  WSAGetLastError());
- 		closesocket(handles[1]);
- 		handles[1] = -1;
- 		closesocket(s);
- 		return -1;
- 	}
- 	handles[0] = (int) tmp_sock;
- 
- 	closesocket(s);
- 	return 0;
- }
- 
- static int
- piperead(int s, char *buf, int len)
- {
- 	int			ret = recv(s, buf, len, 0);
- 
- 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
- 		/* EOF on the pipe! (win32 socket based implementation) */
- 		ret = 0;
- 	return ret;
- }
- 
- #endif
--- 764,766 ----
*** a/src/bin/pg_dump/parallel.h
--- b/src/bin/pg_dump/parallel.h
***************
*** 20,37 ****
  #define PG_DUMP_PARALLEL_H
  
  #include "pg_backup_db.h"
  
  struct _archiveHandle;
  struct _tocEntry;
  
- typedef enum
- {
- 	WRKR_TERMINATED = 0,
- 	WRKR_IDLE,
- 	WRKR_WORKING,
- 	WRKR_FINISHED
- } T_WorkerStatus;
- 
  /* Arguments needed for a worker process */
  typedef struct ParallelArgs
  {
--- 20,30 ----
  #define PG_DUMP_PARALLEL_H
  
  #include "pg_backup_db.h"
+ #include "parallel_utils.h"
  
  struct _archiveHandle;
  struct _tocEntry;
  
  /* Arguments needed for a worker process */
  typedef struct ParallelArgs
  {
***************
*** 39,81 **** typedef struct ParallelArgs
  	struct _tocEntry *te;
  } ParallelArgs;
  
- /* State for each parallel activity slot */
- typedef struct ParallelSlot
- {
- 	ParallelArgs *args;
- 	T_WorkerStatus workerStatus;
- 	int			status;
- 	int			pipeRead;
- 	int			pipeWrite;
- 	int			pipeRevRead;
- 	int			pipeRevWrite;
- #ifdef WIN32
- 	uintptr_t	hThread;
- 	unsigned int threadId;
- #else
- 	pid_t		pid;
- #endif
- } ParallelSlot;
- 
- #define NO_SLOT (-1)
- 
- typedef struct ParallelState
- {
- 	int			numWorkers;
- 	ParallelSlot *parallelSlot;
- } ParallelState;
- 
- #ifdef WIN32
- extern bool parallel_init_done;
- extern DWORD mainThreadId;
- #endif
- 
- extern void init_parallel_dump_utils(void);
- 
- extern int	GetIdleWorker(ParallelState *pstate);
- extern bool IsEveryWorkerIdle(ParallelState *pstate);
  extern void ListenToWorkers(struct _archiveHandle * AH, ParallelState *pstate, bool do_wait);
- extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
  extern void EnsureIdleWorker(struct _archiveHandle * AH, ParallelState *pstate);
  extern void EnsureWorkersFinished(struct _archiveHandle * AH, ParallelState *pstate);
  
--- 32,38 ----
***************
*** 86,95 **** extern void DispatchJobForTocEntry(struct _archiveHandle * AH,
  					   struct _tocEntry * te, T_Action act);
  extern void ParallelBackupEnd(struct _archiveHandle * AH, ParallelState *pstate);
  
- extern void checkAborting(struct _archiveHandle * AH);
- 
- extern void
- exit_horribly(const char *modulename, const char *fmt,...)
- __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
- 
  #endif   /* PG_DUMP_PARALLEL_H */
--- 43,46 ----
*** a/src/bin/pg_dump/pg_backup_archiver.c
--- b/src/bin/pg_dump/pg_backup_archiver.c
***************
*** 3825,3834 **** get_next_work_item(ArchiveHandle *AH, TocEntry *ready_list,
  	if (pref_non_data)
  	{
  		int			count = 0;
! 
  		for (k = 0; k < pstate->numWorkers; k++)
! 			if (pstate->parallelSlot[k].args->te != NULL &&
! 				pstate->parallelSlot[k].args->te->section == SECTION_DATA)
  				count++;
  		if (pstate->numWorkers == 0 || count * 4 < pstate->numWorkers)
  			pref_non_data = false;
--- 3825,3834 ----
  	if (pref_non_data)
  	{
  		int			count = 0;
! 		
  		for (k = 0; k < pstate->numWorkers; k++)
! 			if (((ParallelArgs*)pstate->parallelSlot[k].args)->te != NULL &&
! 				((ParallelArgs*)pstate->parallelSlot[k].args)->te->section == SECTION_DATA)
  				count++;
  		if (pstate->numWorkers == 0 || count * 4 < pstate->numWorkers)
  			pref_non_data = false;
***************
*** 3852,3858 **** get_next_work_item(ArchiveHandle *AH, TocEntry *ready_list,
  
  			if (pstate->parallelSlot[i].workerStatus != WRKR_WORKING)
  				continue;
! 			running_te = pstate->parallelSlot[i].args->te;
  
  			if (has_lock_conflicts(te, running_te) ||
  				has_lock_conflicts(running_te, te))
--- 3852,3858 ----
  
  			if (pstate->parallelSlot[i].workerStatus != WRKR_WORKING)
  				continue;
! 			running_te = ((ParallelArgs*)pstate->parallelSlot[i].args)->te;
  
  			if (has_lock_conflicts(te, running_te) ||
  				has_lock_conflicts(running_te, te))
***************
*** 3926,3932 **** mark_work_done(ArchiveHandle *AH, TocEntry *ready_list,
  {
  	TocEntry   *te = NULL;
  
! 	te = pstate->parallelSlot[worker].args->te;
  
  	if (te == NULL)
  		exit_horribly(modulename, "could not find slot of finished worker\n");
--- 3926,3932 ----
  {
  	TocEntry   *te = NULL;
  
! 	te = ((ParallelArgs*)pstate->parallelSlot[worker].args)->te;
  
  	if (te == NULL)
  		exit_horribly(modulename, "could not find slot of finished worker\n");
*** a/src/bin/pg_dump/pg_backup_directory.c
--- b/src/bin/pg_dump/pg_backup_directory.c
***************
*** 35,42 ****
  
  #include "compress_io.h"
  #include "pg_backup_utils.h"
  #include "parallel.h"
- 
  #include <dirent.h>
  #include <sys/stat.h>
  
--- 35,42 ----
  
  #include "compress_io.h"
  #include "pg_backup_utils.h"
+ #include "parallel_utils.h"
  #include "parallel.h"
  #include <dirent.h>
  #include <sys/stat.h>
  
***************
*** 356,362 **** _WriteData(ArchiveHandle *AH, const void *data, size_t dLen)
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting(AH);
  
  	if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen)
  		WRITE_ERROR_EXIT;
--- 356,362 ----
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting();
  
  	if (dLen > 0 && cfwrite(data, dLen, ctx->dataFH) != dLen)
  		WRITE_ERROR_EXIT;
***************
*** 524,530 **** _WriteBuf(ArchiveHandle *AH, const void *buf, size_t len)
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting(AH);
  
  	if (cfwrite(buf, len, ctx->dataFH) != len)
  		WRITE_ERROR_EXIT;
--- 524,530 ----
  	lclContext *ctx = (lclContext *) AH->formatData;
  
  	/* Are we aborting? */
! 	checkAborting();
  
  	if (cfwrite(buf, len, ctx->dataFH) != len)
  		WRITE_ERROR_EXIT;
*** a/src/bin/pg_dump/pg_backup_utils.c
--- b/src/bin/pg_dump/pg_backup_utils.c
***************
*** 15,33 ****
  
  #include "pg_backup_utils.h"
  #include "parallel.h"
! 
  /* Globals exported by this file */
  const char *progname = NULL;
  
- #define MAX_ON_EXIT_NICELY				20
- 
- static struct
- {
- 	on_exit_nicely_callback function;
- 	void	   *arg;
- }	on_exit_nicely_list[MAX_ON_EXIT_NICELY];
- 
- static int	on_exit_nicely_index;
  
  /*
   * Parse a --section=foo command line argument.
--- 15,24 ----
  
  #include "pg_backup_utils.h"
  #include "parallel.h"
! #include "parallel_utils.h"
  /* Globals exported by this file */
  const char *progname = NULL;
  
  
  /*
   * Parse a --section=foo command line argument.
***************
*** 60,126 **** set_dump_section(const char *arg, int *dumpSections)
  }
  
  
- /*
-  * Write a printf-style message to stderr.
-  *
-  * The program name is prepended, if "progname" has been set.
-  * Also, if modulename isn't NULL, that's included too.
-  * Note that we'll try to translate the modulename and the fmt string.
-  */
- void
- write_msg(const char *modulename, const char *fmt,...)
- {
- 	va_list		ap;
- 
- 	va_start(ap, fmt);
- 	vwrite_msg(modulename, fmt, ap);
- 	va_end(ap);
- }
- 
- /*
-  * As write_msg, but pass a va_list not variable arguments.
-  */
- void
- vwrite_msg(const char *modulename, const char *fmt, va_list ap)
- {
- 	if (progname)
- 	{
- 		if (modulename)
- 			fprintf(stderr, "%s: [%s] ", progname, _(modulename));
- 		else
- 			fprintf(stderr, "%s: ", progname);
- 	}
- 	vfprintf(stderr, _(fmt), ap);
- }
- 
- /* Register a callback to be run when exit_nicely is invoked. */
- void
- on_exit_nicely(on_exit_nicely_callback function, void *arg)
- {
- 	if (on_exit_nicely_index >= MAX_ON_EXIT_NICELY)
- 		exit_horribly(NULL, "out of on_exit_nicely slots\n");
- 	on_exit_nicely_list[on_exit_nicely_index].function = function;
- 	on_exit_nicely_list[on_exit_nicely_index].arg = arg;
- 	on_exit_nicely_index++;
- }
- 
- /*
-  * Run accumulated on_exit_nicely callbacks in reverse order and then exit
-  * quietly.  This needs to be thread-safe.
-  */
- void
- exit_nicely(int code)
- {
- 	int			i;
- 
- 	for (i = on_exit_nicely_index - 1; i >= 0; i--)
- 		(*on_exit_nicely_list[i].function) (code,
- 											on_exit_nicely_list[i].arg);
- 
- #ifdef WIN32
- 	if (parallel_init_done && GetCurrentThreadId() != mainThreadId)
- 		ExitThread(code);
- #endif
- 
- 	exit(code);
- }
--- 51,53 ----
*** a/src/bin/pg_dump/pg_backup_utils.h
--- b/src/bin/pg_dump/pg_backup_utils.h
***************
*** 23,40 **** typedef enum					/* bits returned by set_dump_section */
  	DUMP_UNSECTIONED = 0xff
  } DumpSections;
  
- typedef void (*on_exit_nicely_callback) (int code, void *arg);
- 
- extern const char *progname;
- 
  extern void set_dump_section(const char *arg, int *dumpSections);
- extern void
- write_msg(const char *modulename, const char *fmt,...)
- __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
- extern void
- vwrite_msg(const char *modulename, const char *fmt, va_list ap)
- __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 0)));
- extern void on_exit_nicely(on_exit_nicely_callback function, void *arg);
- extern void exit_nicely(int code) __attribute__((noreturn));
- 
  #endif   /* PG_BACKUP_UTILS_H */
--- 23,27 ----
*** /dev/null
--- b/src/include/parallel_utils.h
***************
*** 0 ****
--- 1,176 ----
+ /*-------------------------------------------------------------------------
+  *
+  * parallel_utils.h
+  *	  Header for src/port/ parallel execution functions.
+  *
+  * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  * src/include/port.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ #ifndef PARALLEL_UTILS_H
+ #define PARALLEL_UTILS_H
+ 
+ #include <ctype.h>
+ #include <netdb.h>
+ #include <pwd.h>
+ 
+ /*
+  *	WIN32 doesn't allow descriptors returned by pipe() to be used in select(),
+  *	so for that platform we use socket() instead of pipe().
+  *	There is some inconsistency here because sometimes we require pg*, like
+  *	pgpipe, but in other cases we define rename to pgrename just on Win32.
+  */
+ #ifndef WIN32
+ /*
+  *	The function prototypes are not supplied because every C file
+  *	includes this file.
+  */
+ #define pgpipe(a)			pipe(a)
+ #define piperead(a,b,c)		read(a,b,c)
+ #define pipewrite(a,b,c)	write(a,b,c)
+ #else
+ extern int	pgpipe(int handles[2]);
+ extern int	piperead(int s, char *buf, int len);
+ #define pipewrite(a,b,c)	send(a,b,c,0)
+ #endif
+ 
+ #ifdef WIN32
+ #define PG_SIGNAL_COUNT 32
+ #define kill(pid,sig)	pgkill(pid,sig)
+ extern int	pgkill(int pid, int sig);
+ #endif
+ 
+ #ifdef WIN32
+ extern DWORD mainThreadId;
+ extern bool parallel_init_done;
+ extern HANDLE termEvent;
+ 
+ #endif
+ 
+ 
+ typedef enum
+ {
+ 	WRKR_TERMINATED = 0,
+ 	WRKR_IDLE,
+ 	WRKR_WORKING,
+ 	WRKR_FINISHED
+ } T_WorkerStatus;
+ 
+ #define PIPE_READ							0
+ #define PIPE_WRITE							1
+ 
+ #define NO_SLOT (-1)
+ 
+ /* State for each parallel activity slot */
+ typedef struct ParallelSlot
+ {
+ 	void *args;
+ 	T_WorkerStatus workerStatus;
+ 	int			status;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ 	int			pipeRevRead;
+ 	int			pipeRevWrite;
+ #ifdef WIN32
+ 	uintptr_t	hThread;
+ 	unsigned int threadId;
+ #else
+ 	pid_t		pid;
+ #endif
+ } ParallelSlot;
+ 
+ typedef struct ParallelState
+ {
+ 	int			numWorkers;
+ 	ParallelSlot *parallelSlot;
+ } ParallelState;
+ 
+ typedef struct ShutdownInformation
+ {
+ 	ParallelState *pstate;
+ 	void     *handle;
+ } ShutdownInformation;
+ 
+ extern ShutdownInformation shutdown_info;
+ 
+ #define MAX_ON_EXIT_NICELY				20
+ 
+ typedef void (*on_exit_nicely_callback) (int code, void *arg);
+ 
+ typedef struct on_exit_nicely_stru
+ {
+ 	on_exit_nicely_callback function;
+ 	void	   *arg;
+ }on_exit_nicely_stru;
+ 
+ extern on_exit_nicely_stru on_exit_nicely_list[MAX_ON_EXIT_NICELY];
+ 
+ extern int	on_exit_nicely_index;
+ 
+ 
+ #ifdef WIN32
+ extern bool parallel_init_done;
+ extern DWORD tls_index;
+ 
+ #else
+ extern bool aborting;
+ 
+ #endif
+ 
+ extern const char *progname;
+ 
+ extern char *
+ readMessageFromPipe(int fd);
+ 
+ void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 0)));
+ 
+ extern void ShutdownWorkersHard(ParallelState *pstate);
+ extern void WaitForTerminatingWorkers(ParallelState *pstate);
+ 
+ extern bool HasEveryWorkerTerminated(ParallelState *pstate);
+ 
+ extern char *getMessageFromMaster(int pipefd[2]);
+ extern void sendMessageToMaster(int pipefd[2], const char *str);
+ extern int	select_loop(int maxFd, fd_set *workerset);
+ extern char *getMessageFromWorker(ParallelState *pstate,
+ 					 bool do_wait, int *worker);
+ extern void sendMessageToWorker(ParallelState *pstate,
+ 					int worker, const char *str);
+ extern int	ReapWorkerStatus(ParallelState *pstate, int *status);
+ 
+ extern ParallelSlot *
+ GetMyPSlot(ParallelState *pstate);
+ 
+ extern void init_parallel_dump_utils(void);
+ extern int GetIdleWorker(ParallelState *pstate);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void checkAborting();
+ 
+ extern void
+ write_msg(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+ extern void
+ vwrite_msg(const char *modulename, const char *fmt, va_list ap)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 0)));
+ extern void on_exit_nicely(on_exit_nicely_callback function, void *arg);
+ extern void exit_nicely(int code) __attribute__((noreturn));
+ 
+ extern void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ __attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3), noreturn));
+ 
+ #ifndef WIN32
+ extern void sigTermHandler(int signum);
+ #endif
+ 
+ #ifdef WIN32
+ extern void shutdown_parallel_dump_utils(int code, void *unused);
+ #endif
+ 
+ #endif   /* PARALLEL_UTILS_H */
*** a/src/port/Makefile
--- b/src/port/Makefile
***************
*** 33,39 **** LIBS += $(PTHREAD_LIBS)
  OBJS = $(LIBOBJS) chklocale.o dirmod.o erand48.o fls.o inet_net_ntop.o \
  	noblock.o path.o pgcheckdir.o pg_crc.o pgmkdirp.o pgsleep.o \
  	pgstrcasecmp.o pqsignal.o \
! 	qsort.o qsort_arg.o quotes.o sprompt.o tar.o thread.o
  
  # foo_srv.o and foo.o are both built from foo.c, but only foo.o has -DFRONTEND
  OBJS_SRV = $(OBJS:%.o=%_srv.o)
--- 33,39 ----
  OBJS = $(LIBOBJS) chklocale.o dirmod.o erand48.o fls.o inet_net_ntop.o \
  	noblock.o path.o pgcheckdir.o pg_crc.o pgmkdirp.o pgsleep.o \
  	pgstrcasecmp.o pqsignal.o \
! 	qsort.o qsort_arg.o quotes.o sprompt.o tar.o thread.o parallel_utils.o
  
  # foo_srv.o and foo.o are both built from foo.c, but only foo.o has -DFRONTEND
  OBJS_SRV = $(OBJS:%.o=%_srv.o)
*** /dev/null
--- b/src/port/parallel_utils.c
***************
*** 0 ****
--- 1,737 ----
+ /*-------------------------------------------------------------------------
+  *
+  * parallel_utils.c
+  *	  kill()
+  *
+  * Copyright (c) 1996-2014, PostgreSQL Global Development Group
+  *
+  *	Utility function for supporing parallel execution in client tools
+  *
+  * IDENTIFICATION
+  *	  src/port/parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "postgres.h"
+ #include "parallel_utils.h"
+ #include "common/fe_memutils.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ 
+ #endif
+ 
+ 
+ #ifdef WIN32
+ DWORD		 mainThreadId;
+ bool parallel_init_done = false;
+ HANDLE termEvent = INVALID_HANDLE_VALUE;
+ DWORD tls_index;
+ #else
+ bool aborting = false;
+ static volatile sig_atomic_t wantAbort = 0;
+ 
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel utils");
+ 
+ ShutdownInformation shutdown_info;
+ int  on_exit_nicely_index;
+ on_exit_nicely_stru on_exit_nicely_list[MAX_ON_EXIT_NICELY];
+ 
+ 
+ 
+  /*
+   * The underlying function to read a message from the communication channel
+   * (fd) with optional blocking (do_wait).
+   */
+ char *
+ readMessageFromPipe(int fd)
+ {
+  char		*msg;
+  int		 msgsize,
+ 			 bufsize;
+  int		 ret;
+ 
+  /*
+   * The problem here is that we need to deal with several possibilites: we
+   * could receive only a partial message or several messages at once. The
+   * caller expects us to return exactly one message however.
+   *
+   * We could either read in as much as we can and keep track of what we
+   * delivered back to the caller or we just read byte by byte. Once we see
+   * (char) 0, we know that it's the message's end. This would be quite
+   * inefficient for more data but since we are reading only on the command
+   * channel, the performance loss does not seem worth the trouble of
+   * keeping internal states for different file descriptors.
+   */
+  bufsize = 64;				 /* could be any number */
+  msg = (char *)malloc(bufsize);
+  if (!msg)
+  {
+ 	 fprintf(stderr, _("out of memory\n"));
+ 	 exit(1);
+  }
+ 
+ 
+  msgsize = 0;
+  for (;;)
+  {
+ 	 Assert(msgsize <= bufsize);
+ 	 ret = piperead(fd, msg + msgsize, 1);
+ 
+ 	 /* worker has closed the connection or another error happened */
+ 	 if (ret <= 0)
+ 		 return NULL;
+ 
+ 	 Assert(ret == 1);
+ 
+ 	 if (msg[msgsize] == '\0')
+ 		 return msg;
+ 
+ 	 msgsize++;
+ 	 if (msgsize == bufsize)
+ 	 {
+ 		 /* could be any number */
+ 		 bufsize += 16;
+ 		 msg = (char *) realloc(msg, bufsize);
+ 	 }
+  }
+ }
+ 
+ #ifdef WIN32
+ /*
+  * This is a replacement version of pipe for Win32 which allows returned
+  * handles to be used in select(). Note that read/write calls must be replaced
+  * with recv/send.  "handles" have to be integers so we check for errors then
+  * cast to integers.
+  */
+ int
+ pgpipe(int handles[2])
+ {
+ 	pgsocket		s, tmp_sock;
+ 	struct sockaddr_in serv_addr;
+ 	int			len = sizeof(serv_addr);
+ 
+ 	/* We have to use the Unix socket invalid file descriptor value here. */
+ 	handles[0] = handles[1] = -1;
+ 
+ 	/*
+ 	 * setup listen socket
+ 	 */
+ 	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not create socket: error code %d\n"),
+ 						WSAGetLastError());
+ 
+ 		return -1;
+ 	}
+ 
+ 	memset((void *) &serv_addr, 0, sizeof(serv_addr));
+ 	serv_addr.sin_family = AF_INET;
+ 	serv_addr.sin_port = htons(0);
+ 	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ 	if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not bind: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (listen(s, 1) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not listen: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: getsockname() failed: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 
+ 	/*
+ 	 * setup pipe handles
+ 	 */
+ 	if ((tmp_sock = socket(AF_INET, SOCK_STREAM, 0)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not create second socket: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	handles[1] = (int) tmp_sock;
+ 
+ 	if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not connect socket: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	if ((tmp_sock = accept(s, (SOCKADDR *) &serv_addr, &len)) == PGINVALID_SOCKET)
+ 	{
+ 		fprintf(stderr, _("pgpipe: could not accept connection: error code %d\n"),
+ 								WSAGetLastError());
+ 		closesocket(handles[1]);
+ 		handles[1] = -1;
+ 		closesocket(s);
+ 		return -1;
+ 	}
+ 	handles[0] = (int) tmp_sock;
+ 
+ 	closesocket(s);
+ 	return 0;
+ }
+ 
+ int
+ piperead(int s, char *buf, int len)
+ {
+ 	int			ret = recv(s, buf, len, 0);
+ 
+ 	if (ret < 0 && WSAGetLastError() == WSAECONNRESET)
+ 		/* EOF on the pipe! (win32 socket based implementation) */
+ 		ret = 0;
+ 	return ret;
+ }
+ 
+ #endif
+ 
+ 
+ #ifdef WIN32
+ void
+ shutdown_parallel_dump_utils(int code, void *unused)
+ {
+ 	/* Call the cleanup function only from the main thread */
+ 	if (mainThreadId == GetCurrentThreadId())
+ 		WSACleanup();
+ }
+ #endif
+ 
+ void
+ init_parallel_dump_utils(void)
+ {
+ #ifdef WIN32
+ 	if (!parallel_init_done)
+ 	{
+ 		WSADATA		wsaData;
+ 		int			err;
+ 
+ 		tls_index = TlsAlloc();
+ 		mainThreadId = GetCurrentThreadId();
+ 		err = WSAStartup(MAKEWORD(2, 2), &wsaData);
+ 		if (err != 0)
+ 		{
+ 			fprintf(stderr, _("%s: WSAStartup failed: %d\n"), progname, err);
+ 			exit_nicely(1);
+ 		}
+ 		on_exit_nicely(shutdown_parallel_dump_utils, NULL);
+ 		parallel_init_done = true;
+ 	}
+ #endif
+ }
+ 
+ ParallelSlot *
+ GetMyPSlot(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ #ifdef WIN32
+ 		if (pstate->parallelSlot[i].threadId == GetCurrentThreadId())
+ #else
+ 		if (pstate->parallelSlot[i].pid == getpid())
+ #endif
+ 			return &(pstate->parallelSlot[i]);
+ 
+ 	return NULL;
+ }
+ 
+ 
+ /*
+  * Fail and die, with a message to stderr.  Parameters as for write_msg.
+  *
+  * This is defined in parallel.c, because in parallel mode, things are more
+  * complicated. If the worker process does exit_horribly(), we forward its
+  * last words to the master process. The master process then does
+  * exit_horribly() with this error message itself and prints it normally.
+  * After printing the message, exit_horribly() on the master will shut down
+  * the remaining worker processes.
+  */
+ void
+ exit_horribly(const char *modulename, const char *fmt,...)
+ {
+ 	va_list		ap;
+ 	ParallelState *pstate = shutdown_info.pstate;
+ 	ParallelSlot *slot;
+ 
+ 	va_start(ap, fmt);
+ 
+ 	if (pstate == NULL)
+ 	{
+ 		/* Not in parallel mode, just write to stderr */
+ 		vwrite_msg(modulename, fmt, ap);
+ 	}
+ 	else
+ 	{
+ 		slot = GetMyPSlot(pstate);
+ 
+ 		if (!slot)
+ 			/* We're the parent, just write the message out */
+ 			vwrite_msg(modulename, fmt, ap);
+ 		else
+ 			/* If we're a worker process, send the msg to the master process */
+ 			parallel_msg_master(slot, modulename, fmt, ap);
+ 	}
+ 
+ 	va_end(ap);
+ 
+ 	exit_nicely(1);
+ }
+ 
+ /* Sends the error message from the worker to the master process */
+ void
+ parallel_msg_master(ParallelSlot *slot, const char *modulename,
+ 					const char *fmt, va_list ap)
+ {
+ 	char		buf[512];
+ 	int			pipefd[2];
+ 
+ 	pipefd[PIPE_READ] = slot->pipeRevRead;
+ 	pipefd[PIPE_WRITE] = slot->pipeRevWrite;
+ 
+ 	strcpy(buf, "ERROR ");
+ 	vsnprintf(buf + strlen("ERROR "),
+ 			  sizeof(buf) - strlen("ERROR "), fmt, ap);
+ 
+ 	sendMessageToMaster(pipefd, buf);
+ }
+ 
+ /*
+  * Shut down any remaining workers, this has an implicit do_wait == true.
+  *
+  * The fastest way we can make the workers terminate gracefully is when
+  * they are listening for new commands and we just tell them to terminate.
+  */
+ void
+ ShutdownWorkersHard(ParallelState *pstate)
+ {
+ 	int 		i;
+ 
+ #ifndef WIN32
+ 	signal(SIGPIPE, SIG_IGN);
+ 
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		kill(pstate->parallelSlot[i].pid, SIGTERM);
+ #else
+ 	/*
+ 	 * Close our write end of the sockets so that the workers know they can
+ 	 * exit.
+ 	 */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 
+ 	/* The workers monitor this event via checkAborting(). */
+ 	SetEvent(termEvent);
+ #endif
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ }
+ 
+ 
+ /*
+  * Wait for the termination of the processes using the OS-specific method.
+  */
+ void
+ WaitForTerminatingWorkers(ParallelState *pstate)
+ {
+ 	while (!HasEveryWorkerTerminated(pstate))
+ 	{
+ 		ParallelSlot *slot = NULL;
+ 		int			j;
+ 
+ #ifndef WIN32
+ 		int			status;
+ 		pid_t		pid = wait(&status);
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].pid == pid)
+ 				slot = &(pstate->parallelSlot[j]);
+ #else
+ 		uintptr_t	hThread;
+ 		DWORD		ret;
+ 		uintptr_t  *lpHandles;
+ 		int			nrun = 0;
+ 
+ 		lpHandles = malloc(sizeof(HANDLE) * pstate->numWorkers);
+ 		if (!lpHandles)
+  		{
+ 	 		fprintf(stderr, _("out of memory\n"));
+ 	 		exit(1);
+  		}
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].workerStatus != WRKR_TERMINATED)
+ 			{
+ 				lpHandles[nrun] = pstate->parallelSlot[j].hThread;
+ 				nrun++;
+ 			}
+ 		ret = WaitForMultipleObjects(nrun, (HANDLE *) lpHandles, false, INFINITE);
+ 		Assert(ret != WAIT_FAILED);
+ 		hThread = lpHandles[ret - WAIT_OBJECT_0];
+ 
+ 		for (j = 0; j < pstate->numWorkers; j++)
+ 			if (pstate->parallelSlot[j].hThread == hThread)
+ 				slot = &(pstate->parallelSlot[j]);
+ 
+ 		free(lpHandles);
+ #endif
+ 		Assert(slot);
+ 
+ 		slot->workerStatus = WRKR_TERMINATED;
+ 	}
+ 	Assert(HasEveryWorkerTerminated(pstate));
+ }
+ 
+ #ifndef WIN32
+ /* Signal handling (UNIX only) */
+ void
+ sigTermHandler(int signum)
+ {
+ 	wantAbort = 1;
+ }
+ #endif
+ 
+ /*
+  * Find the first free parallel slot (if any).
+  */
+ int
+ GetIdleWorker(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_IDLE)
+ 			return i;
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * Return true iff every worker process is in the WRKR_TERMINATED state.
+  */
+ bool
+ HasEveryWorkerTerminated(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_TERMINATED)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * Return true iff every worker is in the WRKR_IDLE state.
+  */
+ bool
+ IsEveryWorkerIdle(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 		if (pstate->parallelSlot[i].workerStatus != WRKR_IDLE)
+ 			return false;
+ 	return true;
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It returns the next message on the communication channel, blocking until it
+  * becomes available.
+  */
+ char *
+ getMessageFromMaster(int pipefd[2])
+ {
+ 	return readMessageFromPipe(pipefd[PIPE_READ]);
+ }
+ 
+ /*
+  * This function is executed in the worker process.
+  *
+  * It sends a message to the master on the communication channel.
+  */
+ void
+ sendMessageToMaster(int pipefd[2], const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pipefd[PIPE_WRITE], str, len) != len)
+ 		exit_horribly(modulename,
+ 					  "could not write to the communication channel: %s\n",
+ 					  strerror(errno));
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	Assert(tMasterThreadId == GetCurrentThreadId());
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		/*
+ 		 * If we Ctrl-C the master process , it's likely that we interrupt
+ 		 * select() here. The signal handler will set wantAbort == true and
+ 		 * the shutdown journey starts from here. Note that we'll come back
+ 		 * here later when we tell all workers to terminate and read their
+ 		 * responses. But then we have aborting set to true.
+ 		 */
+ 		if (wantAbort && !aborting)
+ 			exit_horribly(modulename, "terminated by user\n");
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It returns the next message from the worker on the communication channel,
+  * optionally blocking (do_wait) until it becomes available.
+  *
+  * The id of the worker is returned in *worker.
+  */
+ char *
+ getMessageFromWorker(ParallelState *pstate, bool do_wait, int *worker)
+ {
+ 	int			i;
+ 	fd_set		workerset;
+ 	int			maxFd = -1;
+ 	struct timeval nowait = {0, 0};
+ 
+ 	FD_ZERO(&workerset);
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_TERMINATED)
+ 			continue;
+ 		FD_SET(pstate->parallelSlot[i].pipeRead, &workerset);
+ 		/* actually WIN32 ignores the first parameter to select()... */
+ 		if (pstate->parallelSlot[i].pipeRead > maxFd)
+ 			maxFd = pstate->parallelSlot[i].pipeRead;
+ 	}
+ 
+ 	if (do_wait)
+ 	{
+ 		i = select_loop(maxFd, &workerset);
+ 		Assert(i != 0);
+ 	}
+ 	else
+ 	{
+ 		if ((i = select(maxFd + 1, &workerset, NULL, NULL, &nowait)) == 0)
+ 			return NULL;
+ 	}
+ 
+ 	if (i < 0)
+ 		exit_horribly(modulename, "error in ListenToWorkers(): %s\n", strerror(errno));
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		char	   *msg;
+ 
+ 		if (!FD_ISSET(pstate->parallelSlot[i].pipeRead, &workerset))
+ 			continue;
+ 
+ 		msg = readMessageFromPipe(pstate->parallelSlot[i].pipeRead);
+ 		*worker = i;
+ 		return msg;
+ 	}
+ 	Assert(false);
+ 	return NULL;
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It sends a message to a certain worker on the communication channel.
+  */
+ void
+ sendMessageToWorker(ParallelState *pstate, int worker, const char *str)
+ {
+ 	int			len = strlen(str) + 1;
+ 
+ 	if (pipewrite(pstate->parallelSlot[worker].pipeWrite, str, len) != len)
+ 	{
+ 		/*
+ 		 * If we're already aborting anyway, don't care if we succeed or not.
+ 		 * The child might have gone already.
+ 		 */
+ #ifndef WIN32
+ 		if (!aborting)
+ #endif
+ 			exit_horribly(modulename,
+ 						"could not write to the communication channel: %s\n",
+ 						  strerror(errno));
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * This function is used to get the return value of a terminated worker
+  * process. If a process has terminated, its status is stored in *status and
+  * the id of the worker is returned.
+  */
+ int
+ ReapWorkerStatus(ParallelState *pstate, int *status)
+ {
+ 	int			i;
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		if (pstate->parallelSlot[i].workerStatus == WRKR_FINISHED)
+ 		{
+ 			*status = pstate->parallelSlot[i].status;
+ 			pstate->parallelSlot[i].status = 0;
+ 			pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 			return i;
+ 		}
+ 	}
+ 	return NO_SLOT;
+ }
+ 
+ /*
+  * If we have one worker that terminates for some reason, we'd like the other
+  * threads to terminate as well (and not finish with their 70 GB table dump
+  * first...). Now in UNIX we can just kill these processes, and let the signal
+  * handler set wantAbort to 1. In Windows we set a termEvent and this serves
+  * as the signal for everyone to terminate.
+  */
+ void
+ checkAborting()
+ {
+ #ifdef WIN32
+ 	if (WaitForSingleObject(termEvent, 0) == WAIT_OBJECT_0)
+ #else
+ 	if (wantAbort)
+ #endif
+ 		exit_horribly(modulename, "worker is terminating\n");
+ }
+ 
+ 
+ /*
+  * Write a printf-style message to stderr.
+  *
+  * The program name is prepended, if "progname" has been set.
+  * Also, if modulename isn't NULL, that's included too.
+  * Note that we'll try to translate the modulename and the fmt string.
+  */
+ void
+ write_msg(const char *modulename, const char *fmt,...)
+ {
+ 	va_list		ap;
+ 
+ 	va_start(ap, fmt);
+ 	vwrite_msg(modulename, fmt, ap);
+ 	va_end(ap);
+ }
+ 
+ /*
+  * As write_msg, but pass a va_list not variable arguments.
+  */
+ void
+ vwrite_msg(const char *modulename, const char *fmt, va_list ap)
+ {
+ 	if (progname)
+ 	{
+ 		if (modulename)
+ 			fprintf(stderr, "%s: [%s] ", progname, _(modulename));
+ 		else
+ 			fprintf(stderr, "%s: ", progname);
+ 	}
+ 	vfprintf(stderr, _(fmt), ap);
+ }
+ 
+ /* Register a callback to be run when exit_nicely is invoked. */
+ void
+ on_exit_nicely(on_exit_nicely_callback function, void *arg)
+ {
+ 	if (on_exit_nicely_index >= MAX_ON_EXIT_NICELY)
+ 		exit_horribly(NULL, "out of on_exit_nicely slots\n");
+ 	on_exit_nicely_list[on_exit_nicely_index].function = function;
+ 	on_exit_nicely_list[on_exit_nicely_index].arg = arg;
+ 	on_exit_nicely_index++;
+ }
+ 
+ /*
+  * Run accumulated on_exit_nicely callbacks in reverse order and then exit
+  * quietly.  This needs to be thread-safe.
+  */
+ void
+ exit_nicely(int code)
+ {
+ 	int			i;
+ 
+ 	for (i = on_exit_nicely_index - 1; i >= 0; i--)
+ 		(*on_exit_nicely_list[i].function) (code,
+ 											on_exit_nicely_list[i].arg);
+ 
+ #ifdef WIN32
+ 	if (parallel_init_done && GetCurrentThreadId() != mainThreadId)
+ 		ExitThread(code);
+ #endif
+ 
+ 	exit(code);
+ }
+ 
*** a/src/tools/msvc/Mkvcbuild.pm
--- b/src/tools/msvc/Mkvcbuild.pm
***************
*** 71,77 **** sub mkvcbuild
  	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
  	  mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
  	  sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c
! 	  win32env.c win32error.c win32setlocale.c);
  
  	push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
  
--- 71,77 ----
  	  pgcheckdir.c pg_crc.c pgmkdirp.c pgsleep.c pgstrcasecmp.c pqsignal.c
  	  mkdtemp.c qsort.c qsort_arg.c quotes.c system.c
  	  sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c
! 	  win32env.c win32error.c win32setlocale.c parallel_utils.c);
  
  	push(@pgportfiles, 'rint.c') if ($vsVersion < '12.00');
  

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/Makefile
--- b/src/bin/scripts/Makefile
***************
*** 32,38 **** dropdb: dropdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq subm
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
--- 32,38 ----
  droplang: droplang.o common.o print.o mbprint.o | submake-libpq submake-libpgport
  dropuser: dropuser.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  clusterdb: clusterdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
! vacuumdb: vacuumdb.o vac_parallel.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  reindexdb: reindexdb.o common.o dumputils.o kwlookup.o keywords.o | submake-libpq submake-libpgport
  pg_isready: pg_isready.o common.o | submake-libpq submake-libpgport
  
***************
*** 65,71 **** uninstall:
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
--- 65,71 ----
  
  clean distclean maintainer-clean:
  	rm -f $(addsuffix $(X), $(PROGRAMS)) $(addsuffix .o, $(PROGRAMS))
! 	rm -f common.o dumputils.o kwlookup.o keywords.o print.o mbprint.o vac_parallel.o $(WIN32RES)
  	rm -f dumputils.c print.c mbprint.c kwlookup.c keywords.c
  	rm -rf tmp_check
  
*** /dev/null
--- b/src/bin/scripts/vac_parallel.c
***************
*** 0 ****
--- 1,498 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.c
+  *
+  *	Parallel support for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #include "vac_parallel.h"
+ 
+ #ifndef WIN32
+ #include <sys/types.h>
+ #include <sys/wait.h>
+ #include "signal.h"
+ #include <unistd.h>
+ #include <fcntl.h>
+ #endif
+ #include "common.h"
+ 
+ /* file-scope variables */
+ #ifdef WIN32
+ static unsigned int tMasterThreadId = 0;
+ 
+ /*
+  * Structure to hold info passed by _beginthreadex() to the function it calls
+  * via its single allowed argument.
+  */
+ typedef struct
+ {
+ 	VacOpt		*vopt;
+ 	int			worker;
+ 	int			pipeRead;
+ 	int			pipeWrite;
+ } WorkerInfo;
+ #endif
+ 
+ static const char *modulename = gettext_noop("parallel vacuum");
+ 
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage);
+ 
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2]);
+ 
+ static void
+ vacuum_close_connection(int code, void *arg);
+ 
+ #define messageStartsWith(msg, prefix) \
+ 	(strncmp(msg, prefix, strlen(prefix)) == 0)
+ #define messageEquals(msg, pattern) \
+ 	(strcmp(msg, pattern) == 0)
+ 
+ 
+ #ifdef WIN32
+ static unsigned __stdcall
+ init_spawned_worker_win32(WorkerInfo *wi)
+ {
+ 	PGconn *conn;
+ 	int			pipefd[2] = {wi->pipeRead, wi->pipeWrite};
+ 	int			worker = wi->worker;
+ 	VacOpt		*vopt = wi->vopt;
+ 	ParallelSlot *mySlot = &shutdown_info.pstate->parallelSlot[worker];
+ 
+ 	conn = connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 						   vopt->username, vopt->promptPassword, vopt->progname,
+ 						   false);
+ 
+ 	((ParallelArgs*)mySlot->args)->connection = conn;
+ 
+ 	free(wi);
+ 	SetupWorker(conn, pipefd, worker, vopt->analyze_stage);
+ 	_endthreadex(0);
+ 	return 0;
+ }
+ #endif
+ 
+ 
+ 
+ ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers)
+ {
+ 	ParallelState *pstate;
+ 	int			i;
+ 	const size_t slotSize = numWorkers * sizeof(ParallelSlot);
+ 
+ 	Assert(numWorkers > 0);
+ 
+ 	/* Ensure stdio state is quiesced before forking */
+ 	fflush(NULL);
+ 
+ 	pstate = (ParallelState *) pg_malloc(sizeof(ParallelState));
+ 
+ 	pstate->numWorkers = numWorkers;
+ 	pstate->parallelSlot = NULL;
+ 
+ 	if (numWorkers == 1)
+ 		return pstate;
+ 
+ 	pstate->parallelSlot = (ParallelSlot *) pg_malloc(slotSize);
+ 	memset((void *) pstate->parallelSlot, 0, slotSize);
+ 
+ 	shutdown_info.pstate = pstate;
+ 
+ #ifdef WIN32
+ 		tMasterThreadId = GetCurrentThreadId();
+ 		termEvent = CreateEvent(NULL, true, false, "Terminate");
+ #else
+ 		signal(SIGTERM, sigTermHandler);
+ 		signal(SIGINT, sigTermHandler);
+ 		signal(SIGQUIT, sigTermHandler);
+ #endif
+ 
+ 
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ #ifdef WIN32
+ 		WorkerInfo *wi;
+ 		uintptr_t	handle;
+ #else
+ 		pid_t		pid;
+ #endif
+ 		int			pipeMW[2],
+ 					pipeWM[2];
+ 
+ 		if (pgpipe(pipeMW) < 0 || pgpipe(pipeWM) < 0)
+ 			exit_horribly(modulename,
+ 						  "could not create communication channels: %s\n",
+ 						  strerror(errno));
+ 
+ 		pstate->parallelSlot[i].workerStatus = WRKR_IDLE;
+ 		pstate->parallelSlot[i].args = (ParallelArgs *) pg_malloc(sizeof(ParallelArgs));
+ 		((ParallelArgs*)pstate->parallelSlot[i].args)->vopt = vopt;
+ #ifdef WIN32
+ 		/* Allocate a new structure for every worker */
+ 		wi = (WorkerInfo *) pg_malloc(sizeof(WorkerInfo));
+ 		wi->worker = i;
+ 		wi->pipeRead = pstate->parallelSlot[i].pipeRevRead = pipeMW[PIPE_READ];
+ 		wi->pipeWrite = pstate->parallelSlot[i].pipeRevWrite = pipeWM[PIPE_WRITE];
+ 		wi->vopt = vopt;
+ 		handle = _beginthreadex(NULL, 0, (void *) &init_spawned_worker_win32,
+ 								wi, 0, &(pstate->parallelSlot[i].threadId));
+ 		pstate->parallelSlot[i].hThread = handle;
+ #else
+ 		pid = fork();
+ 		if (pid == 0)
+ 		{
+ 			/* we are the worker */
+ 			int			j;
+ 			int			pipefd[2] = {pipeMW[PIPE_READ], pipeWM[PIPE_WRITE]};
+ 
+ 			/*
+ 			 * Store the fds for the reverse communication in pstate. Actually
+ 			 * we only use this in case of an error and don't use pstate
+ 			 * otherwise in the worker process. On Windows we write to the
+ 			 * global pstate, in Unix we write to our process-local copy but
+ 			 * that's also where we'd retrieve this information back from.
+ 			 */
+ 			pstate->parallelSlot[i].pipeRevRead = pipefd[PIPE_READ];
+ 			pstate->parallelSlot[i].pipeRevWrite = pipefd[PIPE_WRITE];
+ 			pstate->parallelSlot[i].pid = getpid();
+ 
+ 			((ParallelArgs*)pstate->parallelSlot[i].args)->connection
+ 					= connectDatabase(vopt->dbname, vopt->pghost, vopt->pgport,
+ 									  vopt->username, vopt->promptPassword,
+ 									  vopt->progname, false);
+ 
+ 			/* close read end of Worker -> Master */
+ 			closesocket(pipeWM[PIPE_READ]);
+ 
+ 			/* close write end of Master -> Worker */
+ 			closesocket(pipeMW[PIPE_WRITE]);
+ 
+ 			/*
+ 			 * Close all inherited fds for communication of the master with
+ 			 * the other workers.
+ 			 */
+ 			for (j = 0; j < i; j++)
+ 			{
+ 				closesocket(pstate->parallelSlot[j].pipeRead);
+ 				closesocket(pstate->parallelSlot[j].pipeWrite);
+ 			}
+ 
+ 			SetupWorker(((ParallelArgs*)pstate->parallelSlot[i].args)->connection,
+ 						pipefd, i, vopt->analyze_stage);
+ 			exit(0);
+ 		}
+ 		else if (pid < 0)
+ 			/* fork failed */
+ 			exit_horribly(modulename,
+ 						  "could not create worker process: %s\n",
+ 						  strerror(errno));
+ 
+ 		/* we are the Master, pid > 0 here */
+ 		Assert(pid > 0);
+ 
+ 		/* close read end of Master -> Worker */
+ 		closesocket(pipeMW[PIPE_READ]);
+ 
+ 		/* close write end of Worker -> Master */
+ 		closesocket(pipeWM[PIPE_WRITE]);
+ 
+ 		pstate->parallelSlot[i].pid = pid;
+ #endif
+ 
+ 		pstate->parallelSlot[i].pipeRead = pipeWM[PIPE_READ];
+ 		pstate->parallelSlot[i].pipeWrite = pipeMW[PIPE_WRITE];
+ 	}
+ 
+ 	return pstate;
+ }
+ 
+ /*
+  * Tell all of our workers to terminate.
+  *
+  * Pretty straightforward routine, first we tell everyone to terminate, then
+  * we listen to the workers' replies and finally close the sockets that we
+  * have used for communication.
+  */
+ void
+ ParallelVacuumEnd(ParallelState *pstate)
+ {
+ 	int			i;
+ 
+ 	Assert(IsEveryWorkerIdle(pstate));
+ 
+ 	/* close the sockets so that the workers know they can exit */
+ 	for (i = 0; i < pstate->numWorkers; i++)
+ 	{
+ 		closesocket(pstate->parallelSlot[i].pipeRead);
+ 		closesocket(pstate->parallelSlot[i].pipeWrite);
+ 	}
+ 
+ 	WaitForTerminatingWorkers(pstate);
+ 
+ 	/*
+ 	 * Remove the pstate again, so the exit handler in the parent will now
+ 	 * again fall back to closing AH->connection (if connected).
+ 	 */
+ 	shutdown_info.pstate = NULL;
+ 
+ 	free(pstate->parallelSlot);
+ 	free(pstate);
+ }
+ 
+ /*
+  * This function is called by both UNIX and Windows variants to set up a
+  * worker process.
+  */
+ static void
+ SetupWorker(PGconn *connection, int pipefd[2], int worker, int vacStage)
+ {
+ 
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	if (vacStage >= 0)
+ 		executeMaintenanceCommand(connection, stage_commands[vacStage], false);
+ 
+ 	/*
+ 	 * Call the setup worker function that's defined in the ArchiveHandle.
+ 	 *
+ 	 * We get the raw connection only for the reason that we can close it
+ 	 * properly when we shut down. This happens only that way when it is
+ 	 * brought down because of an error.
+ 	 */
+ 	WaitForCommands(connection, pipefd);
+ 	closesocket(pipefd[PIPE_READ]);
+ 	closesocket(pipefd[PIPE_WRITE]);
+ }
+ 
+ 
+ 
+ /*
+  * That's the main routine for the worker.
+  * When it starts up it enters this routine and waits for commands from the
+  * master process. After having processed a command it comes back to here to
+  * wait for the next command. Finally it will receive a TERMINATE command and
+  * exit.
+  */
+ static void
+ WaitForCommands(PGconn * connection, int pipefd[2])
+ {
+ 	char	   *command;
+ 	PQExpBufferData sql;
+ 
+ 	for (;;)
+ 	{
+ 		if (!(command = getMessageFromMaster(pipefd)))
+ 		{
+ 			PQfinish(connection);
+ 			connection = NULL;
+ 			return;
+ 		}
+ 
+ 
+ 		/* check if master has set the terminate event*/
+ 		checkAborting();
+ 
+ 		if (executeMaintenanceCommand(connection, command, false))
+ 			sendMessageToMaster(pipefd, "OK");
+ 		else
+ 		{
+ 			initPQExpBuffer(&sql);
+ 			appendPQExpBuffer(&sql, "ERROR : %s",
+ 						PQerrorMessage(connection));
+ 			sendMessageToMaster(pipefd, sql.data);
+ 			termPQExpBuffer(&sql);
+ 		}
+ 
+ 		/* command was pg_malloc'd and we are responsible for free()ing it. */
+ 		free(command);
+ 	}
+ }
+ 
+ /*
+  * ---------------------------------------------------------------------
+  * Note the status change:
+  *
+  * DispatchJobForTocEntry		WRKR_IDLE -> WRKR_WORKING
+  * ListenToWorkers				WRKR_WORKING -> WRKR_FINISHED / WRKR_TERMINATED
+  * ReapWorkerStatus				WRKR_FINISHED -> WRKR_IDLE
+  * ---------------------------------------------------------------------
+  *
+  * Just calling ReapWorkerStatus() when all workers are working might or might
+  * not give you an idle worker because you need to call ListenToWorkers() in
+  * between and only thereafter ReapWorkerStatus(). This is necessary in order
+  * to get and deal with the status (=result) of the worker's execution.
+  */
+ void
+ ListenToWorkers(ParallelState *pstate, bool do_wait)
+ {
+ 	int			worker;
+ 	char	   *msg;
+ 
+ 	msg = getMessageFromWorker(pstate, do_wait, &worker);
+ 
+ 	if (!msg)
+ 	{
+ 		if (do_wait)
+ 			exit_horribly(modulename, "a worker process died unexpectedly\n");
+ 		return;
+ 	}
+ 
+ 	if (messageStartsWith(msg, "OK"))
+ 	{
+ 		pstate->parallelSlot[worker].workerStatus = WRKR_FINISHED;
+ 	}
+ 	else if (messageStartsWith(msg, "ERROR "))
+ 	{
+ 		ParallelSlot *mySlot = &pstate->parallelSlot[worker];
+ 
+ 		mySlot->workerStatus = WRKR_TERMINATED;
+ 		exit_horribly(modulename,
+ 			"vacuuming of database \"%s\" failed %s",
+ 			((ParallelArgs*)mySlot->args)->vopt->dbname, msg + strlen("ERROR "));
+ 	}
+ 	else
+ 	{
+ 		exit_horribly(modulename,
+ 				"invalid message received from worker: %s\n", msg);
+ 	}
+ 
+ 	/* both Unix and Win32 return pg_malloc()ed space, so we free it */
+ 	free(msg);
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It looks for an idle worker process and only returns if there is one.
+  */
+ void
+ EnsureIdleWorker(ParallelState *pstate)
+ {
+ 	int			ret_worker;
+ 	int			work_status;
+ 
+ 	for (;;)
+ 	{
+ 		int			nTerm = 0;
+ 
+ 		while ((ret_worker = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+ 		{
+ 			if (work_status != 0)
+ 				exit_horribly(modulename, "error processing a parallel work item\n");
+ 
+ 			nTerm++;
+ 		}
+ 
+ 		/*
+ 		 * We need to make sure that we have an idle worker before dispatching
+ 		 * the next item. If nTerm > 0 we already have that (quick check).
+ 		 */
+ 		if (nTerm > 0)
+ 			return;
+ 
+ 		/* explicit check for an idle worker */
+ 		if (GetIdleWorker(pstate) != NO_SLOT)
+ 			return;
+ 
+ 		/*
+ 		 * If we have no idle worker, read the result of one or more workers
+ 		 * and loop the loop to call ReapWorkerStatus() on them
+ 		 */
+ 		ListenToWorkers(pstate, true);
+ 	}
+ }
+ 
+ /*
+  * This function is executed in the master process.
+  *
+  * It waits for all workers to terminate.
+  */
+ void
+ EnsureWorkersFinished(ParallelState *pstate)
+ {
+ 	int			work_status;
+ 
+ 	if (!pstate || pstate->numWorkers == 1)
+ 		return;
+ 
+ 	/* Waiting for the remaining worker processes to finish */
+ 	while (!IsEveryWorkerIdle(pstate))
+ 	{
+ 		if (ReapWorkerStatus(pstate, &work_status) == NO_SLOT)
+ 			ListenToWorkers(pstate, true);
+ 		else if (work_status != 0)
+ 			exit_horribly(modulename,
+ 						  "error processing a parallel work item\n");
+ 	}
+ }
+ 
+ void
+ DispatchJob(ParallelState *pstate, char * command)
+ {
+ 	int			worker;
+ 
+ 	/* our caller makes sure that at least one worker is idle */
+ 	Assert(GetIdleWorker(pstate) != NO_SLOT);
+ 	worker = GetIdleWorker(pstate);
+ 	Assert(worker != NO_SLOT);
+ 
+ 	sendMessageToWorker(pstate, worker, command);
+ 	pstate->parallelSlot[worker].workerStatus = WRKR_WORKING;
+ }
+ 
+ void
+ on_exit_close_vacuum(PGconn *conn)
+ {
+ 	shutdown_info.handle = (void*)conn;
+ 	on_exit_nicely(vacuum_close_connection, &shutdown_info);
+ }
+ 
+ /*
+  * This function can close archives in both the parallel and non-parallel
+  * case.
+  */
+ static void
+ vacuum_close_connection(int code, void *arg)
+ {
+ 	ShutdownInformation *si = (ShutdownInformation *) arg;
+ 
+ 	if (si->pstate)
+ 	{
+ 		ParallelSlot *slot = GetMyPSlot(si->pstate);
+ 
+ 		if (!slot)
+ 		{
+ 			PQfinish((PGconn*)si->handle);
+ #ifndef WIN32
+ 
+ 			/*
+ 			 * Setting aborting to true switches to best-effort-mode
+ 			 * (send/receive but ignore errors) in communicating with our
+ 			 * workers.
+ 			 */
+ 			aborting = true;
+ #endif
+ 			ShutdownWorkersHard(si->pstate);
+ 		}
+ 		else if (((ParallelArgs*)slot->args)->connection)
+ 			PQfinish((((ParallelArgs*)slot->args)->connection));
+ 	}
+ 	else if ((PGconn*)si->handle)
+ 		PQfinish((PGconn*)si->handle);
+ }
+ 
*** /dev/null
--- b/src/bin/scripts/vac_parallel.h
***************
*** 0 ****
--- 1,58 ----
+ /*-------------------------------------------------------------------------
+  *
+  * vac_parallel.h
+  *
+  *	Parallel support header file for the vacuumdb
+  *
+  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *	The author is not responsible for loss or damages that may
+  *	result from its use.
+  *
+  * IDENTIFICATION
+  *		src/bin/scripts/vac_parallel.h
+  *
+  *-------------------------------------------------------------------------
+  */
+ 
+ #ifndef VAC_PARALLEL_H
+ #define VAC_PARALLEL_H
+ 
+ #include "postgres_fe.h"
+ #include <time.h>
+ #include "libpq-fe.h"
+ #include "common.h"
+ #include "parallel_utils.h"
+ 
+ 
+ typedef struct VacOpt
+ {
+ 	char	   *dbname;
+ 	char	   *pgport;
+ 	char	   *pghost;
+ 	char	   *username;
+ 	char 	   *progname;
+ 	enum trivalue promptPassword;
+ 	int		   analyze_stage;
+ }VacOpt;
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelArgs
+ {
+ 	PGconn *connection;
+ 	VacOpt *vopt;
+ } ParallelArgs;
+ 
+ 
+ extern ParallelState * ParallelVacuumStart(VacOpt *vopt, int numWorkers);
+ extern bool IsEveryWorkerIdle(ParallelState *pstate);
+ extern void ListenToWorkers(ParallelState *pstate, bool do_wait);
+ extern void EnsureIdleWorker(ParallelState *pstate);
+ extern void EnsureWorkersFinished(ParallelState *pstate);
+ 
+ extern void DispatchJob(ParallelState *pstate, char * command);
+ extern void on_exit_close_vacuum(PGconn *conn);
+ extern void ParallelVacuumEnd(ParallelState *pstate);
+ 
+ #endif   /* VAC_PARALLEL_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 13,34 ****
  #include "postgres_fe.h"
  #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 13,54 ----
  #include "postgres_fe.h"
  #include "common.h"
  #include "dumputils.h"
+ #include "vac_parallel.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ void run_command(ParallelState *pstate, char *command);
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt);
+ 
+ const char *progname = NULL;
  
  int
  main(int argc, char *argv[])
***************
*** 49,60 **** main(int argc, char *argv[])
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
- 	const char *progname;
  	int			optindex;
  	int			c;
  
--- 69,80 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
  	};
  
  	int			optindex;
  	int			c;
  
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 94,107 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 150,165 ----
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				parallel = atoi(optarg);
+ 				if (parallel <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 					progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 172,178 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 228,234 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 242,280 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										echo);
! 				}
! 			}
! 			else
! 			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 299,309 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 398,409 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
! 							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 424,668 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
! 							echo);
! 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(PGconn *conn, bool echo,
+ 					const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					VacOpt *vopt)
+ {
+     ParallelState *pstate;
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 
+ 	initPQExpBuffer(&sql);
+ 
+     pstate = ParallelVacuumStart(vopt, parallel);
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+         prepare_command(conn, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+         appendPQExpBuffer(&sql, " %s", cell->val);
+         run_command(pstate, sql.data);
+         termPQExpBuffer(&sql);
+     }
+ 
+     EnsureWorkersFinished(pstate);
+     ParallelVacuumEnd(pstate);
+ 	termPQExpBuffer(&sql);
+ }
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			bool echo, int parallel, SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+     VacOpt vopt = {0};
+ 
+     init_parallel_dump_utils();
+ 
+ 	conn = connectDatabase(dbname, host, port, username, prompt_password,
+ 						   progname, false);
+ 
+ 	if (dbname)
+     	vopt.dbname = pg_strdup(dbname);
+ 
+ 	if (host)
+     	vopt.pghost = pg_strdup(host);
+ 
+ 	if (port)
+     	vopt.pgport = pg_strdup(port);
+ 
+ 	if (username)
+     	vopt.username = pg_strdup(username);
+ 
+ 	if (progname)
+     	vopt.progname = pg_strdup(progname);
+ 
+ 	vopt.promptPassword = prompt_password;
+ 
+     on_exit_close_vacuum(conn);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, " \"%s\".\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 
+ 		tables = &dbtables;
+ 
+     }
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 			vopt.analyze_stage = i;
+ 			run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, parallel, &vopt);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		vopt.analyze_stage = -1;
+ 		run_parallel_vacuum(conn, echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel, &vopt);
+ 	}
+ 
+ 	PQfinish(conn);
+ }
+ 
+ void run_command(ParallelState *pstate, char *command)
+ {
+     int work_status;
+     int ret_child;
+ 
+ 	DispatchJob(pstate, command);
+ 
+     /*Listen for worker and get message*/
+     for (;;)
+     {
+         int         nTerm = 0;
+ 
+         ListenToWorkers(pstate, false);
+         while ((ret_child = ReapWorkerStatus(pstate, &work_status)) != NO_SLOT)
+         {
+             nTerm++;
+         }
+ 
+         /*
+          * We need to make sure that we have an idle worker before
+          * re-running the loop. If nTerm > 0 we already have that (quick
+          * check).
+          */
+         if (nTerm > 0)
+             break;
+ 
+         /* if nobody terminated, explicitly check for an idle worker */
+         if (GetIdleWorker(pstate) != NO_SLOT)
+             break;
+     }
+ }
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 682,688 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,239 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel process to perform the operation.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,34 ****
  #include "common.h"
  #include "dumputils.h"
  
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *table, const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 14,71 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password,
  					const char *progname, bool echo);
  static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname, const char *progname);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname, const char *progname);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 86,92 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 112,125 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 129,134 **** main(int argc, char *argv[])
--- 168,183 ----
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				parallel = atoi(optarg);
+ 				if (parallel <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 					progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 190,196 ----
  		}
  	}
  
+     optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 246,252 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 260,298 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
! 			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 317,328 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 417,428 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 443,849 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = parallel;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+ 		/* This will give the free connection slot, if no slot is free it will
+ 		 wait for atleast one slot to get free.*/
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose, and_analyze,
+                         analyze_only, freeze, &sql);
+ 
+         appendPQExpBuffer(&sql, " %s", cell->val);
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+         resetPQExpBuffer(&sql);
+     }
+ 
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/* Some of the slot are free, Process the results for slots whichever are
+ 	free*/
+ 	do
+ 	{
+ 		i = select_loop(maxFd, &slotset);
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname, const char *progname)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 	while((result = PQgetResult(conn)) != NULL)
+ 		lastResult = result;
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	PQclear(lastResult);
+ 
+ 	if (!r)
+ 	{
+ 		fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 		return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int parallel,
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(parallel * sizeof(ParallelSlot));
+ 	for (i = 0; i < parallel; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	conn = connSlot[0].connection;
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	   get the list of all tables and prpare the list*/
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where relkind= \'r\' and c.relnamespace = ns.oid"
+             " order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, "\"%s\".\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+     }
+ 
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel,
+ 					progname, i, connSlot);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					parallel, progname, -1, connSlot);
+ 	}
+ 
+ 	for (i = 0; i < parallel; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 863,869 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel jobs to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,241 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">jobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of parallel connections to perform the operation. This option will enable the vacuum
+        operation to run on parallel connections, at a time one table will be operated on one connection.
+        So at one time as many tables will be vacuumed parallely as number of jobs.
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,29 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 35,72 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet, int parallel);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int parallel, SimpleStringList *tables);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 87,93 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 113,127 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+     int parallel = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 162,188 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				parallel = atoi(optarg);
+ 				if (parallel <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 					progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 195,201 ----
  		}
  	}
  
+     optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 234,245 ----
  
  	setup_cancel_handler();
  
+ 	/* When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (parallel > tbl_count))
+ 		parallel = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 257,263 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, parallel);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 271,309 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (parallel > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
  			{
!     			vacuum_one_database(dbname, full, verbose, and_analyze,
!     								analyze_only, analyze_in_stages,
!     								freeze, NULL,
!     								host, port, username, prompt_password,
!     								progname, echo);
! 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 328,339 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 428,439 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int parallel)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 454,877 ----
  			fflush(stdout);
  		}
  
! 
! 		if (parallel > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, parallel, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 						    freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int parallel,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = parallel;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+     for (cell = tables->head; cell; cell = cell->next)
+     {
+ 		/* This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+         appendPQExpBuffer(&sql, " %s", cell->val);
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+         resetPQExpBuffer(&sql);
+     }
+ 
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 						completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/* Some of the slot are free, Process the results for slots whichever
+ 	 *  are free
+ 	 */
+ 	do
+ 	{
+ 		i = select_loop(maxFd, &slotset);
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 				completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 	while((result = PQgetResult(conn)) != NULL)
+ 		lastResult = result;
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	PQclear(lastResult);
+ 
+ 	if (!r && !completedb)
+ 	{
+ 		fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 		return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ 
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int parallel,
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	bool	vacuum_tables = true;
+ 	int		tbl_count;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/* if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prpare the list
+ 	 */
+     if (!tables || !tables->head)
+     {
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 	    int ntuple;
+ 	    int i;
+ 	    char *relName;
+ 	    char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+         res = executeQuery(conn,
+             "select relname, nspname from pg_class c, pg_namespace ns"
+             " where (relkind = \'r\' or relkind = \'m\')"
+             " and c.relnamespace = ns.oid order by relpages desc",
+             progname, echo);
+ 
+         ntuple = PQntuples(res);
+         for (i = 0; i < ntuple; i++)
+         {
+             relName = PQgetvalue(res, i, 0);
+             nspace = PQgetvalue(res, i, 1);
+ 
+             appendPQExpBuffer(&sql, "\"%s\".\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 			tbl_count++;
+         }
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		vacuum_tables = false;
+ 
+ 		if (parallel > tbl_count)
+ 			parallel = tbl_count;
+     }
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(parallel * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	for (i = 1; i < parallel; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, parallel,
+ 					progname, i, connSlot, vacuum_tables);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					parallel, progname, -1, connSlot, vacuum_tables);
+ 	}
+ 
+ 	for (i = 0; i < parallel; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+                      bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 891,897 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many parallel connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 224,229 **** PostgreSQL documentation
--- 224,250 ----
       </varlistentry>
  
       <varlistentry>
+        <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+        <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></></term>
+        <listitem>
+        <para>
+        Number of asynchronous connections to perform the operation. This option
+        will enable the vacuum operation to run on asynchronous connections,
+        at a time one table will be operated on one connection. So at one time
+        as many tables will be vacuumed parallely as number of jobs.
+        If number of jobs given are more than number of tables then number of
+        jobs will be set to number of tables.
+        </para>
+        <para><application>vacuumdb</> will open <replaceable class="parameter">
+        njobs</replaceable> connections to the database, so make sure your
+        <xref linkend="guc-max-connections"> setting is high enough to
+        accommodate all connections.
+        </para>
+        </para>
+        </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
         <term><option>-?</></term>
         <term><option>--help</></term>
         <listitem>
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,29 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 35,73 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int numAsyncCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					bool freeze, const char *host,
+ 					const char *port, const char *username,
+ 					enum trivalue prompt_password, const char *progname,
+ 					bool echo, int numAsyncCons, SimpleStringList *tables);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int numAsyncCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 88,94 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 114,128 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int numAsyncCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 163,189 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				numAsyncCons = atoi(optarg);
+ 				if (numAsyncCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 196,202 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 235,247 ----
  
  	setup_cancel_handler();
  
+ 	/*
+ 	 * When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (numAsyncCons > tbl_count))
+ 		numAsyncCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 259,265 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, numAsyncCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
  				vacuum_one_database(dbname, full, verbose, and_analyze,
  									analyze_only, analyze_in_stages,
! 									freeze, cell->val,
  									host, port, username, prompt_password,
  									progname, echo);
  			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo);
  	}
  
  	exit(0);
--- 273,311 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (numAsyncCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, numAsyncCons, &tables);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo);
! 				}
! 			}
! 			else
  			{
  				vacuum_one_database(dbname, full, verbose, and_analyze,
  									analyze_only, analyze_in_stages,
! 									freeze, NULL,
  									host, port, username, prompt_password,
  									progname, echo);
+ 
  			}
  		}
  	}
  
  	exit(0);
***************
*** 253,263 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
!    bool analyze_only, bool analyze_in_stages, bool freeze, const char *table,
! 					const char *host, const char *port,
! 					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo)
  {
  	PQExpBufferData sql;
  
--- 330,341 ----
  
  
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose,
! 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
! 					bool freeze, const char *table, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo)
  {
  	PQExpBufferData sql;
  
***************
*** 352,362 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 430,441 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int numAsyncCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 377,391 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  			fflush(stdout);
  		}
  
! 		vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 							analyze_in_stages,
! 						 freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
  	}
  
  	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 456,913 ----
  			fflush(stdout);
  		}
  
! 
! 		if (numAsyncCons > 1)
! 		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, numAsyncCons, NULL);
! 
! 		}
! 		else
! 		{
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages,
! 							freeze, NULL, host, port, username, prompt_password,
  							progname, echo);
+ 		}
  	}
  
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function process the table list,
+  * pick the object on by one and get the Free connections slot, once it
+  * get the free slot send the job on the free connection.
+  */
+ 
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int numAsyncCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = numAsyncCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 						completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot available return the slotid
+  * If no slot is free, Then perform select on all the socket and wait until
+  * atleast one slot is free.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * Some of the slot are free, Process the results for slots whichever
+ 	 * are free
+ 	 */
+ 	do
+ 	{
+ 		i = select_loop(maxFd, &slotset);
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 				completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 	while((result = PQgetResult(conn)) != NULL)
+ 		lastResult = result;
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	PQclear(lastResult);
+ 
+ 	/*
+ 	 * If user has not given the vacuum of complete db, then if
+ 	 * any of the object vacuum failed it can be ignored and vacuuming
+ 	 * of other object can be continued, this is the same behaviour as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r && !completedb)
+ 	{
+ 		fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 		return false;
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open the multiple asynchronous connection as
+  * suggested by used, it will derive the table list using server call
+  * if table list is not given by user and perform the vacuum call
+  */
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int numAsyncCons,
+ 			SimpleStringList *tables)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	bool	vacuum_tables = true;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prpare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		char *relName;
+ 		char *nspace;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT relname, nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			relName = PQgetvalue(res, i, 0);
+ 			nspace = PQgetvalue(res, i, 1);
+ 
+ 			appendPQExpBuffer(&sql, "\"%s\".\"%s\"", nspace, relName);
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		vacuum_tables = false;
+ 
+ 		if (numAsyncCons > ntuple)
+ 			numAsyncCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(numAsyncCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	for (i = 1; i < numAsyncCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		int			i;
+ 
+ 		for (i = 0; i < 3; i++)
+ 		{
+ 			const char *stage_messages[] = {
+ 					gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 					gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 					gettext_noop("Generating default (full) optimizer statistics")};
+ 
+ 			puts(gettext(stage_messages[i]));
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, numAsyncCons,
+ 					progname, i, connSlot, vacuum_tables);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					numAsyncCons, progname, -1, connSlot, vacuum_tables);
+ 	}
+ 
+ 	for (i = 0; i < numAsyncCons; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 405,410 **** help(const char *progname)
--- 927,933 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many asynchronous connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,231 ----
       </varlistentry>
  
       <varlistentry>
+         <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+         <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></></term>
+         <listitem>
+          <para>
+           Number of concurrent connections to perform the operation.
+           This option will enable the vacuum operation to run on asynchronous connections,
+           at a time one table will be operated on one connection.
+           So at one time as many tables will be vacuumed parallely as number of jobs.
+           If number of jobs given are more than number of tables then number of
+           jobs will be set to number of tables.
+           </para>
+          <para>
+           <application>vacuumdb</> will open <replaceable class="parameter">
+           njobs</replaceable> connections to the database, so make sure your
+           <xref linkend="guc-max-connections"> setting is high enough to
+           accommodate all connections.
+          </para>
+          </para>
+         </listitem>
+        </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,26 ****
  
  #include "common.h"
  
! static void SetCancelConn(PGconn *conn);
! static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
--- 19,25 ----
  
  #include "common.h"
  
! 
  
  static PGcancel *volatile cancelConn = NULL;
  
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 290,296 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 320,326 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 49,56 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,30 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
+ #define ERRCODE_UNDEFINED_TABLE  "42P01"
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 36,74 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int numAsyncCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					int stage, bool freeze, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int concurrentCons,
+ 					SimpleStringList *tables, bool quiet);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int numAsyncCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 89,95 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 115,129 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 164,190 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				concurrentCons = atoi(optarg);
+ 				if (concurrentCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 197,203 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 236,248 ----
  
  	setup_cancel_handler();
  
+ 	/*
+ 	 * When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 260,266 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, concurrentCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
- 			for (cell = tables.head; cell; cell = cell->next)
- 			{
- 				vacuum_one_database(dbname, full, verbose, and_analyze,
- 									analyze_only, analyze_in_stages, -1,
- 									freeze, cell->val,
- 									host, port, username, prompt_password,
- 									progname, echo, quiet);
- 			}
  		}
  		else
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
  	}
  
  	exit(0);
--- 274,309 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (concurrentCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages, -1,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, concurrentCons, &tables, quiet);
  
  		}
  		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages, -1,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo, quiet);
! 				}
! 			}
! 			else
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
+ 		}
  	}
  
  	exit(0);
***************
*** 268,323 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
! 	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
! 	}
! 	else
! 	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
! 		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
- 			if (full)
- 			{
- 				appendPQExpBuffer(&sql, "%sFULL", sep);
- 				sep = comma;
- 			}
- 			if (freeze)
- 			{
- 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
- 				sep = comma;
- 			}
- 			if (verbose)
- 			{
- 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
- 				sep = comma;
- 			}
- 			if (and_analyze)
- 			{
- 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
- 				sep = comma;
- 			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
- 		}
- 	}
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
--- 343,351 ----
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	prepare_command(conn, full, verbose,
! 					and_analyze, analyze_only, freeze, &sql);
  
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
***************
*** 374,384 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 402,413 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int numAsyncCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 407,412 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 436,450 ----
  				fflush(stdout);
  			}
  
+ 		if (numAsyncCons > 1)
+ 		{
+ 			vacuum_parallel(dbname, full, verbose, and_analyze,
+ 								analyze_only, analyze_in_stages, stage,
+ 								freeze, host, port, username, prompt_password,
+ 								progname, echo, numAsyncCons, NULL, quiet);
+ 
+ 		}
+ 		else
  			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
  								analyze_in_stages, stage,
  							freeze, NULL, host, port, username, prompt_password,
***************
*** 417,422 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 455,923 ----
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function process the table list,
+  * pick the object on by one and get the Free connections slot, once it
+  * get the free slot send the job on the free connection.
+  */
+ 
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = concurrentCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 						completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot available return the slotid
+  * If no slot is free, Then perform select on all the socket and wait until
+  * atleast one slot is free.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * Some of the slot are free, Process the results for slots whichever
+ 	 * are free
+ 	 */
+ 	do
+ 	{
+ 		SetCancelConn(pSlot[0].connection);
+ 		i = select_loop(maxFd, &slotset);
+ 
+ 		ResetCancelConn();
+ 
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 				completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 	while((result = PQgetResult(conn)) != NULL)
+ 		lastResult = result;
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	PQclear(lastResult);
+ 
+ 	/*
+ 	 * If user has given the vacuum of complete db, then if
+ 	 * any of the object vacuum failed it can be ignored and vacuuming
+ 	 * of other object can be continued, this is the same behavior as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r)
+ 	{
+ 		char *sqlState = PQresultErrorField(result, PG_DIAG_SQLSTATE);
+ 
+ 		if(!completedb ||
+ 			(sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+ 		{
+ 
+ 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 						progname, dbname, PQerrorMessage(conn));
+ 
+ 			return false;
+ 		}
+ 	}
+ 
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open the multiple concurrent connections as
+  * suggested by used, it will derive the table list using server call
+  * if table list is not given by user and perform the vacuum call
+  */
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			int stage, bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int concurrentCons,
+ 			SimpleStringList *tables, bool quiet)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	bool	completeDb = false;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prepare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			appendPQExpBuffer(&sql, "%s",
+ 							fmtQualifiedId(PQserverVersion(conn),
+ 							PQgetvalue(res, i, 1),
+ 							PQgetvalue(res, i, 0)));
+ 
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		completeDb = true;
+ 
+ 		if (concurrentCons > ntuple)
+ 			concurrentCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	for (i = 1; i < concurrentCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 			};
+ 
+ 		if (stage == -1)
+ 		{
+ 			int			i;
+ 			for (i = 0; i < 3; i++)
+ 			{
+ 				if (!quiet)
+ 				{
+ 					puts(gettext(stage_messages[i]));
+ 					fflush(stdout);
+ 				}
+ 
+ 				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, concurrentCons,
+ 						progname, i, connSlot, completeDb);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+ 			 * only that one. */
+ 			if (!quiet)
+ 			{
+ 				puts(gettext(stage_messages[stage]));
+ 				fflush(stdout);
+ 			}
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, concurrentCons,
+ 					progname, stage, connSlot, completeDb);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					concurrentCons, progname, -1, connSlot, completeDb);
+ 	}
+ 
+ 	for (i = 0; i < concurrentCons; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 937,943 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

�PNG


IHDR�
�,�
2PLTE���������������@��Ai��� �@���0`��@�������**��@��333MMMfff�������������������22�������U����������������d�"�".�W��p��������������P����E��r��z�����k������� �����������P@Uk/���@�@��`��`�����@��@��`��p������������������������|�@�� ���___���???������d�H�IDATx���i�� @����r���
#�$�I@

���n:��So@p�����~5U��g%��n�4u�����
"R7�j�5��%���<&
�~��;.�E���~��}���
����Y�j��:.�E�h�}*B&��5���7�p� l"�"���.��!|��]g4�>]���j?W���JjDm`�yVDEm���;���W�6�j���V��x�1�yV����[�����W��Ym`�����9�r�|�!�yV�%TsZ��Ow\m��v�?�M�i`1">���<�
�
z�����G��v_m��v���Z
������}�yV��Ol���[�B�����Ym`��9?������\	���Km��N
�2?~%<���T�g�����[�
��������uR�g�����V��w�_}>(�o��6�jE^��&��O�t�_}Gm����AI�	
}7���4j��6�0�N�"5�T��g�l)_�f���<�
,q
+����>�k���<�
,���?$*���}���KW��Ym`A��}��������<�
,����}�RC���_��Lm��@`���/��1c}�G�yVX�
T����!�9��;�6�j�G�:������}9���j��60o;�������m���@m���M`ya�_T@�:j��60_����[�\������]�6�j�ET��m����xs��<�
���C�K��������[�6�j�������e��;��6�j�#���4IQ�g��y8F����}@�z��60��
_oAx
2j��60�	��?�yV�BSq����:j��60$��J�z��6���9��m�+a/�6�j�
&��j��6��������E=������FP��{�T��7�j�e��Oo���-��D��lJ���g��}�������R�8j��6�oQ#���Z����7�2��
��2���2e�/2�[��/��nhm��Ou�Z/X1
c�M��<��[���e�$�f�4n]o��[r�	�&�T��WT#������<3����&���w�O2�v�1�kc7��[e�[r��K
~�h����ky�~I���U�^?�y��Z���.x��)!
o�_�o���� $�b���.�d-���f&�j��.��������2%=
B~f"ZF�;�'|*�����	�[���0E���6�j���yV������Oo������M���g��}
=P�g��}Fbr��������>"qv��������>" �}���g��=>-�'p�
�Ge`����"�����(�y���]�4�����P��<�h
�})��8�2�[��*�O�	�������7!`�v��3-���{o����-����K�� ���
-�y���Cw�OM�����
���Y�R���7��{pvA���mP��w��9�wI��/��?-y~GI`�$��y��A�|���
oo_5������#���S������o��<�#0�����;(�y>@E`��DQ��+���<�"��[�
�t���y^+�����R��<�!0��5�9��;����!��a-�4��k
y>DC`���T���y�3�;��DA��Q��c[0y>FA`�y>&`B}�UN�����c�/M��%�O���Q?4q��y>!{`�����0������I<�
����3��QI���3r�i���Sr��i���Sr��i���S2��@�c0x&
�A�D�.V�M��-Q�|�B�K��r�v�������"���kE�T����~�L���0��t�-��q�-&���_2d�<u�f>�3�%��.� `2�\�t{�q�-&
�3��<���K��!���w���NA�4��qU� 
���,n�"7����6o�MD#`BdO�5S�Z��8L#��)A�70%��
_��� �+�|
���/�_Z�L���iA�g�/1�&
�A�� ���|
S��O `j�����.�tA�� ���
0=����A���� `p�r����@� �
�e

W0���Y@���. `p

���3��	�A�L ���
'08���@@�e
-�
� `6��9�����`S�..�
��lW�����qH( �e�?�U;�m���od�7�1/2-l��y�k��%�_��ev�"���2���2�/'�y��f<l>lx<V���\����0'
yG��<��en&�:t����9Iq$��1Kk�q��[L��eE6���Ue�N�yf>�3n�-��

���gS�y�h����������-������Y��s[w��p����q�m5
�y��s;tU7�M�|�����������a0�9�}�����T8�������{����V8
����s7��v�(��F������6{��2�.�����+�I9�zN��8���g���m;c��lr �o��g;b�+����"�����Dtk�����������<;�v�p= f
!+?- ��
!+�:���$�y�)��oLG@  d���`���g��N����ynSq1�u��?\]�����@��?�y0�����J�s-�C�V�Z����t���1���0
~�|^A
�O����&a$�?M����S����?]  d���?e����������S��>~I@�S�	����h�SI@���>������?���yy������?����,��4�#y!�����<W��%��Z�����9���JTK��f���c
�z	�s�?t\�
~a"������4����u*
5����i��N���j����/
���C@��	Y�db��VM�O7A#��/K9���	9����m>t�v��������V��?����1O�T�����*���F@��M�L�	O���:��VL�?�$����f�w=*����!�vd���������Q�-F���}S��������*���[��1����{�|��~����.8��f�MX�����_�A�@����>���o
 ���O8��e����|2����t*
K ���g��_���D!Q�m��2@@��]��B��*�n��_)  d���_1  d������r@@�����@@�
BVn( ��BV�' �BV�r;
��,�r7
��0������	������{	������[	��������I@�+���H@�+��  d�>�_�  d�6�_�  d
!+w�

!+7�JEN��Y���[-
KEN@S����k2�#`��v��������T���?��-�����X�h*3������%���K

�6n<����i��C�rI!����	��L@;$����_
E|��W
�!X0I�`�i�+�vC�Bd&��d���3p}�N�������)�b,��/ ��
BVJ�

!+Y)\@�+��  d
!+e�������  d�h
��|�������, ����  d
!+�w
!+YA@�J���-@@�
BV���
BV�����R��������  d�P
��.  d
!+Y)S@��
Y��o�����(��X!�9
M�V[�m��k��"�mH�^��2�������b�j�T����Kn����>$��}����

�C
�����[�60�%
�7Bol9�,����8R�����%N� ��H `��h��rV���G>��w����N�' ��
��  d
!+�	��
!+YA@�Ji���@@�
BV�R���w7�������% ����  d
!+E	��
!+E	�Cm��QQ�g��AT��Ym`�yVDEm��QQ�g��AT��Ym`�yVXCW�0�����8���'��/Z���j��6����K��9��~�Am��D=��]�q~��/;[W���+�<���|�r4/ ���������?�<���eg����j~z��v
�_�������Ym`AT���214��
U;���������'���Gc�(Tc�Nz|��6b�����Ka8����vc�h���9��,��-�idR�6�j�s
�8��7���U��
�^jG=z3y�m�����ns,��jZ}`���fm��hZS�Su�����]���5�N��x�y��<�
,��t��>��=�c@���V������|
��&a��z:j����������}��������h����8�5m~�T��%����fV
�a���e^;ei���j�h}����;�]�c��.>�87:��^��Y����?�.��bVX:�2�xl��p��|���Ec�<u����/��f�l�r+���Z�^�]l4�V����s\�Rt�����Dm��v��e�5�����bU�4r����/m����N�|`�D�����j���G?��,���[���
��;�N�����zj �_��7{�9\>0n������S����O5N�t?h����n�����_�z+���v�8�VO��������:
n����3
O������!�um=�����^}���{<�������������Wsz8M86t�p��m5>_����������u�`�������nR�y�����������s�.�_
�����S�I*������I*�<��G������.��a���A����?*���)� ��vU;���q)u`dOA���
������������ ��>����.�g ��.���h�H�k/��	��?��������Y7,�{
2�����Y�v��!�)�/�?="��c��V�������t�����m�Y� ���y���!*�t�t���.�5�0�%2)��
Q
�m�fb�^g	Fd�O@f��O��X���a{R�T&���f"�����Dp��!��F�v�5��=Dva�A8a$p���e�H&���n�����k�\��X&�H�O�<o�������u������D���0� d"�nlv�����Lu��p�`f"�n�vH�����`��h�>
	�'���v�y��.�5g"�Sq�}���7������X�?=8Zf�$3
p/��1|��u�������BVV
kS���j����[���`�z.��5�7�OW���v�H
��]NVMw<�c��oKmS���m�����nY�"�85q�Rsq2nWlz�������!����.���������n�\�a�x��E���C���;���z�����
���
����m�sh
]�.J�-'��^�����p;�P��(�
��w�4�2��G��-�OOa�9���3}mc�y�o����Rg����
(�d
�aIEND�B`�

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,231 ----
       </varlistentry>
  
       <varlistentry>
+         <term><option>-j <replaceable class="parameter">jobs</replaceable></></term>
+         <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></></term>
+         <listitem>
+          <para>
+           Number of concurrent connections to perform the operation.
+           This option will enable the vacuum operation to run on asynchronous connections,
+           at a time one table will be operated on one connection.
+           So at one time as many tables will be vacuumed parallely as number of jobs.
+           If number of jobs given are more than number of tables then number of
+           jobs will be set to number of tables.
+           </para>
+          <para>
+           <application>vacuumdb</> will open <replaceable class="parameter">
+           njobs</replaceable> connections to the database, so make sure your
+           <xref linkend="guc-max-connections"> setting is high enough to
+           accommodate all connections.
+          </para>
+          </para>
+         </listitem>
+        </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,28 ****
  
  #include "common.h"
  
! static void SetCancelConn(PGconn *conn);
! static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
--- 19,28 ----
  
  #include "common.h"
  
! 
  
  static PGcancel *volatile cancelConn = NULL;
+ static bool inAbort = false;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 291,297 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 321,327 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
***************
*** 358,363 **** handle_sigint(SIGNAL_ARGS)
--- 358,364 ----
  	/* Send QueryCancel if we are processing a database query */
  	if (cancelConn != NULL)
  	{
+ 		inAbort = true;
  		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
  			fprintf(stderr, _("Cancel request sent\n"));
  		else
***************
*** 391,396 **** consoleHandler(DWORD dwCtrlType)
--- 392,399 ----
  		EnterCriticalSection(&cancelConnLock);
  		if (cancelConn != NULL)
  		{
+ 			inAbort = true;
+ 
  			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
  				fprintf(stderr, _("Cancel request sent\n"));
  			else
***************
*** 414,416 **** setup_cancel_handler(void)
--- 417,424 ----
  }
  
  #endif   /* WIN32 */
+ 
+ bool in_abort()
+ {
+ 	return inAbort;
+ }
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 49,57 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ extern bool in_abort(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,30 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
+ #define ERRCODE_UNDEFINED_TABLE  "42P01"
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 36,74 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int concurrentCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					int stage, bool freeze, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int concurrentCons,
+ 					SimpleStringList *tables, bool quiet);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 89,95 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 115,129 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 164,190 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				concurrentCons = atoi(optarg);
+ 				if (concurrentCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 197,203 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 236,248 ----
  
  	setup_cancel_handler();
  
+ 	/*
+ 	 * When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 260,266 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, concurrentCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
- 			for (cell = tables.head; cell; cell = cell->next)
- 			{
- 				vacuum_one_database(dbname, full, verbose, and_analyze,
- 									analyze_only, analyze_in_stages, -1,
- 									freeze, cell->val,
- 									host, port, username, prompt_password,
- 									progname, echo, quiet);
- 			}
  		}
  		else
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
  	}
  
  	exit(0);
--- 274,309 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (concurrentCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages, -1,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, concurrentCons, &tables, quiet);
  
  		}
  		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages, -1,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo, quiet);
! 				}
! 			}
! 			else
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
+ 		}
  	}
  
  	exit(0);
***************
*** 268,323 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
! 	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
! 	}
! 	else
! 	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
! 		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
- 			if (full)
- 			{
- 				appendPQExpBuffer(&sql, "%sFULL", sep);
- 				sep = comma;
- 			}
- 			if (freeze)
- 			{
- 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
- 				sep = comma;
- 			}
- 			if (verbose)
- 			{
- 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
- 				sep = comma;
- 			}
- 			if (and_analyze)
- 			{
- 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
- 				sep = comma;
- 			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
- 		}
- 	}
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
--- 343,351 ----
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	prepare_command(conn, full, verbose,
! 					and_analyze, analyze_only, freeze, &sql);
  
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
***************
*** 374,384 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 402,413 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int concurrentCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 407,412 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 436,450 ----
  				fflush(stdout);
  			}
  
+ 		if (concurrentCons > 1)
+ 		{
+ 			vacuum_parallel(dbname, full, verbose, and_analyze,
+ 								analyze_only, analyze_in_stages, stage,
+ 								freeze, host, port, username, prompt_password,
+ 								progname, echo, concurrentCons, NULL, quiet);
+ 
+ 		}
+ 		else
  			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
  								analyze_in_stages, stage,
  							freeze, NULL, host, port, username, prompt_password,
***************
*** 417,422 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 455,956 ----
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function process the table list,
+  * pick the object on by one and get the Free connections slot, once it
+  * get the free slot send the job on the free connection.
+  */
+ 
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = concurrentCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 							completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		pfree(connSlot);
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot available return the slotid
+  * If no slot is free, Then perform select on all the socket and wait until
+  * atleast one slot is free.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * Some of the slot are free, Process the results for slots whichever
+ 	 * are free
+ 	 */
+ 
+ 	do
+ 	{
+ 		SetCancelConn(pSlot[0].connection);
+ 
+ 		i = select_loop(maxFd, &slotset);
+ 
+ 		ResetCancelConn();
+ 
+ 		if (i < 0)
+ 		{
+ 			/* This can only happen if user has sent the cacle request using
+ 			 * Ctrl+C, Cancle is handled by 0th slot, so fetch the error result
+ 			 */
+ 
+ 			GetQueryResult(pSlot[0].connection, dbname, progname,
+ 						  completedb);
+ 			return NO_SLOT;
+ 		}
+ 
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 								completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 
+ 	SetCancelConn(conn);
+ 	while((result = PQgetResult(conn)) != NULL)
+ 	{
+ 		PQclear(lastResult);
+ 		lastResult = result;
+ 	}
+ 
+ 	ResetCancelConn();
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	/*
+ 	 * If user has given the vacuum of complete db, then if
+ 	 * any of the object's vacuum failed it can be ignored and vacuuming
+ 	 * of other objects can be continued, this is the same behavior as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r)
+ 	{
+ 		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+ 
+ 		if (!completedb ||
+ 		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+ 		{
+ 
+ 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 						progname, dbname, PQerrorMessage(conn));
+ 
+ 			PQclear(lastResult);
+ 			return false;
+ 		}
+ 	}
+ 
+ 	PQclear(lastResult);
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open the multiple concurrent connections as
+  * suggested by used, it will derive the table list using server call
+  * if table list is not given by user and perform the vacuum call
+  */
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			int stage, bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int concurrentCons,
+ 			SimpleStringList *tables, bool quiet)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	bool	completeDb = false;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prepare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		SimpleStringList dbtables = {NULL, NULL};
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			appendPQExpBuffer(&sql, "%s",
+ 							fmtQualifiedId(PQserverVersion(conn),
+ 							PQgetvalue(res, i, 1),
+ 							PQgetvalue(res, i, 0)));
+ 
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		completeDb = true;
+ 
+ 		if (concurrentCons > ntuple)
+ 			concurrentCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	connSlot[0].sock = PQsocket(conn);
+ 
+ 	PQsetnonblocking(connSlot[0].connection, 1);
+ 
+ 	for (i = 1; i < concurrentCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 			};
+ 
+ 		if (stage == -1)
+ 		{
+ 			int			i;
+ 			for (i = 0; i < 3; i++)
+ 			{
+ 				if (!quiet)
+ 				{
+ 					puts(gettext(stage_messages[i]));
+ 					fflush(stdout);
+ 				}
+ 
+ 				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, concurrentCons,
+ 						progname, i, connSlot, completeDb);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+ 			 * only that one. */
+ 			if (!quiet)
+ 			{
+ 				puts(gettext(stage_messages[stage]));
+ 				fflush(stdout);
+ 			}
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, concurrentCons,
+ 					progname, stage, connSlot, completeDb);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					concurrentCons, progname, -1, connSlot, completeDb);
+ 	}
+ 
+ 	for (i = 0; i < concurrentCons; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ 
+ 	pfree(connSlot);
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		if (in_abort())
+ 		{
+ 			return -1;
+ 		}
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	initPQExpBuffer(sql);
+ 
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBuffer(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBuffer(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBuffer(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBuffer(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBuffer(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBuffer(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBuffer(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBuffer(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 970,976 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

diff --git a/doc/src/sgml/ref/vacuumdb.sgml b/doc/src/sgml/ref/vacuumdb.sgml
index 3ecd999..e4a971f 100644
--- a/doc/src/sgml/ref/vacuumdb.sgml
+++ b/doc/src/sgml/ref/vacuumdb.sgml
@@ -204,6 +204,27 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+      <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+      <listitem>
+       <para>
+        Number of concurrent connections to perform the operation.
+        This option will enable the vacuum operation to run on asynchronous
+        connections, at a time one table will be operated on one connection.
+        So at one time as many tables will be vacuumed parallely as number of
+        jobs.  If number of jobs given are more than number of tables then
+        number of jobs will be set to number of tables.
+       </para>
+       <para>
+        <application>vacuumdb</application> will open
+        <replaceable class="parameter"> njobs</replaceable> connections to the
+        database, so make sure your <xref linkend="guc-max-connections">
+        setting is high enough to accommodate all connections.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>--analyze-in-stages</option></term>
       <listitem>
        <para>
diff --git a/src/bin/scripts/common.c b/src/bin/scripts/common.c
index 311fed5..bc5336a 100644
--- a/src/bin/scripts/common.c
+++ b/src/bin/scripts/common.c
@@ -19,10 +19,10 @@
 
 #include "common.h"
 
-static void SetCancelConn(PGconn *conn);
-static void ResetCancelConn(void);
+
 
 static PGcancel *volatile cancelConn = NULL;
+static bool inAbort = false;
 
 #ifdef WIN32
 static CRITICAL_SECTION cancelConnLock;
@@ -291,7 +291,7 @@ yesno_prompt(const char *question)
  *
  * Set cancelConn to point to the current database connection.
  */
-static void
+void
 SetCancelConn(PGconn *conn)
 {
 	PGcancel   *oldCancelConn;
@@ -321,7 +321,7 @@ SetCancelConn(PGconn *conn)
  *
  * Free the current cancel connection, if any, and set to NULL.
  */
-static void
+void
 ResetCancelConn(void)
 {
 	PGcancel   *oldCancelConn;
@@ -358,6 +358,7 @@ handle_sigint(SIGNAL_ARGS)
 	/* Send QueryCancel if we are processing a database query */
 	if (cancelConn != NULL)
 	{
+		inAbort = true;
 		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
 			fprintf(stderr, _("Cancel request sent\n"));
 		else
@@ -391,6 +392,8 @@ consoleHandler(DWORD dwCtrlType)
 		EnterCriticalSection(&cancelConnLock);
 		if (cancelConn != NULL)
 		{
+			inAbort = true;
+
 			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
 				fprintf(stderr, _("Cancel request sent\n"));
 			else
@@ -414,3 +417,8 @@ setup_cancel_handler(void)
 }
 
 #endif   /* WIN32 */
+
+bool in_abort()
+{
+	return inAbort;
+}
diff --git a/src/bin/scripts/common.h b/src/bin/scripts/common.h
index 691f6c6..3bafde3 100644
--- a/src/bin/scripts/common.h
+++ b/src/bin/scripts/common.h
@@ -49,4 +49,9 @@ extern bool yesno_prompt(const char *question);
 
 extern void setup_cancel_handler(void);
 
+extern void SetCancelConn(PGconn *conn);
+extern void ResetCancelConn(void);
+extern bool in_abort(void);
+
+
 #endif   /* COMMON_H */
diff --git a/src/bin/scripts/vacuumdb.c b/src/bin/scripts/vacuumdb.c
index 86e6ab3..8c2abb7 100644
--- a/src/bin/scripts/vacuumdb.c
+++ b/src/bin/scripts/vacuumdb.c
@@ -14,6 +14,17 @@
 #include "common.h"
 #include "dumputils.h"
 
+#define NO_SLOT (-1)
+
+/* Arguments needed for a worker process */
+typedef struct ParallelSlot
+{
+	PGconn *connection;
+	bool isFree;
+	pgsocket sock;
+} ParallelSlot;
+
+#define ERRCODE_UNDEFINED_TABLE  "42P01"
 
 static void vacuum_one_database(const char *dbname, bool full, bool verbose,
 	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
@@ -25,10 +36,39 @@ static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
 					 const char *maintenance_db,
 					 const char *host, const char *port,
 					 const char *username, enum trivalue prompt_password,
-					 const char *progname, bool echo, bool quiet);
+					 const char *progname, bool echo, bool quiet,
+					 int concurrentCons);
 
 static void help(const char *progname);
 
+void vacuum_parallel(const char *dbname, bool full, bool verbose,
+					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+					int stage, bool freeze, const char *host, const char *port,
+					const char *username, enum trivalue prompt_password,
+					const char *progname, bool echo, int concurrentCons,
+					SimpleStringList *tables, bool quiet);
+
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, PQExpBuffer sql);
+static void
+run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+					bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, int concurrentCons,
+					const char *progname, int analyze_stage,
+					ParallelSlot *connSlot, bool completedb);
+static int
+GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+			const char *progname, bool completedb);
+
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+						const char *progname, bool completedb);
+
+static int
+select_loop(int maxFd, fd_set *workerset);
+
+static void DisconnectDatabase(ParallelSlot *slot);
+
 
 int
 main(int argc, char *argv[])
@@ -49,6 +89,7 @@ main(int argc, char *argv[])
 		{"table", required_argument, NULL, 't'},
 		{"full", no_argument, NULL, 'f'},
 		{"verbose", no_argument, NULL, 'v'},
+		{"jobs", required_argument, NULL, 'j'},
 		{"maintenance-db", required_argument, NULL, 2},
 		{"analyze-in-stages", no_argument, NULL, 3},
 		{NULL, 0, NULL, 0}
@@ -74,13 +115,15 @@ main(int argc, char *argv[])
 	bool		full = false;
 	bool		verbose = false;
 	SimpleStringList tables = {NULL, NULL};
+	int concurrentCons = 0;
+	int tbl_count = 0;
 
 	progname = get_progname(argv[0]);
 	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
 
 	handle_help_version_opts(argc, argv, "vacuumdb", help);
 
-	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
+	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
 	{
 		switch (c)
 		{
@@ -121,14 +164,27 @@ main(int argc, char *argv[])
 				alldb = true;
 				break;
 			case 't':
+			{
 				simple_string_list_append(&tables, optarg);
+				tbl_count++;
 				break;
+			}
 			case 'f':
 				full = true;
 				break;
 			case 'v':
 				verbose = true;
 				break;
+			case 'j':
+				concurrentCons = atoi(optarg);
+				if (concurrentCons <= 0)
+				{
+					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+							progname);
+					exit(1);
+				}
+
+				break;
 			case 2:
 				maintenance_db = pg_strdup(optarg);
 				break;
@@ -141,6 +197,7 @@ main(int argc, char *argv[])
 		}
 	}
 
+	optind++;
 
 	/*
 	 * Non-option argument specifies database name as long as it wasn't
@@ -179,6 +236,13 @@ main(int argc, char *argv[])
 
 	setup_cancel_handler();
 
+	/*
+	 * When user is giving the table list, and list is smaller then
+	 * number of tables
+	 */
+	if (tbl_count && (concurrentCons > tbl_count))
+		concurrentCons = tbl_count;
+
 	if (alldb)
 	{
 		if (dbname)
@@ -196,7 +260,7 @@ main(int argc, char *argv[])
 
 		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
 							 maintenance_db, host, port, username,
-							 prompt_password, progname, echo, quiet);
+							 prompt_password, progname, echo, quiet, concurrentCons);
 	}
 	else
 	{
@@ -210,25 +274,36 @@ main(int argc, char *argv[])
 				dbname = get_user_name_or_exit(progname);
 		}
 
-		if (tables.head != NULL)
+		if (concurrentCons > 1)
 		{
-			SimpleStringListCell *cell;
+			vacuum_parallel(dbname, full, verbose, and_analyze,
+								analyze_only, analyze_in_stages, -1,
+								freeze, host, port, username, prompt_password,
+								progname, echo, concurrentCons, &tables, quiet);
 
-			for (cell = tables.head; cell; cell = cell->next)
-			{
-				vacuum_one_database(dbname, full, verbose, and_analyze,
-									analyze_only, analyze_in_stages, -1,
-									freeze, cell->val,
-									host, port, username, prompt_password,
-									progname, echo, quiet);
-			}
 		}
 		else
-			vacuum_one_database(dbname, full, verbose, and_analyze,
+		{
+			if (tables.head != NULL)
+			{
+				SimpleStringListCell *cell;
+
+				for (cell = tables.head; cell; cell = cell->next)
+				{
+					vacuum_one_database(dbname, full, verbose, and_analyze,
+										analyze_only, analyze_in_stages, -1,
+										freeze, cell->val,
+										host, port, username, prompt_password,
+										progname, echo, quiet);
+				}
+			}
+			else
+				vacuum_one_database(dbname, full, verbose, and_analyze,
 								analyze_only, analyze_in_stages, -1,
 								freeze, NULL,
 								host, port, username, prompt_password,
 								progname, echo, quiet);
+		}
 	}
 
 	exit(0);
@@ -268,56 +343,9 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 	conn = connectDatabase(dbname, host, port, username, prompt_password,
 						   progname, false);
 
-	if (analyze_only)
-	{
-		appendPQExpBufferStr(&sql, "ANALYZE");
-		if (verbose)
-			appendPQExpBufferStr(&sql, " VERBOSE");
-	}
-	else
-	{
-		appendPQExpBufferStr(&sql, "VACUUM");
-		if (PQserverVersion(conn) >= 90000)
-		{
-			const char *paren = " (";
-			const char *comma = ", ";
-			const char *sep = paren;
+	prepare_command(conn, full, verbose,
+					and_analyze, analyze_only, freeze, &sql);
 
-			if (full)
-			{
-				appendPQExpBuffer(&sql, "%sFULL", sep);
-				sep = comma;
-			}
-			if (freeze)
-			{
-				appendPQExpBuffer(&sql, "%sFREEZE", sep);
-				sep = comma;
-			}
-			if (verbose)
-			{
-				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
-				sep = comma;
-			}
-			if (and_analyze)
-			{
-				appendPQExpBuffer(&sql, "%sANALYZE", sep);
-				sep = comma;
-			}
-			if (sep != paren)
-				appendPQExpBufferStr(&sql, ")");
-		}
-		else
-		{
-			if (full)
-				appendPQExpBufferStr(&sql, " FULL");
-			if (freeze)
-				appendPQExpBufferStr(&sql, " FREEZE");
-			if (verbose)
-				appendPQExpBufferStr(&sql, " VERBOSE");
-			if (and_analyze)
-				appendPQExpBufferStr(&sql, " ANALYZE");
-		}
-	}
 	if (table)
 		appendPQExpBuffer(&sql, " %s", table);
 	appendPQExpBufferStr(&sql, ";");
@@ -353,8 +381,10 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 		}
 		else
 		{
-			/* Otherwise, we got a stage from vacuum_all_databases(), so run
-			 * only that one. */
+			/*
+			 * Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one.
+			 */
 			if (!quiet)
 			{
 				puts(gettext(stage_messages[stage]));
@@ -374,11 +404,12 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 
 
 static void
-vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
-			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
-					 const char *host, const char *port,
-					 const char *username, enum trivalue prompt_password,
-					 const char *progname, bool echo, bool quiet)
+vacuum_all_databases(bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool analyze_in_stages, bool freeze,
+					const char *maintenance_db, const char *host,
+					const char *port, const char *username,
+					enum trivalue prompt_password, const char *progname,
+					bool echo, bool quiet, int concurrentCons)
 {
 	PGconn	   *conn;
 	PGresult   *result;
@@ -407,6 +438,15 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 				fflush(stdout);
 			}
 
+		if (concurrentCons > 1)
+		{
+			vacuum_parallel(dbname, full, verbose, and_analyze,
+								analyze_only, analyze_in_stages, stage,
+								freeze, host, port, username, prompt_password,
+								progname, echo, concurrentCons, NULL, quiet);
+
+		}
+		else
 			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
 								analyze_in_stages, stage,
 							freeze, NULL, host, port, username, prompt_password,
@@ -417,6 +457,503 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 	PQclear(result);
 }
 
+/*
+ * run_parallel_vacuum
+ * This function process the table list,
+ * pick the object on by one and get the Free connections slot, once it
+ * get the free slot send the job on the free connection.
+ */
+
+static void
+run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+					bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, int concurrentCons,
+					const char *progname, int analyze_stage,
+					ParallelSlot *connSlot, bool completedb)
+{
+	PQExpBufferData sql;
+	SimpleStringListCell *cell;
+	int max_slot = concurrentCons;
+	int i;
+	int free_slot;
+	PGconn *slotconn;
+	bool  error = false;
+	const char *stage_commands[] = {
+			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+			"RESET default_statistics_target;"};
+
+	initPQExpBuffer(&sql);
+
+	if (analyze_stage >= 0)
+	{
+		for (i = 0; i < max_slot; i++)
+		{
+			executeCommand(connSlot[i].connection,
+					stage_commands[analyze_stage], progname, echo);
+		}
+	}
+
+	for (cell = tables->head; cell; cell = cell->next)
+	{
+		/*
+		 * This will give the free connection slot, if no slot is free it will
+		 * wait for atleast one slot to get free.
+		 */
+		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+								completedb);
+		if (free_slot == NO_SLOT)
+		{
+			error = true;
+			goto fail;
+		}
+
+		prepare_command(connSlot[free_slot].connection, full, verbose,
+					and_analyze, analyze_only, freeze, &sql);
+
+		appendPQExpBuffer(&sql, " %s", cell->val);
+
+		connSlot[free_slot].isFree = false;
+
+		slotconn = connSlot[free_slot].connection;
+		PQsendQuery(slotconn, sql.data);
+
+		resetPQExpBuffer(&sql);
+	}
+
+	for (i = 0; i < max_slot; i++)
+	{
+		/* wait for all connection to return the results*/
+		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+							completedb))
+		{
+			error = true;
+			goto fail;
+		}
+
+		connSlot[i].isFree = true;
+	}
+
+fail:
+
+	termPQExpBuffer(&sql);
+
+	if (error)
+	{
+		for (i = 0; i < max_slot; i++)
+		{
+			DisconnectDatabase(&connSlot[i]);
+		}
+
+		pfree(connSlot);
+
+		exit(1);
+	}
+}
+
+/*
+ * GetIdleSlot
+ * Process the slot list, if any free slot available return the slotid
+ * If no slot is free, Then perform select on all the socket and wait until
+ * atleast one slot is free.
+ */
+static int
+GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+			const char *progname, bool completedb)
+{
+	int		i;
+	fd_set	slotset;
+	int 	firstFree = -1;
+	pgsocket maxFd;
+
+	for (i = 0; i < max_slot; i++)
+		if (pSlot[i].isFree)
+			return i;
+
+	FD_ZERO(&slotset);
+
+	maxFd = pSlot[0].sock;
+
+	for (i = 0; i < max_slot; i++)
+	{
+		FD_SET(pSlot[i].sock, &slotset);
+		if (pSlot[i].sock > maxFd)
+			maxFd = pSlot[i].sock;
+	}
+
+	/*
+	 * Some of the slot are free, Process the results for slots whichever
+	 * are free
+	 */
+
+	do
+	{
+		SetCancelConn(pSlot[0].connection);
+
+		i = select_loop(maxFd, &slotset);
+
+		ResetCancelConn();
+
+		if (i < 0)
+		{
+			/*
+			 * This can only happen if user has sent the cancel request using
+			 * Ctrl+C, Cancel is handled by 0th slot, so fetch the error result.
+			 */
+
+			GetQueryResult(pSlot[0].connection, dbname, progname,
+						   completedb);
+			return NO_SLOT;
+		}
+
+		Assert(i != 0);
+
+		for (i = 0; i < max_slot; i++)
+		{
+			if (!FD_ISSET(pSlot[i].sock, &slotset))
+				continue;
+
+			PQconsumeInput(pSlot[i].connection);
+			if (PQisBusy(pSlot[i].connection))
+				continue;
+
+			pSlot[i].isFree = true;
+
+			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+								completedb))
+				return NO_SLOT;
+
+			if (firstFree < 0)
+				firstFree = i;
+		}
+	}while(firstFree < 0);
+
+	return firstFree;
+}
+
+/*
+ * GetQueryResult
+ * Process the query result.
+ */
+
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+						const char *progname, bool completedb)
+{
+	PGresult    *result = NULL;
+	PGresult    *lastResult = NULL;
+	bool r;
+
+
+	SetCancelConn(conn);
+	while((result = PQgetResult(conn)) != NULL)
+	{
+		PQclear(lastResult);
+		lastResult = result;
+	}
+
+	ResetCancelConn();
+
+	if (!lastResult)
+		return true;
+
+	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+
+	/*
+	 * If user has given the vacuum of complete db, then if
+	 * any of the object's vacuum failed it can be ignored and vacuuming
+	 * of other objects can be continued, this is the same behavior as
+	 * vacuuming of complete db is handled without --jobs option
+	 */
+	if (!r)
+	{
+		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+
+		if (!completedb ||
+		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+		{
+
+			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+					progname, dbname, PQerrorMessage(conn));
+
+			PQclear(lastResult);
+			return false;
+		}
+	}
+
+	PQclear(lastResult);
+	return true;
+}
+
+/*
+ * vacuum_parallel
+ * This function will open the multiple concurrent connections as
+ * suggested by user, it will derive the table list using server call
+ * if table list is not given by user and perform the vacuum call
+ */
+
+void
+vacuum_parallel(const char *dbname, bool full, bool verbose,
+			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+			int stage, bool freeze, const char *host, const char *port,
+			const char *username, enum trivalue prompt_password,
+			const char *progname, bool echo, int concurrentCons,
+			SimpleStringList *tables, bool quiet)
+{
+
+	PGconn	   *conn;
+	int i;
+	ParallelSlot *connSlot;
+	bool	completeDb = false;
+
+	conn = connectDatabase(dbname, host, port, username,
+					  prompt_password, progname, false);
+
+	/*
+	 * if table list is not provided then we need to do vaccum for whole DB
+	 * get the list of all tables and prepare the list
+	 */
+	if (!tables || !tables->head)
+	{
+		SimpleStringList dbtables = {NULL, NULL};
+		PGresult *res;
+		int ntuple;
+		int i;
+		PQExpBufferData sql;
+
+		initPQExpBuffer(&sql);
+
+		res = executeQuery(conn,
+				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+				" WHERE (relkind = \'r\' or relkind = \'m\')"
+				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+				progname, echo);
+
+		ntuple = PQntuples(res);
+		for (i = 0; i < ntuple; i++)
+		{
+			appendPQExpBuffer(&sql, "%s",
+							fmtQualifiedId(PQserverVersion(conn),
+							PQgetvalue(res, i, 1),
+							PQgetvalue(res, i, 0)));
+
+			simple_string_list_append(&dbtables, sql.data);
+			resetPQExpBuffer(&sql);
+		}
+
+		termPQExpBuffer(&sql);
+		tables = &dbtables;
+
+		/* Vaccuming full database*/
+		completeDb = true;
+
+		if (concurrentCons > ntuple)
+			concurrentCons = ntuple;
+	}
+
+	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+	connSlot[0].connection = conn;
+	connSlot[0].sock = PQsocket(conn);
+
+	PQsetnonblocking(connSlot[0].connection, 1);
+
+	for (i = 1; i < concurrentCons; i++)
+	{
+		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+								  prompt_password, progname, false);
+
+		PQsetnonblocking(connSlot[i].connection, 1);
+		connSlot[i].isFree = true;
+		connSlot[i].sock = PQsocket(connSlot[i].connection);
+	}
+
+	if (analyze_in_stages)
+	{
+		const char *stage_messages[] = {
+			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+			gettext_noop("Generating default (full) optimizer statistics")
+			};
+
+		if (stage == -1)
+		{
+			int			i;
+			for (i = 0; i < 3; i++)
+			{
+				if (!quiet)
+				{
+					puts(gettext(stage_messages[i]));
+					fflush(stdout);
+				}
+
+				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+						and_analyze, analyze_only, freeze, concurrentCons,
+						progname, i, connSlot, completeDb);
+			}
+		}
+		else
+		{
+			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one. */
+			if (!quiet)
+			{
+				puts(gettext(stage_messages[stage]));
+				fflush(stdout);
+			}
+
+			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+					and_analyze, analyze_only, freeze, concurrentCons,
+					progname, stage, connSlot, completeDb);
+		}
+	}
+	else
+	{
+		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+					and_analyze, analyze_only, freeze,
+					concurrentCons, progname, -1, connSlot, completeDb);
+	}
+
+	for (i = 0; i < concurrentCons; i++)
+	{
+		PQfinish(connSlot[i].connection);
+	}
+
+	pfree(connSlot);
+}
+
+/*
+ * A select loop that repeats calling select until a descriptor in the read
+ * set becomes readable. On Windows we have to check for the termination event
+ * from time to time, on Unix we can just block forever.
+ */
+static int
+select_loop(int maxFd, fd_set *workerset)
+{
+	int			i;
+	fd_set		saveSet = *workerset;
+
+#ifdef WIN32
+	/* should always be the master */
+	for (;;)
+	{
+		/*
+		 * sleep a quarter of a second before checking if we should terminate.
+		 */
+		struct timeval tv = {0, 250000};
+
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+
+		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+			continue;
+		if (i)
+			break;
+	}
+#else							/* UNIX */
+
+	for (;;)
+	{
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+
+		if (in_abort())
+		{
+			return -1;
+		}
+
+		if (i < 0 && errno == EINTR)
+			continue;
+		break;
+	}
+#endif
+
+	return i;
+}
+
+/*
+ * DisconnectDatabase
+ * disconnect all the connections.
+ */
+void
+DisconnectDatabase(ParallelSlot *slot)
+{
+	PGcancel   *cancel;
+	char		errbuf[1];
+
+	if (!slot->connection)
+		return;
+
+	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+	{
+		if ((cancel = PQgetCancel(slot->connection)))
+		{
+			PQcancel(cancel, errbuf, sizeof(errbuf));
+			PQfreeCancel(cancel);
+		}
+	}
+
+	PQfinish(slot->connection);
+	slot->connection= NULL;
+}
+
+
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, PQExpBuffer sql)
+{
+	initPQExpBuffer(sql);
+
+	if (analyze_only)
+	{
+		appendPQExpBuffer(sql, "ANALYZE");
+		if (verbose)
+			appendPQExpBuffer(sql, " VERBOSE");
+	}
+	else
+	{
+		appendPQExpBuffer(sql, "VACUUM");
+		if (PQserverVersion(conn) >= 90000)
+		{
+			const char *paren = " (";
+			const char *comma = ", ";
+			const char *sep = paren;
+
+			if (full)
+			{
+				appendPQExpBuffer(sql, "%sFULL", sep);
+				sep = comma;
+			}
+			if (freeze)
+			{
+				appendPQExpBuffer(sql, "%sFREEZE", sep);
+				sep = comma;
+			}
+			if (verbose)
+			{
+				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+				sep = comma;
+			}
+			if (and_analyze)
+			{
+				appendPQExpBuffer(sql, "%sANALYZE", sep);
+				sep = comma;
+			}
+			if (sep != paren)
+				appendPQExpBuffer(sql, ")");
+		}
+		else
+		{
+			if (full)
+				appendPQExpBuffer(sql, " FULL");
+			if (freeze)
+				appendPQExpBuffer(sql, " FREEZE");
+			if (verbose)
+				appendPQExpBuffer(sql, " VERBOSE");
+			if (and_analyze)
+				appendPQExpBuffer(sql, " ANALYZE");
+		}
+	}
+}
+
 
 static void
 help(const char *progname)
@@ -436,6 +973,7 @@ help(const char *progname)
 	printf(_("  -V, --version                   output version information, then exit\n"));
 	printf(_("  -z, --analyze                   update optimizer statistics\n"));
 	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
 	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
 		   "                                  stages for faster results\n"));
 	printf(_("  -?, --help                      show this help, then exit\n"));

diff --git a/doc/src/sgml/ref/vacuumdb.sgml b/doc/src/sgml/ref/vacuumdb.sgml
index 3ecd999..e4a971f 100644
--- a/doc/src/sgml/ref/vacuumdb.sgml
+++ b/doc/src/sgml/ref/vacuumdb.sgml
@@ -204,6 +204,27 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+      <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+      <listitem>
+       <para>
+        Number of concurrent connections to perform the operation.
+        This option will enable the vacuum operation to run on asynchronous
+        connections, at a time one table will be operated on one connection.
+        So at one time as many tables will be vacuumed parallely as number of
+        jobs.  If number of jobs given are more than number of tables then
+        number of jobs will be set to number of tables.
+       </para>
+       <para>
+        <application>vacuumdb</application> will open
+        <replaceable class="parameter"> njobs</replaceable> connections to the
+        database, so make sure your <xref linkend="guc-max-connections">
+        setting is high enough to accommodate all connections.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>--analyze-in-stages</option></term>
       <listitem>
        <para>
diff --git a/src/bin/scripts/common.c b/src/bin/scripts/common.c
index 311fed5..bc5336a 100644
--- a/src/bin/scripts/common.c
+++ b/src/bin/scripts/common.c
@@ -19,10 +19,10 @@
 
 #include "common.h"
 
-static void SetCancelConn(PGconn *conn);
-static void ResetCancelConn(void);
+
 
 static PGcancel *volatile cancelConn = NULL;
+static bool inAbort = false;
 
 #ifdef WIN32
 static CRITICAL_SECTION cancelConnLock;
@@ -291,7 +291,7 @@ yesno_prompt(const char *question)
  *
  * Set cancelConn to point to the current database connection.
  */
-static void
+void
 SetCancelConn(PGconn *conn)
 {
 	PGcancel   *oldCancelConn;
@@ -321,7 +321,7 @@ SetCancelConn(PGconn *conn)
  *
  * Free the current cancel connection, if any, and set to NULL.
  */
-static void
+void
 ResetCancelConn(void)
 {
 	PGcancel   *oldCancelConn;
@@ -358,6 +358,7 @@ handle_sigint(SIGNAL_ARGS)
 	/* Send QueryCancel if we are processing a database query */
 	if (cancelConn != NULL)
 	{
+		inAbort = true;
 		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
 			fprintf(stderr, _("Cancel request sent\n"));
 		else
@@ -391,6 +392,8 @@ consoleHandler(DWORD dwCtrlType)
 		EnterCriticalSection(&cancelConnLock);
 		if (cancelConn != NULL)
 		{
+			inAbort = true;
+
 			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
 				fprintf(stderr, _("Cancel request sent\n"));
 			else
@@ -414,3 +417,8 @@ setup_cancel_handler(void)
 }
 
 #endif   /* WIN32 */
+
+bool in_abort()
+{
+	return inAbort;
+}
diff --git a/src/bin/scripts/common.h b/src/bin/scripts/common.h
index 691f6c6..3bafde3 100644
--- a/src/bin/scripts/common.h
+++ b/src/bin/scripts/common.h
@@ -49,4 +49,9 @@ extern bool yesno_prompt(const char *question);
 
 extern void setup_cancel_handler(void);
 
+extern void SetCancelConn(PGconn *conn);
+extern void ResetCancelConn(void);
+extern bool in_abort(void);
+
+
 #endif   /* COMMON_H */
diff --git a/src/bin/scripts/vacuumdb.c b/src/bin/scripts/vacuumdb.c
index 86e6ab3..f45b2f0 100644
--- a/src/bin/scripts/vacuumdb.c
+++ b/src/bin/scripts/vacuumdb.c
@@ -14,6 +14,17 @@
 #include "common.h"
 #include "dumputils.h"
 
+#define NO_SLOT (-1)
+
+/* Arguments needed for a worker process */
+typedef struct ParallelSlot
+{
+	PGconn *connection;
+	bool isFree;
+	pgsocket sock;
+} ParallelSlot;
+
+#define ERRCODE_UNDEFINED_TABLE  "42P01"
 
 static void vacuum_one_database(const char *dbname, bool full, bool verbose,
 	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
@@ -25,10 +36,39 @@ static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
 					 const char *maintenance_db,
 					 const char *host, const char *port,
 					 const char *username, enum trivalue prompt_password,
-					 const char *progname, bool echo, bool quiet);
+					 const char *progname, bool echo, bool quiet,
+					 int concurrentCons);
 
 static void help(const char *progname);
 
+void vacuum_parallel(const char *dbname, bool full, bool verbose,
+					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+					int stage, bool freeze, const char *host, const char *port,
+					const char *username, enum trivalue prompt_password,
+					const char *progname, bool echo, int concurrentCons,
+					SimpleStringList *tables, bool quiet);
+
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, PQExpBuffer sql);
+static void
+run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+					bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, int concurrentCons,
+					const char *progname, int analyze_stage,
+					ParallelSlot *connSlot, bool completedb);
+static int
+GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+			const char *progname, bool completedb);
+
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+						const char *progname, bool completedb);
+
+static int
+select_loop(int maxFd, fd_set *workerset);
+
+static void DisconnectDatabase(ParallelSlot *slot);
+
 
 int
 main(int argc, char *argv[])
@@ -49,6 +89,7 @@ main(int argc, char *argv[])
 		{"table", required_argument, NULL, 't'},
 		{"full", no_argument, NULL, 'f'},
 		{"verbose", no_argument, NULL, 'v'},
+		{"jobs", required_argument, NULL, 'j'},
 		{"maintenance-db", required_argument, NULL, 2},
 		{"analyze-in-stages", no_argument, NULL, 3},
 		{NULL, 0, NULL, 0}
@@ -74,13 +115,15 @@ main(int argc, char *argv[])
 	bool		full = false;
 	bool		verbose = false;
 	SimpleStringList tables = {NULL, NULL};
+	int concurrentCons = 0;
+	int tbl_count = 0;
 
 	progname = get_progname(argv[0]);
 	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
 
 	handle_help_version_opts(argc, argv, "vacuumdb", help);
 
-	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
+	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
 	{
 		switch (c)
 		{
@@ -121,14 +164,27 @@ main(int argc, char *argv[])
 				alldb = true;
 				break;
 			case 't':
+			{
 				simple_string_list_append(&tables, optarg);
+				tbl_count++;
 				break;
+			}
 			case 'f':
 				full = true;
 				break;
 			case 'v':
 				verbose = true;
 				break;
+			case 'j':
+				concurrentCons = atoi(optarg);
+				if (concurrentCons <= 0)
+				{
+					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+							progname);
+					exit(1);
+				}
+
+				break;
 			case 2:
 				maintenance_db = pg_strdup(optarg);
 				break;
@@ -141,6 +197,7 @@ main(int argc, char *argv[])
 		}
 	}
 
+	optind++;
 
 	/*
 	 * Non-option argument specifies database name as long as it wasn't
@@ -179,6 +236,13 @@ main(int argc, char *argv[])
 
 	setup_cancel_handler();
 
+	/*
+	 * When user is giving the table list, and list is smaller then
+	 * number of tables
+	 */
+	if (tbl_count && (concurrentCons > tbl_count))
+		concurrentCons = tbl_count;
+
 	if (alldb)
 	{
 		if (dbname)
@@ -196,7 +260,7 @@ main(int argc, char *argv[])
 
 		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
 							 maintenance_db, host, port, username,
-							 prompt_password, progname, echo, quiet);
+							 prompt_password, progname, echo, quiet, concurrentCons);
 	}
 	else
 	{
@@ -210,25 +274,36 @@ main(int argc, char *argv[])
 				dbname = get_user_name_or_exit(progname);
 		}
 
-		if (tables.head != NULL)
+		if (concurrentCons > 1)
 		{
-			SimpleStringListCell *cell;
+			vacuum_parallel(dbname, full, verbose, and_analyze,
+								analyze_only, analyze_in_stages, -1,
+								freeze, host, port, username, prompt_password,
+								progname, echo, concurrentCons, &tables, quiet);
 
-			for (cell = tables.head; cell; cell = cell->next)
-			{
-				vacuum_one_database(dbname, full, verbose, and_analyze,
-									analyze_only, analyze_in_stages, -1,
-									freeze, cell->val,
-									host, port, username, prompt_password,
-									progname, echo, quiet);
-			}
 		}
 		else
-			vacuum_one_database(dbname, full, verbose, and_analyze,
+		{
+			if (tables.head != NULL)
+			{
+				SimpleStringListCell *cell;
+
+				for (cell = tables.head; cell; cell = cell->next)
+				{
+					vacuum_one_database(dbname, full, verbose, and_analyze,
+										analyze_only, analyze_in_stages, -1,
+										freeze, cell->val,
+										host, port, username, prompt_password,
+										progname, echo, quiet);
+				}
+			}
+			else
+				vacuum_one_database(dbname, full, verbose, and_analyze,
 								analyze_only, analyze_in_stages, -1,
 								freeze, NULL,
 								host, port, username, prompt_password,
 								progname, echo, quiet);
+		}
 	}
 
 	exit(0);
@@ -268,56 +343,9 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 	conn = connectDatabase(dbname, host, port, username, prompt_password,
 						   progname, false);
 
-	if (analyze_only)
-	{
-		appendPQExpBufferStr(&sql, "ANALYZE");
-		if (verbose)
-			appendPQExpBufferStr(&sql, " VERBOSE");
-	}
-	else
-	{
-		appendPQExpBufferStr(&sql, "VACUUM");
-		if (PQserverVersion(conn) >= 90000)
-		{
-			const char *paren = " (";
-			const char *comma = ", ";
-			const char *sep = paren;
+	prepare_command(conn, full, verbose,
+					and_analyze, analyze_only, freeze, &sql);
 
-			if (full)
-			{
-				appendPQExpBuffer(&sql, "%sFULL", sep);
-				sep = comma;
-			}
-			if (freeze)
-			{
-				appendPQExpBuffer(&sql, "%sFREEZE", sep);
-				sep = comma;
-			}
-			if (verbose)
-			{
-				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
-				sep = comma;
-			}
-			if (and_analyze)
-			{
-				appendPQExpBuffer(&sql, "%sANALYZE", sep);
-				sep = comma;
-			}
-			if (sep != paren)
-				appendPQExpBufferStr(&sql, ")");
-		}
-		else
-		{
-			if (full)
-				appendPQExpBufferStr(&sql, " FULL");
-			if (freeze)
-				appendPQExpBufferStr(&sql, " FREEZE");
-			if (verbose)
-				appendPQExpBufferStr(&sql, " VERBOSE");
-			if (and_analyze)
-				appendPQExpBufferStr(&sql, " ANALYZE");
-		}
-	}
 	if (table)
 		appendPQExpBuffer(&sql, " %s", table);
 	appendPQExpBufferStr(&sql, ";");
@@ -353,8 +381,10 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 		}
 		else
 		{
-			/* Otherwise, we got a stage from vacuum_all_databases(), so run
-			 * only that one. */
+			/*
+			 * Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one.
+			 */
 			if (!quiet)
 			{
 				puts(gettext(stage_messages[stage]));
@@ -374,11 +404,12 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 
 
 static void
-vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
-			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
-					 const char *host, const char *port,
-					 const char *username, enum trivalue prompt_password,
-					 const char *progname, bool echo, bool quiet)
+vacuum_all_databases(bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool analyze_in_stages, bool freeze,
+					const char *maintenance_db, const char *host,
+					const char *port, const char *username,
+					enum trivalue prompt_password, const char *progname,
+					bool echo, bool quiet, int concurrentCons)
 {
 	PGconn	   *conn;
 	PGresult   *result;
@@ -407,6 +438,15 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 				fflush(stdout);
 			}
 
+		if (concurrentCons > 1)
+		{
+			vacuum_parallel(dbname, full, verbose, and_analyze,
+								analyze_only, analyze_in_stages, stage,
+								freeze, host, port, username, prompt_password,
+								progname, echo, concurrentCons, NULL, quiet);
+
+		}
+		else
 			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
 								analyze_in_stages, stage,
 							freeze, NULL, host, port, username, prompt_password,
@@ -417,6 +457,503 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 	PQclear(result);
 }
 
+/*
+ * run_parallel_vacuum
+ * This function process the table list,
+ * pick the object on by one and get the Free connections slot, once it
+ * get the free slot send the job on the free connection.
+ */
+
+static void
+run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+					bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, int concurrentCons,
+					const char *progname, int analyze_stage,
+					ParallelSlot *connSlot, bool completedb)
+{
+	PQExpBufferData sql;
+	SimpleStringListCell *cell;
+	int max_slot = concurrentCons;
+	int i;
+	int free_slot;
+	PGconn *slotconn;
+	bool  error = false;
+	const char *stage_commands[] = {
+			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+			"RESET default_statistics_target;"};
+
+	initPQExpBuffer(&sql);
+
+	if (analyze_stage >= 0)
+	{
+		for (i = 0; i < max_slot; i++)
+		{
+			executeCommand(connSlot[i].connection,
+					stage_commands[analyze_stage], progname, echo);
+		}
+	}
+
+	for (cell = tables->head; cell; cell = cell->next)
+	{
+		/*
+		 * This will give the free connection slot, if no slot is free it will
+		 * wait for atleast one slot to get free.
+		 */
+		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+								completedb);
+		if (free_slot == NO_SLOT)
+		{
+			error = true;
+			goto fail;
+		}
+
+		prepare_command(connSlot[free_slot].connection, full, verbose,
+					and_analyze, analyze_only, freeze, &sql);
+
+		appendPQExpBuffer(&sql, " %s", cell->val);
+
+		connSlot[free_slot].isFree = false;
+
+		slotconn = connSlot[free_slot].connection;
+		PQsendQuery(slotconn, sql.data);
+
+		resetPQExpBuffer(&sql);
+	}
+
+	for (i = 0; i < max_slot; i++)
+	{
+		/* wait for all connection to return the results*/
+		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+							completedb))
+		{
+			error = true;
+			goto fail;
+		}
+
+		connSlot[i].isFree = true;
+	}
+
+fail:
+
+	termPQExpBuffer(&sql);
+
+	if (error)
+	{
+		for (i = 0; i < max_slot; i++)
+		{
+			DisconnectDatabase(&connSlot[i]);
+		}
+
+		pfree(connSlot);
+
+		exit(1);
+	}
+}
+
+/*
+ * GetIdleSlot
+ * Process the slot list, if any free slot available return the slotid
+ * If no slot is free, Then perform select on all the socket and wait until
+ * atleast one slot is free.
+ */
+static int
+GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+			const char *progname, bool completedb)
+{
+	int		i;
+	fd_set	slotset;
+	int 	firstFree = -1;
+	pgsocket maxFd;
+
+	for (i = 0; i < max_slot; i++)
+		if (pSlot[i].isFree)
+			return i;
+
+	FD_ZERO(&slotset);
+
+	maxFd = pSlot[0].sock;
+
+	for (i = 0; i < max_slot; i++)
+	{
+		FD_SET(pSlot[i].sock, &slotset);
+		if (pSlot[i].sock > maxFd)
+			maxFd = pSlot[i].sock;
+	}
+
+	/*
+	 * Some of the slot are free, Process the results for slots whichever
+	 * are free
+	 */
+
+	do
+	{
+		SetCancelConn(pSlot[0].connection);
+
+		i = select_loop(maxFd, &slotset);
+
+		ResetCancelConn();
+
+		if (i < 0)
+		{
+			/*
+			 * This can only happen if user has sent the cancel request using
+			 * Ctrl+C, Cancel is handled by 0th slot, so fetch the error result.
+			 */
+
+			GetQueryResult(pSlot[0].connection, dbname, progname,
+						   completedb);
+			return NO_SLOT;
+		}
+
+		Assert(i != 0);
+
+		for (i = 0; i < max_slot; i++)
+		{
+			if (!FD_ISSET(pSlot[i].sock, &slotset))
+				continue;
+
+			PQconsumeInput(pSlot[i].connection);
+			if (PQisBusy(pSlot[i].connection))
+				continue;
+
+			pSlot[i].isFree = true;
+
+			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+								completedb))
+				return NO_SLOT;
+
+			if (firstFree < 0)
+				firstFree = i;
+		}
+	}while(firstFree < 0);
+
+	return firstFree;
+}
+
+/*
+ * GetQueryResult
+ * Process the query result.
+ */
+
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+						const char *progname, bool completedb)
+{
+	PGresult    *result = NULL;
+	PGresult    *lastResult = NULL;
+	bool r;
+
+
+	SetCancelConn(conn);
+	while((result = PQgetResult(conn)) != NULL)
+	{
+		PQclear(lastResult);
+		lastResult = result;
+	}
+
+	ResetCancelConn();
+
+	if (!lastResult)
+		return true;
+
+	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+
+	/*
+	 * If user has given the vacuum of complete db, then if
+	 * any of the object's vacuum failed it can be ignored and vacuuming
+	 * of other objects can be continued, this is the same behavior as
+	 * vacuuming of complete db is handled without --jobs option
+	 */
+	if (!r)
+	{
+		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+
+		if (!completedb ||
+		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+		{
+
+			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+					progname, dbname, PQerrorMessage(conn));
+
+			PQclear(lastResult);
+			return false;
+		}
+	}
+
+	PQclear(lastResult);
+	return true;
+}
+
+/*
+ * vacuum_parallel
+ * This function will open the multiple concurrent connections as
+ * suggested by user, it will derive the table list using server call
+ * if table list is not given by user and perform the vacuum call
+ */
+
+void
+vacuum_parallel(const char *dbname, bool full, bool verbose,
+			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+			int stage, bool freeze, const char *host, const char *port,
+			const char *username, enum trivalue prompt_password,
+			const char *progname, bool echo, int concurrentCons,
+			SimpleStringList *tables, bool quiet)
+{
+
+	PGconn	   *conn;
+	int i;
+	ParallelSlot *connSlot;
+	SimpleStringList dbtables = {NULL, NULL};
+	bool	completeDb = false;
+
+	conn = connectDatabase(dbname, host, port, username,
+					  prompt_password, progname, false);
+
+	/*
+	 * if table list is not provided then we need to do vaccum for whole DB
+	 * get the list of all tables and prepare the list
+	 */
+	if (!tables || !tables->head)
+	{
+		PGresult *res;
+		int ntuple;
+		int i;
+		PQExpBufferData sql;
+
+		initPQExpBuffer(&sql);
+
+		res = executeQuery(conn,
+				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+				" WHERE (relkind = \'r\' or relkind = \'m\')"
+				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+				progname, echo);
+
+		ntuple = PQntuples(res);
+		for (i = 0; i < ntuple; i++)
+		{
+			appendPQExpBuffer(&sql, "%s",
+							fmtQualifiedId(PQserverVersion(conn),
+							PQgetvalue(res, i, 1),
+							PQgetvalue(res, i, 0)));
+
+			simple_string_list_append(&dbtables, sql.data);
+			resetPQExpBuffer(&sql);
+		}
+
+		termPQExpBuffer(&sql);
+		tables = &dbtables;
+
+		/* Vaccuming full database*/
+		completeDb = true;
+
+		if (concurrentCons > ntuple)
+			concurrentCons = ntuple;
+	}
+
+	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+	connSlot[0].connection = conn;
+	connSlot[0].sock = PQsocket(conn);
+
+	PQsetnonblocking(connSlot[0].connection, 1);
+
+	for (i = 1; i < concurrentCons; i++)
+	{
+		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+								  prompt_password, progname, false);
+
+		PQsetnonblocking(connSlot[i].connection, 1);
+		connSlot[i].isFree = true;
+		connSlot[i].sock = PQsocket(connSlot[i].connection);
+	}
+
+	if (analyze_in_stages)
+	{
+		const char *stage_messages[] = {
+			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+			gettext_noop("Generating default (full) optimizer statistics")
+			};
+
+		if (stage == -1)
+		{
+			int			i;
+			for (i = 0; i < 3; i++)
+			{
+				if (!quiet)
+				{
+					puts(gettext(stage_messages[i]));
+					fflush(stdout);
+				}
+
+				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+						and_analyze, analyze_only, freeze, concurrentCons,
+						progname, i, connSlot, completeDb);
+			}
+		}
+		else
+		{
+			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one. */
+			if (!quiet)
+			{
+				puts(gettext(stage_messages[stage]));
+				fflush(stdout);
+			}
+
+			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+					and_analyze, analyze_only, freeze, concurrentCons,
+					progname, stage, connSlot, completeDb);
+		}
+	}
+	else
+	{
+		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+					and_analyze, analyze_only, freeze,
+					concurrentCons, progname, -1, connSlot, completeDb);
+	}
+
+	for (i = 0; i < concurrentCons; i++)
+	{
+		PQfinish(connSlot[i].connection);
+	}
+
+	pfree(connSlot);
+}
+
+/*
+ * A select loop that repeats calling select until a descriptor in the read
+ * set becomes readable. On Windows we have to check for the termination event
+ * from time to time, on Unix we can just block forever.
+ */
+static int
+select_loop(int maxFd, fd_set *workerset)
+{
+	int			i;
+	fd_set		saveSet = *workerset;
+
+#ifdef WIN32
+	/* should always be the master */
+	for (;;)
+	{
+		/*
+		 * sleep a quarter of a second before checking if we should terminate.
+		 */
+		struct timeval tv = {0, 250000};
+
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+
+		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+			continue;
+		if (i)
+			break;
+	}
+#else							/* UNIX */
+
+	for (;;)
+	{
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+
+		if (in_abort())
+		{
+			return -1;
+		}
+
+		if (i < 0 && errno == EINTR)
+			continue;
+		break;
+	}
+#endif
+
+	return i;
+}
+
+/*
+ * DisconnectDatabase
+ * disconnect all the connections.
+ */
+void
+DisconnectDatabase(ParallelSlot *slot)
+{
+	PGcancel   *cancel;
+	char		errbuf[1];
+
+	if (!slot->connection)
+		return;
+
+	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+	{
+		if ((cancel = PQgetCancel(slot->connection)))
+		{
+			PQcancel(cancel, errbuf, sizeof(errbuf));
+			PQfreeCancel(cancel);
+		}
+	}
+
+	PQfinish(slot->connection);
+	slot->connection= NULL;
+}
+
+
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, PQExpBuffer sql)
+{
+	initPQExpBuffer(sql);
+
+	if (analyze_only)
+	{
+		appendPQExpBuffer(sql, "ANALYZE");
+		if (verbose)
+			appendPQExpBuffer(sql, " VERBOSE");
+	}
+	else
+	{
+		appendPQExpBuffer(sql, "VACUUM");
+		if (PQserverVersion(conn) >= 90000)
+		{
+			const char *paren = " (";
+			const char *comma = ", ";
+			const char *sep = paren;
+
+			if (full)
+			{
+				appendPQExpBuffer(sql, "%sFULL", sep);
+				sep = comma;
+			}
+			if (freeze)
+			{
+				appendPQExpBuffer(sql, "%sFREEZE", sep);
+				sep = comma;
+			}
+			if (verbose)
+			{
+				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+				sep = comma;
+			}
+			if (and_analyze)
+			{
+				appendPQExpBuffer(sql, "%sANALYZE", sep);
+				sep = comma;
+			}
+			if (sep != paren)
+				appendPQExpBuffer(sql, ")");
+		}
+		else
+		{
+			if (full)
+				appendPQExpBuffer(sql, " FULL");
+			if (freeze)
+				appendPQExpBuffer(sql, " FREEZE");
+			if (verbose)
+				appendPQExpBuffer(sql, " VERBOSE");
+			if (and_analyze)
+				appendPQExpBuffer(sql, " ANALYZE");
+		}
+	}
+}
+
 
 static void
 help(const char *progname)
@@ -436,6 +973,7 @@ help(const char *progname)
 	printf(_("  -V, --version                   output version information, then exit\n"));
 	printf(_("  -z, --analyze                   update optimizer statistics\n"));
 	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
 	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
 		   "                                  stages for faster results\n"));
 	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,230 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+       <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+       <listitem>
+        <para>
+         Number of concurrent connections to perform the operation.
+         This option will enable the vacuum operation to run on asynchronous
+         connections, at a time one table will be operated on one connection.
+         So at one time as many tables will be vacuumed parallely as number of
+         jobs.  If number of jobs given are more than number of tables then
+         number of jobs will be set to number of tables.
+        </para>
+        <para>
+         <application>vacuumdb</application> will open
+         <replaceable class="parameter"> njobs</replaceable> connections to the
+         database, so make sure your <xref linkend="guc-max-connections">
+         setting is high enough to accommodate all connections.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,28 ****
  
  #include "common.h"
  
! static void SetCancelConn(PGconn *conn);
! static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
--- 19,28 ----
  
  #include "common.h"
  
! 
  
  static PGcancel *volatile cancelConn = NULL;
+ static bool inAbort = false;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 291,297 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 321,327 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
***************
*** 358,363 **** handle_sigint(SIGNAL_ARGS)
--- 358,364 ----
  	/* Send QueryCancel if we are processing a database query */
  	if (cancelConn != NULL)
  	{
+ 		inAbort = true;
  		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
  			fprintf(stderr, _("Cancel request sent\n"));
  		else
***************
*** 391,396 **** consoleHandler(DWORD dwCtrlType)
--- 392,399 ----
  		EnterCriticalSection(&cancelConnLock);
  		if (cancelConn != NULL)
  		{
+ 			inAbort = true;
+ 
  			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
  				fprintf(stderr, _("Cancel request sent\n"));
  			else
***************
*** 414,416 **** setup_cancel_handler(void)
--- 417,424 ----
  }
  
  #endif   /* WIN32 */
+ 
+ bool in_abort()
+ {
+ 	return inAbort;
+ }
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 49,57 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ extern bool in_abort(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,30 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
+ #define ERRCODE_UNDEFINED_TABLE  "42P01"
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 36,74 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int concurrentCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					int stage, bool freeze, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int concurrentCons,
+ 					SimpleStringList *tables, bool quiet);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 89,95 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 115,129 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 164,190 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				concurrentCons = atoi(optarg);
+ 				if (concurrentCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 197,203 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 236,248 ----
  
  	setup_cancel_handler();
  
+ 	/*
+ 	 * When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 260,266 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, concurrentCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
- 			for (cell = tables.head; cell; cell = cell->next)
- 			{
- 				vacuum_one_database(dbname, full, verbose, and_analyze,
- 									analyze_only, analyze_in_stages, -1,
- 									freeze, cell->val,
- 									host, port, username, prompt_password,
- 									progname, echo, quiet);
- 			}
  		}
  		else
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
  	}
  
  	exit(0);
--- 274,309 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (concurrentCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages, -1,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, concurrentCons, &tables, quiet);
  
  		}
  		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages, -1,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo, quiet);
! 				}
! 			}
! 			else
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
+ 		}
  	}
  
  	exit(0);
***************
*** 268,323 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
! 	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
! 	}
! 	else
! 	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
! 		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
- 			if (full)
- 			{
- 				appendPQExpBuffer(&sql, "%sFULL", sep);
- 				sep = comma;
- 			}
- 			if (freeze)
- 			{
- 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
- 				sep = comma;
- 			}
- 			if (verbose)
- 			{
- 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
- 				sep = comma;
- 			}
- 			if (and_analyze)
- 			{
- 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
- 				sep = comma;
- 			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
- 		}
- 	}
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
--- 343,351 ----
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	prepare_command(conn, full, verbose,
! 					and_analyze, analyze_only, freeze, &sql);
  
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
***************
*** 353,360 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  		}
  		else
  		{
! 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one. */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
--- 381,390 ----
  		}
  		else
  		{
! 			/*
! 			 * Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one.
! 			 */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
***************
*** 374,384 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 404,415 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int concurrentCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 407,412 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 438,452 ----
  				fflush(stdout);
  			}
  
+ 		if (concurrentCons > 1)
+ 		{
+ 			vacuum_parallel(dbname, full, verbose, and_analyze,
+ 								analyze_only, analyze_in_stages, stage,
+ 								freeze, host, port, username, prompt_password,
+ 								progname, echo, concurrentCons, NULL, quiet);
+ 
+ 		}
+ 		else
  			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
  								analyze_in_stages, stage,
  							freeze, NULL, host, port, username, prompt_password,
***************
*** 417,422 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 457,958 ----
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function process the table list,
+  * pick the object one by one and get the Free connections slot, once it
+  * get the free slot send the job on the free connection.
+  */
+ 
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = concurrentCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 		appendPQExpBufferStr(&sql, ";");
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 							completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		pfree(connSlot);
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot available return the slotid
+  * If no slot is free, Then perform select on all the socket and wait until
+  * atleast one slot is free.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * Some of the slot are free, Process the results for slots whichever
+ 	 * are free
+ 	 */
+ 
+ 	do
+ 	{
+ 		SetCancelConn(pSlot[0].connection);
+ 
+ 		i = select_loop(maxFd, &slotset);
+ 
+ 		ResetCancelConn();
+ 
+ 		if (i < 0)
+ 		{
+ 			/*
+ 			 * This can only happen if user has sent the cancel request using
+ 			 * Ctrl+C, Cancel is handled by 0th slot, so fetch the error result.
+ 			 */
+ 
+ 			GetQueryResult(pSlot[0].connection, dbname, progname,
+ 						   completedb);
+ 			return NO_SLOT;
+ 		}
+ 
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 								completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 
+ 	SetCancelConn(conn);
+ 	while((result = PQgetResult(conn)) != NULL)
+ 	{
+ 		PQclear(lastResult);
+ 		lastResult = result;
+ 	}
+ 
+ 	ResetCancelConn();
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	/*
+ 	 * If user has given the vacuum of complete db, then if
+ 	 * any of the object's vacuum failed it can be ignored and vacuuming
+ 	 * of other objects can be continued, this is the same behavior as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r)
+ 	{
+ 		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+ 
+ 		if (!completedb ||
+ 		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+ 		{
+ 
+ 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 
+ 			PQclear(lastResult);
+ 			return false;
+ 		}
+ 	}
+ 
+ 	PQclear(lastResult);
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open the multiple concurrent connections as
+  * suggested by user, it will derive the table list using server call
+  * if table list is not given by user and perform the vacuum call
+  */
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			int stage, bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int concurrentCons,
+ 			SimpleStringList *tables, bool quiet)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	SimpleStringList dbtables = {NULL, NULL};
+ 	bool	completeDb = false;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prepare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			appendPQExpBuffer(&sql, "%s",
+ 							fmtQualifiedId(PQserverVersion(conn),
+ 							PQgetvalue(res, i, 1),
+ 							PQgetvalue(res, i, 0)));
+ 
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		completeDb = true;
+ 
+ 		if (concurrentCons > ntuple)
+ 			concurrentCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	connSlot[0].sock = PQsocket(conn);
+ 
+ 	PQsetnonblocking(connSlot[0].connection, 1);
+ 
+ 	for (i = 1; i < concurrentCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 			};
+ 
+ 		if (stage == -1)
+ 		{
+ 			int			i;
+ 			for (i = 0; i < 3; i++)
+ 			{
+ 				if (!quiet)
+ 				{
+ 					puts(gettext(stage_messages[i]));
+ 					fflush(stdout);
+ 				}
+ 
+ 				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, concurrentCons,
+ 						progname, i, connSlot, completeDb);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+ 			 * only that one. */
+ 			if (!quiet)
+ 			{
+ 				puts(gettext(stage_messages[stage]));
+ 				fflush(stdout);
+ 			}
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, concurrentCons,
+ 					progname, stage, connSlot, completeDb);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					concurrentCons, progname, -1, connSlot, completeDb);
+ 	}
+ 
+ 	for (i = 0; i < concurrentCons; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ 
+ 	pfree(connSlot);
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 
+ 		if (in_abort())
+ 		{
+ 			return -1;
+ 		}
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBufferStr(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBufferStr(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBufferStr(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBufferStr(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBufferStr(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBufferStr(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBufferStr(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBufferStr(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 972,978 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,230 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+       <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+       <listitem>
+        <para>
+         Number of concurrent connections to perform the operation.
+         This option will enable the vacuum operation to run on asynchronous
+         connections, at a time one table will be operated on one connection.
+         So at one time as many tables will be vacuumed parallely as number of
+         jobs.  If number of jobs given are more than number of tables then
+         number of jobs will be set to number of tables.
+        </para>
+        <para>
+         <application>vacuumdb</application> will open
+         <replaceable class="parameter"> njobs</replaceable> connections to the
+         database, so make sure your <xref linkend="guc-max-connections">
+         setting is high enough to accommodate all connections.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,28 ****
  
  #include "common.h"
  
! static void SetCancelConn(PGconn *conn);
! static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
--- 19,28 ----
  
  #include "common.h"
  
! 
  
  static PGcancel *volatile cancelConn = NULL;
+ static bool inAbort = false;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 291,297 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 321,327 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
***************
*** 359,368 **** handle_sigint(SIGNAL_ARGS)
--- 359,375 ----
  	if (cancelConn != NULL)
  	{
  		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 		{
+ 			inAbort = true;
  			fprintf(stderr, _("Cancel request sent\n"));
+ 		}
  		else
  			fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  	}
+ 	else
+ 	{
+ 		inAbort = true;
+ 	}
  
  	errno = save_errno;			/* just in case the write changed it */
  }
***************
*** 392,401 **** consoleHandler(DWORD dwCtrlType)
--- 399,416 ----
  		if (cancelConn != NULL)
  		{
  			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 			{
  				fprintf(stderr, _("Cancel request sent\n"));
+ 				inAbort = true;
+ 			}
  			else
  				fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  		}
+ 		else
+ 		{
+ 			inAbort = true;
+ 		}
+ 
  		LeaveCriticalSection(&cancelConnLock);
  
  		return TRUE;
***************
*** 414,416 **** setup_cancel_handler(void)
--- 429,436 ----
  }
  
  #endif   /* WIN32 */
+ 
+ bool in_abort()
+ {
+ 	return inAbort;
+ }
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 49,57 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ extern bool in_abort(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,30 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
+ #define ERRCODE_UNDEFINED_TABLE  "42P01"
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 36,74 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int concurrentCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					int stage, bool freeze, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int concurrentCons,
+ 					SimpleStringList *tables, bool quiet);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 89,95 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 115,129 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 164,190 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				concurrentCons = atoi(optarg);
+ 				if (concurrentCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 197,203 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 236,248 ----
  
  	setup_cancel_handler();
  
+ 	/*
+ 	 * When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 260,266 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, concurrentCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
- 			for (cell = tables.head; cell; cell = cell->next)
- 			{
- 				vacuum_one_database(dbname, full, verbose, and_analyze,
- 									analyze_only, analyze_in_stages, -1,
- 									freeze, cell->val,
- 									host, port, username, prompt_password,
- 									progname, echo, quiet);
- 			}
  		}
  		else
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
  	}
  
  	exit(0);
--- 274,309 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (concurrentCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages, -1,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, concurrentCons, &tables, quiet);
  
  		}
  		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages, -1,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo, quiet);
! 				}
! 			}
! 			else
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
+ 		}
  	}
  
  	exit(0);
***************
*** 268,323 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
! 	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
! 	}
! 	else
! 	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
! 		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
- 			if (full)
- 			{
- 				appendPQExpBuffer(&sql, "%sFULL", sep);
- 				sep = comma;
- 			}
- 			if (freeze)
- 			{
- 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
- 				sep = comma;
- 			}
- 			if (verbose)
- 			{
- 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
- 				sep = comma;
- 			}
- 			if (and_analyze)
- 			{
- 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
- 				sep = comma;
- 			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
- 		}
- 	}
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
--- 343,351 ----
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	prepare_command(conn, full, verbose,
! 					and_analyze, analyze_only, freeze, &sql);
  
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
***************
*** 353,360 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  		}
  		else
  		{
! 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one. */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
--- 381,390 ----
  		}
  		else
  		{
! 			/*
! 			 * Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one.
! 			 */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
***************
*** 374,384 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 404,415 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int concurrentCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 390,396 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  	PQfinish(conn);
  
  	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage. */
  	for (stage = (analyze_in_stages ? 0 : -1);
  		 stage < (analyze_in_stages ? 3 : 0);
  		 stage++)
--- 421,428 ----
  	PQfinish(conn);
  
  	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage.
! 	 */
  	for (stage = (analyze_in_stages ? 0 : -1);
  		 stage < (analyze_in_stages ? 3 : 0);
  		 stage++)
***************
*** 407,412 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 439,453 ----
  				fflush(stdout);
  			}
  
+ 		if (concurrentCons > 1)
+ 		{
+ 			vacuum_parallel(dbname, full, verbose, and_analyze,
+ 								analyze_only, analyze_in_stages, stage,
+ 								freeze, host, port, username, prompt_password,
+ 								progname, echo, concurrentCons, NULL, quiet);
+ 
+ 		}
+ 		else
  			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
  								analyze_in_stages, stage,
  							freeze, NULL, host, port, username, prompt_password,
***************
*** 417,422 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 458,969 ----
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function process the table list,
+  * pick the object one by one and get the Free connections slot, once it
+  * get the free slot send the job on the free connection.
+  */
+ 
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = concurrentCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		if (in_abort())
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 		appendPQExpBufferStr(&sql, ";");
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 							completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		pfree(connSlot);
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot available return the slotid
+  * If no slot is free, Then perform select on all the socket and wait until
+  * atleast one slot is free.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * Some of the slot are free, Process the results for slots whichever
+ 	 * are free
+ 	 */
+ 
+ 	do
+ 	{
+ 		SetCancelConn(pSlot[0].connection);
+ 
+ 		i = select_loop(maxFd, &slotset);
+ 
+ 		ResetCancelConn();
+ 
+ 		if (i < 0)
+ 		{
+ 			/*
+ 			 * This can only happen if user has sent the cancel request using
+ 			 * Ctrl+C, Cancel is handled by 0th slot, so fetch the error result.
+ 			 */
+ 
+ 			GetQueryResult(pSlot[0].connection, dbname, progname,
+ 						   completedb);
+ 			return NO_SLOT;
+ 		}
+ 
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 								completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 
+ 	SetCancelConn(conn);
+ 	while((result = PQgetResult(conn)) != NULL)
+ 	{
+ 		PQclear(lastResult);
+ 		lastResult = result;
+ 	}
+ 
+ 	ResetCancelConn();
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	/*
+ 	 * If user has given the vacuum of complete db, then if
+ 	 * any of the object's vacuum failed it can be ignored and vacuuming
+ 	 * of other objects can be continued, this is the same behavior as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r)
+ 	{
+ 		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+ 
+ 		if (!completedb ||
+ 		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+ 		{
+ 
+ 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 
+ 			PQclear(lastResult);
+ 			return false;
+ 		}
+ 	}
+ 
+ 	PQclear(lastResult);
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open the multiple concurrent connections as
+  * suggested by user, it will derive the table list using server call
+  * if table list is not given by user and perform the vacuum call
+  */
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			int stage, bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int concurrentCons,
+ 			SimpleStringList *tables, bool quiet)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	SimpleStringList dbtables = {NULL, NULL};
+ 	bool	completeDb = false;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prepare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			appendPQExpBuffer(&sql, "%s",
+ 							fmtQualifiedId(PQserverVersion(conn),
+ 							PQgetvalue(res, i, 1),
+ 							PQgetvalue(res, i, 0)));
+ 
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		completeDb = true;
+ 
+ 		if (concurrentCons > ntuple)
+ 			concurrentCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	connSlot[0].sock = PQsocket(conn);
+ 
+ 	PQsetnonblocking(connSlot[0].connection, 1);
+ 
+ 	for (i = 1; i < concurrentCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 			};
+ 
+ 		if (stage == -1)
+ 		{
+ 			int			i;
+ 			for (i = 0; i < 3; i++)
+ 			{
+ 				if (!quiet)
+ 				{
+ 					puts(gettext(stage_messages[i]));
+ 					fflush(stdout);
+ 				}
+ 
+ 				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, concurrentCons,
+ 						progname, i, connSlot, completeDb);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+ 			 * only that one.
+ 			 */
+ 			if (!quiet)
+ 			{
+ 				puts(gettext(stage_messages[stage]));
+ 				fflush(stdout);
+ 			}
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, concurrentCons,
+ 					progname, stage, connSlot, completeDb);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					concurrentCons, progname, -1, connSlot, completeDb);
+ 	}
+ 
+ 	for (i = 0; i < concurrentCons; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ 
+ 	pfree(connSlot);
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 		if (in_abort())
+ 		{
+ 			return -1;
+ 		}
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (in_abort())
+ 		{
+ 			return -1;
+ 		}
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBufferStr(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBufferStr(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBufferStr(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBufferStr(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBufferStr(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBufferStr(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBufferStr(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBufferStr(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 983,989 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,230 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+       <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+       <listitem>
+        <para>
+         Number of concurrent connections to perform the operation.
+         This option will enable the vacuum operation to run on asynchronous
+         connections, at a time one table will be operated on one connection.
+         So at one time as many tables will be vacuumed parallely as number of
+         jobs.  If number of jobs given are more than number of tables then
+         number of jobs will be set to number of tables.
+        </para>
+        <para>
+         <application>vacuumdb</application> will open
+         <replaceable class="parameter"> njobs</replaceable> connections to the
+         database, so make sure your <xref linkend="guc-max-connections">
+         setting is high enough to accommodate all connections.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,28 ****
  
  #include "common.h"
  
! static void SetCancelConn(PGconn *conn);
! static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
--- 19,28 ----
  
  #include "common.h"
  
! 
  
  static PGcancel *volatile cancelConn = NULL;
+ static bool inAbort = false;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 291,297 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 321,327 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
***************
*** 359,368 **** handle_sigint(SIGNAL_ARGS)
--- 359,375 ----
  	if (cancelConn != NULL)
  	{
  		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 		{
+ 			inAbort = true;
  			fprintf(stderr, _("Cancel request sent\n"));
+ 		}
  		else
  			fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  	}
+ 	else
+ 	{
+ 		inAbort = true;
+ 	}
  
  	errno = save_errno;			/* just in case the write changed it */
  }
***************
*** 392,401 **** consoleHandler(DWORD dwCtrlType)
--- 399,416 ----
  		if (cancelConn != NULL)
  		{
  			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 			{
  				fprintf(stderr, _("Cancel request sent\n"));
+ 				inAbort = true;
+ 			}
  			else
  				fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  		}
+ 		else
+ 		{
+ 			inAbort = true;
+ 		}
+ 
  		LeaveCriticalSection(&cancelConnLock);
  
  		return TRUE;
***************
*** 414,416 **** setup_cancel_handler(void)
--- 429,436 ----
  }
  
  #endif   /* WIN32 */
+ 
+ bool in_abort()
+ {
+ 	return inAbort;
+ }
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 49,57 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ extern bool in_abort(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,31 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
+ #define ERRCODE_UNDEFINED_TABLE  "42P01"
+ #define ERROR_IN_ABORT				-2
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 37,75 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int concurrentCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 					int stage, bool freeze, const char *host, const char *port,
+ 					const char *username, enum trivalue prompt_password,
+ 					const char *progname, bool echo, int concurrentCons,
+ 					SimpleStringList *tables, bool quiet);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 90,96 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 116,130 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 165,191 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				concurrentCons = atoi(optarg);
+ 				if (concurrentCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,146 **** main(int argc, char *argv[])
--- 198,204 ----
  		}
  	}
  
+ 	optind++;
  
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
***************
*** 179,184 **** main(int argc, char *argv[])
--- 237,249 ----
  
  	setup_cancel_handler();
  
+ 	/*
+ 	 * When user is giving the table list, and list is smaller then
+ 	 * number of tables
+ 	 */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 261,267 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, concurrentCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
- 			for (cell = tables.head; cell; cell = cell->next)
- 			{
- 				vacuum_one_database(dbname, full, verbose, and_analyze,
- 									analyze_only, analyze_in_stages, -1,
- 									freeze, cell->val,
- 									host, port, username, prompt_password,
- 									progname, echo, quiet);
- 			}
  		}
  		else
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
  	}
  
  	exit(0);
--- 275,310 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (concurrentCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages, -1,
! 								freeze, host, port, username, prompt_password,
! 								progname, echo, concurrentCons, &tables, quiet);
  
  		}
  		else
! 		{
! 			if (tables.head != NULL)
! 			{
! 				SimpleStringListCell *cell;
! 
! 				for (cell = tables.head; cell; cell = cell->next)
! 				{
! 					vacuum_one_database(dbname, full, verbose, and_analyze,
! 										analyze_only, analyze_in_stages, -1,
! 										freeze, cell->val,
! 										host, port, username, prompt_password,
! 										progname, echo, quiet);
! 				}
! 			}
! 			else
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
  								analyze_only, analyze_in_stages, -1,
  								freeze, NULL,
  								host, port, username, prompt_password,
  								progname, echo, quiet);
+ 		}
  	}
  
  	exit(0);
***************
*** 268,323 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
! 	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
! 	}
! 	else
! 	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
! 		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
- 			if (full)
- 			{
- 				appendPQExpBuffer(&sql, "%sFULL", sep);
- 				sep = comma;
- 			}
- 			if (freeze)
- 			{
- 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
- 				sep = comma;
- 			}
- 			if (verbose)
- 			{
- 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
- 				sep = comma;
- 			}
- 			if (and_analyze)
- 			{
- 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
- 				sep = comma;
- 			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
- 		}
- 	}
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
--- 344,352 ----
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	prepare_command(conn, full, verbose,
! 					and_analyze, analyze_only, freeze, &sql);
  
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
***************
*** 353,360 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  		}
  		else
  		{
! 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one. */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
--- 382,391 ----
  		}
  		else
  		{
! 			/*
! 			 * Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one.
! 			 */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
***************
*** 374,384 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 405,416 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int concurrentCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 390,396 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  	PQfinish(conn);
  
  	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage. */
  	for (stage = (analyze_in_stages ? 0 : -1);
  		 stage < (analyze_in_stages ? 3 : 0);
  		 stage++)
--- 422,429 ----
  	PQfinish(conn);
  
  	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage.
! 	 */
  	for (stage = (analyze_in_stages ? 0 : -1);
  		 stage < (analyze_in_stages ? 3 : 0);
  		 stage++)
***************
*** 407,412 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 440,454 ----
  				fflush(stdout);
  			}
  
+ 		if (concurrentCons > 1)
+ 		{
+ 			vacuum_parallel(dbname, full, verbose, and_analyze,
+ 								analyze_only, analyze_in_stages, stage,
+ 								freeze, host, port, username, prompt_password,
+ 								progname, echo, concurrentCons, NULL, quiet);
+ 
+ 		}
+ 		else
  			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
  								analyze_in_stages, stage,
  							freeze, NULL, host, port, username, prompt_password,
***************
*** 417,422 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 459,972 ----
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function process the table list,
+  * pick the object one by one and get the Free connections slot, once it
+  * get the free slot send the job on the free connection.
+  */
+ 
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = concurrentCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		if (in_abort())
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 		appendPQExpBufferStr(&sql, ";");
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 							completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		pfree(connSlot);
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot available return the slotid
+  * If no slot is free, Then perform select on all the socket and wait until
+  * atleast one slot is free.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * No free slot found, so wait for all the connetions,
+ 	 * once any of the connetion get respose, check if
+ 	 * any of the connection finished it task, if yes,
+ 	 * return the slot, otherwise wait again.
+ 	 */
+ 
+ 	do
+ 	{
+ 		SetCancelConn(pSlot[0].connection);
+ 
+ 		i = select_loop(maxFd, &slotset);
+ 
+ 		ResetCancelConn();
+ 
+ 		if (ERROR_IN_ABORT == i)
+ 		{
+ 			/*
+ 			 * This can only happen if user has sent the cancel request using
+ 			 * Ctrl+C, Cancel is handled by 0th slot, so fetch the error result.
+ 			 */
+ 
+ 			GetQueryResult(pSlot[0].connection, dbname, progname,
+ 						   completedb);
+ 			return NO_SLOT;
+ 		}
+ 
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 								completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 
+ 	SetCancelConn(conn);
+ 	while((result = PQgetResult(conn)) != NULL)
+ 	{
+ 		PQclear(lastResult);
+ 		lastResult = result;
+ 	}
+ 
+ 	ResetCancelConn();
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	/*
+ 	 * If user has given the vacuum of complete db, then if
+ 	 * any of the object's vacuum failed it can be ignored and vacuuming
+ 	 * of other objects can be continued, this is the same behavior as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r)
+ 	{
+ 		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+ 
+ 		if (!completedb ||
+ 		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+ 		{
+ 
+ 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 
+ 			PQclear(lastResult);
+ 			return false;
+ 		}
+ 	}
+ 
+ 	PQclear(lastResult);
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open the multiple concurrent connections as
+  * suggested by user, it will derive the table list using server call
+  * if table list is not given by user and perform the vacuum call
+  */
+ 
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			int stage, bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int concurrentCons,
+ 			SimpleStringList *tables, bool quiet)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	SimpleStringList dbtables = {NULL, NULL};
+ 	bool	completeDb = false;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prepare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			appendPQExpBuffer(&sql, "%s",
+ 							fmtQualifiedId(PQserverVersion(conn),
+ 							PQgetvalue(res, i, 1),
+ 							PQgetvalue(res, i, 0)));
+ 
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* Vaccuming full database*/
+ 		completeDb = true;
+ 
+ 		if (concurrentCons > ntuple)
+ 			concurrentCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	connSlot[0].sock = PQsocket(conn);
+ 
+ 	PQsetnonblocking(connSlot[0].connection, 1);
+ 
+ 	for (i = 1; i < concurrentCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 			};
+ 
+ 		if (stage == -1)
+ 		{
+ 			int			i;
+ 			for (i = 0; i < 3; i++)
+ 			{
+ 				if (!quiet)
+ 				{
+ 					puts(gettext(stage_messages[i]));
+ 					fflush(stdout);
+ 				}
+ 
+ 				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 						and_analyze, analyze_only, freeze, concurrentCons,
+ 						progname, i, connSlot, completeDb);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
+ 			 * only that one.
+ 			 */
+ 			if (!quiet)
+ 			{
+ 				puts(gettext(stage_messages[stage]));
+ 				fflush(stdout);
+ 			}
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze, concurrentCons,
+ 					progname, stage, connSlot, completeDb);
+ 		}
+ 	}
+ 	else
+ 	{
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 					and_analyze, analyze_only, freeze,
+ 					concurrentCons, progname, -1, connSlot, completeDb);
+ 	}
+ 
+ 	for (i = 0; i < concurrentCons; i++)
+ 	{
+ 		PQfinish(connSlot[i].connection);
+ 	}
+ 
+ 	pfree(connSlot);
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 		if (in_abort())
+ 		{
+ 			return ERROR_IN_ABORT;
+ 		}
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (in_abort())
+ 		{
+ 			return -1;
+ 		}
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBufferStr(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBufferStr(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBufferStr(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBufferStr(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBufferStr(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBufferStr(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBufferStr(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBufferStr(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 986,992 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

diff --git a/doc/src/sgml/ref/vacuumdb.sgml b/doc/src/sgml/ref/vacuumdb.sgml
index 3ecd999..e4a971f 100644
--- a/doc/src/sgml/ref/vacuumdb.sgml
+++ b/doc/src/sgml/ref/vacuumdb.sgml
@@ -204,6 +204,27 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+      <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+      <listitem>
+       <para>
+        Number of concurrent connections to perform the operation.
+        This option will enable the vacuum operation to run on asynchronous
+        connections, at a time one table will be operated on one connection.
+        So at one time as many tables will be vacuumed parallely as number of
+        jobs.  If number of jobs given are more than number of tables then
+        number of jobs will be set to number of tables.
+       </para>
+       <para>
+        <application>vacuumdb</application> will open
+        <replaceable class="parameter"> njobs</replaceable> connections to the
+        database, so make sure your <xref linkend="guc-max-connections">
+        setting is high enough to accommodate all connections.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>--analyze-in-stages</option></term>
       <listitem>
        <para>
diff --git a/src/bin/scripts/common.c b/src/bin/scripts/common.c
index 311fed5..2220a4e 100644
--- a/src/bin/scripts/common.c
+++ b/src/bin/scripts/common.c
@@ -19,10 +19,9 @@
 
 #include "common.h"
 
-static void SetCancelConn(PGconn *conn);
-static void ResetCancelConn(void);
 
 static PGcancel *volatile cancelConn = NULL;
+static bool inAbort = false;
 
 #ifdef WIN32
 static CRITICAL_SECTION cancelConnLock;
@@ -291,7 +290,7 @@ yesno_prompt(const char *question)
  *
  * Set cancelConn to point to the current database connection.
  */
-static void
+void
 SetCancelConn(PGconn *conn)
 {
 	PGcancel   *oldCancelConn;
@@ -321,7 +320,7 @@ SetCancelConn(PGconn *conn)
  *
  * Free the current cancel connection, if any, and set to NULL.
  */
-static void
+void
 ResetCancelConn(void)
 {
 	PGcancel   *oldCancelConn;
@@ -359,10 +358,15 @@ handle_sigint(SIGNAL_ARGS)
 	if (cancelConn != NULL)
 	{
 		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+		{
+			inAbort = true;
 			fprintf(stderr, _("Cancel request sent\n"));
+		}
 		else
 			fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
 	}
+	else
+		inAbort = true;
 
 	errno = save_errno;			/* just in case the write changed it */
 }
@@ -392,10 +396,16 @@ consoleHandler(DWORD dwCtrlType)
 		if (cancelConn != NULL)
 		{
 			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+			{
 				fprintf(stderr, _("Cancel request sent\n"));
+				inAbort = true;
+			}
 			else
 				fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
 		}
+		else
+			inAbort = true;
+
 		LeaveCriticalSection(&cancelConnLock);
 
 		return TRUE;
@@ -414,3 +424,8 @@ setup_cancel_handler(void)
 }
 
 #endif   /* WIN32 */
+
+bool in_abort()
+{
+	return inAbort;
+}
diff --git a/src/bin/scripts/common.h b/src/bin/scripts/common.h
index 691f6c6..3bafde3 100644
--- a/src/bin/scripts/common.h
+++ b/src/bin/scripts/common.h
@@ -49,4 +49,9 @@ extern bool yesno_prompt(const char *question);
 
 extern void setup_cancel_handler(void);
 
+extern void SetCancelConn(PGconn *conn);
+extern void ResetCancelConn(void);
+extern bool in_abort(void);
+
+
 #endif   /* COMMON_H */
diff --git a/src/bin/scripts/vacuumdb.c b/src/bin/scripts/vacuumdb.c
index 86e6ab3..05cd74f 100644
--- a/src/bin/scripts/vacuumdb.c
+++ b/src/bin/scripts/vacuumdb.c
@@ -14,6 +14,18 @@
 #include "common.h"
 #include "dumputils.h"
 
+#define NO_SLOT (-1)
+
+/* Arguments needed for a worker process */
+typedef struct ParallelSlot
+{
+	PGconn *connection;
+	bool isFree;
+	pgsocket sock;
+} ParallelSlot;
+
+#define ERRCODE_UNDEFINED_TABLE  "42P01"
+#define ERROR_IN_ABORT				-2
 
 static void vacuum_one_database(const char *dbname, bool full, bool verbose,
 	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
@@ -25,10 +37,40 @@ static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
 					 const char *maintenance_db,
 					 const char *host, const char *port,
 					 const char *username, enum trivalue prompt_password,
-					 const char *progname, bool echo, bool quiet);
+					 const char *progname, bool echo, bool quiet,
+					 int concurrentCons);
 
 static void help(const char *progname);
 
+void vacuum_parallel(const char *dbname, bool full, bool verbose,
+					 bool and_analyze, bool analyze_only,
+					 bool analyze_in_stages, int stage, bool freeze,
+					 const char *host, const char *port,
+					 const char *username, enum trivalue prompt_password,
+					 const char *progname, bool echo, int concurrentCons,
+					 SimpleStringList *tables, bool quiet);
+
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+					 bool analyze_only, bool freeze, PQExpBuffer sql);
+static void
+run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+					bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, int concurrentCons,
+					const char *progname, int analyze_stage,
+					ParallelSlot *connSlot, bool completedb);
+static int
+GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+			const char *progname, bool completedb);
+
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+						   const char *progname, bool completedb);
+
+static int
+select_loop(int maxFd, fd_set *workerset);
+
+static void DisconnectDatabase(ParallelSlot *slot);
+
 
 int
 main(int argc, char *argv[])
@@ -49,6 +91,7 @@ main(int argc, char *argv[])
 		{"table", required_argument, NULL, 't'},
 		{"full", no_argument, NULL, 'f'},
 		{"verbose", no_argument, NULL, 'v'},
+		{"jobs", required_argument, NULL, 'j'},
 		{"maintenance-db", required_argument, NULL, 2},
 		{"analyze-in-stages", no_argument, NULL, 3},
 		{NULL, 0, NULL, 0}
@@ -74,13 +117,15 @@ main(int argc, char *argv[])
 	bool		full = false;
 	bool		verbose = false;
 	SimpleStringList tables = {NULL, NULL};
+	int concurrentCons = 0;
+	int tbl_count = 0;
 
 	progname = get_progname(argv[0]);
 	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
 
 	handle_help_version_opts(argc, argv, "vacuumdb", help);
 
-	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
+	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
 	{
 		switch (c)
 		{
@@ -121,14 +166,27 @@ main(int argc, char *argv[])
 				alldb = true;
 				break;
 			case 't':
+			{
 				simple_string_list_append(&tables, optarg);
+				tbl_count++;
 				break;
+			}
 			case 'f':
 				full = true;
 				break;
 			case 'v':
 				verbose = true;
 				break;
+			case 'j':
+				concurrentCons = atoi(optarg);
+				if (concurrentCons <= 0)
+				{
+					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+							progname);
+					exit(1);
+				}
+
+				break;
 			case 2:
 				maintenance_db = pg_strdup(optarg);
 				break;
@@ -141,6 +199,7 @@ main(int argc, char *argv[])
 		}
 	}
 
+	optind++;
 
 	/*
 	 * Non-option argument specifies database name as long as it wasn't
@@ -179,6 +238,10 @@ main(int argc, char *argv[])
 
 	setup_cancel_handler();
 
+	/* Avoid opening extra connections. */
+	if (tbl_count && (concurrentCons > tbl_count))
+		concurrentCons = tbl_count;
+
 	if (alldb)
 	{
 		if (dbname)
@@ -196,7 +259,7 @@ main(int argc, char *argv[])
 
 		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
 							 maintenance_db, host, port, username,
-							 prompt_password, progname, echo, quiet);
+							 prompt_password, progname, echo, quiet, concurrentCons);
 	}
 	else
 	{
@@ -210,25 +273,36 @@ main(int argc, char *argv[])
 				dbname = get_user_name_or_exit(progname);
 		}
 
-		if (tables.head != NULL)
+		if (concurrentCons > 1)
 		{
-			SimpleStringListCell *cell;
+			vacuum_parallel(dbname, full, verbose, and_analyze,
+							analyze_only, analyze_in_stages, -1,
+							freeze, host, port, username, prompt_password,
+							progname, echo, concurrentCons, &tables, quiet);
 
-			for (cell = tables.head; cell; cell = cell->next)
+		}
+		else
+		{
+			if (tables.head != NULL)
 			{
+				SimpleStringListCell *cell;
+
+				for (cell = tables.head; cell; cell = cell->next)
+				{
+					vacuum_one_database(dbname, full, verbose, and_analyze,
+										analyze_only, analyze_in_stages, -1,
+										freeze, cell->val,
+										host, port, username, prompt_password,
+										progname, echo, quiet);
+				}
+			}
+			else
 				vacuum_one_database(dbname, full, verbose, and_analyze,
 									analyze_only, analyze_in_stages, -1,
-									freeze, cell->val,
+									freeze, NULL,
 									host, port, username, prompt_password,
 									progname, echo, quiet);
-			}
 		}
-		else
-			vacuum_one_database(dbname, full, verbose, and_analyze,
-								analyze_only, analyze_in_stages, -1,
-								freeze, NULL,
-								host, port, username, prompt_password,
-								progname, echo, quiet);
 	}
 
 	exit(0);
@@ -268,56 +342,9 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 	conn = connectDatabase(dbname, host, port, username, prompt_password,
 						   progname, false);
 
-	if (analyze_only)
-	{
-		appendPQExpBufferStr(&sql, "ANALYZE");
-		if (verbose)
-			appendPQExpBufferStr(&sql, " VERBOSE");
-	}
-	else
-	{
-		appendPQExpBufferStr(&sql, "VACUUM");
-		if (PQserverVersion(conn) >= 90000)
-		{
-			const char *paren = " (";
-			const char *comma = ", ";
-			const char *sep = paren;
+	prepare_command(conn, full, verbose,
+					and_analyze, analyze_only, freeze, &sql);
 
-			if (full)
-			{
-				appendPQExpBuffer(&sql, "%sFULL", sep);
-				sep = comma;
-			}
-			if (freeze)
-			{
-				appendPQExpBuffer(&sql, "%sFREEZE", sep);
-				sep = comma;
-			}
-			if (verbose)
-			{
-				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
-				sep = comma;
-			}
-			if (and_analyze)
-			{
-				appendPQExpBuffer(&sql, "%sANALYZE", sep);
-				sep = comma;
-			}
-			if (sep != paren)
-				appendPQExpBufferStr(&sql, ")");
-		}
-		else
-		{
-			if (full)
-				appendPQExpBufferStr(&sql, " FULL");
-			if (freeze)
-				appendPQExpBufferStr(&sql, " FREEZE");
-			if (verbose)
-				appendPQExpBufferStr(&sql, " VERBOSE");
-			if (and_analyze)
-				appendPQExpBufferStr(&sql, " ANALYZE");
-		}
-	}
 	if (table)
 		appendPQExpBuffer(&sql, " %s", table);
 	appendPQExpBufferStr(&sql, ";");
@@ -353,8 +380,10 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 		}
 		else
 		{
-			/* Otherwise, we got a stage from vacuum_all_databases(), so run
-			 * only that one. */
+			/*
+			 * Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one.
+			 */
 			if (!quiet)
 			{
 				puts(gettext(stage_messages[stage]));
@@ -374,11 +403,12 @@ vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
 
 
 static void
-vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
-			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
-					 const char *host, const char *port,
-					 const char *username, enum trivalue prompt_password,
-					 const char *progname, bool echo, bool quiet)
+vacuum_all_databases(bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool analyze_in_stages, bool freeze,
+					const char *maintenance_db, const char *host,
+					const char *port, const char *username,
+					enum trivalue prompt_password, const char *progname,
+					bool echo, bool quiet, int concurrentCons)
 {
 	PGconn	   *conn;
 	PGresult   *result;
@@ -390,7 +420,8 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 	PQfinish(conn);
 
 	/* If analyzing in stages, then run through all stages.  Otherwise just
-	 * run once, passing -1 as the stage. */
+	 * run once, passing -1 as the stage.
+	 */
 	for (stage = (analyze_in_stages ? 0 : -1);
 		 stage < (analyze_in_stages ? 3 : 0);
 		 stage++)
@@ -407,6 +438,15 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 				fflush(stdout);
 			}
 
+		if (concurrentCons > 1)
+		{
+			vacuum_parallel(dbname, full, verbose, and_analyze,
+								analyze_only, analyze_in_stages, stage,
+								freeze, host, port, username, prompt_password,
+								progname, echo, concurrentCons, NULL, quiet);
+
+		}
+		else
 			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
 								analyze_in_stages, stage,
 							freeze, NULL, host, port, username, prompt_password,
@@ -417,6 +457,507 @@ vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
 	PQclear(result);
 }
 
+/*
+ * run_parallel_vacuum
+ * This function does the actual work for sending the jobs
+ * concurrently to server.
+ */
+static void
+run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+					bool full, bool verbose, bool and_analyze,
+					bool analyze_only, bool freeze, int concurrentCons,
+					const char *progname, int analyze_stage,
+					ParallelSlot *connSlot, bool completedb)
+{
+	PQExpBufferData sql;
+	SimpleStringListCell *cell;
+	int max_slot = concurrentCons;
+	int i;
+	int free_slot;
+	PGconn *slotconn;
+	bool  error = false;
+	const char *stage_commands[] = {
+			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+			"RESET default_statistics_target;"};
+
+	initPQExpBuffer(&sql);
+
+	if (analyze_stage >= 0)
+	{
+		for (i = 0; i < max_slot; i++)
+		{
+			executeCommand(connSlot[i].connection,
+					stage_commands[analyze_stage], progname, echo);
+		}
+	}
+
+	for (cell = tables->head; cell; cell = cell->next)
+	{
+		if (in_abort())
+		{
+			error = true;
+			goto fail;
+		}
+
+		/*
+		 * This will give the free connection slot, if no slot is free it will
+		 * wait for atleast one slot to get free.
+		 */
+		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+								completedb);
+		if (free_slot == NO_SLOT)
+		{
+			error = true;
+			goto fail;
+		}
+
+		prepare_command(connSlot[free_slot].connection, full, verbose,
+					and_analyze, analyze_only, freeze, &sql);
+
+		appendPQExpBuffer(&sql, " %s", cell->val);
+		appendPQExpBufferStr(&sql, ";");
+
+		connSlot[free_slot].isFree = false;
+
+		slotconn = connSlot[free_slot].connection;
+		PQsendQuery(slotconn, sql.data);
+
+		resetPQExpBuffer(&sql);
+	}
+
+	for (i = 0; i < max_slot; i++)
+	{
+		/* wait for all connection to return the results*/
+		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+							completedb))
+		{
+			error = true;
+			goto fail;
+		}
+
+		connSlot[i].isFree = true;
+	}
+
+fail:
+
+	termPQExpBuffer(&sql);
+
+	if (error)
+	{
+		for (i = 0; i < max_slot; i++)
+		{
+			DisconnectDatabase(&connSlot[i]);
+		}
+
+		pfree(connSlot);
+
+		exit(1);
+	}
+}
+
+/*
+ * GetIdleSlot
+ * Process the slot list, if any free slot is available then return
+ * the slotid else perform the select on all the socket's and wait
+ * until atleast one slot becomes available.
+ */
+static int
+GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+			const char *progname, bool completedb)
+{
+	int		i;
+	fd_set	slotset;
+	int 	firstFree = -1;
+	pgsocket maxFd;
+
+	for (i = 0; i < max_slot; i++)
+		if (pSlot[i].isFree)
+			return i;
+
+	FD_ZERO(&slotset);
+
+	maxFd = pSlot[0].sock;
+
+	for (i = 0; i < max_slot; i++)
+	{
+		FD_SET(pSlot[i].sock, &slotset);
+		if (pSlot[i].sock > maxFd)
+			maxFd = pSlot[i].sock;
+	}
+
+	/*
+	 * No free slot found, so wait untill one of the connections
+	 * has finished it's task and return the available slot.
+	 */
+	do
+	{
+		SetCancelConn(pSlot[0].connection);
+
+		i = select_loop(maxFd, &slotset);
+
+		ResetCancelConn();
+
+		if (i == ERROR_IN_ABORT)
+		{
+			/*
+			 * This can only happen if user has sent the cancel request using
+			 * Ctrl+C, cancel is handled by 0th slot, so fetch the error result.
+			 */
+			GetQueryResult(pSlot[0].connection, dbname, progname,
+						   completedb);
+			return NO_SLOT;
+		}
+
+		Assert(i != 0);
+
+		for (i = 0; i < max_slot; i++)
+		{
+			if (!FD_ISSET(pSlot[i].sock, &slotset))
+				continue;
+
+			PQconsumeInput(pSlot[i].connection);
+			if (PQisBusy(pSlot[i].connection))
+				continue;
+
+			pSlot[i].isFree = true;
+
+			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+								completedb))
+				return NO_SLOT;
+
+			if (firstFree < 0)
+				firstFree = i;
+		}
+	}while(firstFree < 0);
+
+	return firstFree;
+}
+
+/*
+ * GetQueryResult
+ * Process the query result.
+ */
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+						   const char *progname, bool completedb)
+{
+	PGresult    *result = NULL;
+	PGresult    *lastResult = NULL;
+	bool r;
+
+
+	SetCancelConn(conn);
+	while((result = PQgetResult(conn)) != NULL)
+	{
+		PQclear(lastResult);
+		lastResult = result;
+	}
+
+	ResetCancelConn();
+
+	if (!lastResult)
+		return true;
+
+	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+
+	/*
+	 * If user has given the vacuum of complete db and vacuum for
+	 * any of the object is failed, it can be ignored and vacuuming
+	 * of other objects can be continued, this is the same behavior as
+	 * vacuuming of complete db is handled without --jobs option
+	 */
+	if (!r)
+	{
+		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+
+		if (!completedb ||
+		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+		{
+
+			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+					progname, dbname, PQerrorMessage(conn));
+
+			PQclear(lastResult);
+			return false;
+		}
+	}
+
+	PQclear(lastResult);
+	return true;
+}
+
+/*
+ * vacuum_parallel
+ * This function will open multiple connections to perform the
+ * vacuum on table's concurrently. Incase vacuum needs to be performed
+ * on database, it retrieve's the list of tables and then perform
+ * vacuum.
+ */
+void
+vacuum_parallel(const char *dbname, bool full, bool verbose,
+			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+			int stage, bool freeze, const char *host, const char *port,
+			const char *username, enum trivalue prompt_password,
+			const char *progname, bool echo, int concurrentCons,
+			SimpleStringList *tables, bool quiet)
+{
+
+	PGconn	   *conn;
+	int i;
+	ParallelSlot *connSlot;
+	SimpleStringList dbtables = {NULL, NULL};
+	bool	completeDb = false;
+
+	conn = connectDatabase(dbname, host, port, username,
+					  prompt_password, progname, false);
+
+	/*
+	 * if table list is not provided then we need to do vaccum for whole DB
+	 * get the list of all tables and prepare the list
+	 */
+	if (!tables || !tables->head)
+	{
+		PGresult *res;
+		int ntuple;
+		int i;
+		PQExpBufferData sql;
+
+		initPQExpBuffer(&sql);
+
+		res = executeQuery(conn,
+				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+				" WHERE (relkind = \'r\' or relkind = \'m\')"
+				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+				progname, echo);
+
+		ntuple = PQntuples(res);
+		for (i = 0; i < ntuple; i++)
+		{
+			appendPQExpBuffer(&sql, "%s",
+							fmtQualifiedId(PQserverVersion(conn),
+							PQgetvalue(res, i, 1),
+							PQgetvalue(res, i, 0)));
+
+			simple_string_list_append(&dbtables, sql.data);
+			resetPQExpBuffer(&sql);
+		}
+
+		termPQExpBuffer(&sql);
+		tables = &dbtables;
+
+		/* remember that we are vaccuming full database. */
+		completeDb = true;
+
+		if (concurrentCons > ntuple)
+			concurrentCons = ntuple;
+	}
+
+	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+	connSlot[0].connection = conn;
+	connSlot[0].sock = PQsocket(conn);
+
+	PQsetnonblocking(connSlot[0].connection, 1);
+
+	for (i = 1; i < concurrentCons; i++)
+	{
+		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+								  prompt_password, progname, false);
+
+		PQsetnonblocking(connSlot[i].connection, 1);
+		connSlot[i].isFree = true;
+		connSlot[i].sock = PQsocket(connSlot[i].connection);
+	}
+
+	if (analyze_in_stages)
+	{
+		const char *stage_messages[] = {
+			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+			gettext_noop("Generating default (full) optimizer statistics")
+			};
+
+		if (stage == -1)
+		{
+			int			i;
+			for (i = 0; i < 3; i++)
+			{
+				if (!quiet)
+				{
+					puts(gettext(stage_messages[i]));
+					fflush(stdout);
+				}
+
+				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+									and_analyze, analyze_only, freeze,
+									concurrentCons, progname, i, connSlot,
+									completeDb);
+			}
+		}
+		else
+		{
+			/*
+			 * Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one.
+			 */
+			if (!quiet)
+			{
+				puts(gettext(stage_messages[stage]));
+				fflush(stdout);
+			}
+
+			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+								and_analyze, analyze_only, freeze,
+								concurrentCons, progname, stage,
+								connSlot, completeDb);
+		}
+	}
+	else
+		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+							and_analyze, analyze_only, freeze,
+							concurrentCons, progname, -1, connSlot,
+							completeDb);
+
+	for (i = 0; i < concurrentCons; i++)
+		 PQfinish(connSlot[i].connection);
+
+	pfree(connSlot);
+}
+
+/*
+ * A select loop that repeats calling select until a descriptor in the read
+ * set becomes readable. On Windows we have to check for the termination event
+ * from time to time, on Unix we can just block forever.
+ */
+static int
+select_loop(int maxFd, fd_set *workerset)
+{
+	int			i;
+	fd_set		saveSet = *workerset;
+
+#ifdef WIN32
+	/* should always be the master */
+	for (;;)
+	{
+		/*
+		 * sleep a quarter of a second before checking if we should terminate.
+		 */
+		struct timeval tv = {0, 250000};
+
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+		if (in_abort())
+		{
+			return ERROR_IN_ABORT;
+		}
+
+		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+			continue;
+		if (i)
+			break;
+	}
+#else							/* UNIX */
+
+	for (;;)
+	{
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+		if (in_abort())
+		{
+			return -1;
+		}
+
+		if (i < 0 && errno == EINTR)
+			continue;
+		break;
+	}
+#endif
+
+	return i;
+}
+
+/*
+ * DisconnectDatabase
+ * disconnect all the connections.
+ */
+void
+DisconnectDatabase(ParallelSlot *slot)
+{
+	PGcancel   *cancel;
+	char		errbuf[1];
+
+	if (!slot->connection)
+		return;
+
+	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+	{
+		if ((cancel = PQgetCancel(slot->connection)))
+		{
+			PQcancel(cancel, errbuf, sizeof(errbuf));
+			PQfreeCancel(cancel);
+		}
+	}
+
+	PQfinish(slot->connection);
+	slot->connection= NULL;
+}
+
+
+
+void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+					 bool analyze_only, bool freeze, PQExpBuffer sql)
+{
+	if (analyze_only)
+	{
+		appendPQExpBufferStr(sql, "ANALYZE");
+		if (verbose)
+			appendPQExpBufferStr(sql, " VERBOSE");
+	}
+	else
+	{
+		appendPQExpBufferStr(sql, "VACUUM");
+		if (PQserverVersion(conn) >= 90000)
+		{
+			const char *paren = " (";
+			const char *comma = ", ";
+			const char *sep = paren;
+
+			if (full)
+			{
+				appendPQExpBuffer(sql, "%sFULL", sep);
+				sep = comma;
+			}
+			if (freeze)
+			{
+				appendPQExpBuffer(sql, "%sFREEZE", sep);
+				sep = comma;
+			}
+			if (verbose)
+			{
+				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+				sep = comma;
+			}
+			if (and_analyze)
+			{
+				appendPQExpBuffer(sql, "%sANALYZE", sep);
+				sep = comma;
+			}
+			if (sep != paren)
+				appendPQExpBufferStr(sql, ")");
+		}
+		else
+		{
+			if (full)
+				appendPQExpBufferStr(sql, " FULL");
+			if (freeze)
+				appendPQExpBufferStr(sql, " FREEZE");
+			if (verbose)
+				appendPQExpBufferStr(sql, " VERBOSE");
+			if (and_analyze)
+				appendPQExpBufferStr(sql, " ANALYZE");
+		}
+	}
+}
+
 
 static void
 help(const char *progname)
@@ -436,6 +977,7 @@ help(const char *progname)
 	printf(_("  -V, --version                   output version information, then exit\n"));
 	printf(_("  -z, --analyze                   update optimizer statistics\n"));
 	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
 	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
 		   "                                  stages for faster results\n"));
 	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,228 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+       <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+       <listitem>
+        <para>
+         This option will enable the vacuum operation to run on concurrent
+         connections. Maximum number of tables can be vacuumed concurrently
+         is equal to number of jobs. If number of jobs given is more than
+         number of tables then number of jobs will be set to number of tables.
+        </para>
+        <para>
+         <application>vacuumdb</application> will open
+         <replaceable class="parameter"> njobs</replaceable> connections to the
+         database, so make sure your <xref linkend="guc-max-connections">
+         setting is high enough to accommodate all connections.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,28 ****
  
  #include "common.h"
  
- static void SetCancelConn(PGconn *conn);
- static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
--- 19,27 ----
  
  #include "common.h"
  
  
  static PGcancel *volatile cancelConn = NULL;
+ static bool inAbort = false;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 290,296 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 320,326 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
***************
*** 359,368 **** handle_sigint(SIGNAL_ARGS)
--- 358,372 ----
  	if (cancelConn != NULL)
  	{
  		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 		{
+ 			inAbort = true;
  			fprintf(stderr, _("Cancel request sent\n"));
+ 		}
  		else
  			fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  	}
+ 	else
+ 		inAbort = true;
  
  	errno = save_errno;			/* just in case the write changed it */
  }
***************
*** 392,401 **** consoleHandler(DWORD dwCtrlType)
--- 396,411 ----
  		if (cancelConn != NULL)
  		{
  			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 			{
  				fprintf(stderr, _("Cancel request sent\n"));
+ 				inAbort = true;
+ 			}
  			else
  				fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  		}
+ 		else
+ 			inAbort = true;
+ 
  		LeaveCriticalSection(&cancelConnLock);
  
  		return TRUE;
***************
*** 414,416 **** setup_cancel_handler(void)
--- 424,431 ----
  }
  
  #endif   /* WIN32 */
+ 
+ bool in_abort()
+ {
+ 	return inAbort;
+ }
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 49,57 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ extern bool in_abort(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 14,19 ****
--- 14,31 ----
  #include "common.h"
  #include "dumputils.h"
  
+ #define NO_SLOT (-1)
+ 
+ /* Arguments needed for a worker process */
+ typedef struct ParallelSlot
+ {
+ 	PGconn *connection;
+ 	bool isFree;
+ 	pgsocket sock;
+ } ParallelSlot;
+ 
+ #define ERRCODE_UNDEFINED_TABLE  "42P01"
+ #define ERROR_IN_ABORT				-2
  
  static void vacuum_one_database(const char *dbname, bool full, bool verbose,
  	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
***************
*** 25,34 **** static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 37,76 ----
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet,
! 					 int concurrentCons);
  
  static void help(const char *progname);
  
+ void vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 					 bool and_analyze, bool analyze_only,
+ 					 bool analyze_in_stages, int stage, bool freeze,
+ 					 const char *host, const char *port,
+ 					 const char *username, enum trivalue prompt_password,
+ 					 const char *progname, bool echo, int concurrentCons,
+ 					 SimpleStringList *tables, bool quiet);
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					 bool analyze_only, bool freeze, PQExpBuffer sql);
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb);
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						   const char *progname, bool completedb);
+ 
+ static int
+ select_loop(int maxFd, fd_set *workerset);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 91,97 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 74,86 **** main(int argc, char *argv[])
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 117,131 ----
  	bool		full = false;
  	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv:j:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 121,134 **** main(int argc, char *argv[])
--- 166,192 ----
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
  				full = true;
  				break;
  			case 'v':
  				verbose = true;
  				break;
+ 			case 'j':
+ 				concurrentCons = atoi(optarg);
+ 				if (concurrentCons <= 0)
+ 				{
+ 					fprintf(stderr, _("%s: Number of parallel \"jobs\" should be at least 1\n"),
+ 							progname);
+ 					exit(1);
+ 				}
+ 
+ 				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
***************
*** 141,147 **** main(int argc, char *argv[])
  		}
  	}
  
- 
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
  	 * already specified with -d / --dbname
--- 199,204 ----
***************
*** 179,184 **** main(int argc, char *argv[])
--- 236,245 ----
  
  	setup_cancel_handler();
  
+ 	/* Avoid opening extra connections. */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 196,202 **** main(int argc, char *argv[])
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 257,263 ----
  
  		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
  							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet, concurrentCons);
  	}
  	else
  	{
***************
*** 210,234 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
  		{
! 			SimpleStringListCell *cell;
  
! 			for (cell = tables.head; cell; cell = cell->next)
  			{
  				vacuum_one_database(dbname, full, verbose, and_analyze,
  									analyze_only, analyze_in_stages, -1,
! 									freeze, cell->val,
  									host, port, username, prompt_password,
  									progname, echo, quiet);
- 			}
  		}
- 		else
- 			vacuum_one_database(dbname, full, verbose, and_analyze,
- 								analyze_only, analyze_in_stages, -1,
- 								freeze, NULL,
- 								host, port, username, prompt_password,
- 								progname, echo, quiet);
  	}
  
  	exit(0);
--- 271,306 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (concurrentCons > 1)
  		{
! 			vacuum_parallel(dbname, full, verbose, and_analyze,
! 							analyze_only, analyze_in_stages, -1,
! 							freeze, host, port, username, prompt_password,
! 							progname, echo, concurrentCons, &tables, quiet);
  
! 		}
! 		else
! 		{
! 			if (tables.head != NULL)
  			{
+ 				SimpleStringListCell *cell;
+ 
+ 				for (cell = tables.head; cell; cell = cell->next)
+ 				{
+ 					vacuum_one_database(dbname, full, verbose, and_analyze,
+ 										analyze_only, analyze_in_stages, -1,
+ 										freeze, cell->val,
+ 										host, port, username, prompt_password,
+ 										progname, echo, quiet);
+ 				}
+ 			}
+ 			else
  				vacuum_one_database(dbname, full, verbose, and_analyze,
  									analyze_only, analyze_in_stages, -1,
! 									freeze, NULL,
  									host, port, username, prompt_password,
  									progname, echo, quiet);
  		}
  	}
  
  	exit(0);
***************
*** 268,323 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
! 	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
! 	}
! 	else
! 	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
! 		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
- 			if (full)
- 			{
- 				appendPQExpBuffer(&sql, "%sFULL", sep);
- 				sep = comma;
- 			}
- 			if (freeze)
- 			{
- 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
- 				sep = comma;
- 			}
- 			if (verbose)
- 			{
- 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
- 				sep = comma;
- 			}
- 			if (and_analyze)
- 			{
- 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
- 				sep = comma;
- 			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
- 		}
- 	}
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
--- 340,348 ----
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	prepare_command(conn, full, verbose,
! 					and_analyze, analyze_only, freeze, &sql);
  
  	if (table)
  		appendPQExpBuffer(&sql, " %s", table);
  	appendPQExpBufferStr(&sql, ";");
***************
*** 353,360 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  		}
  		else
  		{
! 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one. */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
--- 378,387 ----
  		}
  		else
  		{
! 			/*
! 			 * Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one.
! 			 */
  			if (!quiet)
  			{
  				puts(gettext(stage_messages[stage]));
***************
*** 374,384 **** vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyz
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
! 					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
--- 401,412 ----
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					bool analyze_only, bool analyze_in_stages, bool freeze,
! 					const char *maintenance_db, const char *host,
! 					const char *port, const char *username,
! 					enum trivalue prompt_password, const char *progname,
! 					bool echo, bool quiet, int concurrentCons)
  {
  	PGconn	   *conn;
  	PGresult   *result;
***************
*** 390,396 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
  	PQfinish(conn);
  
  	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage. */
  	for (stage = (analyze_in_stages ? 0 : -1);
  		 stage < (analyze_in_stages ? 3 : 0);
  		 stage++)
--- 418,425 ----
  	PQfinish(conn);
  
  	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage.
! 	 */
  	for (stage = (analyze_in_stages ? 0 : -1);
  		 stage < (analyze_in_stages ? 3 : 0);
  		 stage++)
***************
*** 407,412 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 436,450 ----
  				fflush(stdout);
  			}
  
+ 		if (concurrentCons > 1)
+ 		{
+ 			vacuum_parallel(dbname, full, verbose, and_analyze,
+ 								analyze_only, analyze_in_stages, stage,
+ 								freeze, host, port, username, prompt_password,
+ 								progname, echo, concurrentCons, NULL, quiet);
+ 
+ 		}
+ 		else
  			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
  								analyze_in_stages, stage,
  							freeze, NULL, host, port, username, prompt_password,
***************
*** 417,422 **** vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_onl
--- 455,967 ----
  	PQclear(result);
  }
  
+ /*
+  * run_parallel_vacuum
+  * This function does the actual work for sending the jobs
+  * concurrently to server.
+  */
+ static void
+ run_parallel_vacuum(bool echo, const char *dbname, SimpleStringList *tables,
+ 					bool full, bool verbose, bool and_analyze,
+ 					bool analyze_only, bool freeze, int concurrentCons,
+ 					const char *progname, int analyze_stage,
+ 					ParallelSlot *connSlot, bool completedb)
+ {
+ 	PQExpBufferData sql;
+ 	SimpleStringListCell *cell;
+ 	int max_slot = concurrentCons;
+ 	int i;
+ 	int free_slot;
+ 	PGconn *slotconn;
+ 	bool  error = false;
+ 	const char *stage_commands[] = {
+ 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 			"RESET default_statistics_target;"};
+ 
+ 	initPQExpBuffer(&sql);
+ 
+ 	if (analyze_stage >= 0)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			executeCommand(connSlot[i].connection,
+ 					stage_commands[analyze_stage], progname, echo);
+ 		}
+ 	}
+ 
+ 	for (cell = tables->head; cell; cell = cell->next)
+ 	{
+ 		if (in_abort())
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		/*
+ 		 * This will give the free connection slot, if no slot is free it will
+ 		 * wait for atleast one slot to get free.
+ 		 */
+ 		free_slot = GetIdleSlot(connSlot, max_slot, dbname, progname,
+ 								completedb);
+ 		if (free_slot == NO_SLOT)
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		prepare_command(connSlot[free_slot].connection, full, verbose,
+ 					and_analyze, analyze_only, freeze, &sql);
+ 
+ 		appendPQExpBuffer(&sql, " %s", cell->val);
+ 		appendPQExpBufferStr(&sql, ";");
+ 
+ 		connSlot[free_slot].isFree = false;
+ 
+ 		slotconn = connSlot[free_slot].connection;
+ 		PQsendQuery(slotconn, sql.data);
+ 
+ 		resetPQExpBuffer(&sql);
+ 	}
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		/* wait for all connection to return the results*/
+ 		if (!GetQueryResult(connSlot[i].connection, dbname, progname,
+ 							completedb))
+ 		{
+ 			error = true;
+ 			goto fail;
+ 		}
+ 
+ 		connSlot[i].isFree = true;
+ 	}
+ 
+ fail:
+ 
+ 	termPQExpBuffer(&sql);
+ 
+ 	if (error)
+ 	{
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			DisconnectDatabase(&connSlot[i]);
+ 		}
+ 
+ 		pfree(connSlot);
+ 
+ 		exit(1);
+ 	}
+ }
+ 
+ /*
+  * GetIdleSlot
+  * Process the slot list, if any free slot is available then return
+  * the slotid else perform the select on all the socket's and wait
+  * until atleast one slot becomes available.
+  */
+ static int
+ GetIdleSlot(ParallelSlot *pSlot, int max_slot, const char *dbname,
+ 			const char *progname, bool completedb)
+ {
+ 	int		i;
+ 	fd_set	slotset;
+ 	int 	firstFree = -1;
+ 	pgsocket maxFd;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 		if (pSlot[i].isFree)
+ 			return i;
+ 
+ 	FD_ZERO(&slotset);
+ 
+ 	maxFd = pSlot[0].sock;
+ 
+ 	for (i = 0; i < max_slot; i++)
+ 	{
+ 		FD_SET(pSlot[i].sock, &slotset);
+ 		if (pSlot[i].sock > maxFd)
+ 			maxFd = pSlot[i].sock;
+ 	}
+ 
+ 	/*
+ 	 * No free slot found, so wait untill one of the connections
+ 	 * has finished it's task and return the available slot.
+ 	 */
+ 	do
+ 	{
+ 		SetCancelConn(pSlot[0].connection);
+ 
+ 		i = select_loop(maxFd, &slotset);
+ 
+ 		ResetCancelConn();
+ 
+ 		if (i == ERROR_IN_ABORT)
+ 		{
+ 			/*
+ 			 * This can only happen if user has sent the cancel request using
+ 			 * Ctrl+C, cancel is handled by 0th slot, so fetch the error result.
+ 			 */
+ 			GetQueryResult(pSlot[0].connection, dbname, progname,
+ 						   completedb);
+ 			return NO_SLOT;
+ 		}
+ 
+ 		Assert(i != 0);
+ 
+ 		for (i = 0; i < max_slot; i++)
+ 		{
+ 			if (!FD_ISSET(pSlot[i].sock, &slotset))
+ 				continue;
+ 
+ 			PQconsumeInput(pSlot[i].connection);
+ 			if (PQisBusy(pSlot[i].connection))
+ 				continue;
+ 
+ 			pSlot[i].isFree = true;
+ 
+ 			if (!GetQueryResult(pSlot[i].connection, dbname, progname,
+ 								completedb))
+ 				return NO_SLOT;
+ 
+ 			if (firstFree < 0)
+ 				firstFree = i;
+ 		}
+ 	}while(firstFree < 0);
+ 
+ 	return firstFree;
+ }
+ 
+ /*
+  * GetQueryResult
+  * Process the query result.
+  */
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 						   const char *progname, bool completedb)
+ {
+ 	PGresult    *result = NULL;
+ 	PGresult    *lastResult = NULL;
+ 	bool r;
+ 
+ 
+ 	SetCancelConn(conn);
+ 	while((result = PQgetResult(conn)) != NULL)
+ 	{
+ 		PQclear(lastResult);
+ 		lastResult = result;
+ 	}
+ 
+ 	ResetCancelConn();
+ 
+ 	if (!lastResult)
+ 		return true;
+ 
+ 	r = (PQresultStatus(lastResult) == PGRES_COMMAND_OK);
+ 
+ 	/*
+ 	 * If user has given the vacuum of complete db and vacuum for
+ 	 * any of the object is failed, it can be ignored and vacuuming
+ 	 * of other objects can be continued, this is the same behavior as
+ 	 * vacuuming of complete db is handled without --jobs option
+ 	 */
+ 	if (!r)
+ 	{
+ 		char *sqlState = PQresultErrorField(lastResult, PG_DIAG_SQLSTATE);
+ 
+ 		if (!completedb ||
+ 		   (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0))
+ 		{
+ 
+ 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+ 					progname, dbname, PQerrorMessage(conn));
+ 
+ 			PQclear(lastResult);
+ 			return false;
+ 		}
+ 	}
+ 
+ 	PQclear(lastResult);
+ 	return true;
+ }
+ 
+ /*
+  * vacuum_parallel
+  * This function will open multiple connections to perform the
+  * vacuum on table's concurrently. Incase vacuum needs to be performed
+  * on database, it retrieve's the list of tables and then perform
+  * vacuum.
+  */
+ void
+ vacuum_parallel(const char *dbname, bool full, bool verbose,
+ 			bool and_analyze, bool analyze_only, bool analyze_in_stages,
+ 			int stage, bool freeze, const char *host, const char *port,
+ 			const char *username, enum trivalue prompt_password,
+ 			const char *progname, bool echo, int concurrentCons,
+ 			SimpleStringList *tables, bool quiet)
+ {
+ 
+ 	PGconn	   *conn;
+ 	int i;
+ 	ParallelSlot *connSlot;
+ 	SimpleStringList dbtables = {NULL, NULL};
+ 	bool	completeDb = false;
+ 
+ 	conn = connectDatabase(dbname, host, port, username,
+ 					  prompt_password, progname, false);
+ 
+ 	/*
+ 	 * if table list is not provided then we need to do vaccum for whole DB
+ 	 * get the list of all tables and prepare the list
+ 	 */
+ 	if (!tables || !tables->head)
+ 	{
+ 		PGresult *res;
+ 		int ntuple;
+ 		int i;
+ 		PQExpBufferData sql;
+ 
+ 		initPQExpBuffer(&sql);
+ 
+ 		res = executeQuery(conn,
+ 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns"
+ 				" WHERE (relkind = \'r\' or relkind = \'m\')"
+ 				" and c.relnamespace = ns.oid ORDER BY c.relpages desc",
+ 				progname, echo);
+ 
+ 		ntuple = PQntuples(res);
+ 		for (i = 0; i < ntuple; i++)
+ 		{
+ 			appendPQExpBuffer(&sql, "%s",
+ 							fmtQualifiedId(PQserverVersion(conn),
+ 							PQgetvalue(res, i, 1),
+ 							PQgetvalue(res, i, 0)));
+ 
+ 			simple_string_list_append(&dbtables, sql.data);
+ 			resetPQExpBuffer(&sql);
+ 		}
+ 
+ 		termPQExpBuffer(&sql);
+ 		tables = &dbtables;
+ 
+ 		/* remember that we are vaccuming full database. */
+ 		completeDb = true;
+ 
+ 		if (concurrentCons > ntuple)
+ 			concurrentCons = ntuple;
+ 	}
+ 
+ 	connSlot = (ParallelSlot*)pg_malloc(concurrentCons * sizeof(ParallelSlot));
+ 	connSlot[0].connection = conn;
+ 	connSlot[0].sock = PQsocket(conn);
+ 
+ 	PQsetnonblocking(connSlot[0].connection, 1);
+ 
+ 	for (i = 1; i < concurrentCons; i++)
+ 	{
+ 		connSlot[i].connection = connectDatabase(dbname, host, port, username,
+ 								  prompt_password, progname, false);
+ 
+ 		PQsetnonblocking(connSlot[i].connection, 1);
+ 		connSlot[i].isFree = true;
+ 		connSlot[i].sock = PQsocket(connSlot[i].connection);
+ 	}
+ 
+ 	if (analyze_in_stages)
+ 	{
+ 		const char *stage_messages[] = {
+ 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
+ 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
+ 			gettext_noop("Generating default (full) optimizer statistics")
+ 			};
+ 
+ 		if (stage == -1)
+ 		{
+ 			int			i;
+ 			for (i = 0; i < 3; i++)
+ 			{
+ 				if (!quiet)
+ 				{
+ 					puts(gettext(stage_messages[i]));
+ 					fflush(stdout);
+ 				}
+ 
+ 				run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 									and_analyze, analyze_only, freeze,
+ 									concurrentCons, progname, i, connSlot,
+ 									completeDb);
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/*
+ 			 * Otherwise, we got a stage from vacuum_all_databases(), so run
+ 			 * only that one.
+ 			 */
+ 			if (!quiet)
+ 			{
+ 				puts(gettext(stage_messages[stage]));
+ 				fflush(stdout);
+ 			}
+ 
+ 			run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 								and_analyze, analyze_only, freeze,
+ 								concurrentCons, progname, stage,
+ 								connSlot, completeDb);
+ 		}
+ 	}
+ 	else
+ 		run_parallel_vacuum(echo, dbname, tables, full, verbose,
+ 							and_analyze, analyze_only, freeze,
+ 							concurrentCons, progname, -1, connSlot,
+ 							completeDb);
+ 
+ 	for (i = 0; i < concurrentCons; i++)
+ 		 PQfinish(connSlot[i].connection);
+ 
+ 	pfree(connSlot);
+ }
+ 
+ /*
+  * A select loop that repeats calling select until a descriptor in the read
+  * set becomes readable. On Windows we have to check for the termination event
+  * from time to time, on Unix we can just block forever.
+  */
+ static int
+ select_loop(int maxFd, fd_set *workerset)
+ {
+ 	int			i;
+ 	fd_set		saveSet = *workerset;
+ 
+ #ifdef WIN32
+ 	/* should always be the master */
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * sleep a quarter of a second before checking if we should terminate.
+ 		 * after every quarter seconds we need to check if user have terminated
+ 		 * using a Ctrl+C.
+ 		 */
+ 		struct timeval tv = {0, 250000};
+ 
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, &tv);
+ 		if (in_abort())
+ 		{
+ 			return ERROR_IN_ABORT;
+ 		}
+ 
+ 		if (i == SOCKET_ERROR && WSAGetLastError() == WSAEINTR)
+ 			continue;
+ 		if (i)
+ 			break;
+ 	}
+ #else							/* UNIX */
+ 
+ 	for (;;)
+ 	{
+ 		/*
+ 		 * In linux sleep forever, because cancel even is handled using signal
+ 		 * handler.
+ 		 */
+ 		*workerset = saveSet;
+ 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
+ 		if (in_abort())
+ 		{
+ 			return -1;
+ 		}
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;
+ 		break;
+ 	}
+ #endif
+ 
+ 	return i;
+ }
+ 
+ /*
+  * DisconnectDatabase
+  * disconnect all the connections.
+  */
+ void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	PGcancel   *cancel;
+ 	char		errbuf[1];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection= NULL;
+ }
+ 
+ 
+ 
+ void prepare_command(PGconn *conn, bool full, bool verbose, bool and_analyze,
+ 					 bool analyze_only, bool freeze, PQExpBuffer sql)
+ {
+ 	if (analyze_only)
+ 	{
+ 		appendPQExpBufferStr(sql, "ANALYZE");
+ 		if (verbose)
+ 			appendPQExpBufferStr(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBufferStr(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBufferStr(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (full)
+ 				appendPQExpBufferStr(sql, " FULL");
+ 			if (freeze)
+ 				appendPQExpBufferStr(sql, " FREEZE");
+ 			if (verbose)
+ 				appendPQExpBufferStr(sql, " VERBOSE");
+ 			if (and_analyze)
+ 				appendPQExpBufferStr(sql, " ANALYZE");
+ 		}
+ 	}
+ }
+ 
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 981,987 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));

diff --git a/doc/src/sgml/ref/vacuumdb.sgml b/doc/src/sgml/ref/vacuumdb.sgml
index 3ecd999..211235a 100644
--- a/doc/src/sgml/ref/vacuumdb.sgml
+++ b/doc/src/sgml/ref/vacuumdb.sgml
@@ -204,6 +204,25 @@ PostgreSQL documentation
      </varlistentry>
 
      <varlistentry>
+      <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+      <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+      <listitem>
+       <para>
+        This option will enable the vacuum operation to run on concurrent
+        connections. Maximum number of tables can be vacuumed concurrently
+        is equal to number of jobs. If number of jobs given is more than
+        number of tables then number of jobs will be set to number of tables.
+       </para>
+       <para>
+        <application>vacuumdb</application> will open
+        <replaceable class="parameter"> njobs</replaceable> connections to the
+        database, so make sure your <xref linkend="guc-max-connections">
+        setting is high enough to accommodate all connections.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry>
       <term><option>--analyze-in-stages</option></term>
       <listitem>
        <para>
diff --git a/src/bin/pg_dump/parallel.c b/src/bin/pg_dump/parallel.c
index d942a75..1bf7611 100644
--- a/src/bin/pg_dump/parallel.c
+++ b/src/bin/pg_dump/parallel.c
@@ -1160,7 +1160,7 @@ select_loop(int maxFd, fd_set *workerset)
 		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
 
 		/*
-		 * If we Ctrl-C the master process , it's likely that we interrupt
+		 * If we Ctrl-C the master process, it's likely that we interrupt
 		 * select() here. The signal handler will set wantAbort == true and
 		 * the shutdown journey starts from here. Note that we'll come back
 		 * here later when we tell all workers to terminate and read their
diff --git a/src/bin/scripts/common.c b/src/bin/scripts/common.c
index 6bfe2e6..da142aa 100644
--- a/src/bin/scripts/common.c
+++ b/src/bin/scripts/common.c
@@ -19,10 +19,9 @@
 
 #include "common.h"
 
-static void SetCancelConn(PGconn *conn);
-static void ResetCancelConn(void);
 
 static PGcancel *volatile cancelConn = NULL;
+bool CancelRequested = false;
 
 #ifdef WIN32
 static CRITICAL_SECTION cancelConnLock;
@@ -291,7 +290,7 @@ yesno_prompt(const char *question)
  *
  * Set cancelConn to point to the current database connection.
  */
-static void
+void
 SetCancelConn(PGconn *conn)
 {
 	PGcancel   *oldCancelConn;
@@ -321,7 +320,7 @@ SetCancelConn(PGconn *conn)
  *
  * Free the current cancel connection, if any, and set to NULL.
  */
-static void
+void
 ResetCancelConn(void)
 {
 	PGcancel   *oldCancelConn;
@@ -345,9 +344,8 @@ ResetCancelConn(void)
 
 #ifndef WIN32
 /*
- * Handle interrupt signals by canceling the current command,
- * if it's being executed through executeMaintenanceCommand(),
- * and thus has a cancelConn set.
+ * Handle interrupt signals by canceling the current command, if a cancelConn
+ * is set.
  */
 static void
 handle_sigint(SIGNAL_ARGS)
@@ -359,10 +357,15 @@ handle_sigint(SIGNAL_ARGS)
 	if (cancelConn != NULL)
 	{
 		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+		{
+			CancelRequested = true;
 			fprintf(stderr, _("Cancel request sent\n"));
+		}
 		else
 			fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
 	}
+	else
+		CancelRequested = true;
 
 	errno = save_errno;			/* just in case the write changed it */
 }
@@ -392,10 +395,16 @@ consoleHandler(DWORD dwCtrlType)
 		if (cancelConn != NULL)
 		{
 			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+			{
 				fprintf(stderr, _("Cancel request sent\n"));
+				CancelRequested = true;
+			}
 			else
 				fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
 		}
+		else
+			CancelRequested = true;
+
 		LeaveCriticalSection(&cancelConnLock);
 
 		return TRUE;
diff --git a/src/bin/scripts/common.h b/src/bin/scripts/common.h
index c0c1715..b5ce1ed 100644
--- a/src/bin/scripts/common.h
+++ b/src/bin/scripts/common.h
@@ -21,6 +21,8 @@ enum trivalue
 	TRI_YES
 };
 
+extern bool CancelRequested;
+
 typedef void (*help_handler) (const char *progname);
 
 extern void handle_help_version_opts(int argc, char *argv[],
@@ -49,4 +51,8 @@ extern bool yesno_prompt(const char *question);
 
 extern void setup_cancel_handler(void);
 
+extern void SetCancelConn(PGconn *conn);
+extern void ResetCancelConn(void);
+
+
 #endif   /* COMMON_H */
diff --git a/src/bin/scripts/vacuumdb.c b/src/bin/scripts/vacuumdb.c
index 957fdb6..89af9d5 100644
--- a/src/bin/scripts/vacuumdb.c
+++ b/src/bin/scripts/vacuumdb.c
@@ -11,24 +11,108 @@
  */
 
 #include "postgres_fe.h"
+
 #include "common.h"
 #include "dumputils.h"
 
 
-static void vacuum_one_database(const char *dbname, bool full, bool verbose,
-	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
-					const char *table, const char *host, const char *port,
+#define ERRCODE_UNDEFINED_TABLE  "42P01"
+
+/* Parallel vacuuming stuff */
+typedef struct ParallelSlot
+{
+	PGconn *connection;
+	pgsocket sock;
+	bool isFree;
+} ParallelSlot;
+
+/* vacuum options controlled by user flags */
+typedef struct vacuumingOptions
+{
+	bool	analyze_only;
+	bool	verbose;
+	bool	and_analyze;
+	bool	full;
+	bool	freeze;
+} vacuumingOptions;
+
+
+static void vacuum_one_database(const char *dbname, vacuumingOptions *vacopts,
+					bool analyze_in_stages, int stage,
+					SimpleStringList *tables,
+					const char *host, const char *port,
 					const char *username, enum trivalue prompt_password,
 					const char *progname, bool echo, bool quiet);
-static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
-					 bool analyze_only, bool analyze_in_stages, bool freeze,
+static void vacuum_one_database_parallel(const char *dbname, vacuumingOptions *vacopts,
+					 bool analyze_in_stages, int stage,
+					 SimpleStringList *tables,
+					 const char *host, const char *port,
+					 const char *username, enum trivalue prompt_password,
+					 int concurrentCons,
+					 const char *progname, bool echo, bool quiet);
+static void vacuum_all_databases(vacuumingOptions *vacopts,
+					 bool analyze_in_stages,
 					 const char *maintenance_db,
 					 const char *host, const char *port,
 					 const char *username, enum trivalue prompt_password,
+					 int concurrentCons,
 					 const char *progname, bool echo, bool quiet);
+static void vacuum_database_stage(const char *dbname, vacuumingOptions *vacopts,
+					  bool analyze_in_stages, int stage,
+					  SimpleStringList *tables,
+					  const char *host, const char *port, const char *username,
+					  enum trivalue prompt_password,
+					  int concurrentCons,
+					  const char *progname, bool echo, bool quiet);
 
 static void help(const char *progname);
 
+static void prepare_command(PQExpBuffer sql, PGconn *conn,
+				vacuumingOptions *vacopts, const char *table);
+static void run_parallel_vacuum(bool echo,
+					SimpleStringList *tables, vacuumingOptions *vacopts,
+					int concurrentCons, int analyze_stage,
+					ParallelSlot slots[],
+					const char *dbname, const char *progname);
+static ParallelSlot *GetIdleSlot(ParallelSlot slots[], int numslots,
+			const char *dbname, const char *progname);
+
+static bool GetQueryResult(PGconn *conn, const char *dbname,
+			   const char *progname);
+
+static int select_loop(int maxFd, fd_set *workerset, bool *aborting);
+
+static void DisconnectDatabase(ParallelSlot *slot);
+
+
+/*
+ * Preparatory commands and corresponding user-visible message for the
+ * analyze-in-stages feature.  Note the ANALYZE command itself must be sent
+ * separately.
+ */
+static const struct
+{
+	const char *prepcmd;
+	const char *message;
+}
+staged_analyze[3] =
+{
+	{
+		"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+		gettext_noop("Generating minimal optimizer statistics (1 target)")
+	},
+	{
+		"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+		gettext_noop("Generating medium optimizer statistics (10 targets)")
+	},
+	{
+		"RESET default_statistics_target;",
+		gettext_noop("Generating default (full) optimizer statistics")
+	}
+};
+
+#define ANALYZE_ALL_STAGES	-1
+
 
 int
 main(int argc, char *argv[])
@@ -49,6 +133,7 @@ main(int argc, char *argv[])
 		{"table", required_argument, NULL, 't'},
 		{"full", no_argument, NULL, 'f'},
 		{"verbose", no_argument, NULL, 'v'},
+		{"jobs", required_argument, NULL, 'j'},
 		{"maintenance-db", required_argument, NULL, 2},
 		{"analyze-in-stages", no_argument, NULL, 3},
 		{NULL, 0, NULL, 0}
@@ -57,7 +142,6 @@ main(int argc, char *argv[])
 	const char *progname;
 	int			optindex;
 	int			c;
-
 	const char *dbname = NULL;
 	const char *maintenance_db = NULL;
 	char	   *host = NULL;
@@ -66,21 +150,23 @@ main(int argc, char *argv[])
 	enum trivalue prompt_password = TRI_DEFAULT;
 	bool		echo = false;
 	bool		quiet = false;
-	bool		and_analyze = false;
-	bool		analyze_only = false;
+	vacuumingOptions vacopts;
 	bool		analyze_in_stages = false;
-	bool		freeze = false;
 	bool		alldb = false;
-	bool		full = false;
-	bool		verbose = false;
 	SimpleStringList tables = {NULL, NULL};
+	int concurrentCons = 0;
+	int tbl_count = 0;
+
+	/* initialize options to all false */
+	memset(&vacopts, 0, sizeof(vacopts));
 
 	progname = get_progname(argv[0]);
+
 	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
 
 	handle_help_version_opts(argc, argv, "vacuumdb", help);
 
-	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
+	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fvj:", long_options, &optindex)) != -1)
 	{
 		switch (c)
 		{
@@ -109,31 +195,43 @@ main(int argc, char *argv[])
 				dbname = pg_strdup(optarg);
 				break;
 			case 'z':
-				and_analyze = true;
+				vacopts.and_analyze = true;
 				break;
 			case 'Z':
-				analyze_only = true;
+				vacopts.analyze_only = true;
 				break;
 			case 'F':
-				freeze = true;
+				vacopts.freeze = true;
 				break;
 			case 'a':
 				alldb = true;
 				break;
 			case 't':
+			{
 				simple_string_list_append(&tables, optarg);
+				tbl_count++;
 				break;
+			}
 			case 'f':
-				full = true;
+				vacopts.full = true;
 				break;
 			case 'v':
-				verbose = true;
+				vacopts.verbose = true;
+				break;
+			case 'j':
+				concurrentCons = atoi(optarg);
+				if (concurrentCons <= 0)
+				{
+					fprintf(stderr, _("%s: number of parallel \"jobs\" must be at least 1\n"),
+							progname);
+					exit(1);
+				}
 				break;
 			case 2:
 				maintenance_db = pg_strdup(optarg);
 				break;
 			case 3:
-				analyze_in_stages = analyze_only = true;
+				analyze_in_stages = vacopts.analyze_only = true;
 				break;
 			default:
 				fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
@@ -141,7 +239,6 @@ main(int argc, char *argv[])
 		}
 	}
 
-
 	/*
 	 * Non-option argument specifies database name as long as it wasn't
 	 * already specified with -d / --dbname
@@ -160,18 +257,18 @@ main(int argc, char *argv[])
 		exit(1);
 	}
 
-	if (analyze_only)
+	if (vacopts.analyze_only)
 	{
-		if (full)
+		if (vacopts.full)
 		{
-			fprintf(stderr, _("%s: cannot use the \"full\" option when performing only analyze\n"),
-					progname);
+			fprintf(stderr, _("%s: cannot use the \"%s\" option when performing only analyze\n"),
+					progname, "full");
 			exit(1);
 		}
-		if (freeze)
+		if (vacopts.freeze)
 		{
-			fprintf(stderr, _("%s: cannot use the \"freeze\" option when performing only analyze\n"),
-					progname);
+			fprintf(stderr, _("%s: cannot use the \"%s\" option when performing only analyze\n"),
+					progname, "freeze");
 			exit(1);
 		}
 		/* allow 'and_analyze' with 'analyze_only' */
@@ -179,6 +276,10 @@ main(int argc, char *argv[])
 
 	setup_cancel_handler();
 
+	/* Avoid opening extra connections. */
+	if (tbl_count && (concurrentCons > tbl_count))
+		concurrentCons = tbl_count;
+
 	if (alldb)
 	{
 		if (dbname)
@@ -194,9 +295,12 @@ main(int argc, char *argv[])
 			exit(1);
 		}
 
-		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
-							 maintenance_db, host, port, username,
-							 prompt_password, progname, echo, quiet);
+		vacuum_all_databases(&vacopts,
+							 analyze_in_stages,
+							 maintenance_db,
+							 host, port, username, prompt_password,
+							 concurrentCons,
+							 progname, echo, quiet);
 	}
 	else
 	{
@@ -210,35 +314,35 @@ main(int argc, char *argv[])
 				dbname = get_user_name_or_exit(progname);
 		}
 
-		if (tables.head != NULL)
-		{
-			SimpleStringListCell *cell;
-
-			for (cell = tables.head; cell; cell = cell->next)
-			{
-				vacuum_one_database(dbname, full, verbose, and_analyze,
-									analyze_only, analyze_in_stages, -1,
-									freeze, cell->val,
-									host, port, username, prompt_password,
-									progname, echo, quiet);
-			}
-		}
-		else
-			vacuum_one_database(dbname, full, verbose, and_analyze,
-								analyze_only, analyze_in_stages, -1,
-								freeze, NULL,
-								host, port, username, prompt_password,
-								progname, echo, quiet);
+		vacuum_database_stage(dbname, &vacopts,
+							  analyze_in_stages, ANALYZE_ALL_STAGES,
+							  &tables,
+							  host, port, username, prompt_password,
+							  concurrentCons,
+							  progname, echo, quiet);
 	}
 
 	exit(0);
 }
 
-
+/*
+ * Execute a vacuum/analyze command to the server.
+ *
+ * Result status is checked only if 'async' is false.
+ */
 static void
-run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname, const char *table, const char *progname)
+run_vacuum_command(PGconn *conn, const char *sql, bool echo,
+				   const char *dbname, const char *table,
+				   const char *progname, bool async)
 {
-	if (!executeMaintenanceCommand(conn, sql, echo))
+	if (async)
+	{
+		if (echo)
+			printf("%s\n", sql);
+
+		PQsendQuery(conn, sql);
+	}
+	else if (!executeMaintenanceCommand(conn, sql, echo))
 	{
 		if (table)
 			fprintf(stderr, _("%s: vacuuming of table \"%s\" in database \"%s\" failed: %s"),
@@ -251,172 +355,648 @@ run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
 	}
 }
 
-
+/*
+ * vacuum_one_database
+ *
+ * Process tables in the given database.  If the 'tables' list is empty,
+ * process all tables in the database.  Note there is no paralellization here.
+ */
 static void
-vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
-	bool analyze_only, bool analyze_in_stages, int stage, bool freeze, const char *table,
+vacuum_one_database(const char *dbname, vacuumingOptions *vacopts,
+					bool analyze_in_stages, int stage,
+					SimpleStringList *tables,
 					const char *host, const char *port,
 					const char *username, enum trivalue prompt_password,
 					const char *progname, bool echo, bool quiet)
 {
 	PQExpBufferData sql;
-
 	PGconn	   *conn;
-
-	initPQExpBuffer(&sql);
+	SimpleStringListCell *cell;
 
 	conn = connectDatabase(dbname, host, port, username, prompt_password,
 						   progname, false);
 
-	if (analyze_only)
+	initPQExpBuffer(&sql);
+
+	cell = tables ? tables->head : NULL;
+	do
 	{
-		appendPQExpBufferStr(&sql, "ANALYZE");
-		if (verbose)
-			appendPQExpBufferStr(&sql, " VERBOSE");
-	}
-	else
-	{
-		appendPQExpBufferStr(&sql, "VACUUM");
-		if (PQserverVersion(conn) >= 90000)
+		const char *tabname;
+
+		tabname = cell ? cell->val : NULL;
+		prepare_command(&sql, conn, vacopts, tabname);
+
+		if (analyze_in_stages)
 		{
-			const char *paren = " (";
-			const char *comma = ", ";
-			const char *sep = paren;
+			if (stage == ANALYZE_ALL_STAGES)
+			{
+				int		i;
 
-			if (full)
-			{
-				appendPQExpBuffer(&sql, "%sFULL", sep);
-				sep = comma;
-			}
-			if (freeze)
-			{
-				appendPQExpBuffer(&sql, "%sFREEZE", sep);
-				sep = comma;
-			}
-			if (verbose)
-			{
-				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
-				sep = comma;
+				/* Run all stages. */
+				for (i = 0; i < 3; i++)
+				{
+					if (!quiet)
+					{
+						puts(gettext(staged_analyze[i].message));
+						fflush(stdout);
+					}
+					executeCommand(conn, staged_analyze[i].prepcmd, progname, echo);
+					run_vacuum_command(conn, sql.data, echo, dbname, tabname, progname, false);
+				}
 			}
-			if (and_analyze)
+			else
 			{
-				appendPQExpBuffer(&sql, "%sANALYZE", sep);
-				sep = comma;
+				/*
+				 * Otherwise, we got a stage from vacuum_all_databases(), so run
+				 * only that one.
+				 */
+				if (!quiet)
+				{
+					puts(gettext(staged_analyze[stage].message));
+					fflush(stdout);
+				}
+				executeCommand(conn, staged_analyze[stage].prepcmd, progname, echo);
+				run_vacuum_command(conn, sql.data, echo, dbname, tabname, progname, false);
 			}
-			if (sep != paren)
-				appendPQExpBufferStr(&sql, ")");
 		}
 		else
+			run_vacuum_command(conn, sql.data, echo, dbname, NULL, progname, false);
+
+		cell = cell->next;
+	} while (cell != NULL);
+
+	PQfinish(conn);
+	termPQExpBuffer(&sql);
+}
+
+static void
+init_slot(ParallelSlot *slot, PGconn *conn)
+{
+	slot->connection = conn;
+	slot->isFree = true;
+	slot->sock = PQsocket(conn);
+}
+
+/*
+ * vacuum_one_database_parallel
+ *
+ * Like vacuum_one_database, but drive multiple connections in parallel.
+ * Another significant difference is that if the table list is empty, rather
+ * than running unadorned VACUUM commands (which would vacuum all the tables in
+ * the database, as vacuum_one_database does) we need to query the catalogs to
+ * obtain the list of tables first.
+ */
+static void
+vacuum_one_database_parallel(const char *dbname, vacuumingOptions *vacopts,
+							 bool analyze_in_stages, int stage,
+							 SimpleStringList *tables,
+							 const char *host, const char *port,
+							 const char *username, enum trivalue prompt_password,
+							 int concurrentCons,
+							 const char *progname, bool echo, bool quiet)
+{
+	PGconn	   *conn;
+	ParallelSlot *slots;
+	SimpleStringList dbtables = {NULL, NULL};
+	int			i;
+
+	conn = connectDatabase(dbname, host, port, username,
+						   prompt_password, progname, false);
+
+	/*
+	 * If a table list is not provided then we need to vacuum the whole
+	 * database; prepare the list of tables.
+	 */
+	if (!tables || !tables->head)
+	{
+		PQExpBufferData buf;
+		PGresult *res;
+		int		ntups;
+		int		i;
+
+		initPQExpBuffer(&buf);
+
+		res = executeQuery(conn,
+				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns\n"
+				" WHERE relkind IN (\'r\', \'m\') AND c.relnamespace = ns.oid\n"
+				" ORDER BY c.relpages DESC",
+				progname, echo);
+
+		ntups = PQntuples(res);
+		for (i = 0; i < ntups; i++)
 		{
-			if (full)
-				appendPQExpBufferStr(&sql, " FULL");
-			if (freeze)
-				appendPQExpBufferStr(&sql, " FREEZE");
-			if (verbose)
-				appendPQExpBufferStr(&sql, " VERBOSE");
-			if (and_analyze)
-				appendPQExpBufferStr(&sql, " ANALYZE");
+			appendPQExpBuffer(&buf, "%s",
+							  fmtQualifiedId(PQserverVersion(conn),
+											 PQgetvalue(res, i, 1),
+											 PQgetvalue(res, i, 0)));
+
+			simple_string_list_append(&dbtables, buf.data);
+			resetPQExpBuffer(&buf);
 		}
+
+		termPQExpBuffer(&buf);
+		tables = &dbtables;
+
+		/*
+		 * If there are more connections than vacuumable relations, we don't
+		 * need to use them all.
+		 */
+		if (concurrentCons > ntups)
+			concurrentCons = ntups;
+	}
+
+	slots = (ParallelSlot *) pg_malloc(sizeof(ParallelSlot) * concurrentCons);
+	init_slot(slots, conn);
+
+	for (i = 1; i < concurrentCons; i++)
+	{
+		conn = connectDatabase(dbname, host, port, username, prompt_password,
+							   progname, false);
+		init_slot(slots + i, conn);
 	}
-	if (table)
-		appendPQExpBuffer(&sql, " %s", table);
-	appendPQExpBufferStr(&sql, ";");
 
 	if (analyze_in_stages)
 	{
-		const char *stage_commands[] = {
-			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
-			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
-			"RESET default_statistics_target;"
-		};
-		const char *stage_messages[] = {
-			gettext_noop("Generating minimal optimizer statistics (1 target)"),
-			gettext_noop("Generating medium optimizer statistics (10 targets)"),
-			gettext_noop("Generating default (full) optimizer statistics")
-		};
-
-		if (stage == -1)
+		if (stage == ANALYZE_ALL_STAGES)
 		{
-			int		i;
+			int			i;
 
-			/* Run all stages. */
 			for (i = 0; i < 3; i++)
 			{
 				if (!quiet)
 				{
-					puts(gettext(stage_messages[i]));
+					puts(gettext(staged_analyze[i].message));
 					fflush(stdout);
 				}
-				executeCommand(conn, stage_commands[i], progname, echo);
-				run_vacuum_command(conn, sql.data, echo, dbname, table, progname);
+
+				run_parallel_vacuum(echo, tables, vacopts,
+									concurrentCons, i, slots,
+									dbname, progname);
 			}
 		}
 		else
 		{
-			/* Otherwise, we got a stage from vacuum_all_databases(), so run
-			 * only that one. */
+			/*
+			 * Otherwise, we got a stage from vacuum_all_databases(), so run
+			 * only that one.
+			 */
 			if (!quiet)
 			{
-				puts(gettext(stage_messages[stage]));
+				puts(gettext(staged_analyze[stage].message));
 				fflush(stdout);
 			}
-			executeCommand(conn, stage_commands[stage], progname, echo);
-			run_vacuum_command(conn, sql.data, echo, dbname, table, progname);
-		}
 
+			run_parallel_vacuum(echo, tables, vacopts,
+								concurrentCons, stage, slots,
+								dbname, progname);
+		}
 	}
 	else
-		run_vacuum_command(conn, sql.data, echo, dbname, NULL, progname);
+		run_parallel_vacuum(echo, tables, vacopts,
+							concurrentCons, ANALYZE_ALL_STAGES, slots,
+							dbname, progname);
 
-	PQfinish(conn);
-	termPQExpBuffer(&sql);
+	for (i = 0; i < concurrentCons; i++)
+		DisconnectDatabase(&slots[i]);
+
+	pfree(slots);
 }
 
-
 static void
-vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
-			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
-					 const char *host, const char *port,
-					 const char *username, enum trivalue prompt_password,
+vacuum_all_databases(vacuumingOptions *vacopts,
+					 bool analyze_in_stages,
+					 const char *maintenance_db, const char *host,
+					 const char *port, const char *username,
+					 enum trivalue prompt_password,
+					 int concurrentCons,
 					 const char *progname, bool echo, bool quiet)
 {
 	PGconn	   *conn;
 	PGresult   *result;
 	int			stage;
+	int			i;
 
 	conn = connectMaintenanceDatabase(maintenance_db, host, port,
 									  username, prompt_password, progname);
-	result = executeQuery(conn, "SELECT datname FROM pg_database WHERE datallowconn ORDER BY 1;", progname, echo);
+	result = executeQuery(conn,
+						  "SELECT datname FROM pg_database WHERE datallowconn ORDER BY 1;",
+						  progname, echo);
 	PQfinish(conn);
 
-	/* If analyzing in stages, then run through all stages.  Otherwise just
-	 * run once, passing -1 as the stage. */
-	for (stage = (analyze_in_stages ? 0 : -1);
-		 stage < (analyze_in_stages ? 3 : 0);
-		 stage++)
+	if (analyze_in_stages)
 	{
-		int			i;
+		for (stage = 0; stage < 3; stage++)
+		{
+			for (i = 0; i < PQntuples(result); i++)
+			{
+				const char *dbname;
 
+				dbname = PQgetvalue(result, i, 0);
+				vacuum_database_stage(dbname, vacopts,
+									  analyze_in_stages, stage,
+									  NULL,
+									  host, port, username, prompt_password,
+									  concurrentCons,
+									  progname, echo, quiet);
+			}
+		}
+	}
+	else
+	{
 		for (i = 0; i < PQntuples(result); i++)
 		{
-			char	   *dbname = PQgetvalue(result, i, 0);
+			const char *dbname;
 
-			if (!quiet)
-			{
-				printf(_("%s: vacuuming database \"%s\"\n"), progname, dbname);
-				fflush(stdout);
-			}
-
-			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
-								analyze_in_stages, stage,
-							freeze, NULL, host, port, username, prompt_password,
-								progname, echo, quiet);
+			dbname = PQgetvalue(result, i, 0);
+			vacuum_database_stage(dbname, vacopts,
+								  analyze_in_stages, ANALYZE_ALL_STAGES,
+								  NULL,
+								  host, port, username, prompt_password,
+								  concurrentCons,
+								  progname, echo, quiet);
 		}
 	}
 
 	PQclear(result);
 }
 
+static void
+vacuum_database_stage(const char *dbname, vacuumingOptions *vacopts,
+					  bool analyze_in_stages, int stage,
+					  SimpleStringList *tables,
+					  const char *host, const char *port, const char *username,
+					  enum trivalue prompt_password,
+					  int concurrentCons,
+					  const char *progname, bool echo, bool quiet)
+{
+	if (!quiet)
+	{
+		printf(_("%s: vacuuming database \"%s\"\n"), progname, dbname);
+		fflush(stdout);
+	}
+
+	if (concurrentCons > 1)
+		vacuum_one_database_parallel(dbname, vacopts,
+									 analyze_in_stages, stage,
+									 tables,
+									 host, port, username, prompt_password,
+									 concurrentCons,
+									 progname, echo, quiet);
+	else
+		vacuum_one_database(dbname, vacopts,
+							analyze_in_stages, stage,
+							tables,
+							host, port, username, prompt_password,
+							progname, echo, quiet);
+}
+
+/*
+ * run_parallel_vacuum
+ *
+ * This function does the actual work for sending the jobs concurrently to
+ * server.
+ */
+static void
+run_parallel_vacuum(bool echo, SimpleStringList *tables,
+					vacuumingOptions *vacopts, int concurrentCons,
+					int analyze_stage, ParallelSlot slots[],
+					const char *dbname, const char *progname)
+{
+	PQExpBufferData sql;
+	SimpleStringListCell *cell;
+	int			i;
+
+	initPQExpBuffer(&sql);
+
+	if (analyze_stage >= 0)
+	{
+		for (i = 0; i < concurrentCons; i++)
+		{
+			executeCommand((slots + i)->connection,
+						   staged_analyze[analyze_stage].prepcmd,
+						   progname, echo);
+		}
+	}
+
+	for (cell = tables->head; cell; cell = cell->next)
+	{
+		ParallelSlot *free_slot;
+
+		if (CancelRequested)
+			goto fail;
+
+		/*
+		 * Get a free slot, waiting until one becomes free if none currently
+		 * is.
+		 */
+		free_slot = GetIdleSlot(slots, concurrentCons, dbname, progname);
+		if (!free_slot)
+			goto fail;
+
+		free_slot->isFree = false;
+
+		prepare_command(&sql, free_slot->connection, vacopts, cell->val);
+		run_vacuum_command(free_slot->connection, sql.data,
+						   echo, dbname, cell->val, progname, true);
+	}
+
+	for (i = 0; i < concurrentCons; i++)
+	{
+		/* wait for all connection to return the results */
+		if (!GetQueryResult((slots + i)->connection, dbname, progname))
+			goto fail;
+
+		(slots + i)->isFree = true;	/* XXX what's the point? */
+	}
+
+	if (false)
+	{
+fail:
+		for (i = 0; i < concurrentCons; i++)
+			DisconnectDatabase(slots + i);
+		exit(1);
+	}
+
+	termPQExpBuffer(&sql);
+}
+
+/*
+ * GetIdleSlot
+ *		Return a connection slot that is ready to execute a command.
+ *
+ * We return the first slot we find that is marked isFree, if one is;
+ * otherwise, we loop on select() until one socket becomes available.  When
+ * this happens, we read the whole set and mark as free all sockets that become
+ * available.
+ *
+ * Process the slot list, if any free slot is available then return the slotid
+ * else perform the select on all the socket's and wait until at least one slot
+ * becomes available.
+ *
+ * If an error occurs, NULL is returned.
+ */
+static ParallelSlot *
+GetIdleSlot(ParallelSlot slots[], int numslots, const char *dbname,
+			const char *progname)
+{
+	int		i;
+	int		firstFree = -1;
+	fd_set	slotset;
+	pgsocket maxFd;
+
+	for (i = 0; i < numslots; i++)
+		if ((slots + i)->isFree)
+			return slots + i;
+
+	FD_ZERO(&slotset);
+
+	maxFd = slots->sock;
+	for (i = 0; i < numslots; i++)
+	{
+		FD_SET((slots + i)->sock, &slotset);
+		if ((slots + i)->sock > maxFd)
+			maxFd = (slots + i)->sock;
+	}
+
+	/*
+	 * No free slot found, so wait until one of the connections has finished
+	 * its task and return the available slot.
+	 */
+	for (firstFree = -1; firstFree < 0; )
+	{
+		bool	aborting;
+
+		SetCancelConn(slots->connection);
+		i = select_loop(maxFd, &slotset, &aborting);
+		ResetCancelConn();
+
+		if (aborting)
+		{
+			/*
+			 * We set the cancel-receiving connection to the one in the zeroth
+			 * slot above, so fetch the error from there.
+			 */
+			GetQueryResult(slots->connection, dbname, progname);
+			return NULL;
+		}
+		Assert(i != 0);
+
+		for (i = 0; i < numslots; i++)
+		{
+			if (!FD_ISSET((slots + i)->sock, &slotset))
+				continue;
+
+			PQconsumeInput((slots + i)->connection);
+			if (PQisBusy((slots + i)->connection))
+				continue;
+
+			(slots + i)->isFree = true;
+
+			if (!GetQueryResult((slots + i)->connection, dbname, progname))
+				return NULL;
+
+			if (firstFree < 0)
+				firstFree = i;
+		}
+	}
+
+	return slots + firstFree;
+}
+
+/*
+ * GetQueryResult
+ *
+ * Process the query result.  Returns true if there's no error, false
+ * otherwise -- but errors about trying to vacuum a missing relation are
+ * reported and subsequently ignored.
+ */
+static bool
+GetQueryResult(PGconn *conn, const char *dbname, const char *progname)
+{
+	PGresult    *result;
+
+	SetCancelConn(conn);
+	while ((result = PQgetResult(conn)) != NULL)
+	{
+		/*
+		 * If errors are found, report them.  Errors about a missing table are
+		 * harmless so we continue processing; but die for other errors.
+		 */
+		if (PQresultStatus(result) != PGRES_COMMAND_OK)
+		{
+			char *sqlState = PQresultErrorField(result, PG_DIAG_SQLSTATE);
+
+			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
+					progname, dbname, PQerrorMessage(conn));
+
+			if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0)
+			{
+				PQclear(result);
+				return false;
+			}
+		}
+
+		PQclear(result);
+	}
+	ResetCancelConn();
+
+	return true;
+}
+
+/*
+ * Loop on select() until a descriptor from the given set becomes readable.
+ *
+ * If we get a cancel request while we're waiting, we forego all further
+ * processing and set the *aborting flag to true.  The return value must be
+ * ignored in this case.  Otherwise, *aborting is set to false.
+ */
+static int
+select_loop(int maxFd, fd_set *workerset, bool *aborting)
+{
+	int			i;
+	fd_set		saveSet = *workerset;
+
+	if (CancelRequested)
+	{
+		*aborting = true;
+		return -1;
+	}
+	else
+		*aborting = false;
+
+	for (;;)
+	{
+		/*
+		 * On Windows, we need to check once in a while for cancel requests; on
+		 * other platforms we rely on select() returning when interrupted.
+		 */
+		struct timeval *tvp;
+#ifdef WIN32
+		struct timeval tv;
+
+		tv = {0, 1000000};
+		tvp = &tv;
+#else
+		tvp = NULL;
+#endif
+
+		*workerset = saveSet;
+		i = select(maxFd + 1, workerset, NULL, NULL, tvp);
+
+#ifdef WIN32
+		if (i == SOCKET_ERROR)
+		{
+			i = -1;
+			TranslateSocketError();
+		}
+#endif
+
+		if (i < 0 && errno == EINTR)
+			continue;			/* ignore this */
+		if (i < 0 || CancelRequested)
+			*aborting = true;	/* but not this */
+		if (i == 0)
+			continue;			/* timeout (Win32 only) */
+		break;
+	}
+
+	return i;
+}
+
+/*
+ * DisconnectDatabase
+ *		Disconnect the connection associated with the given slot
+ */
+static void
+DisconnectDatabase(ParallelSlot *slot)
+{
+	char		errbuf[256];
+
+	if (!slot->connection)
+		return;
+
+	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+	{
+		PGcancel   *cancel;
+
+		if ((cancel = PQgetCancel(slot->connection)))
+		{
+			PQcancel(cancel, errbuf, sizeof(errbuf));
+			PQfreeCancel(cancel);
+		}
+	}
+
+	PQfinish(slot->connection);
+	slot->connection = NULL;
+}
+
+/*
+ * Construct a vacuum/analyze command to run based on the given options, in the
+ * given string buffer, which may contain previous garbage.
+ *
+ * An optional table name can be passed; this must be already be properly
+ * quoted.  The command is semicolon-terminated.
+ */
+static void
+prepare_command(PQExpBuffer sql, PGconn *conn, vacuumingOptions *vacopts,
+				const char *table)
+{
+	resetPQExpBuffer(sql);
+
+	if (vacopts->analyze_only)
+	{
+		appendPQExpBufferStr(sql, "ANALYZE");
+		if (vacopts->verbose)
+			appendPQExpBufferStr(sql, " VERBOSE");
+	}
+	else
+	{
+		appendPQExpBufferStr(sql, "VACUUM");
+		if (PQserverVersion(conn) >= 90000)
+		{
+			const char *paren = " (";
+			const char *comma = ", ";
+			const char *sep = paren;
+
+			if (vacopts->full)
+			{
+				appendPQExpBuffer(sql, "%sFULL", sep);
+				sep = comma;
+			}
+			if (vacopts->freeze)
+			{
+				appendPQExpBuffer(sql, "%sFREEZE", sep);
+				sep = comma;
+			}
+			if (vacopts->verbose)
+			{
+				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+				sep = comma;
+			}
+			if (vacopts->and_analyze)
+			{
+				appendPQExpBuffer(sql, "%sANALYZE", sep);
+				sep = comma;
+			}
+			if (sep != paren)
+				appendPQExpBufferStr(sql, ")");
+		}
+		else
+		{
+			if (vacopts->full)
+				appendPQExpBufferStr(sql, " FULL");
+			if (vacopts->freeze)
+				appendPQExpBufferStr(sql, " FREEZE");
+			if (vacopts->verbose)
+				appendPQExpBufferStr(sql, " VERBOSE");
+			if (vacopts->and_analyze)
+				appendPQExpBufferStr(sql, " ANALYZE");
+		}
+	}
+
+	if (table)
+		appendPQExpBuffer(sql, " %s;", table);
+}
 
 static void
 help(const char *progname)
@@ -436,6 +1016,7 @@ help(const char *progname)
 	printf(_("  -V, --version                   output version information, then exit\n"));
 	printf(_("  -z, --analyze                   update optimizer statistics\n"));
 	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
 	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
 		   "                                  stages for faster results\n"));
 	printf(_("  -?, --help                      show this help, then exit\n"));

*** a/doc/src/sgml/ref/vacuumdb.sgml
--- b/doc/src/sgml/ref/vacuumdb.sgml
***************
*** 204,209 **** PostgreSQL documentation
--- 204,228 ----
       </varlistentry>
  
       <varlistentry>
+       <term><option>-j <replaceable class="parameter">jobs</replaceable></option></term>
+       <term><option>--jobs=<replaceable class="parameter">njobs</replaceable></option></term>
+       <listitem>
+        <para>
+         This option will enable the vacuum operation to run on concurrent
+         connections. Maximum number of tables can be vacuumed concurrently
+         is equal to number of jobs. If number of jobs given is more than
+         number of tables then number of jobs will be set to number of tables.
+        </para>
+        <para>
+         <application>vacuumdb</application> will open
+         <replaceable class="parameter"> njobs</replaceable> connections to the
+         database, so make sure your <xref linkend="guc-max-connections">
+         setting is high enough to accommodate all connections.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
+      <varlistentry>
        <term><option>--analyze-in-stages</option></term>
        <listitem>
         <para>
*** a/src/backend/port/win32/socket.c
--- b/src/backend/port/win32/socket.c
***************
*** 42,48 **** int			pgwin32_noblock = 0;
  /*
   * Convert the last socket error code into errno
   */
! static void
  TranslateSocketError(void)
  {
  	switch (WSAGetLastError())
--- 42,48 ----
  /*
   * Convert the last socket error code into errno
   */
! void
  TranslateSocketError(void)
  {
  	switch (WSAGetLastError())
*** a/src/bin/pg_dump/parallel.c
--- b/src/bin/pg_dump/parallel.c
***************
*** 1160,1166 **** select_loop(int maxFd, fd_set *workerset)
  		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
  
  		/*
! 		 * If we Ctrl-C the master process , it's likely that we interrupt
  		 * select() here. The signal handler will set wantAbort == true and
  		 * the shutdown journey starts from here. Note that we'll come back
  		 * here later when we tell all workers to terminate and read their
--- 1160,1166 ----
  		i = select(maxFd + 1, workerset, NULL, NULL, NULL);
  
  		/*
! 		 * If we Ctrl-C the master process, it's likely that we interrupt
  		 * select() here. The signal handler will set wantAbort == true and
  		 * the shutdown journey starts from here. Note that we'll come back
  		 * here later when we tell all workers to terminate and read their
*** a/src/bin/scripts/common.c
--- b/src/bin/scripts/common.c
***************
*** 19,28 ****
  
  #include "common.h"
  
- static void SetCancelConn(PGconn *conn);
- static void ResetCancelConn(void);
  
  static PGcancel *volatile cancelConn = NULL;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
--- 19,27 ----
  
  #include "common.h"
  
  
  static PGcancel *volatile cancelConn = NULL;
+ bool CancelRequested = false;
  
  #ifdef WIN32
  static CRITICAL_SECTION cancelConnLock;
***************
*** 291,297 **** yesno_prompt(const char *question)
   *
   * Set cancelConn to point to the current database connection.
   */
! static void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
--- 290,296 ----
   *
   * Set cancelConn to point to the current database connection.
   */
! void
  SetCancelConn(PGconn *conn)
  {
  	PGcancel   *oldCancelConn;
***************
*** 321,327 **** SetCancelConn(PGconn *conn)
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! static void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
--- 320,326 ----
   *
   * Free the current cancel connection, if any, and set to NULL.
   */
! void
  ResetCancelConn(void)
  {
  	PGcancel   *oldCancelConn;
***************
*** 345,353 **** ResetCancelConn(void)
  
  #ifndef WIN32
  /*
!  * Handle interrupt signals by canceling the current command,
!  * if it's being executed through executeMaintenanceCommand(),
!  * and thus has a cancelConn set.
   */
  static void
  handle_sigint(SIGNAL_ARGS)
--- 344,351 ----
  
  #ifndef WIN32
  /*
!  * Handle interrupt signals by canceling the current command, if a cancelConn
!  * is set.
   */
  static void
  handle_sigint(SIGNAL_ARGS)
***************
*** 359,368 **** handle_sigint(SIGNAL_ARGS)
--- 357,371 ----
  	if (cancelConn != NULL)
  	{
  		if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 		{
+ 			CancelRequested = true;
  			fprintf(stderr, _("Cancel request sent\n"));
+ 		}
  		else
  			fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  	}
+ 	else
+ 		CancelRequested = true;
  
  	errno = save_errno;			/* just in case the write changed it */
  }
***************
*** 392,401 **** consoleHandler(DWORD dwCtrlType)
--- 395,410 ----
  		if (cancelConn != NULL)
  		{
  			if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ 			{
  				fprintf(stderr, _("Cancel request sent\n"));
+ 				CancelRequested = true;
+ 			}
  			else
  				fprintf(stderr, _("Could not send cancel request: %s"), errbuf);
  		}
+ 		else
+ 			CancelRequested = true;
+ 
  		LeaveCriticalSection(&cancelConnLock);
  
  		return TRUE;
*** a/src/bin/scripts/common.h
--- b/src/bin/scripts/common.h
***************
*** 21,26 **** enum trivalue
--- 21,28 ----
  	TRI_YES
  };
  
+ extern bool CancelRequested;
+ 
  typedef void (*help_handler) (const char *progname);
  
  extern void handle_help_version_opts(int argc, char *argv[],
***************
*** 49,52 **** extern bool yesno_prompt(const char *question);
--- 51,58 ----
  
  extern void setup_cancel_handler(void);
  
+ extern void SetCancelConn(PGconn *conn);
+ extern void ResetCancelConn(void);
+ 
+ 
  #endif   /* COMMON_H */
*** a/src/bin/scripts/vacuumdb.c
--- b/src/bin/scripts/vacuumdb.c
***************
*** 11,34 ****
   */
  
  #include "postgres_fe.h"
  #include "common.h"
  #include "dumputils.h"
  
  
! static void vacuum_one_database(const char *dbname, bool full, bool verbose,
! 	bool and_analyze, bool analyze_only, bool analyze_in_stages, int stage, bool freeze,
! 					const char *table, const char *host, const char *port,
  					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo, bool quiet);
! static void vacuum_all_databases(bool full, bool verbose, bool and_analyze,
! 					 bool analyze_only, bool analyze_in_stages, bool freeze,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
  					 const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
  
  int
  main(int argc, char *argv[])
--- 11,111 ----
   */
  
  #include "postgres_fe.h"
+ 
  #include "common.h"
  #include "dumputils.h"
  
  
! #define ERRCODE_UNDEFINED_TABLE  "42P01"
! 
! /* Parallel vacuuming stuff */
! typedef struct ParallelSlot
! {
! 	PGconn *connection;
! 	pgsocket sock;
! 	bool isFree;
! } ParallelSlot;
! 
! /* vacuum options controlled by user flags */
! typedef struct vacuumingOptions
! {
! 	bool	analyze_only;
! 	bool	verbose;
! 	bool	and_analyze;
! 	bool	full;
! 	bool	freeze;
! } vacuumingOptions;
! 
! 
! static void vacuum_one_database(const char *dbname, vacuumingOptions *vacopts,
! 					bool analyze_in_stages, int stage,
! 					SimpleStringList *tables,
! 					const char *host, const char *port,
  					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo, bool quiet,
! 					int concurrentCons);
! 
! static void vacuum_all_databases(vacuumingOptions *vacopts,
! 					 bool analyze_in_stages,
  					 const char *maintenance_db,
  					 const char *host, const char *port,
  					 const char *username, enum trivalue prompt_password,
+ 					 int concurrentCons,
  					 const char *progname, bool echo, bool quiet);
+ static void vacuum_database_stage(const char *dbname, vacuumingOptions *vacopts,
+ 					  bool analyze_in_stages, int stage,
+ 					  SimpleStringList *tables,
+ 					  const char *host, const char *port, const char *username,
+ 					  enum trivalue prompt_password,
+ 					  int concurrentCons,
+ 					  const char *progname, bool echo, bool quiet);
  
  static void help(const char *progname);
  
+ static void prepare_command(PQExpBuffer sql, PGconn *conn,
+ 				vacuumingOptions *vacopts, const char *table);
+ 
+ static ParallelSlot *GetIdleSlot(ParallelSlot slots[], int numslots,
+ 			const char *dbname, const char *progname);
+ 
+ static bool GetQueryResult(PGconn *conn, const char *dbname,
+ 			   const char *progname);
+ 
+ static int select_loop(int maxFd, fd_set *workerset, bool *aborting);
+ 
+ static void DisconnectDatabase(ParallelSlot *slot);
+ static void init_slot(ParallelSlot *slot, PGconn *conn);
+ 
+ 
+ 
+ /*
+  * Preparatory commands and corresponding user-visible message for the
+  * analyze-in-stages feature.  Note the ANALYZE command itself must be sent
+  * separately.
+  */
+ static const struct
+ {
+ 	const char *prepcmd;
+ 	const char *message;
+ }
+ staged_analyze[3] =
+ {
+ 	{
+ 		"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
+ 		gettext_noop("Generating minimal optimizer statistics (1 target)")
+ 	},
+ 	{
+ 		"SET default_statistics_target=10; RESET vacuum_cost_delay;",
+ 		gettext_noop("Generating medium optimizer statistics (10 targets)")
+ 	},
+ 	{
+ 		"RESET default_statistics_target;",
+ 		gettext_noop("Generating default (full) optimizer statistics")
+ 	}
+ };
+ 
+ #define ANALYZE_ALL_STAGES	-1
+ 
  
  int
  main(int argc, char *argv[])
***************
*** 49,54 **** main(int argc, char *argv[])
--- 126,132 ----
  		{"table", required_argument, NULL, 't'},
  		{"full", no_argument, NULL, 'f'},
  		{"verbose", no_argument, NULL, 'v'},
+ 		{"jobs", required_argument, NULL, 'j'},
  		{"maintenance-db", required_argument, NULL, 2},
  		{"analyze-in-stages", no_argument, NULL, 3},
  		{NULL, 0, NULL, 0}
***************
*** 57,63 **** main(int argc, char *argv[])
  	const char *progname;
  	int			optindex;
  	int			c;
- 
  	const char *dbname = NULL;
  	const char *maintenance_db = NULL;
  	char	   *host = NULL;
--- 135,140 ----
***************
*** 66,86 **** main(int argc, char *argv[])
  	enum trivalue prompt_password = TRI_DEFAULT;
  	bool		echo = false;
  	bool		quiet = false;
! 	bool		and_analyze = false;
! 	bool		analyze_only = false;
  	bool		analyze_in_stages = false;
- 	bool		freeze = false;
  	bool		alldb = false;
- 	bool		full = false;
- 	bool		verbose = false;
  	SimpleStringList tables = {NULL, NULL};
  
  	progname = get_progname(argv[0]);
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fv", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
--- 143,165 ----
  	enum trivalue prompt_password = TRI_DEFAULT;
  	bool		echo = false;
  	bool		quiet = false;
! 	vacuumingOptions vacopts;
  	bool		analyze_in_stages = false;
  	bool		alldb = false;
  	SimpleStringList tables = {NULL, NULL};
+ 	int concurrentCons = 0;
+ 	int tbl_count = 0;
+ 
+ 	/* initialize options to all false */
+ 	memset(&vacopts, 0, sizeof(vacopts));
  
  	progname = get_progname(argv[0]);
+ 
  	set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
  
  	handle_help_version_opts(argc, argv, "vacuumdb", help);
  
! 	while ((c = getopt_long(argc, argv, "h:p:U:wWeqd:zZFat:fvj:", long_options, &optindex)) != -1)
  	{
  		switch (c)
  		{
***************
*** 109,139 **** main(int argc, char *argv[])
  				dbname = pg_strdup(optarg);
  				break;
  			case 'z':
! 				and_analyze = true;
  				break;
  			case 'Z':
! 				analyze_only = true;
  				break;
  			case 'F':
! 				freeze = true;
  				break;
  			case 'a':
  				alldb = true;
  				break;
  			case 't':
  				simple_string_list_append(&tables, optarg);
  				break;
  			case 'f':
! 				full = true;
  				break;
  			case 'v':
! 				verbose = true;
  				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
  			case 3:
! 				analyze_in_stages = analyze_only = true;
  				break;
  			default:
  				fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
--- 188,230 ----
  				dbname = pg_strdup(optarg);
  				break;
  			case 'z':
! 				vacopts.and_analyze = true;
  				break;
  			case 'Z':
! 				vacopts.analyze_only = true;
  				break;
  			case 'F':
! 				vacopts.freeze = true;
  				break;
  			case 'a':
  				alldb = true;
  				break;
  			case 't':
+ 			{
  				simple_string_list_append(&tables, optarg);
+ 				tbl_count++;
  				break;
+ 			}
  			case 'f':
! 				vacopts.full = true;
  				break;
  			case 'v':
! 				vacopts.verbose = true;
! 				break;
! 			case 'j':
! 				concurrentCons = atoi(optarg);
! 				if (concurrentCons <= 0)
! 				{
! 					fprintf(stderr, _("%s: number of parallel \"jobs\" must be at least 1\n"),
! 							progname);
! 					exit(1);
! 				}
  				break;
  			case 2:
  				maintenance_db = pg_strdup(optarg);
  				break;
  			case 3:
! 				analyze_in_stages = vacopts.analyze_only = true;
  				break;
  			default:
  				fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
***************
*** 141,147 **** main(int argc, char *argv[])
  		}
  	}
  
- 
  	/*
  	 * Non-option argument specifies database name as long as it wasn't
  	 * already specified with -d / --dbname
--- 232,237 ----
***************
*** 160,177 **** main(int argc, char *argv[])
  		exit(1);
  	}
  
! 	if (analyze_only)
  	{
! 		if (full)
  		{
! 			fprintf(stderr, _("%s: cannot use the \"full\" option when performing only analyze\n"),
! 					progname);
  			exit(1);
  		}
! 		if (freeze)
  		{
! 			fprintf(stderr, _("%s: cannot use the \"freeze\" option when performing only analyze\n"),
! 					progname);
  			exit(1);
  		}
  		/* allow 'and_analyze' with 'analyze_only' */
--- 250,267 ----
  		exit(1);
  	}
  
! 	if (vacopts.analyze_only)
  	{
! 		if (vacopts.full)
  		{
! 			fprintf(stderr, _("%s: cannot use the \"%s\" option when performing only analyze\n"),
! 					progname, "full");
  			exit(1);
  		}
! 		if (vacopts.freeze)
  		{
! 			fprintf(stderr, _("%s: cannot use the \"%s\" option when performing only analyze\n"),
! 					progname, "freeze");
  			exit(1);
  		}
  		/* allow 'and_analyze' with 'analyze_only' */
***************
*** 179,184 **** main(int argc, char *argv[])
--- 269,278 ----
  
  	setup_cancel_handler();
  
+ 	/* Avoid opening extra connections. */
+ 	if (tbl_count && (concurrentCons > tbl_count))
+ 		concurrentCons = tbl_count;
+ 
  	if (alldb)
  	{
  		if (dbname)
***************
*** 194,202 **** main(int argc, char *argv[])
  			exit(1);
  		}
  
! 		vacuum_all_databases(full, verbose, and_analyze, analyze_only, analyze_in_stages, freeze,
! 							 maintenance_db, host, port, username,
! 							 prompt_password, progname, echo, quiet);
  	}
  	else
  	{
--- 288,299 ----
  			exit(1);
  		}
  
! 		vacuum_all_databases(&vacopts,
! 							 analyze_in_stages,
! 							 maintenance_db,
! 							 host, port, username, prompt_password,
! 							 concurrentCons,
! 							 progname, echo, quiet);
  	}
  	else
  	{
***************
*** 210,244 **** main(int argc, char *argv[])
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		if (tables.head != NULL)
! 		{
! 			SimpleStringListCell *cell;
! 
! 			for (cell = tables.head; cell; cell = cell->next)
! 			{
! 				vacuum_one_database(dbname, full, verbose, and_analyze,
! 									analyze_only, analyze_in_stages, -1,
! 									freeze, cell->val,
! 									host, port, username, prompt_password,
! 									progname, echo, quiet);
! 			}
! 		}
! 		else
! 			vacuum_one_database(dbname, full, verbose, and_analyze,
! 								analyze_only, analyze_in_stages, -1,
! 								freeze, NULL,
! 								host, port, username, prompt_password,
! 								progname, echo, quiet);
  	}
  
  	exit(0);
  }
  
! 
  static void
! run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname, const char *table, const char *progname)
  {
! 	if (!executeMaintenanceCommand(conn, sql, echo))
  	{
  		if (table)
  			fprintf(stderr, _("%s: vacuuming of table \"%s\" in database \"%s\" failed: %s"),
--- 307,341 ----
  				dbname = get_user_name_or_exit(progname);
  		}
  
! 		vacuum_database_stage(dbname, &vacopts,
! 							  analyze_in_stages, ANALYZE_ALL_STAGES,
! 							  &tables,
! 							  host, port, username, prompt_password,
! 							  concurrentCons,
! 							  progname, echo, quiet);
  	}
  
  	exit(0);
  }
  
! /*
!  * Execute a vacuum/analyze command to the server.
!  *
!  * Result status is checked only if 'async' is false.
!  */
  static void
! run_vacuum_command(PGconn *conn, const char *sql, bool echo,
! 				   const char *dbname, const char *table,
! 				   const char *progname, bool async)
  {
! 	if (async)
! 	{
! 		if (echo)
! 			printf("%s\n", sql);
! 
! 		PQsendQuery(conn, sql);
! 	}
! 	else if (!executeMaintenanceCommand(conn, sql, echo))
  	{
  		if (table)
  			fprintf(stderr, _("%s: vacuuming of table \"%s\" in database \"%s\" failed: %s"),
***************
*** 251,422 **** run_vacuum_command(PGconn *conn, const char *sql, bool echo, const char *dbname,
  	}
  }
  
! 
  static void
! vacuum_one_database(const char *dbname, bool full, bool verbose, bool and_analyze,
! 	bool analyze_only, bool analyze_in_stages, int stage, bool freeze, const char *table,
  					const char *host, const char *port,
  					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo, bool quiet)
  {
  	PQExpBufferData sql;
- 
  	PGconn	   *conn;
! 
! 	initPQExpBuffer(&sql);
  
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	if (analyze_only)
  	{
! 		appendPQExpBufferStr(&sql, "ANALYZE");
! 		if (verbose)
! 			appendPQExpBufferStr(&sql, " VERBOSE");
  	}
! 	else
  	{
! 		appendPQExpBufferStr(&sql, "VACUUM");
! 		if (PQserverVersion(conn) >= 90000)
  		{
! 			const char *paren = " (";
! 			const char *comma = ", ";
! 			const char *sep = paren;
  
! 			if (full)
  			{
! 				appendPQExpBuffer(&sql, "%sFULL", sep);
! 				sep = comma;
  			}
! 			if (freeze)
  			{
! 				appendPQExpBuffer(&sql, "%sFREEZE", sep);
! 				sep = comma;
  			}
! 			if (verbose)
  			{
! 				appendPQExpBuffer(&sql, "%sVERBOSE", sep);
! 				sep = comma;
  			}
! 			if (and_analyze)
  			{
! 				appendPQExpBuffer(&sql, "%sANALYZE", sep);
! 				sep = comma;
  			}
- 			if (sep != paren)
- 				appendPQExpBufferStr(&sql, ")");
- 		}
- 		else
- 		{
- 			if (full)
- 				appendPQExpBufferStr(&sql, " FULL");
- 			if (freeze)
- 				appendPQExpBufferStr(&sql, " FREEZE");
- 			if (verbose)
- 				appendPQExpBufferStr(&sql, " VERBOSE");
- 			if (and_analyze)
- 				appendPQExpBufferStr(&sql, " ANALYZE");
  		}
- 	}
- 	if (table)
- 		appendPQExpBuffer(&sql, " %s", table);
- 	appendPQExpBufferStr(&sql, ";");
  
! 	if (analyze_in_stages)
! 	{
! 		const char *stage_commands[] = {
! 			"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
! 			"SET default_statistics_target=10; RESET vacuum_cost_delay;",
! 			"RESET default_statistics_target;"
! 		};
! 		const char *stage_messages[] = {
! 			gettext_noop("Generating minimal optimizer statistics (1 target)"),
! 			gettext_noop("Generating medium optimizer statistics (10 targets)"),
! 			gettext_noop("Generating default (full) optimizer statistics")
! 		};
! 
! 		if (stage == -1)
  		{
! 			int		i;
  
! 			/* Run all stages. */
! 			for (i = 0; i < 3; i++)
  			{
! 				if (!quiet)
  				{
! 					puts(gettext(stage_messages[i]));
! 					fflush(stdout);
  				}
! 				executeCommand(conn, stage_commands[i], progname, echo);
! 				run_vacuum_command(conn, sql.data, echo, dbname, table, progname);
  			}
! 		}
! 		else
  		{
! 			/* Otherwise, we got a stage from vacuum_all_databases(), so run
! 			 * only that one. */
! 			if (!quiet)
  			{
! 				puts(gettext(stage_messages[stage]));
! 				fflush(stdout);
  			}
- 			executeCommand(conn, stage_commands[stage], progname, echo);
- 			run_vacuum_command(conn, sql.data, echo, dbname, table, progname);
  		}
  
  	}
  	else
! 		run_vacuum_command(conn, sql.data, echo, dbname, NULL, progname);
  
- 	PQfinish(conn);
  	termPQExpBuffer(&sql);
  }
  
  
  static void
! vacuum_all_databases(bool full, bool verbose, bool and_analyze, bool analyze_only,
! 			 bool analyze_in_stages, bool freeze, const char *maintenance_db,
! 					 const char *host, const char *port,
! 					 const char *username, enum trivalue prompt_password,
  					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
  	int			stage;
  
  	conn = connectMaintenanceDatabase(maintenance_db, host, port,
  									  username, prompt_password, progname);
! 	result = executeQuery(conn, "SELECT datname FROM pg_database WHERE datallowconn ORDER BY 1;", progname, echo);
  	PQfinish(conn);
  
! 	/* If analyzing in stages, then run through all stages.  Otherwise just
! 	 * run once, passing -1 as the stage. */
! 	for (stage = (analyze_in_stages ? 0 : -1);
! 		 stage < (analyze_in_stages ? 3 : 0);
! 		 stage++)
  	{
- 		int			i;
- 
  		for (i = 0; i < PQntuples(result); i++)
  		{
! 			char	   *dbname = PQgetvalue(result, i, 0);
  
! 			if (!quiet)
  			{
! 				printf(_("%s: vacuuming database \"%s\"\n"), progname, dbname);
! 				fflush(stdout);
  			}
  
! 			vacuum_one_database(dbname, full, verbose, and_analyze, analyze_only,
! 								analyze_in_stages, stage,
! 							freeze, NULL, host, port, username, prompt_password,
! 								progname, echo, quiet);
  		}
  	}
  
! 	PQclear(result);
  }
  
  
  static void
  help(const char *progname)
--- 348,914 ----
  	}
  }
  
! /*
!  * vacuum_one_database
!  *
!  * Process tables in the given database.  If the 'tables' list is empty,
!  * process all tables in the database.  Note there is no paralellization here.
!  */
  static void
! vacuum_one_database(const char *dbname, vacuumingOptions *vacopts,
! 					bool analyze_in_stages, int stage,
! 					SimpleStringList *tables,
  					const char *host, const char *port,
  					const char *username, enum trivalue prompt_password,
! 					const char *progname, bool echo, bool quiet,
! 					int concurrentCons)
  {
  	PQExpBufferData sql;
  	PGconn	   *conn;
! 	SimpleStringListCell *cell;
! 	ParallelSlot *slots = NULL;
! 	SimpleStringList dbtables = {NULL, NULL};
! 	int			i;
! 	bool result = 0;
  
  	conn = connectDatabase(dbname, host, port, username, prompt_password,
  						   progname, false);
  
! 	initPQExpBuffer(&sql);
! 
! 	/*
! 	 * If a table list is not provided and concurrentCons option is given
! 	 * then we need to vacuum the whole database, prepare the list of tables.
! 	 */
! 	if (concurrentCons && (!tables || !tables->head))
  	{
! 		PQExpBufferData buf;
! 		PGresult *res;
! 		int		ntups;
! 		int		i;
! 
! 		initPQExpBuffer(&buf);
! 
! 		res = executeQuery(conn,
! 				"SELECT c.relname, ns.nspname FROM pg_class c, pg_namespace ns\n"
! 				" WHERE relkind IN (\'r\', \'m\') AND c.relnamespace = ns.oid\n"
! 				" ORDER BY c.relpages DESC",
! 				progname, echo);
! 
! 		ntups = PQntuples(res);
! 		for (i = 0; i < ntups; i++)
! 		{
! 			appendPQExpBuffer(&buf, "%s",
! 							  fmtQualifiedId(PQserverVersion(conn),
! 											 PQgetvalue(res, i, 1),
! 											 PQgetvalue(res, i, 0)));
! 
! 			simple_string_list_append(&dbtables, buf.data);
! 			resetPQExpBuffer(&buf);
! 		}
! 
! 		termPQExpBuffer(&buf);
! 		tables = &dbtables;
! 
! 		/*
! 		 * If there are more connections than vacuumable relations, we don't
! 		 * need to use them all.
! 		 */
! 		if (concurrentCons > ntups)
! 			concurrentCons = ntups;
  	}
! 
! 	if (concurrentCons)
  	{
! 		slots = (ParallelSlot *) pg_malloc(sizeof(ParallelSlot) * concurrentCons);
! 		init_slot(slots, conn);
! 
! 		for (i = 1; i < concurrentCons; i++)
  		{
! 			conn = connectDatabase(dbname, host, port, username, prompt_password,
! 								   progname, false);
! 			init_slot(slots + i, conn);
! 		}
! 	}
! 
! 	for (i = 0; i < 3; i++)
! 	{
! 		cell = tables ? tables->head : NULL;
! 
! 		if (analyze_in_stages)
! 		{
! 			int currentStage;
  
! 			if (stage == ANALYZE_ALL_STAGES)
  			{
! 				currentStage = i;
  			}
! 			else
  			{
! 				currentStage = stage;
  			}
! 
! 			if (!quiet)
  			{
! 				puts(gettext(staged_analyze[currentStage].message));
! 				fflush(stdout);
  			}
! 
! 			if (concurrentCons)
  			{
! 				int j;
! 				for (j = 0; j < concurrentCons; j++)
! 				{
! 					executeCommand((slots + j)->connection,
! 						staged_analyze[currentStage].prepcmd, progname, echo);
! 				}
! 			}
! 			else
! 			{
! 				executeCommand(conn, staged_analyze[currentStage].prepcmd, progname, echo);
  			}
  		}
  
! 		do
  		{
! 			const char *tabname;
! 			tabname = cell ? cell->val : NULL;
! 			prepare_command(&sql, conn, vacopts, tabname);
  
! 			if (concurrentCons)
  			{
! 				ParallelSlot *free_slot;
! 
! 				if (CancelRequested)
! 				{
! 					result = -1;
! 					goto finish;
! 				}
! 
! 				/*
! 				 * Get a free slot, waiting until one becomes free if none currently
! 				 * is.
! 				 */
! 				free_slot = GetIdleSlot(slots, concurrentCons, dbname, progname);
! 				if (!free_slot)
  				{
! 					result = -1;
! 					goto finish;
  				}
! 
! 				free_slot->isFree = false;
! 
! 				run_vacuum_command(free_slot->connection, sql.data,
! 								   echo, dbname, cell->val, progname, true);
  			}
! 			else
! 				run_vacuum_command(conn, sql.data, echo, dbname, NULL, progname, false);
! 
! 			if (cell)
! 				cell = cell->next;
! 		} while (cell != NULL);
! 
! 		if (concurrentCons)
  		{
! 			int j;
! 
! 			for (j = 0; j < concurrentCons; j++)
  			{
! 				/* wait for all connection to return the results */
! 				if (!GetQueryResult((slots + j)->connection, dbname, progname))
! 					goto finish;
! 
! 				(slots + j)->isFree = true;	/* XXX what's the point? */
  			}
  		}
  
+ 		if (!analyze_in_stages || stage != ANALYZE_ALL_STAGES)
+ 			break;
+ 	}
+ 
+ finish:
+ 	if (concurrentCons)
+ 	{
+ 		for (i = 0; i < concurrentCons; i++)
+ 			DisconnectDatabase(&slots[i]);
+ 
+ 		pfree(slots);
  	}
  	else
! 		PQfinish(conn);
  
  	termPQExpBuffer(&sql);
+ 
+ 	if (result == -1)
+ 		exit(1);
  }
  
+ static void
+ init_slot(ParallelSlot *slot, PGconn *conn)
+ {
+ 	slot->connection = conn;
+ 	slot->isFree = true;
+ 	slot->sock = PQsocket(conn);
+ }
  
  static void
! vacuum_all_databases(vacuumingOptions *vacopts,
! 					 bool analyze_in_stages,
! 					 const char *maintenance_db, const char *host,
! 					 const char *port, const char *username,
! 					 enum trivalue prompt_password,
! 					 int concurrentCons,
  					 const char *progname, bool echo, bool quiet)
  {
  	PGconn	   *conn;
  	PGresult   *result;
  	int			stage;
+ 	int			i;
  
  	conn = connectMaintenanceDatabase(maintenance_db, host, port,
  									  username, prompt_password, progname);
! 	result = executeQuery(conn,
! 						  "SELECT datname FROM pg_database WHERE datallowconn ORDER BY 1;",
! 						  progname, echo);
  	PQfinish(conn);
  
! 	if (analyze_in_stages)
! 	{
! 		for (stage = 0; stage < 3; stage++)
! 		{
! 			for (i = 0; i < PQntuples(result); i++)
! 			{
! 				const char *dbname;
! 
! 				dbname = PQgetvalue(result, i, 0);
! 				vacuum_database_stage(dbname, vacopts,
! 									  analyze_in_stages, stage,
! 									  NULL,
! 									  host, port, username, prompt_password,
! 									  concurrentCons,
! 									  progname, echo, quiet);
! 			}
! 		}
! 	}
! 	else
  	{
  		for (i = 0; i < PQntuples(result); i++)
  		{
! 			const char *dbname;
! 
! 			dbname = PQgetvalue(result, i, 0);
! 			vacuum_database_stage(dbname, vacopts,
! 								  analyze_in_stages, ANALYZE_ALL_STAGES,
! 								  NULL,
! 								  host, port, username, prompt_password,
! 								  concurrentCons,
! 								  progname, echo, quiet);
! 		}
! 	}
  
! 	PQclear(result);
! }
! 
! static void
! vacuum_database_stage(const char *dbname, vacuumingOptions *vacopts,
! 					  bool analyze_in_stages, int stage,
! 					  SimpleStringList *tables,
! 					  const char *host, const char *port, const char *username,
! 					  enum trivalue prompt_password,
! 					  int concurrentCons,
! 					  const char *progname, bool echo, bool quiet)
! {
! 	if (!quiet)
! 	{
! 		printf(_("%s: vacuuming database \"%s\"\n"), progname, dbname);
! 		fflush(stdout);
! 	}
! 
! 	vacuum_one_database(dbname, vacopts,
! 						analyze_in_stages, stage,
! 						tables,
! 						host, port, username, prompt_password,
! 						progname, echo, quiet, concurrentCons);
! }
! 
! /*
!  * GetIdleSlot
!  *		Return a connection slot that is ready to execute a command.
!  *
!  * We return the first slot we find that is marked isFree, if one is;
!  * otherwise, we loop on select() until one socket becomes available.  When
!  * this happens, we read the whole set and mark as free all sockets that become
!  * available.
!  *
!  * Process the slot list, if any free slot is available then return the slotid
!  * else perform the select on all the socket's and wait until at least one slot
!  * becomes available.
!  *
!  * If an error occurs, NULL is returned.
!  */
! static ParallelSlot *
! GetIdleSlot(ParallelSlot slots[], int numslots, const char *dbname,
! 			const char *progname)
! {
! 	int		i;
! 	int		firstFree = -1;
! 	fd_set	slotset;
! 	pgsocket maxFd;
! 
! 	for (i = 0; i < numslots; i++)
! 		if ((slots + i)->isFree)
! 			return slots + i;
! 
! 	FD_ZERO(&slotset);
! 
! 	maxFd = slots->sock;
! 	for (i = 0; i < numslots; i++)
! 	{
! 		FD_SET((slots + i)->sock, &slotset);
! 		if ((slots + i)->sock > maxFd)
! 			maxFd = (slots + i)->sock;
! 	}
! 
! 	/*
! 	 * No free slot found, so wait until one of the connections has finished
! 	 * its task and return the available slot.
! 	 */
! 	for (firstFree = -1; firstFree < 0; )
! 	{
! 		bool	aborting;
! 
! 		SetCancelConn(slots->connection);
! 		i = select_loop(maxFd, &slotset, &aborting);
! 		ResetCancelConn();
! 
! 		if (aborting)
! 		{
! 			/*
! 			 * We set the cancel-receiving connection to the one in the zeroth
! 			 * slot above, so fetch the error from there.
! 			 */
! 			GetQueryResult(slots->connection, dbname, progname);
! 			return NULL;
! 		}
! 		Assert(i != 0);
! 
! 		for (i = 0; i < numslots; i++)
! 		{
! 			if (!FD_ISSET((slots + i)->sock, &slotset))
! 				continue;
! 
! 			PQconsumeInput((slots + i)->connection);
! 			if (PQisBusy((slots + i)->connection))
! 				continue;
! 
! 			(slots + i)->isFree = true;
! 
! 			if (!GetQueryResult((slots + i)->connection, dbname, progname))
! 				return NULL;
! 
! 			if (firstFree < 0)
! 				firstFree = i;
! 		}
! 	}
! 
! 	return slots + firstFree;
! }
! 
! /*
!  * GetQueryResult
!  *
!  * Process the query result.  Returns true if there's no error, false
!  * otherwise -- but errors about trying to vacuum a missing relation are
!  * reported and subsequently ignored.
!  */
! static bool
! GetQueryResult(PGconn *conn, const char *dbname, const char *progname)
! {
! 	PGresult    *result;
! 
! 	SetCancelConn(conn);
! 	while ((result = PQgetResult(conn)) != NULL)
! 	{
! 		/*
! 		 * If errors are found, report them.  Errors about a missing table are
! 		 * harmless so we continue processing; but die for other errors.
! 		 */
! 		if (PQresultStatus(result) != PGRES_COMMAND_OK)
! 		{
! 			char *sqlState = PQresultErrorField(result, PG_DIAG_SQLSTATE);
! 
! 			fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
! 					progname, dbname, PQerrorMessage(conn));
! 
! 			if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0)
  			{
! 				PQclear(result);
! 				return false;
  			}
+ 		}
+ 
+ 		PQclear(result);
+ 	}
+ 	ResetCancelConn();
+ 
+ 	return true;
+ }
  
! /*
!  * Loop on select() until a descriptor from the given set becomes readable.
!  *
!  * If we get a cancel request while we're waiting, we forego all further
!  * processing and set the *aborting flag to true.  The return value must be
!  * ignored in this case.  Otherwise, *aborting is set to false.
!  */
! static int
! select_loop(int maxFd, fd_set *workerset, bool *aborting)
! {
! 	int			i;
! 	fd_set		saveSet = *workerset;
! 
! 	if (CancelRequested)
! 	{
! 		*aborting = true;
! 		return -1;
! 	}
! 	else
! 		*aborting = false;
! 
! 	for (;;)
! 	{
! 		/*
! 		 * On Windows, we need to check once in a while for cancel requests; on
! 		 * other platforms we rely on select() returning when interrupted.
! 		 */
! 		struct timeval *tvp;
! #ifdef WIN32
! 		struct timeval tv = {0, 1000000};
! 
! 		tvp = &tv;
! #else
! 		tvp = NULL;
! #endif
! 
! 		*workerset = saveSet;
! 		i = select(maxFd + 1, workerset, NULL, NULL, tvp);
! 
! #ifdef WIN32
! 		if (i == SOCKET_ERROR)
! 		{
! 			i = -1;
! 
! 			if (WSAGetLastError() == WSAEINTR)
! 				errno == EINTR;
  		}
+ #endif
+ 
+ 		if (i < 0 && errno == EINTR)
+ 			continue;			/* ignore this */
+ 		if (i < 0 || CancelRequested)
+ 			*aborting = true;	/* but not this */
+ 		if (i == 0)
+ 			continue;			/* timeout (Win32 only) */
+ 		break;
  	}
  
! 	return i;
  }
  
+ /*
+  * DisconnectDatabase
+  *		Disconnect the connection associated with the given slot
+  */
+ static void
+ DisconnectDatabase(ParallelSlot *slot)
+ {
+ 	char		errbuf[256];
+ 
+ 	if (!slot->connection)
+ 		return;
+ 
+ 	if (PQtransactionStatus(slot->connection) == PQTRANS_ACTIVE)
+ 	{
+ 		PGcancel   *cancel;
+ 
+ 		if ((cancel = PQgetCancel(slot->connection)))
+ 		{
+ 			PQcancel(cancel, errbuf, sizeof(errbuf));
+ 			PQfreeCancel(cancel);
+ 		}
+ 	}
+ 
+ 	PQfinish(slot->connection);
+ 	slot->connection = NULL;
+ }
+ 
+ /*
+  * Construct a vacuum/analyze command to run based on the given options, in the
+  * given string buffer, which may contain previous garbage.
+  *
+  * An optional table name can be passed; this must be already be properly
+  * quoted.  The command is semicolon-terminated.
+  */
+ static void
+ prepare_command(PQExpBuffer sql, PGconn *conn, vacuumingOptions *vacopts,
+ 				const char *table)
+ {
+ 	resetPQExpBuffer(sql);
+ 
+ 	if (vacopts->analyze_only)
+ 	{
+ 		appendPQExpBufferStr(sql, "ANALYZE");
+ 		if (vacopts->verbose)
+ 			appendPQExpBufferStr(sql, " VERBOSE");
+ 	}
+ 	else
+ 	{
+ 		appendPQExpBufferStr(sql, "VACUUM");
+ 		if (PQserverVersion(conn) >= 90000)
+ 		{
+ 			const char *paren = " (";
+ 			const char *comma = ", ";
+ 			const char *sep = paren;
+ 
+ 			if (vacopts->full)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFULL", sep);
+ 				sep = comma;
+ 			}
+ 			if (vacopts->freeze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sFREEZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (vacopts->verbose)
+ 			{
+ 				appendPQExpBuffer(sql, "%sVERBOSE", sep);
+ 				sep = comma;
+ 			}
+ 			if (vacopts->and_analyze)
+ 			{
+ 				appendPQExpBuffer(sql, "%sANALYZE", sep);
+ 				sep = comma;
+ 			}
+ 			if (sep != paren)
+ 				appendPQExpBufferStr(sql, ")");
+ 		}
+ 		else
+ 		{
+ 			if (vacopts->full)
+ 				appendPQExpBufferStr(sql, " FULL");
+ 			if (vacopts->freeze)
+ 				appendPQExpBufferStr(sql, " FREEZE");
+ 			if (vacopts->verbose)
+ 				appendPQExpBufferStr(sql, " VERBOSE");
+ 			if (vacopts->and_analyze)
+ 				appendPQExpBufferStr(sql, " ANALYZE");
+ 		}
+ 	}
+ 
+ 	if (table)
+ 		appendPQExpBuffer(sql, " %s;", table);
+ }
  
  static void
  help(const char *progname)
***************
*** 436,441 **** help(const char *progname)
--- 928,934 ----
  	printf(_("  -V, --version                   output version information, then exit\n"));
  	printf(_("  -z, --analyze                   update optimizer statistics\n"));
  	printf(_("  -Z, --analyze-only              only update optimizer statistics\n"));
+ 	printf(_("  -j, --jobs=NUM                  use this many concurrent connections to vacuum\n"));
  	printf(_("      --analyze-in-stages         only update optimizer statistics, in multiple\n"
  		   "                                  stages for faster results\n"));
  	printf(_("  -?, --help                      show this help, then exit\n"));
***************
*** 449,451 **** help(const char *progname)
--- 942,945 ----
  	printf(_("\nRead the description of the SQL command VACUUM for details.\n"));
  	printf(_("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
  }
+